Source: models/predicates.js

  1. 'use strict';
  3. const stringify = require('safe-stable-stringify'),
  4.     safeRegex = require('safe-regex'),
  5.     jsonpath = require('./jsonpath.js'),
  6.     helpers = require('../util/helpers.js'),
  7.     xPath = require('./xpath.js'),
  8.     combinators = require('../util/combinators.js'),
  9.     errors = require('../util/errors.js'),
  10.     compatibility = require('./compatibility.js');
  12. /**
  13.  * All the predicates that determine whether a stub matches a request
  14.  * @module
  15.  */
  17. function sortObjects (a, b) {
  18.     const isObject = helpers.isObject;
  20.     if (isObject(a) && isObject(b)) {
  21.         // Make best effort at sorting arrays of objects to make
  22.         // deepEquals order-independent
  23.         return sortObjects(stringify(a), stringify(b));
  24.     }
  25.     else if (a < b) {
  26.         return -1;
  27.     }
  28.     else {
  29.         return 1;
  30.     }
  31. }
  33. function forceStrings (value) {
  34.     const isObject = helpers.isObject;
  36.     if (value === null) {
  37.         return 'null';
  38.     }
  39.     else if (Array.isArray(value)) {
  40.         return value.map(forceStrings);
  41.     }
  42.     else if (isObject(value)) {
  43.         return Object.keys(value).reduce((accumulator, key) => {
  44.             accumulator[key] = forceStrings(value[key]);
  45.             return accumulator;
  46.         }, {});
  47.     }
  48.     else if (typeof value.toString === 'function') {
  49.         return value.toString();
  50.     }
  51.     else {
  52.         return value;
  53.     }
  54. }
  56. function select (type, selectFn, encoding) {
  57.     if (encoding === 'base64') {
  58.         throw errors.ValidationError(`the ${type} predicate parameter is not allowed in binary mode`);
  59.     }
  61.     const nodeValues = selectFn();
  63.     // Return either a string if one match or array if multiple
  64.     // This matches the behavior of node's handling of query parameters,
  65.     // which allows us to maintain the same semantics between deepEquals
  66.     // (all have to match, passing in an array if necessary) and the other
  67.     // predicates (any can match)
  68.     if (nodeValues && nodeValues.length === 1) {
  69.         return nodeValues[0];
  70.     }
  71.     else {
  72.         return nodeValues;
  73.     }
  74. }
  76. function orderIndependent (possibleArray) {
  77.     if (Array.isArray(possibleArray)) {
  78.         return possibleArray.sort(sortObjects);
  79.     }
  80.     else {
  81.         return possibleArray;
  82.     }
  83. }
  85. function transformObject (obj, transform) {
  86.     Object.keys(obj).forEach(key => {
  87.         obj[key] = transform(obj[key]);
  88.     });
  89.     return obj;
  90. }
  92. function selectXPath (config, encoding, text) {
  93.     const selectFn = combinators.curry(xPath.select, config.selector, config.ns, text);
  95.     return orderIndependent(select('xpath', selectFn, encoding));
  96. }
  98. function selectTransform (config, options, logger) {
  99.     const cloned = helpers.clone(config);
  101.     if (config.jsonpath) {
  102.         const stringTransform = options.shouldForceStrings ? forceStrings : combinators.identity;
  104.         // use keyCaseSensitive instead of caseSensitive to help "matches" predicates too
  105.         // see https://github.com/bbyars/mountebank/issues/361
  106.         if (!cloned.keyCaseSensitive) {
  107.             cloned.jsonpath.selector = cloned.jsonpath.selector.toLowerCase();
  108.         }
  110.         return combinators.curry(selectJSONPath, cloned.jsonpath, options.encoding, config, stringTransform, logger);
  111.     }
  112.     else if (config.xpath) {
  113.         if (!cloned.caseSensitive) {
  114.             cloned.xpath.ns = transformObject(cloned.xpath.ns || {}, lowercase);
  115.             cloned.xpath.selector = cloned.xpath.selector.toLowerCase();
  116.         }
  117.         return combinators.curry(selectXPath, cloned.xpath, options.encoding);
  118.     }
  119.     else {
  120.         return combinators.identity;
  121.     }
  122. }
  124. function lowercase (text) {
  125.     return text.toLowerCase();
  126. }
  128. function caseTransform (config) {
  129.     return config.caseSensitive ? combinators.identity : lowercase;
  130. }
  132. function exceptTransform (config, logger) {
  133.     const exceptRegexOptions = config.caseSensitive ? 'g' : 'gi';
  135.     if (config.except) {
  136.         if (!safeRegex(config.except)) {
  137.             logger.warn(`If mountebank becomes unresponsive, it is because of this unsafe regular expression: ${config.except}`);
  138.         }
  139.         return text => text.replace(new RegExp(config.except, exceptRegexOptions), '');
  140.     }
  141.     else {
  142.         return combinators.identity;
  143.     }
  144. }
  146. function encodingTransform (encoding) {
  147.     if (encoding === 'base64') {
  148.         return text => Buffer.from(text, 'base64').toString();
  149.     }
  150.     else {
  151.         return combinators.identity;
  152.     }
  153. }
  155. function tryJSON (value, predicateConfig, logger) {
  156.     try {
  157.         const keyCaseTransform = predicateConfig.keyCaseSensitive === false ? lowercase : caseTransform(predicateConfig),
  158.             valueTransforms = [exceptTransform(predicateConfig, logger), caseTransform(predicateConfig)];
  160.         // We can't call normalize because we want to avoid the array sort transform,
  161.         // which will mess up indexed selectors like $..title[1]
  162.         return transformAll(JSON.parse(value), [keyCaseTransform], valueTransforms, []);
  163.     }
  164.     catch (e) {
  165.         return value;
  166.     }
  167. }
  169. // eslint-disable-next-line max-params
  170. function selectJSONPath (config, encoding, predicateConfig, stringTransform, logger, text) {
  171.     const possibleJSON = stringTransform(tryJSON(text, predicateConfig, logger)),
  172.         selectFn = combinators.curry(jsonpath.select, config.selector, possibleJSON);
  174.     return orderIndependent(select('jsonpath', selectFn, encoding));
  175. }
  177. function transformAll (obj, keyTransforms, valueTransforms, arrayTransforms) {
  178.     const apply = fns => combinators.compose.apply(null, fns),
  179.         isObject = helpers.isObject;
  181.     if (Array.isArray(obj)) {
  182.         return apply(arrayTransforms)(obj.map(element => transformAll(element, keyTransforms, valueTransforms, arrayTransforms)));
  183.     }
  184.     else if (isObject(obj)) {
  185.         return Object.keys(obj).reduce((accumulator, key) => {
  186.             accumulator[apply(keyTransforms)(key)] = transformAll(obj[key], keyTransforms, valueTransforms, arrayTransforms);
  187.             return accumulator;
  188.         }, {});
  189.     }
  190.     else if (typeof obj === 'string') {
  191.         return apply(valueTransforms)(obj);
  192.     }
  193.     else {
  194.         return obj;
  195.     }
  196. }
  198. function normalize (obj, config, options, logger) {
  199.     // Needed to solve a tricky case conversion for "matches" predicates with jsonpath/xpath parameters
  200.     if (typeof config.keyCaseSensitive === 'undefined') {
  201.         config.keyCaseSensitive = config.caseSensitive;
  202.     }
  204.     const keyCaseTransform = config.keyCaseSensitive === false ? lowercase : caseTransform(config),
  205.         sortTransform = array => array.sort(sortObjects),
  206.         transforms = [];
  208.     if (options.withSelectors) {
  209.         transforms.push(selectTransform(config, options, logger));
  210.     }
  212.     transforms.push(exceptTransform(config, logger));
  213.     transforms.push(caseTransform(config));
  214.     transforms.push(encodingTransform(options.encoding));
  216.     // sort to provide deterministic comparison for deepEquals,
  217.     // where the order in the array for multi-valued querystring keys
  218.     // and xpath selections isn't important
  219.     return transformAll(obj, [keyCaseTransform], transforms, [sortTransform]);
  220. }
  222. function testPredicate (expected, actual, predicateConfig, predicateFn) {
  223.     if (!helpers.defined(actual)) {
  224.         actual = '';
  225.     }
  226.     if (helpers.isObject(expected)) {
  227.         return predicateSatisfied(expected, actual, predicateConfig, predicateFn);
  228.     }
  229.     else {
  230.         return predicateFn(expected, actual);
  231.     }
  232. }
  234. function bothArrays (expected, actual) {
  235.     return Array.isArray(actual) && Array.isArray(expected);
  236. }
  238. function allExpectedArrayValuesMatchActualArray (expectedArray, actualArray, predicateConfig, predicateFn) {
  239.     return expectedArray.every(expectedValue =>
  240.         actualArray.some(actualValue => testPredicate(expectedValue, actualValue, predicateConfig, predicateFn)));
  241. }
  243. function onlyActualIsArray (expected, actual) {
  244.     return Array.isArray(actual) && !Array.isArray(expected);
  245. }
  247. function expectedMatchesAtLeastOneValueInActualArray (expected, actualArray, predicateConfig, predicateFn) {
  248.     return actualArray.some(actual => testPredicate(expected, actual, predicateConfig, predicateFn));
  249. }
  251. function expectedLeftOffArraySyntaxButActualIsArrayOfObjects (expected, actual, fieldName) {
  252.     return !Array.isArray(expected[fieldName]) && !helpers.defined(actual[fieldName]) && Array.isArray(actual);
  253. }
  255. function predicateSatisfied (expected, actual, predicateConfig, predicateFn) {
  256.     if (!actual) {
  257.         return false;
  258.     }
  260.     // Support predicates that reach into fields encoded in JSON strings (e.g. HTTP bodies)
  261.     if (typeof actual === 'string') {
  262.         actual = tryJSON(actual, predicateConfig);
  263.     }
  265.     return Object.keys(expected).every(fieldName => {
  266.         const isObject = helpers.isObject;
  268.         if (bothArrays(expected[fieldName], actual[fieldName])) {
  269.             return allExpectedArrayValuesMatchActualArray(
  270.                 expected[fieldName], actual[fieldName], predicateConfig, predicateFn);
  271.         }
  272.         else if (onlyActualIsArray(expected[fieldName], actual[fieldName])) {
  273.             if (predicateConfig.exists && expected[fieldName]) {
  274.                 return true;
  275.             }
  276.             else {
  277.                 return expectedMatchesAtLeastOneValueInActualArray(
  278.                     expected[fieldName], actual[fieldName], predicateConfig, predicateFn);
  279.             }
  280.         }
  281.         else if (expectedLeftOffArraySyntaxButActualIsArrayOfObjects(expected, actual, fieldName)) {
  282.             // This is a little confusing, but predated the ability for users to specify an
  283.             // array for the expected values and is left for backwards compatibility.
  284.             // The predicate might be:
  285.             //     { equals: { examples: { key: 'third' } } }
  286.             // and the request might be
  287.             //     { examples: '[{ "key": "first" }, { "different": true }, { "key": "third" }]' }
  288.             // We expect that the "key" field in the predicate definition matches any object key
  289.             // in the actual array
  290.             return expectedMatchesAtLeastOneValueInActualArray(expected, actual, predicateConfig, predicateFn);
  291.         }
  292.         else if (isObject(expected[fieldName])) {
  293.             return predicateSatisfied(expected[fieldName], actual[fieldName], predicateConfig, predicateFn);
  294.         }
  295.         else {
  296.             return testPredicate(expected[fieldName], actual[fieldName], predicateConfig, predicateFn);
  297.         }
  298.     });
  299. }
  301. function create (operator, predicateFn) {
  302.     return (predicate, request, encoding, logger) => {
  303.         const expected = normalize(predicate[operator], predicate, { encoding: encoding }, logger),
  304.             actual = normalize(request, predicate, { encoding: encoding, withSelectors: true }, logger);
  306.         return predicateSatisfied(expected, actual, predicate, predicateFn);
  307.     };
  308. }
  310. function deepEquals (predicate, request, encoding, logger) {
  311.     const expected = normalize(forceStrings(predicate.deepEquals), predicate, { encoding: encoding }, logger),
  312.         actual = normalize(forceStrings(request), predicate, { encoding: encoding, withSelectors: true, shouldForceStrings: true }, logger),
  313.         isObject = helpers.isObject;
  315.     return Object.keys(expected).every(fieldName => {
  316.         // Support predicates that reach into fields encoded in JSON strings (e.g. HTTP bodies)
  317.         if (isObject(expected[fieldName]) && typeof actual[fieldName] === 'string') {
  318.             const possibleJSON = tryJSON(actual[fieldName], predicate);
  319.             actual[fieldName] = normalize(forceStrings(possibleJSON), predicate, { encoding: encoding }, logger);
  320.         }
  321.         return stringify(expected[fieldName]) === stringify(actual[fieldName]);
  322.     });
  323. }
  325. function matches (predicate, request, encoding, logger) {
  326.     // We want to avoid the lowerCase transform on values so we don't accidentally butcher
  327.     // a regular expression with upper case metacharacters like \W and \S
  328.     // However, we need to maintain the case transform for keys like http header names (issue #169)
  329.     // eslint-disable-next-line no-unneeded-ternary
  330.     const caseSensitive = predicate.caseSensitive ? true : false, // convert to boolean even if undefined
  331.         clone = helpers.merge(predicate, { caseSensitive: true, keyCaseSensitive: caseSensitive }),
  332.         noexcept = helpers.merge(clone, { except: '' }),
  333.         expected = normalize(predicate.matches, noexcept, { encoding: encoding }, logger),
  334.         actual = normalize(request, clone, { encoding: encoding, withSelectors: true }, logger),
  335.         options = caseSensitive ? '' : 'i';
  337.     if (encoding === 'base64') {
  338.         throw errors.ValidationError('the matches predicate is not allowed in binary mode');
  339.     }
  341.     return predicateSatisfied(expected, actual, clone, (a, b) => {
  342.         if (!safeRegex(a)) {
  343.             logger.warn(`If mountebank becomes unresponsive, it is because of this unsafe regular expression: ${a}`);
  344.         }
  345.         return new RegExp(a, options).test(b);
  346.     });
  347. }
  349. function not (predicate, request, encoding, logger, imposterState) {
  350.     return !evaluate(predicate.not, request, encoding, logger, imposterState);
  351. }
  353. function evaluateFn (request, encoding, logger, imposterState) {
  354.     return subPredicate => evaluate(subPredicate, request, encoding, logger, imposterState);
  355. }
  357. function or (predicate, request, encoding, logger, imposterState) {
  358.     return predicate.or.some(evaluateFn(request, encoding, logger, imposterState));
  359. }
  361. function and (predicate, request, encoding, logger, imposterState) {
  362.     return predicate.and.every(evaluateFn(request, encoding, logger, imposterState));
  363. }
  365. function inject (predicate, request, encoding, logger, imposterState) {
  366.     if (request.isDryRun === true) {
  367.         return true;
  368.     }
  370.     const config = {
  371.         request: helpers.clone(request),
  372.         state: imposterState,
  373.         logger: logger
  374.     };
  376.     compatibility.downcastInjectionConfig(config);
  378.     const injected = `(${predicate.inject})(config, logger, imposterState);`;
  380.     try {
  381.         return eval(injected);
  382.     }
  383.     catch (error) {
  384.         logger.error(`injection X=> ${error}`);
  385.         logger.error(`    source: ${JSON.stringify(injected)}`);
  386.         logger.error(`    config.request: ${JSON.stringify(config.request)}`);
  387.         logger.error(`    config.state: ${JSON.stringify(config.state)}`);
  388.         throw errors.InjectionError('invalid predicate injection', { source: injected, data: error.message });
  389.     }
  390. }
  392. function toString (value) {
  393.     if (value !== null && typeof value !== 'undefined' && typeof value.toString === 'function') {
  394.         return value.toString();
  395.     }
  396.     else {
  397.         return value;
  398.     }
  399. }
  401. const predicates = {
  402.     equals: create('equals', (expected, actual) => toString(expected) === toString(actual)),
  403.     deepEquals,
  404.     contains: create('contains', (expected, actual) => actual.indexOf(expected) >= 0),
  405.     startsWith: create('startsWith', (expected, actual) => actual.indexOf(expected) === 0),
  406.     endsWith: create('endsWith', (expected, actual) => actual.indexOf(expected, actual.length - expected.length) >= 0),
  407.     matches,
  408.     exists: create('exists', function (expected, actual) {
  409.         return expected ? (typeof actual !== 'undefined' && actual !== '') : (typeof actual === 'undefined' || actual === '');
  410.     }),
  411.     not,
  412.     or,
  413.     and,
  414.     inject
  415. };
  417. /**
  418.  * Resolves all predicate keys in given predicate
  419.  * @param {Object} predicate - The predicate configuration
  420.  * @param {Object} request - The protocol request object
  421.  * @param {string} encoding - utf8 or base64
  422.  * @param {Object} logger - The logger, useful for debugging purposes
  423.  * @param {Object} imposterState - The current state for the imposter
  424.  * @returns {boolean}
  425.  */
  426. function evaluate (predicate, request, encoding, logger, imposterState) {
  427.     const predicateFn = Object.keys(predicate).find(key => Object.keys(predicates).indexOf(key) >= 0),
  428.         clone = helpers.clone(predicate);
  430.     if (predicateFn) {
  431.         return predicates[predicateFn](clone, request, encoding, logger, imposterState);
  432.     }
  433.     else {
  434.         throw errors.ValidationError('missing predicate', { source: predicate });
  435.     }
  436. }
  438. module.exports = { evaluate };