predicates.js

'use strict';

const stringify = require('safe-stable-stringify'),
    safeRegex = require('safe-regex'),
    jsonpath = require('./jsonpath.js'),
    helpers = require('../util/helpers.js'),
    xPath = require('./xpath.js'),
    combinators = require('../util/combinators.js'),
    errors = require('../util/errors.js'),
    compatibility = require('./compatibility.js');

/**
 * All the predicates that determine whether a stub matches a request
 * @module
 */

function sortObjects (a, b) {
    const isObject = helpers.isObject;

    if (isObject(a) && isObject(b)) {
        // Make best effort at sorting arrays of objects to make
        // deepEquals order-independent
        return sortObjects(stringify(a), stringify(b));
    }
    else if (a < b) {
        return -1;
    }
    else {
        return 1;
    }
}

function forceStrings (value) {
    const isObject = helpers.isObject;

    if (value === null) {
        return 'null';
    }
    else if (Array.isArray(value)) {
        return value.map(forceStrings);
    }
    else if (isObject(value)) {
        return Object.keys(value).reduce((accumulator, key) => {
            accumulator[key] = forceStrings(value[key]);
            return accumulator;
        }, {});
    }
    else if (typeof value.toString === 'function') {
        return value.toString();
    }
    else {
        return value;
    }
}

function select (type, selectFn, encoding) {
    if (encoding === 'base64') {
        throw errors.ValidationError(`the ${type} predicate parameter is not allowed in binary mode`);
    }

    const nodeValues = selectFn();

    // Return either a string if one match or array if multiple
    // This matches the behavior of node's handling of query parameters,
    // which allows us to maintain the same semantics between deepEquals
    // (all have to match, passing in an array if necessary) and the other
    // predicates (any can match)
    if (nodeValues && nodeValues.length === 1) {
        return nodeValues[0];
    }
    else {
        return nodeValues;
    }
}

function orderIndependent (possibleArray) {
    if (Array.isArray(possibleArray)) {
        return possibleArray.sort(sortObjects);
    }
    else {
        return possibleArray;
    }
}

function transformObject (obj, transform) {
    Object.keys(obj).forEach(key => {
        obj[key] = transform(obj[key]);
    });
    return obj;
}

function selectXPath (config, encoding, text) {
    const selectFn = combinators.curry(xPath.select, config.selector, config.ns, text);

    return orderIndependent(select('xpath', selectFn, encoding));
}

function selectTransform (config, options, logger) {
    const cloned = helpers.clone(config);

    if (config.jsonpath) {
        const stringTransform = options.shouldForceStrings ? forceStrings : combinators.identity;

        // use keyCaseSensitive instead of caseSensitive to help "matches" predicates too
        // see https://github.com/bbyars/mountebank/issues/361
        if (!cloned.keyCaseSensitive) {
            cloned.jsonpath.selector = cloned.jsonpath.selector.toLowerCase();
        }

        return combinators.curry(selectJSONPath, cloned.jsonpath, options.encoding, config, stringTransform, logger);
    }
    else if (config.xpath) {
        if (!cloned.caseSensitive) {
            cloned.xpath.ns = transformObject(cloned.xpath.ns || {}, lowercase);
            cloned.xpath.selector = cloned.xpath.selector.toLowerCase();
        }
        return combinators.curry(selectXPath, cloned.xpath, options.encoding);
    }
    else {
        return combinators.identity;
    }
}

function lowercase (text) {
    return text.toLowerCase();
}

function caseTransform (config) {
    return config.caseSensitive ? combinators.identity : lowercase;
}

function exceptTransform (config, logger) {
    const exceptRegexOptions = config.caseSensitive ? 'g' : 'gi';

    if (config.except) {
        if (!safeRegex(config.except)) {
            logger.warn(`If mountebank becomes unresponsive, it is because of this unsafe regular expression: ${config.except}`);
        }
        return text => text.replace(new RegExp(config.except, exceptRegexOptions), '');
    }
    else {
        return combinators.identity;
    }
}

function encodingTransform (encoding) {
    if (encoding === 'base64') {
        return text => Buffer.from(text, 'base64').toString();
    }
    else {
        return combinators.identity;
    }
}

function tryJSON (value, predicateConfig, logger) {
    try {
        const keyCaseTransform = predicateConfig.keyCaseSensitive === false ? lowercase : caseTransform(predicateConfig),
            valueTransforms = [exceptTransform(predicateConfig, logger), caseTransform(predicateConfig)];

        // We can't call normalize because we want to avoid the array sort transform,
        // which will mess up indexed selectors like $..title[1]
        return transformAll(JSON.parse(value), [keyCaseTransform], valueTransforms, []);
    }
    catch (e) {
        return value;
    }
}

// eslint-disable-next-line max-params
function selectJSONPath (config, encoding, predicateConfig, stringTransform, logger, text) {
    const possibleJSON = stringTransform(tryJSON(text, predicateConfig, logger)),
        selectFn = combinators.curry(jsonpath.select, config.selector, possibleJSON);

    return orderIndependent(select('jsonpath', selectFn, encoding));
}

function transformAll (obj, keyTransforms, valueTransforms, arrayTransforms) {
    const apply = fns => combinators.compose.apply(null, fns),
        isObject = helpers.isObject;

    if (Array.isArray(obj)) {
        return apply(arrayTransforms)(obj.map(element => transformAll(element, keyTransforms, valueTransforms, arrayTransforms)));
    }
    else if (isObject(obj)) {
        return Object.keys(obj).reduce((accumulator, key) => {
            accumulator[apply(keyTransforms)(key)] = transformAll(obj[key], keyTransforms, valueTransforms, arrayTransforms);
            return accumulator;
        }, {});
    }
    else if (typeof obj === 'string') {
        return apply(valueTransforms)(obj);
    }
    else {
        return obj;
    }
}

function normalize (obj, config, options, logger) {
    // Needed to solve a tricky case conversion for "matches" predicates with jsonpath/xpath parameters
    if (typeof config.keyCaseSensitive === 'undefined') {
        config.keyCaseSensitive = config.caseSensitive;
    }

    const keyCaseTransform = config.keyCaseSensitive === false ? lowercase : caseTransform(config),
        sortTransform = array => array.sort(sortObjects),
        transforms = [];

    if (options.withSelectors) {
        transforms.push(selectTransform(config, options, logger));
    }

    transforms.push(exceptTransform(config, logger));
    transforms.push(caseTransform(config));
    transforms.push(encodingTransform(options.encoding));

    // sort to provide deterministic comparison for deepEquals,
    // where the order in the array for multi-valued querystring keys
    // and xpath selections isn't important
    return transformAll(obj, [keyCaseTransform], transforms, [sortTransform]);
}

function testPredicate (expected, actual, predicateConfig, predicateFn) {
    if (!helpers.defined(actual)) {
        actual = '';
    }
    if (helpers.isObject(expected)) {
        return predicateSatisfied(expected, actual, predicateConfig, predicateFn);
    }
    else {
        return predicateFn(expected, actual);
    }
}

function bothArrays (expected, actual) {
    return Array.isArray(actual) && Array.isArray(expected);
}

function allExpectedArrayValuesMatchActualArray (expectedArray, actualArray, predicateConfig, predicateFn) {
    return expectedArray.every(expectedValue =>
        actualArray.some(actualValue => testPredicate(expectedValue, actualValue, predicateConfig, predicateFn)));
}

function onlyActualIsArray (expected, actual) {
    return Array.isArray(actual) && !Array.isArray(expected);
}

function expectedMatchesAtLeastOneValueInActualArray (expected, actualArray, predicateConfig, predicateFn) {
    return actualArray.some(actual => testPredicate(expected, actual, predicateConfig, predicateFn));
}

function expectedLeftOffArraySyntaxButActualIsArrayOfObjects (expected, actual, fieldName) {
    return !Array.isArray(expected[fieldName]) && !helpers.defined(actual[fieldName]) && Array.isArray(actual);
}

function predicateSatisfied (expected, actual, predicateConfig, predicateFn) {
    if (!actual) {
        return false;
    }

    // Support predicates that reach into fields encoded in JSON strings (e.g. HTTP bodies)
    if (typeof actual === 'string') {
        actual = tryJSON(actual, predicateConfig);
    }

    return Object.keys(expected).every(fieldName => {
        const isObject = helpers.isObject;

        if (bothArrays(expected[fieldName], actual[fieldName])) {
            return allExpectedArrayValuesMatchActualArray(
                expected[fieldName], actual[fieldName], predicateConfig, predicateFn);
        }
        else if (onlyActualIsArray(expected[fieldName], actual[fieldName])) {
            if (predicateConfig.exists && expected[fieldName]) {
                return true;
            }
            else {
                return expectedMatchesAtLeastOneValueInActualArray(
                    expected[fieldName], actual[fieldName], predicateConfig, predicateFn);
            }
        }
        else if (expectedLeftOffArraySyntaxButActualIsArrayOfObjects(expected, actual, fieldName)) {
            // This is a little confusing, but predated the ability for users to specify an
            // array for the expected values and is left for backwards compatibility.
            // The predicate might be:
            //     { equals: { examples: { key: 'third' } } }
            // and the request might be
            //     { examples: '[{ "key": "first" }, { "different": true }, { "key": "third" }]' }
            // We expect that the "key" field in the predicate definition matches any object key
            // in the actual array
            return expectedMatchesAtLeastOneValueInActualArray(expected, actual, predicateConfig, predicateFn);
        }
        else if (isObject(expected[fieldName])) {
            return predicateSatisfied(expected[fieldName], actual[fieldName], predicateConfig, predicateFn);
        }
        else {
            return testPredicate(expected[fieldName], actual[fieldName], predicateConfig, predicateFn);
        }
    });
}

function create (operator, predicateFn) {
    return (predicate, request, encoding, logger) => {
        const expected = normalize(predicate[operator], predicate, { encoding: encoding }, logger),
            actual = normalize(request, predicate, { encoding: encoding, withSelectors: true }, logger);

        return predicateSatisfied(expected, actual, predicate, predicateFn);
    };
}

function deepEquals (predicate, request, encoding, logger) {
    const expected = normalize(forceStrings(predicate.deepEquals), predicate, { encoding: encoding }, logger),
        actual = normalize(forceStrings(request), predicate, { encoding: encoding, withSelectors: true, shouldForceStrings: true }, logger),
        isObject = helpers.isObject;

    return Object.keys(expected).every(fieldName => {
        // Support predicates that reach into fields encoded in JSON strings (e.g. HTTP bodies)
        if (isObject(expected[fieldName]) && typeof actual[fieldName] === 'string') {
            const possibleJSON = tryJSON(actual[fieldName], predicate);
            actual[fieldName] = normalize(forceStrings(possibleJSON), predicate, { encoding: encoding }, logger);
        }
        return stringify(expected[fieldName]) === stringify(actual[fieldName]);
    });
}

function matches (predicate, request, encoding, logger) {
    // We want to avoid the lowerCase transform on values so we don't accidentally butcher
    // a regular expression with upper case metacharacters like \W and \S
    // However, we need to maintain the case transform for keys like http header names (issue #169)
    // eslint-disable-next-line no-unneeded-ternary
    const caseSensitive = predicate.caseSensitive ? true : false, // convert to boolean even if undefined
        clone = helpers.merge(predicate, { caseSensitive: true, keyCaseSensitive: caseSensitive }),
        noexcept = helpers.merge(clone, { except: '' }),
        expected = normalize(predicate.matches, noexcept, { encoding: encoding }, logger),
        actual = normalize(request, clone, { encoding: encoding, withSelectors: true }, logger),
        options = caseSensitive ? '' : 'i';

    if (encoding === 'base64') {
        throw errors.ValidationError('the matches predicate is not allowed in binary mode');
    }

    return predicateSatisfied(expected, actual, clone, (a, b) => {
        if (!safeRegex(a)) {
            logger.warn(`If mountebank becomes unresponsive, it is because of this unsafe regular expression: ${a}`);
        }
        return new RegExp(a, options).test(b);
    });
}

function not (predicate, request, encoding, logger, imposterState) {
    return !evaluate(predicate.not, request, encoding, logger, imposterState);
}

function evaluateFn (request, encoding, logger, imposterState) {
    return subPredicate => evaluate(subPredicate, request, encoding, logger, imposterState);
}

function or (predicate, request, encoding, logger, imposterState) {
    return predicate.or.some(evaluateFn(request, encoding, logger, imposterState));
}

function and (predicate, request, encoding, logger, imposterState) {
    return predicate.and.every(evaluateFn(request, encoding, logger, imposterState));
}

function inject (predicate, request, encoding, logger, imposterState) {
    if (request.isDryRun === true) {
        return true;
    }

    const config = {
        request: helpers.clone(request),
        state: imposterState,
        logger: logger
    };

    compatibility.downcastInjectionConfig(config);

    const injected = `(${predicate.inject})(config, logger, imposterState);`;

    try {
        return eval(injected);
    }
    catch (error) {
        logger.error(`injection X=> ${error}`);
        logger.error(`    source: ${JSON.stringify(injected)}`);
        logger.error(`    config.request: ${JSON.stringify(config.request)}`);
        logger.error(`    config.state: ${JSON.stringify(config.state)}`);
        throw errors.InjectionError('invalid predicate injection', { source: injected, data: error.message });
    }
}

function toString (value) {
    if (value !== null && typeof value !== 'undefined' && typeof value.toString === 'function') {
        return value.toString();
    }
    else {
        return value;
    }
}

function contains (actual, expected) {
    if (typeof actual === 'string') {
        return actual.indexOf(expected) >= 0;
    }
    return actual.toString().indexOf(expected) >= 0;
}

function startsWith (actual, expected) {
    if (typeof actual === 'string') {
        return actual.indexOf(expected) === 0;
    }
    return actual.toString().indexOf(expected) === 0;
}

function endsWith (actual, expected) {
    if (typeof actual === 'string') {
        return actual.indexOf(expected, actual.length - expected.length) >= 0;
    }
    return actual.toString().indexOf(expected, actual.length - expected.length) >= 0;
}

const predicates = {
    equals: create('equals', (expected, actual) => toString(expected) === toString(actual)),
    deepEquals,
    contains: create('contains', (expected, actual) => contains(actual, expected)),
    startsWith: create('startsWith', (expected, actual) => startsWith(actual, expected)),
    endsWith: create('endsWith', (expected, actual) => endsWith(actual, expected)),
    matches,
    exists: create('exists', function (expected, actual) {
        return expected ? (typeof actual !== 'undefined' && actual !== '') : (typeof actual === 'undefined' || actual === '');
    }),
    not,
    or,
    and,
    inject
};

/**
 * Resolves all predicate keys in given predicate
 * @param {Object} predicate - The predicate configuration
 * @param {Object} request - The protocol request object
 * @param {string} encoding - utf8 or base64
 * @param {Object} logger - The logger, useful for debugging purposes
 * @param {Object} imposterState - The current state for the imposter
 * @returns {boolean}
 */
function evaluate (predicate, request, encoding, logger, imposterState) {
    const predicateFn = Object.keys(predicate).find(key => Object.keys(predicates).indexOf(key) >= 0),
        clone = helpers.clone(predicate);

    if (predicateFn) {
        return predicates[predicateFn](clone, request, encoding, logger, imposterState);
    }
    else {
        throw errors.ValidationError('missing predicate', { source: predicate });
    }
}

module.exports = { evaluate };