@mbtest/mountebank 2.9.2-beta.9050

package/src/models/behaviorsValidator.js

@@ -0,0 +1,186 @@
+'use strict';
+
+const exceptions = require('../util/errors.js'),
+    helpers = require('../util/helpers.js');
+
+/**
+ * The module that does validation of behavior configuration
+ * @module
+ */
+
+/**
+ * Creates the validator
+ * @returns {{validate: validate}}
+ */
+function create () {
+    function hasExactlyOneKey (obj) {
+        const keys = Object.keys(obj);
+        return keys.length === 1;
+    }
+
+    function navigate (config, path) {
+        if (path === '') {
+            return config;
+        }
+        else {
+            return path.split('.').reduce(function (field, fieldName) {
+                return field[fieldName];
+            }, config);
+        }
+    }
+
+    function typeErrorMessageFor (allowedTypes, additionalContext) {
+        const spellings = { number: 'a', object: 'an', string: 'a' };
+        let message = `must be ${spellings[allowedTypes[0]]} ${allowedTypes[0]}`;
+
+        for (let i = 1; i < allowedTypes.length; i += 1) {
+            message += ` or ${spellings[allowedTypes[i]]} ${allowedTypes[i]}`;
+        }
+        if (additionalContext) {
+            message += `, representing ${additionalContext}`;
+        }
+        return message;
+    }
+
+    function pathFor (pathPrefix, fieldName) {
+        if (pathPrefix === '') {
+            return fieldName;
+        }
+        else {
+            return `${pathPrefix}.${fieldName}`;
+        }
+    }
+
+    function nonMetadata (fieldName) {
+        return fieldName.indexOf('_') !== 0;
+    }
+
+    function isTopLevelSpec (spec) {
+        // True of copy and lookup behaviors that define the metadata below the top level keys
+        return helpers.isObject(spec)
+            && Object.keys(spec).filter(nonMetadata).length === Object.keys(spec).length;
+
+    }
+    function enumFieldFor (field) {
+        const isObject = helpers.isObject;
+
+        // Can be the string value or the object key
+        if (isObject(field) && Object.keys(field).length > 0) {
+            return Object.keys(field)[0];
+        }
+        else {
+            return field;
+        }
+    }
+
+    function matchesEnum (field, enumSpec) {
+        return enumSpec.indexOf(enumFieldFor(field)) >= 0;
+    }
+
+    function addMissingFieldError (fieldSpec, path, addErrorFn) {
+        // eslint-disable-next-line no-underscore-dangle
+        if (fieldSpec._required) {
+            addErrorFn(path, 'required');
+        }
+    }
+
+    function addTypeErrors (fieldSpec, path, field, config, addErrorFn) {
+        /* eslint complexity: 0 */
+        const fieldType = typeof field,
+            allowedTypes = Object.keys(fieldSpec._allowedTypes), // eslint-disable-line no-underscore-dangle
+            typeSpec = fieldSpec._allowedTypes[fieldType]; // eslint-disable-line no-underscore-dangle
+
+        if (!helpers.defined(typeSpec)) {
+            addErrorFn(path, typeErrorMessageFor(allowedTypes, fieldSpec._additionalContext)); // eslint-disable-line no-underscore-dangle
+        }
+        else {
+            if (typeSpec.singleKeyOnly && !hasExactlyOneKey(field)) {
+                addErrorFn(path, 'must have exactly one key');
+            }
+            else if (typeSpec.enum && !matchesEnum(field, typeSpec.enum)) {
+                addErrorFn(path, `must be one of [${typeSpec.enum.join(', ')}]`);
+            }
+            else if (typeSpec.nonNegativeInteger && field < 0) {
+                addErrorFn(path, 'must be an integer greater than or equal to 0');
+            }
+            else if (typeSpec.positiveInteger && field <= 0) {
+                addErrorFn(path, 'must be an integer greater than 0');
+            }
+
+            addErrorsFor(config, path, fieldSpec, addErrorFn);
+        }
+    }
+
+    function addErrorsFor (config, pathPrefix, spec, addErrorFn) {
+        Object.keys(spec).filter(nonMetadata).forEach(fieldName => {
+            const fieldSpec = spec[fieldName],
+                path = pathFor(pathPrefix, fieldName),
+                field = navigate(config, path);
+
+            if (!helpers.defined(field)) {
+                addMissingFieldError(fieldSpec, path, addErrorFn);
+            }
+            else if (isTopLevelSpec(fieldSpec)) {
+                // Recurse but reset pathPrefix so error message is cleaner
+                // e.g. 'copy behavior "from" field required' instead of 'copy behavior "copy.from" field required'
+                addErrorsFor(field, '', fieldSpec, addErrorFn);
+            }
+            else {
+                addTypeErrors(fieldSpec, path, field, config, addErrorFn);
+            }
+        });
+    }
+
+    /**
+     * Validates the behavior configuration and returns all errors
+     * @memberOf module:models/behaviorsValidator#
+     * @param {Object} behaviors - The behaviors list
+     * @param {Object} validationSpec - the specification to validate against
+     * @returns {Object} The array of errors
+     */
+    function validate (behaviors, validationSpec) {
+        const errors = [];
+
+        (behaviors || []).forEach(config => {
+            const validBehaviors = [],
+                unrecognizedKeys = [];
+
+            Object.keys(config).forEach(key => {
+                const addError = function (field, message, subConfig) {
+                        errors.push(exceptions.ValidationError(`${key} behavior "${field}" field ${message}`,
+                            { source: subConfig || config }));
+                    },
+                    spec = {};
+
+                if (validationSpec[key]) {
+                    validBehaviors.push(key);
+                    spec[key] = validationSpec[key];
+                    addErrorsFor(config, '', spec, addError);
+                }
+                else {
+                    unrecognizedKeys.push({ key: key, source: config });
+                }
+            });
+
+            // Allow adding additional custom fields to valid behaviors but ensure there is a valid behavior
+            if (validBehaviors.length === 0 && unrecognizedKeys.length > 0) {
+                errors.push(exceptions.ValidationError(`Unrecognized behavior: "${unrecognizedKeys[0].key}"`,
+                    { source: unrecognizedKeys[0].source }));
+            }
+            if (validBehaviors.length > 1) {
+                errors.push(exceptions.ValidationError('Each behavior object must have only one behavior type',
+                    { source: config }));
+            }
+        });
+
+        return errors;
+    }
+
+    return {
+        validate
+    };
+}
+
+module.exports = {
+    create
+};

package/src/models/compatibility.js

@@ -0,0 +1,133 @@
+'use strict';
+
+const helpers = require('../util/helpers');
+
+/**
+ * mountebank aims to evolve without requiring users to have to worry about versioning,
+ * so breaking changes to the API are A Big Deal. This module exists to support transforming
+ * older versions of the API to a newer format, so that most of the code can assume the
+ * new format, but users who still use the old format don't need to migrate.
+ * @module
+ */
+
+/**
+ * The original shellTransform only accepted one command
+ * The new syntax expects an array, creating a shell pipeline
+ * @param {Object} request - the request to upcast
+ */
+function upcastShellTransformToArray (request) {
+    (request.stubs || []).forEach(stub => {
+        (stub.responses || []).forEach(response => {
+            if (response._behaviors && response._behaviors.shellTransform &&
+                typeof response._behaviors.shellTransform === 'string') {
+                response._behaviors.shellTransform = [response._behaviors.shellTransform];
+            }
+        });
+    });
+}
+
+function canUpcastBehaviors (response) {
+    const isObject = helpers.isObject;
+
+    return typeof response.behaviors === 'undefined'
+        && typeof response.repeat === 'undefined'
+        && isObject(response._behaviors);
+}
+
+function upcastResponseBehaviors (response) {
+    const behaviors = [],
+        add = (key, value) => {
+            const obj = {};
+            obj[key] = value;
+            behaviors.push(obj);
+        };
+
+    // This was the old line of code that executed the behaviors, which defined the order:
+    //     return combinators.compose(decorateFn, shellTransformFn, copyFn, lookupFn, waitFn, Q)(response);
+    ['wait', 'lookup', 'copy', 'shellTransform', 'decorate'].forEach(key => {
+        if (typeof response._behaviors[key] !== 'undefined') {
+            if (Array.isArray(response._behaviors[key])) {
+                response._behaviors[key].forEach(element => add(key, element));
+            }
+            else {
+                add(key, response._behaviors[key]);
+            }
+        }
+    });
+
+    // The repeat behavior can't be stacked multiple times and sequence of execution doesn't matter,
+    // so putting it in the array risks confusion and additional error checking. Pulling it outside
+    // the array clearly indicates it only applies once to the entire response.
+    if (typeof response._behaviors.repeat !== 'undefined') {
+        response.repeat = response._behaviors.repeat;
+    }
+
+    response.behaviors = behaviors;
+    delete response._behaviors;
+}
+
+/**
+ * The original _behaviors took an object with undefined ordering
+ * The new syntax expects an array, creating a behaviors pipeline
+ * @param {Object} request - the request to upcast
+ */
+function upcastBehaviorsToArray (request) {
+    (request.stubs || []).forEach(stub => {
+        (stub.responses || [])
+            .filter(canUpcastBehaviors)
+            .forEach(upcastResponseBehaviors);
+    });
+}
+
+/**
+ * The original tcp proxy.to was an object with a host and port field
+ * The new syntax uses a tcp:// url for symmetry with http/s
+ * @param {Object} request - the request to upcast
+ */
+function upcastTcpProxyDestinationToUrl (request) {
+    if (request.protocol !== 'tcp') {
+        return;
+    }
+
+    const isObject = helpers.isObject;
+
+    (request.stubs || []).forEach(stub => {
+        (stub.responses || []).forEach(response => {
+            const proxy = response.proxy;
+            if (proxy && isObject(proxy.to) && proxy.to.host && proxy.to.port) {
+                proxy.to = `tcp://${proxy.to.host}:${proxy.to.port}`;
+            }
+        });
+    });
+}
+
+/**
+ * Upcast the request to the current version
+ * @param {Object} request - the request to upcast
+ */
+function upcast (request) {
+    upcastShellTransformToArray(request);
+    upcastTcpProxyDestinationToUrl(request);
+    upcastBehaviorsToArray(request);
+}
+
+/**
+ * While the new injection interface takes a single config object, the old
+ * interface took several parameters, starting with the request object.
+ * To make the new interface backwards compatible, we have to add all the
+ * request fields to the config object
+ * @param {Object} config - the injection parameter
+ */
+function downcastInjectionConfig (config) {
+    // Only possible to use older format for http/s and tcp protocols
+    if (config.request.method || config.request.data) {
+        Object.keys(config.request).forEach(key => {
+            config[key] = config.request[key];
+        });
+    }
+}
+
+module.exports = {
+    upcast,
+    downcastInjectionConfig
+};

package/src/models/dryRunValidator.js

@@ -0,0 +1,261 @@
+'use strict';
+
+const exceptions = require('../util/errors.js'),
+    helpers = require('../util/helpers.js'),
+    responseResolver = require('./responseResolver.js'),
+    inMemoryImpostersRepository = require('./inMemoryImpostersRepository.js'),
+    predicates = require('./predicates.js'),
+    combinators = require('../util/combinators.js'),
+    behaviors = require('./behaviors.js');
+
+/**
+ * Validating a syntactically correct imposter creation statically is quite difficult.
+ * This module validates dynamically by running test requests through each predicate and each stub
+ * to see if it throws an error.  A valid request is one that passes the dry run error-free.
+ * @module
+ */
+
+/**
+ * Creates the validator
+ * @param {Object} options - Configuration for the validator
+ * @param {Object} options.testRequest - The protocol-specific request used for each dry run
+ * @param {Object} options.testProxyResponse - The protocol-specific fake response from a proxy call
+ * @param {boolean} options.allowInjection - Whether JavaScript injection is allowed or not
+ * @param {function} options.additionalValidation - A function that performs protocol-specific validation
+ * @returns {Object}
+ */
+function create (options) {
+    function stubForResponse (originalStub, response, withPredicates) {
+        // Each dry run only validates the first response, so we
+        // explode the number of stubs to dry run each response separately
+        const clonedStub = helpers.clone(originalStub),
+            clonedResponse = helpers.clone(response);
+        clonedStub.responses = [clonedResponse];
+
+        // If the predicates don't match the test request, we won't dry run
+        // the response (although the predicates will be dry run).  We remove
+        // the predicates to account for this scenario.
+        if (!withPredicates) {
+            delete clonedStub.predicates;
+        }
+
+        return clonedStub;
+    }
+
+    function reposToTestFor (stub) {
+        // Test with predicates (likely won't match) to make sure predicates don't blow up
+        // Test without predicates (always matches) to make sure response doesn't blow up
+        const stubsToValidateWithPredicates = stub.responses.map(response => stubForResponse(stub, response, true)),
+            stubsToValidateWithoutPredicates = stub.responses.map(response => stubForResponse(stub, response, false)),
+            stubsToValidate = stubsToValidateWithPredicates.concat(stubsToValidateWithoutPredicates),
+            promises = stubsToValidate.map(async stubToValidate => {
+                const stubRepository = inMemoryImpostersRepository.create().createStubsRepository();
+                await stubRepository.add(stubToValidate);
+                return stubRepository;
+            });
+
+        return Promise.all(promises);
+    }
+
+    // We call map before calling every so we make sure to call every
+    // predicate during dry run validation rather than short-circuiting
+    function trueForAll (list, predicate) {
+        return list.map(predicate).every(result => result);
+    }
+
+    function findFirstMatch (stubRepository, request, encoding, logger) {
+        const filter = stubPredicates => {
+            return trueForAll(stubPredicates,
+                predicate => predicates.evaluate(predicate, request, encoding, logger, {}));
+        };
+
+        return stubRepository.first(filter);
+    }
+
+    function resolverFor (stubRepository) {
+        // We can get a better test (running behaviors on proxied result) if the protocol gives
+        // us a testProxyResult
+        if (options.testProxyResponse) {
+            const dryRunProxy = { to: proxyTo => {
+                if (proxyTo === undefined) {
+                    throw exceptions.ValidationError('Missing to');
+                }
+                const url = new URL(proxyTo);
+                if (url.protocol.indexOf('http') === 0 && url.pathname !== '/') {
+                    throw exceptions.ValidationError(`proxy.to must not contain a path '${url.pathname}'`);
+                }
+                return Promise.resolve(options.testProxyResponse);
+            } };
+            return responseResolver.create(stubRepository, dryRunProxy);
+        }
+        else {
+            return responseResolver.create(stubRepository, undefined, 'URL');
+        }
+    }
+
+    async function dryRunSingleRepo (stubRepository, encoding, dryRunLogger) {
+        const match = await findFirstMatch(stubRepository, options.testRequest, encoding, dryRunLogger),
+            responseConfig = await match.stub.nextResponse();
+
+        return resolverFor(stubRepository).resolve(responseConfig, options.testRequest, dryRunLogger, {});
+    }
+
+    async function dryRun (stub, encoding, logger) {
+        options.testRequest = options.testRequest || {};
+        options.testRequest.isDryRun = true;
+
+        const dryRunLogger = {
+                debug: combinators.noop,
+                info: combinators.noop,
+                warn: combinators.noop,
+                error: logger.error
+            },
+            dryRunRepositories = await reposToTestFor(stub),
+            dryRuns = dryRunRepositories.map(stubRepository => dryRunSingleRepo(stubRepository, encoding, dryRunLogger));
+
+        return Promise.all(dryRuns);
+    }
+
+    async function addDryRunErrors (stub, encoding, errors, logger) {
+        try {
+            await dryRun(stub, encoding, logger);
+        }
+        catch (reason) {
+            reason.source = reason.source || JSON.stringify(stub);
+            errors.push(reason);
+        }
+    }
+
+    function hasPredicateGeneratorInjection (response) {
+        return response.proxy && response.proxy.predicateGenerators &&
+            response.proxy.predicateGenerators.some(generator => generator.inject);
+    }
+
+    function hasBehavior (response, type, valueFilter) {
+        if (typeof valueFilter === 'undefined') {
+            valueFilter = () => true;
+        }
+        return (response.behaviors || []).some(behavior => {
+            return typeof behavior[type] !== 'undefined' && valueFilter(behavior[type]);
+        });
+    }
+
+    function hasStubInjection (stub) {
+        const hasResponseInjections = stub.responses.some(response => {
+                const hasDecorator = hasBehavior(response, 'decorate'),
+                    hasWaitFunction = hasBehavior(response, 'wait', value => typeof value === 'string');
+
+                return response.inject || hasDecorator || hasWaitFunction || hasPredicateGeneratorInjection(response);
+            }),
+            hasPredicateInjections = Object.keys(stub.predicates || {}).some(predicate => stub.predicates[predicate].inject),
+            hasAddDecorateBehaviorInProxy = stub.responses.some(response => response.proxy && response.proxy.addDecorateBehavior);
+        return hasResponseInjections || hasPredicateInjections || hasAddDecorateBehaviorInProxy;
+    }
+
+    function hasShellExecution (stub) {
+        return stub.responses.some(response => hasBehavior(response, 'shellTransform'));
+    }
+
+    function addStubInjectionErrors (stub, errors) {
+        if (options.allowInjection) {
+            return;
+        }
+
+        if (hasStubInjection(stub)) {
+            errors.push(exceptions.InjectionError(
+                'JavaScript injection is not allowed unless mb is run with the --allowInjection flag', { source: stub }));
+        }
+        if (hasShellExecution(stub)) {
+            errors.push(exceptions.InjectionError(
+                'Shell execution is not allowed unless mb is run with the --allowInjection flag', { source: stub }));
+        }
+    }
+
+    function addAllTo (values, additionalValues) {
+        additionalValues.forEach(value => {
+            values.push(value);
+        });
+    }
+
+    function addRepeatErrorsTo (errors, response) {
+        const repeat = response.repeat,
+            type = typeof repeat,
+            error = exceptions.ValidationError('"repeat" field must be an integer greater than 0', {
+                source: response
+            });
+
+        if (['undefined', 'number', 'string'].indexOf(type) < 0) {
+            errors.push(error);
+        }
+        if ((type === 'string' && parseInt(repeat) <= 0) || (type === 'number' && repeat <= 0)) {
+            errors.push(error);
+        }
+    }
+
+    function addBehaviorErrors (stub, errors) {
+        stub.responses.forEach(response => {
+            addAllTo(errors, behaviors.validate(response.behaviors));
+            addRepeatErrorsTo(errors, response);
+        });
+    }
+
+    async function errorsForStub (stub, encoding, logger) {
+        const errors = [];
+
+        if (!Array.isArray(stub.responses) || stub.responses.length === 0) {
+            errors.push(exceptions.ValidationError("'responses' must be a non-empty array", {
+                source: stub
+            }));
+        }
+        else {
+            addStubInjectionErrors(stub, errors);
+            addBehaviorErrors(stub, errors);
+        }
+
+        if (errors.length === 0) {
+            // no sense in dry-running if there are already problems;
+            // it will just add noise to the errors
+            await addDryRunErrors(stub, encoding, errors, logger);
+        }
+
+        return errors;
+    }
+
+    function errorsForRequest (request) {
+        const errors = [],
+            hasRequestInjection = request.endOfRequestResolver && request.endOfRequestResolver.inject;
+
+        if (!options.allowInjection && hasRequestInjection) {
+            errors.push(exceptions.InjectionError(
+                'JavaScript injection is not allowed unless mb is run with the --allowInjection flag',
+                { source: request.endOfRequestResolver }));
+        }
+        return errors;
+    }
+
+    /**
+     * Validates that the imposter creation is syntactically valid
+     * @memberOf module:models/dryRunValidator#
+     * @param {Object} request - The request containing the imposter definition
+     * @param {Object} logger - The logger
+     * @returns {Object} Promise resolving to an object containing isValid and an errors array
+     */
+    async function validate (request, logger) {
+        const stubs = request.stubs || [],
+            encoding = request.mode === 'binary' ? 'base64' : 'utf8',
+            validations = stubs.map(stub => errorsForStub(stub, encoding, logger));
+
+        validations.push(Promise.resolve(errorsForRequest(request)));
+        if (typeof options.additionalValidation === 'function') {
+            validations.push(Promise.resolve(options.additionalValidation(request)));
+        }
+
+        const errorsForAllStubs = await Promise.all(validations),
+            allErrors = errorsForAllStubs.reduce((stubErrors, accumulator) => accumulator.concat(stubErrors), []);
+        return { isValid: allErrors.length === 0, errors: allErrors };
+    }
+
+    return { validate };
+}
+
+module.exports = { create };