@mbtest/mountebank 2.9.2-beta.9050

package/src/models/predicates.js

@@ -0,0 +1,438 @@
+'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/mountebank-testing/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;
+    }
+}
+
+const predicates = {
+    equals: create('equals', (expected, actual) => toString(expected) === toString(actual)),
+    deepEquals,
+    contains: create('contains', (expected, actual) => actual.indexOf(expected) >= 0),
+    startsWith: create('startsWith', (expected, actual) => actual.indexOf(expected) === 0),
+    endsWith: create('endsWith', (expected, actual) => actual.indexOf(expected, actual.length - expected.length) >= 0),
+    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 };

package/src/models/protocols.js

@@ -0,0 +1,242 @@
+'use strict';
+
+const responseResolver = require('./responseResolver'),
+    childProcess = require('child_process'),
+    fsExtra = require('fs-extra'),
+    path = require('path'),
+    errors = require('../util/errors.js'),
+    Imposter = require('./imposter.js'),
+    helpers = require('../util/helpers.js'),
+    tcpServer = require('./tcp/tcpServer.js'),
+    httpServer = require('./http/httpServer.js'),
+    httpsServer = require('./https/httpsServer.js'),
+    smtpServer = require('./smtp/smtpServer.js');
+
+/**
+ * Abstracts the protocol configuration between the built-in in-memory implementations and out of process
+ * implementations
+ * @module
+ */
+
+/**
+ * Loads the imposter creation functions for all built in and custom protocols
+ * @param builtInProtocols {Object} - the in-memory protocol implementations that ship with mountebank
+ * @param customProtocols {Object} - custom out-of-process protocol implementations
+ * @param options {Object} - command line configuration
+ * @param isAllowedConnection {Function} - a function that determines whether the connection is allowed or not for security verification
+ * @param mbLogger {Object} - the logger
+ * @param impostersRepository {Object} - the imposters repository
+ * @returns {Object} - a map of protocol name to creation functions
+ */
+// eslint-disable-next-line max-params
+function load (builtInProtocols, customProtocols, options, isAllowedConnection, mbLogger, impostersRepository) {
+    function inProcessCreate (createProtocol) {
+        return async (creationRequest, logger, responseFn) => {
+            const server = await createProtocol(creationRequest, logger, responseFn),
+                stubs = impostersRepository.stubsFor(server.port),
+                resolver = responseResolver.create(stubs, server.proxy);
+
+            return {
+                port: server.port,
+                metadata: server.metadata,
+                stubs: stubs,
+                resolver: resolver,
+                close: server.close,
+                encoding: server.encoding || 'utf8'
+            };
+        };
+    }
+
+    function outOfProcessCreate (protocolName, config) {
+        function customFieldsFor (creationRequest) {
+            const fields = {},
+                commonFields = ['protocol', 'port', 'name', 'recordRequests', 'stubs', 'defaultResponse'];
+            Object.keys(creationRequest).forEach(key => {
+                if (commonFields.indexOf(key) < 0) {
+                    fields[key] = creationRequest[key];
+                }
+            });
+            return fields;
+        }
+
+        return (creationRequest, logger) => new Promise((res, rej) => {
+            let isPending = true;
+            const { spawn } = childProcess,
+                command = config.createCommand.split(' ')[0],
+                args = config.createCommand.split(' ').splice(1),
+                port = creationRequest.port,
+                commonArgs = {
+                    port,
+                    callbackURLTemplate: options.callbackURLTemplate,
+                    loglevel: options.loglevel,
+                    allowInjection: options.allowInjection
+                },
+                configArgs = helpers.merge(commonArgs, customFieldsFor(creationRequest)),
+                resolve = obj => {
+                    isPending = false;
+                    res(obj);
+                },
+                reject = err => {
+                    isPending = false;
+                    rej(err);
+                };
+
+            if (typeof creationRequest.defaultResponse !== 'undefined') {
+                configArgs.defaultResponse = creationRequest.defaultResponse;
+            }
+
+            const allArgs = args.concat(JSON.stringify(configArgs)),
+                imposterProcess = spawn(command, allArgs);
+
+            let closeCalled = false;
+
+            imposterProcess.on('error', error => {
+                const message = `Invalid configuration for protocol "${protocolName}": cannot run "${config.createCommand}"`;
+
+                reject(errors.ProtocolError(message,
+                    { source: config.createCommand, details: error }));
+            });
+
+            imposterProcess.once('exit', code => {
+                if (code !== 0 && isPending) {
+                    const message = `"${protocolName}" start command failed (exit code ${code})`;
+
+                    reject(errors.ProtocolError(message, { source: config.createCommand }));
+                }
+                else if (!closeCalled) {
+                    logger.error("Uh oh! I've crashed! Expect subsequent requests to fail.");
+                }
+            });
+
+            function resolveWithMetadata (possibleJSON) {
+                let metadata = {};
+
+                try {
+                    metadata = JSON.parse(possibleJSON);
+                }
+                catch (error) { /* do nothing */ }
+
+                let serverPort = creationRequest.port;
+                if (metadata.port) {
+                    serverPort = metadata.port;
+                    delete metadata.port;
+                }
+                const callbackURL = options.callbackURLTemplate.replace(':port', serverPort),
+                    encoding = metadata.encoding || 'utf8',
+                    stubs = impostersRepository.stubsFor(serverPort),
+                    resolver = responseResolver.create(stubs, undefined, callbackURL);
+
+                delete metadata.encoding;
+
+                resolve({
+                    port: serverPort,
+                    metadata: metadata,
+                    stubs,
+                    resolver,
+                    encoding,
+                    close: callback => {
+                        closeCalled = true;
+                        imposterProcess.once('exit', callback);
+                        imposterProcess.kill();
+                    }
+                });
+            }
+
+            function log (message) {
+                if (message.indexOf(' ') > 0) {
+                    const words = message.split(' '),
+                        level = words[0],
+                        rest = words.splice(1).join(' ').trim();
+                    if (['debug', 'info', 'warn', 'error'].indexOf(level) >= 0) {
+                        logger[level](rest);
+                    }
+                }
+            }
+
+            imposterProcess.stdout.on('data', data => {
+                const lines = data.toString('utf8').trim().split(/\r?\n/);
+                lines.forEach(line => {
+                    if (isPending) {
+                        resolveWithMetadata(line);
+                    }
+                    log(line);
+                });
+            });
+
+            imposterProcess.stderr.on('data', logger.error);
+        });
+    }
+
+    function createImposter (Protocol, creationRequest) {
+        return Imposter.create(Protocol, creationRequest, mbLogger.baseLogger, options, isAllowedConnection);
+    }
+
+    const result = {};
+    Object.keys(builtInProtocols).forEach(key => {
+        result[key] = builtInProtocols[key];
+        result[key].createServer = inProcessCreate(result[key].create);
+        result[key].createImposterFrom = creationRequest => createImposter(result[key], creationRequest);
+    });
+    Object.keys(customProtocols).forEach(key => {
+        result[key] = customProtocols[key];
+        result[key].createServer = outOfProcessCreate(key, result[key]);
+        result[key].createImposterFrom = creationRequest => createImposter(result[key], creationRequest);
+    });
+    return result;
+}
+
+function isBuiltInProtocol (protocol) {
+    return ['tcp', 'smtp', 'http', 'https'].indexOf(protocol) >= 0;
+}
+
+function loadCustomProtocols (protofile, logger) {
+    if (typeof protofile === 'undefined') {
+        return {};
+    }
+
+    const filename = path.resolve(path.relative(process.cwd(), protofile));
+
+    if (fsExtra.existsSync(filename)) {
+        try {
+            const customProtocols = require(filename);
+            Object.keys(customProtocols).forEach(proto => {
+                if (isBuiltInProtocol(proto)) {
+                    logger.warn(`Using custom ${proto} implementation instead of the built-in one`);
+                }
+                else {
+                    logger.info(`Loaded custom protocol ${proto}`);
+                }
+            });
+            return customProtocols;
+        }
+        catch (e) {
+            logger.error(`${protofile} contains invalid JSON -- no custom protocols loaded`);
+            return {};
+        }
+    }
+    else {
+        return {};
+    }
+}
+
+function loadProtocols (options, baseURL, logger, isAllowedConnection, imposters) {
+    const builtInProtocols = {
+            tcp: tcpServer,
+            http: httpServer,
+            https: httpsServer,
+            smtp: smtpServer
+        },
+        customProtocols = loadCustomProtocols(options.protofile, logger),
+        config = {
+            callbackURLTemplate: `${baseURL}/imposters/:port/_requests`,
+            recordRequests: options.mock,
+            recordMatches: options.debug,
+            loglevel: options.log.level,
+            allowInjection: options.allowInjection,
+            host: options.host
+        };
+
+    return load(builtInProtocols, customProtocols, config, isAllowedConnection, logger, imposters);
+}
+
+module.exports = { load, loadProtocols };