@mbtest/mountebank 2.9.2-beta.9050

package/src/models/responseResolver.js

@@ -0,0 +1,398 @@
+'use strict';
+
+const prometheus = require('prom-client'),
+    stringify = require('safe-stable-stringify'),
+    helpers = require('../util/helpers.js'),
+    compatibility = require('./compatibility.js'),
+    exceptions = require('../util/errors.js'),
+    xpath = require('./xpath.js'),
+    jsonpath = require('./jsonpath.js'),
+    behaviors = require('./behaviors.js');
+
+/**
+ * Determines the response for a stub based on the user-provided response configuration
+ * @module
+ */
+
+const metrics = {
+    proxyDuration: new prometheus.Histogram({
+        name: 'mb_proxy_duration_seconds',
+        help: 'Time it takes to get the response from the downstream service',
+        buckets: [0.1, 0.2, 0.5, 1, 3, 5, 10, 30],
+        labelNames: ['imposter']
+    }),
+    proxyCount: new prometheus.Counter({
+        name: 'mb_proxy_total',
+        help: 'Number of times a request was proxied to a downstream service',
+        labelNames: ['imposter']
+    })
+};
+
+/**
+ * Creates the resolver
+ * @param {Object} stubs - The stubs repository
+ * @param {Object} proxy - The protocol-specific proxy implementation
+ * @param {String} callbackURL - The protocol callback URL for response resolution
+ * @returns {Object}
+ */
+function create (stubs, proxy, callbackURL) {
+    // injectState is deprecated in favor of imposterState, but kept for backwards compatibility
+    const injectState = {}, // eslint-disable-line no-unused-vars
+        pendingProxyResolutions = {},
+        inProcessProxy = Boolean(proxy);
+    let nextProxyResolutionKey = 0;
+
+    function inject (request, fn, logger, imposterState) {
+        if (request.isDryRun) {
+            return Promise.resolve({});
+        }
+
+        return new Promise((done, reject) => {
+            // Leave parameters for older interface
+            const injected = `(${fn})(config, injectState, logger, done, imposterState);`,
+                config = {
+                    request: helpers.clone(request),
+                    state: imposterState,
+                    logger: logger,
+                    callback: done
+                };
+
+            compatibility.downcastInjectionConfig(config);
+
+            try {
+                const response = eval(injected);
+                if (helpers.defined(response)) {
+                    done(response);
+                }
+            }
+            catch (error) {
+                logger.error(`injection X=> ${error}`);
+                logger.error(`    full source: ${JSON.stringify(injected)}`);
+                logger.error(`    config.request: ${JSON.stringify(config.request)}`);
+                logger.error(`    config.state: ${JSON.stringify(config.state)}`);
+                reject(exceptions.InjectionError('invalid response injection', {
+                    source: injected,
+                    data: error.message
+                }));
+            }
+        });
+    }
+
+    function selectionValue (nodes) {
+        if (!helpers.defined(nodes)) {
+            return '';
+        }
+        else if (!Array.isArray(nodes)) {
+            return nodes; // booleans and counts
+        }
+        else {
+            return (nodes.length === 1) ? nodes[0] : nodes;
+        }
+    }
+
+    function xpathValue (xpathConfig, possibleXML, logger) {
+        const nodes = xpath.select(xpathConfig.selector, xpathConfig.ns, possibleXML, logger);
+
+        return selectionValue(nodes);
+    }
+
+    function jsonpathValue (jsonpathConfig, possibleJSON, logger) {
+        const nodes = jsonpath.select(jsonpathConfig.selector, possibleJSON, logger);
+
+        return selectionValue(nodes);
+    }
+
+    function buildDeepEqual (request, fieldName, predicateGenerators, valueOf) {
+        if (!predicateGenerators.ignore) {
+            return valueOf(request[fieldName]);
+        }
+        const objFilter = helpers.objFilter;
+        return valueOf(objFilter(request[fieldName], predicateGenerators.ignore[fieldName]));
+    }
+
+    function buildEquals (request, matchers, valueOf) {
+        const result = {},
+            isObject = helpers.isObject;
+
+        Object.keys(matchers).forEach(key => {
+            if (isObject(request[key])) {
+                result[key] = buildEquals(request[key], matchers[key], valueOf);
+            }
+            else {
+                result[key] = valueOf(request[key]);
+            }
+        });
+        return result;
+    }
+
+    const path = [];
+
+    function buildExists (request, fieldName, matchers, initialRequest) {
+        const isObject = helpers.isObject,
+            setDeep = helpers.setDeep;
+        Object.keys(request).forEach(key => {
+            path.push(key);
+            if (isObject(request[key])) {
+                buildExists(request[key], fieldName, matchers[key], initialRequest);
+            }
+            else {
+                const booleanValue = (typeof fieldName !== 'undefined' && fieldName !== null && fieldName !== '');
+                setDeep(initialRequest, path, booleanValue);
+            }
+        });
+        return initialRequest;
+    }
+
+    function predicatesFor (request, matchers, logger) {
+        const predicates = [];
+
+        matchers.forEach(matcher => {
+            if (matcher.inject) {
+                // eslint-disable-next-line no-unused-vars
+                const config = { request, logger },
+                    injected = `(${matcher.inject})(config);`;
+
+                try {
+                    predicates.push(...eval(injected));
+                }
+                catch (error) {
+                    logger.error(`injection X=> ${error}`);
+                    logger.error(`    source: ${JSON.stringify(injected)}`);
+                    logger.error(`    request: ${JSON.stringify(request)}`);
+                    throw exceptions.InjectionError('invalid predicateGenerator injection', { source: injected, data: error.message });
+                }
+                return;
+            }
+
+            const basePredicate = {};
+            let hasPredicateOperator = false;
+            let predicateOperator; // eslint-disable-line no-unused-vars
+            let valueOf = field => field;
+
+            // Add parameters
+            Object.keys(matcher).forEach(key => {
+                if (key !== 'matches' && key !== 'predicateOperator' && key !== 'ignore') {
+                    basePredicate[key] = matcher[key];
+                }
+                if (key === 'xpath') {
+                    valueOf = field => xpathValue(matcher.xpath, field, logger);
+                }
+                else if (key === 'jsonpath') {
+                    valueOf = field => jsonpathValue(matcher.jsonpath, field, logger);
+                }
+                else if (key === 'predicateOperator') {
+                    hasPredicateOperator = true;
+                }
+            });
+
+            Object.keys(matcher.matches).forEach(fieldName => {
+                const matcherValue = matcher.matches[fieldName],
+                    predicate = helpers.clone(basePredicate);
+
+                if (matcherValue === true && hasPredicateOperator === false) {
+                    predicate.deepEquals = {};
+                    predicate.deepEquals[fieldName] = buildDeepEqual(request, fieldName, matcher, valueOf);
+                }
+                else if (hasPredicateOperator === true && matcher.predicateOperator === 'exists') {
+                    predicate[matcher.predicateOperator] = buildExists(request, fieldName, matcherValue, request);
+                }
+                else if (hasPredicateOperator === true && matcher.predicateOperator !== 'exists') {
+                    predicate[matcher.predicateOperator] = valueOf(request);
+                }
+                else {
+                    predicate.equals = {};
+                    predicate.equals[fieldName] = buildEquals(request[fieldName], matcherValue, valueOf);
+                }
+
+                predicates.push(predicate);
+            });
+        });
+
+        return predicates;
+    }
+
+    function deepEqual (obj1, obj2) {
+        return stringify(obj1) === stringify(obj2);
+    }
+
+    function newIsResponse (response, proxyConfig) {
+        const result = { is: response },
+            addBehaviors = [];
+
+        if (proxyConfig.addWaitBehavior && response._proxyResponseTime) {
+            addBehaviors.push({ wait: response._proxyResponseTime });
+        }
+        if (proxyConfig.addDecorateBehavior) {
+            addBehaviors.push({ decorate: proxyConfig.addDecorateBehavior });
+        }
+
+        if (addBehaviors.length > 0) {
+            result.behaviors = addBehaviors;
+        }
+        return result;
+    }
+
+    async function recordProxyAlways (newPredicates, newResponse, responseConfig) {
+        const filter = stubPredicates => deepEqual(newPredicates, stubPredicates),
+            index = await responseConfig.stubIndex(),
+            match = await stubs.first(filter, index + 1);
+
+        if (match.success) {
+            return match.stub.addResponse(newResponse);
+        }
+        else {
+            return stubs.add({ predicates: newPredicates, responses: [newResponse] });
+        }
+    }
+
+    async function recordProxyResponse (responseConfig, request, response, logger) {
+        const newPredicates = predicatesFor(request, responseConfig.proxy.predicateGenerators || [], logger),
+            newResponse = newIsResponse(response, responseConfig.proxy);
+
+        if (responseConfig.proxy.mode === 'proxyOnce') {
+            const index = await responseConfig.stubIndex();
+            await stubs.insertAtIndex({ predicates: newPredicates, responses: [newResponse] }, index);
+        }
+        else if (responseConfig.proxy.mode === 'proxyAlways') {
+            await recordProxyAlways(newPredicates, newResponse, responseConfig);
+        }
+    }
+
+    async function proxyAndRecord (responseConfig, request, logger, requestDetails, imposterState) {
+        const startTime = new Date(),
+            observeProxyDuration = metrics.proxyDuration.startTimer();
+
+        metrics.proxyCount.inc({ imposter: logger.scopePrefix });
+
+        if (['proxyOnce', 'proxyAlways', 'proxyTransparent'].indexOf(responseConfig.proxy.mode) < 0) {
+            responseConfig.proxy.mode = 'proxyOnce';
+        }
+
+        if (inProcessProxy) {
+            const response = await proxy.to(responseConfig.proxy.to, request, responseConfig.proxy, requestDetails);
+            observeProxyDuration({ imposter: logger.scopePrefix });
+            response._proxyResponseTime = new Date() - startTime;
+
+            // Run behaviors here to persist decorated response
+            const transformed = await behaviors.execute(request, response, responseConfig.behaviors, logger, imposterState);
+            await recordProxyResponse(responseConfig, request, transformed, logger);
+            return transformed;
+        }
+        else {
+            pendingProxyResolutions[nextProxyResolutionKey] = {
+                responseConfig: responseConfig,
+                request: request,
+                requestDetails: requestDetails,
+                observeProxyDuration: observeProxyDuration,
+                startTime: startTime
+            };
+            nextProxyResolutionKey += 1;
+            return {
+                proxy: responseConfig.proxy,
+                request: request,
+                callbackURL: `${callbackURL}/${nextProxyResolutionKey - 1}`
+            };
+        }
+    }
+
+    function processResponse (responseConfig, request, logger, imposterState, requestDetails) {
+        if (responseConfig.is) {
+            // Clone to prevent accidental state changes downstream
+            return Promise.resolve(helpers.clone(responseConfig.is));
+        }
+        else if (responseConfig.proxy) {
+            return proxyAndRecord(responseConfig, request, logger, requestDetails, imposterState);
+        }
+        else if (responseConfig.inject) {
+            return inject(request, responseConfig.inject, logger, imposterState);
+        }
+        else if (responseConfig.fault) {
+            // Clone to prevent accidental state changes downstream
+            return Promise.resolve(helpers.clone(responseConfig));
+        }
+        else {
+            return Promise.reject(exceptions.ValidationError('unrecognized response type',
+                { source: helpers.clone(responseConfig) }));
+        }
+    }
+
+    // eslint-disable-next-line complexity
+    function hasMultipleTypes (responseConfig) {
+        return (responseConfig.is && responseConfig.proxy) ||
+               (responseConfig.is && responseConfig.inject) ||
+               (responseConfig.proxy && responseConfig.inject) ||
+               (responseConfig.fault && responseConfig.proxy) ||
+               (responseConfig.fault && responseConfig.is) ||
+               (responseConfig.fault && responseConfig.inject);
+    }
+
+    /**
+     * Resolves a single response
+     * @memberOf module:models/responseResolver#
+     * @param {Object} responseConfig - The API-provided response configuration
+     * @param {Object} request - The protocol-specific request object
+     * @param {Object} logger - The logger
+     * @param {Object} imposterState - The current state for the imposter
+     * @param {Object} options - Additional options not carried with the request
+     * @returns {Object} - Promise resolving to the response
+     */
+    async function resolve (responseConfig, request, logger, imposterState, options) {
+        if (hasMultipleTypes(responseConfig)) {
+            return Promise.reject(exceptions.ValidationError('each response object must have only one response type',
+                { source: responseConfig }));
+        }
+
+        let response = await processResponse(responseConfig, helpers.clone(request), logger, imposterState, options);
+
+        // We may have already run the behaviors in the proxy call to persist the decorated response
+        // in the new stub. If so, we need to ensure we don't re-run it
+        // If we're doing fault simulation there's no need to execute the behaviours
+        if (!responseConfig.proxy && !responseConfig.fault) {
+            response = await behaviors.execute(request, response, responseConfig.behaviors, logger, imposterState);
+        }
+
+        if (inProcessProxy) {
+            return response;
+        }
+        else {
+            return responseConfig.proxy ? response : { response };
+        }
+    }
+
+    /**
+     * Finishes the protocol implementation dance for proxy. On the first call,
+     * mountebank selects a JSON proxy response and sends it to the protocol implementation,
+     * saving state indexed by proxyResolutionKey. The protocol implementation sends the proxy
+     * to the downstream system and calls mountebank again with the response so mountebank
+     * can save it and add behaviors
+     * @memberOf module:models/responseResolver#
+     * @param {Object} proxyResponse - the proxy response from the protocol implementation
+     * @param {Number} proxyResolutionKey - the key into the saved proxy state
+     * @param {Object} logger - the logger
+     * @param {Object} imposterState - the user controlled state variable
+     * @returns {Object} - Promise resolving to the response
+     */
+    async function resolveProxy (proxyResponse, proxyResolutionKey, logger, imposterState) {
+        const pendingProxyConfig = pendingProxyResolutions[proxyResolutionKey];
+
+        if (pendingProxyConfig) {
+            pendingProxyConfig.observeProxyDuration({ imposter: logger.scopePrefix });
+            proxyResponse._proxyResponseTime = new Date() - pendingProxyConfig.startTime;
+
+            const response = await behaviors.execute(pendingProxyConfig.request, proxyResponse,
+                pendingProxyConfig.responseConfig.behaviors, logger, imposterState);
+            await recordProxyResponse(pendingProxyConfig.responseConfig, pendingProxyConfig.request, response, logger);
+            delete pendingProxyResolutions[proxyResolutionKey];
+            return response;
+        }
+        else {
+            logger.error('Invalid proxy resolution key: ' + proxyResolutionKey);
+            return Promise.reject(exceptions.MissingResourceError('invalid proxy resolution key',
+                { source: `${callbackURL}/${proxyResolutionKey}` }));
+        }
+    }
+
+    return { resolve, resolveProxy };
+}
+
+module.exports = { create };

package/src/models/smtp/index.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const config = JSON.parse(process.argv[2]),
+    smtpServer = require('./smtpServer'),
+    mbConnection = require('../mbConnection').create(config);
+
+smtpServer.create(config, mbConnection.logger(), mbConnection.getResponse).then(server => {
+    mbConnection.setPort(server.port);
+
+    const metadata = server.metadata;
+    metadata.port = server.port;
+    console.log(JSON.stringify(metadata));
+}).catch(error => {
+    console.error(JSON.stringify(error));
+    process.exit(1); // eslint-disable-line no-process-exit
+});

package/src/models/smtp/smtpRequest.js

@@ -0,0 +1,60 @@
+'use strict';
+
+/**
+ * Transforms an SMTP request into the simplified API-friendly mountebank request
+ * @module
+ */
+
+const mailParser = require('mailparser');
+
+function addressValues (addresses) {
+    // mailparser sometimes returns an array, sometimes an object, so we have to normalize
+    if (!addresses) {
+        addresses = [];
+    }
+    if (!Array.isArray(addresses)) {
+        addresses = [addresses];
+    }
+    return addresses.map(address => address.value[0]);
+}
+
+function transform (session, email) {
+    return {
+        requestFrom: session.remoteAddress,
+        ip: session.remoteAddress,
+        envelopeFrom: session.envelope.mailFrom.address,
+        envelopeTo: session.envelope.rcptTo.map(value => value.address),
+        from: email.from.value[0],
+        to: addressValues(email.to),
+        cc: addressValues(email.cc),
+        bcc: addressValues(email.bcc),
+        subject: email.subject,
+        priority: email.priority || 'normal',
+        references: email.references || [],
+        inReplyTo: email.inReplyTo || [],
+        text: (email.text || '').trim(),
+        html: (email.html || '').trim(),
+        attachments: email.attachments || []
+    };
+}
+
+/**
+ * Transforms the raw SMTP request into the mountebank request
+ * @param {Object} request - The raw SMTP request
+ * @returns {Object}
+ */
+function createFrom (request) {
+    return new Promise((resolve, reject) => {
+        const simpleParser = mailParser.simpleParser;
+        simpleParser(request.source, (err, mail) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve(transform(request.session, mail));
+            }
+        });
+    });
+}
+
+module.exports = { createFrom };

package/src/models/smtp/smtpServer.js

@@ -0,0 +1,109 @@
+'use strict';
+
+const smtpServer = require('smtp-server'),
+    helpers = require('../../util/helpers.js'),
+    errors = require('../../util/errors.js'),
+    smtpRequest = require('./smtpRequest.js');
+
+/**
+ * Represents an smtp imposter
+ * @module
+ */
+
+function create (options, logger, responseFn) {
+    const connections = {},
+        SMTPServer = smtpServer.SMTPServer,
+        server = new SMTPServer({
+            maxAllowedUnauthenticatedCommands: 1000,
+            disableReverseLookup: true,
+            authOptional: true,
+            onConnect (socket, callback) {
+                const name = helpers.socketName(socket);
+
+                logger.debug('%s ESTABLISHED', name);
+
+                if (socket.on) {
+                    connections[name] = socket;
+
+                    socket.on('error', error => {
+                        logger.error('%s transmission error X=> %s', name, JSON.stringify(error));
+                    });
+
+                    socket.on('end', () => {
+                        logger.debug('%s LAST-ACK', name);
+                    });
+
+                    socket.on('close', () => {
+                        logger.debug('%s CLOSED', name);
+                        delete connections[name];
+                    });
+                }
+                return callback();
+            },
+            onData (stream, socket, callback) {
+                const request = { session: socket, source: stream, callback: callback },
+                    clientName = helpers.socketName(socket);
+
+                try {
+                    smtpRequest.createFrom(request).then(simpleRequest => {
+                        logger.info(`${clientName} => Envelope from: ${JSON.stringify(simpleRequest.from)} to: ${JSON.stringify(simpleRequest.to)}`);
+                        logger.debug('%s => %s', clientName, JSON.stringify(simpleRequest));
+                        return responseFn(simpleRequest);
+                    }).then(response => {
+                        if (response) {
+                            logger.debug('%s <= %s', clientName, JSON.stringify(response));
+                        }
+                        return Promise.resolve(true);
+                    }).then(() => Promise.resolve(request.callback()))
+                        .catch(error => {
+                            logger.error('%s X=> %s', clientName, JSON.stringify(errors.details(error)));
+                        });
+                }
+                catch (error) {
+                    logger.error('%s X=> %s', clientName, JSON.stringify(errors.details(error)));
+                }
+            }
+        });
+
+    return new Promise((resolve, reject) => {
+        server.on('error', error => {
+            if (error.errno === 'EADDRINUSE') {
+                reject(errors.ResourceConflictError(`Port ${options.port} is already in use`));
+            }
+            else if (error.errno === 'EACCES') {
+                reject(errors.InsufficientAccessError());
+            }
+            else {
+                reject(error);
+            }
+        });
+
+        server.listen(options.port || 0, options.host, () => {
+            resolve({
+                port: server.server.address().port,
+                metadata: {},
+                close: callback => {
+                    server.close(callback);
+                    Object.keys(connections).forEach(socket => {
+                        connections[socket].destroy();
+                    });
+                },
+                proxy: {},
+                encoding: 'utf8'
+            });
+        });
+    });
+}
+
+module.exports = {
+    testRequest: {
+        from: 'test@test.com',
+        to: ['test@test.com'],
+        subject: 'Test',
+        text: 'Test'
+    },
+    testProxyResponse: {},
+    create: create,
+    validate: undefined
+};
+

package/src/models/tcp/index.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const config = JSON.parse(process.argv[2]),
+    tcpServer = require('./tcpServer.js'),
+    tcpProxy = require('./tcpProxy.js'),
+    mbConnection = require('../mbConnection.js').create(config);
+
+tcpServer.create(config, mbConnection.logger(), mbConnection.getResponse).then(server => {
+    mbConnection.setPort(server.port);
+    mbConnection.setProxy(tcpProxy.create(mbConnection.logger(), server.encoding, server.isEndOfRequest));
+
+    const metadata = server.metadata;
+    metadata.port = server.port;
+    console.log(JSON.stringify(metadata));
+}).catch(error => {
+    console.error(JSON.stringify(error));
+    process.exit(1); // eslint-disable-line no-process-exit
+});