@mbtest/mountebank 2.9.2-beta.9050

package/src/models/tcp/tcpProxy.js

@@ -0,0 +1,110 @@
+'use strict';
+
+const net = require('net'),
+    errors = require('../../util/errors.js');
+
+/**
+ * Represents the tcp proxy implementation
+ * @module
+ */
+
+/**
+ * Creates the proxy
+ * @param {Object} logger - The logger
+ * @param {string} encoding - utf8 or base64, depending on if the destination expects text or binary
+ * @param {Function} isEndOfRequest - the function defining a logical request
+ * @returns {Object}
+ */
+function create (logger, encoding, isEndOfRequest) {
+
+    if (typeof isEndOfRequest === 'undefined') {
+        isEndOfRequest = () => true; // defaults to a packet boundary
+    }
+
+    function socketName (socket) {
+        return `${socket.host}:${socket.port}`;
+    }
+
+    function format (request) {
+        return request.data.toString(encoding);
+    }
+
+    function connectionInfoFor (proxyDestination) {
+        const parts = new URL(proxyDestination);
+
+        if (parts.protocol !== 'tcp:') {
+            throw errors.InvalidProxyError('Unable to proxy to any protocol other than tcp',
+                { source: proxyDestination });
+        }
+        return { host: parts.hostname, port: parts.port };
+    }
+
+    /**
+     * Proxies a tcp request to the destination
+     * @param {string} proxyDestination - The URL to proxy to (e.g. tcp://127.0.0.1:3535)
+     * @param {Object} originalRequest - The tcp request to forward
+     * @param {Object} options - Proxy options
+     * @param {Boolean} options.keepalive - Whether to keep the connection alive or not
+     * @returns {Object} - A promise resolving to the response
+     */
+    function to (proxyDestination, originalRequest, options = {}) {
+        return new Promise((resolve, reject) => {
+            try {
+                const proxyName = socketName(connectionInfoFor(proxyDestination)),
+                    log = (direction, what) => {
+                        logger.debug('Proxy %s %s %s %s %s',
+                            originalRequest.requestFrom, direction, JSON.stringify(format(what)), direction, proxyName);
+                    },
+                    buffer = Buffer.from(originalRequest.data, encoding),
+                    socket = net.connect(connectionInfoFor(proxyDestination), () => {
+                        socket.write(buffer);
+                    }),
+                    packets = [];
+
+                log('=>', originalRequest);
+
+                socket.on('end', () => {
+                    logger.debug('%s LAST-ACK', proxyName);
+                });
+
+                socket.on('close', () => {
+                    logger.debug('%s CLOSED', proxyName);
+                });
+
+                socket.on('data', data => {
+                    packets.push(data);
+                    const requestBuffer = Buffer.concat(packets);
+                    if (isEndOfRequest(requestBuffer, logger)) {
+                        if (!options.keepalive) {
+                            socket.end();
+                        }
+                        const response = { data: requestBuffer.toString(encoding) };
+                        log('<=', response);
+                        resolve(response);
+                    }
+                });
+
+                socket.once('error', error => {
+                    logger.error(`Proxy ${proxyName} transmission error X=> ${JSON.stringify(error)}`);
+
+                    if (error.code === 'ENOTFOUND' || error.code === 'EAI_AGAIN') {
+                        reject(errors.InvalidProxyError(`Cannot resolve ${JSON.stringify(proxyDestination)}`));
+                    }
+                    else if (error.code === 'ECONNREFUSED') {
+                        reject(errors.InvalidProxyError(`Unable to connect to ${JSON.stringify(proxyDestination)}`));
+                    }
+                    else {
+                        reject(error);
+                    }
+                });
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+    }
+
+    return { to };
+}
+
+module.exports = { create };

package/src/models/tcp/tcpRequest.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const helpers = require('../../util/helpers.js');
+
+/**
+ * Transforms a raw tcp request into the API-friendly representation of one
+ * @module
+ */
+
+/**
+ * Transforms the raw tcp request into a mountebank tcp request
+ * @param {Object} request - The raw tcp request
+ * @returns {Object} - A promise resolving to the mountebank tcp request
+ */
+function createFrom (request) {
+    return Promise.resolve({
+        requestFrom: helpers.socketName(request.socket),
+        ip: request.socket.remoteAddress,
+        data: request.data
+    });
+}
+
+module.exports = { createFrom };

package/src/models/tcp/tcpServer.js

@@ -0,0 +1,156 @@
+'use strict';
+const net = require('net'),
+    helpers = require('../../util/helpers.js'),
+    tcpRequest = require('./tcpRequest.js'),
+    tcpProxy = require('./tcpProxy.js'),
+    tcpValidator = require('./tcpValidator.js'),
+    errors = require('../../util/errors.js');
+
+/**
+ * Represents a tcp imposter
+ * @module
+ */
+
+function create (options, logger, responseFn) {
+    const mode = options.mode ? options.mode : 'text',
+        encoding = mode === 'binary' ? 'base64' : 'utf8',
+        server = net.createServer(),
+        connections = {},
+        defaultResponse = options.defaultResponse || { data: '' };
+
+    // Used to determine logical end of request; defaults to one packet but
+    // changeable through injection
+    function isEndOfRequest (requestData) {
+        if (!options.endOfRequestResolver || !options.endOfRequestResolver.inject) {
+            return true;
+        }
+
+        const injected = `(${options.endOfRequestResolver.inject})(requestData, logger)`;
+
+        if (mode === 'text') {
+            requestData = requestData.toString('utf8');
+        }
+
+        try {
+            return eval(injected);
+        }
+        catch (error) {
+            logger.error(`injection X=> ${error}`);
+            logger.error(`    full source: ${JSON.stringify(injected)}`);
+            logger.error(`    requestData: ${JSON.stringify(requestData)}`);
+            return false;
+        }
+    }
+
+    // eslint-disable-next-line complexity
+    async function respond (payload, request, clientName, socket) {
+        let formattedRequestData = payload.toString(encoding);
+        if (formattedRequestData.length > 20) {
+            formattedRequestData = formattedRequestData.substring(0, 20) + '...';
+        }
+        logger.info('%s => %s', clientName, formattedRequestData);
+
+        try {
+            // Translate network request to JSON
+            const jsonRequest = await tcpRequest.createFrom(request);
+            logger.debug('%s => %s', clientName, JSON.stringify(jsonRequest.data.toString(encoding)));
+
+            // call mountebank with JSON request
+            const mbResponse = await responseFn(jsonRequest),
+                processedResponse = mbResponse.data || defaultResponse.data,
+                buffer = Buffer.isBuffer(processedResponse)
+                    ? processedResponse
+                    : Buffer.from(processedResponse, encoding);
+
+            if (mbResponse.blocked) {
+                socket.destroy();
+                return;
+            }
+
+            if (helpers.simulateFault(socket, mbResponse.fault, logger)) {
+                return;
+            }
+
+            if (buffer.length > 0) {
+                socket.write(buffer);
+                logger.debug('%s <= %s', clientName, JSON.stringify(buffer.toString(encoding)));
+            }
+        }
+        catch (error) {
+            logger.error('%s X=> %s', clientName, JSON.stringify(errors.details(error)));
+            socket.write(JSON.stringify({ errors: [error] }), 'utf8');
+        }
+    }
+
+    server.on('connection', socket => {
+        let packets = [];
+        const clientName = helpers.socketName(socket);
+
+        logger.debug('%s ESTABLISHED', clientName);
+
+        connections[clientName] = socket;
+
+        socket.on('error', error => {
+            logger.error('%s transmission error X=> %s', clientName, JSON.stringify(error));
+        });
+
+        socket.on('end', () => {
+            logger.debug('%s LAST-ACK', clientName);
+        });
+
+        socket.on('close', () => {
+            logger.debug('%s CLOSED', clientName);
+            delete connections[clientName];
+        });
+
+        socket.on('data', async data => {
+            packets.push(data);
+
+            const payload = Buffer.concat(packets),
+                request = { socket: socket, data: payload.toString(encoding) };
+
+            if (isEndOfRequest(payload)) {
+                packets = [];
+                await respond(payload, request, clientName, socket);
+            }
+        });
+    });
+
+    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);
+            }
+        });
+
+        // Bind the socket to a port (the || 0 bit auto-selects a port if one isn't provided)
+        server.listen(options.port || 0, options.host, () => {
+            resolve({
+                port: server.address().port,
+                metadata: { mode },
+                close: callback => {
+                    server.close(() => { callback(); });
+                    Object.keys(connections).forEach(socket => {
+                        connections[socket].destroy();
+                    });
+                },
+                proxy: tcpProxy.create(logger, encoding, isEndOfRequest),
+                encoding: encoding,
+                isEndOfRequest: isEndOfRequest
+            });
+        });
+    });
+}
+
+module.exports = {
+    testRequest: { data: 'test' },
+    testProxyResponse: { data: '' },
+    create: create,
+    validate: tcpValidator.validate
+};

package/src/models/tcp/tcpValidator.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const exceptions = require('../../util/errors.js');
+
+/**
+ * Additional tcp-specific validations
+ * @module
+ */
+
+function validate (request) {
+    const errors = [];
+
+    if (request.mode && ['text', 'binary'].indexOf(request.mode) < 0) {
+        errors.push(exceptions.ValidationError("'mode' must be one of ['text', 'binary']"));
+    }
+    return errors;
+}
+
+module.exports = { validate };

package/src/models/xpath.js

@@ -0,0 +1,95 @@
+'use strict';
+
+const xpath = require('xpath'),
+    xmlDom = require('@xmldom/xmldom'),
+    errors = require('../util/errors.js'),
+    helpers = require('../util/helpers.js');
+
+/**
+ * Shared logic for xpath selector
+ * @module
+ */
+
+function xpathSelect (selectFn, selector, doc) {
+    if (!helpers.defined(doc)) {
+        return [];
+    }
+
+    if (doc && doc.implementation) {
+        // Monkey patch due to some legacy case sensitivity check in xpath
+        // Couldn't find a way to patch xpath due to closures so patched the dom instead
+        const originalHasFeature = doc.implementation.hasFeature;
+        doc.implementation.hasFeature = (feature, version) => {
+            if (feature === 'HTML' && version === '2.0') {
+                return false;
+            }
+            else {
+                return originalHasFeature.apply(doc.implementation, [feature, version]);
+            }
+        };
+    }
+
+    try {
+        return selectFn(selector, doc);
+    }
+    catch (e) {
+        throw errors.ValidationError('malformed xpath predicate selector', {
+            source: selector,
+            inner: e
+        });
+    }
+}
+
+function nodeValue (node) {
+    if (node.nodeType === node.TEXT_NODE) {
+        return node.nodeValue;
+    }
+    else if (node.nodeType === node.ATTRIBUTE_NODE) {
+        return node.value;
+    }
+    else if (node.firstChild) {
+        // Converting to a string allows exists to return true if the node exists,
+        // even if there's no data
+        return String(node.firstChild.data);
+    }
+    else {
+        return String(node.data);
+    }
+}
+
+/**
+ * Returns xpath value(s) from given xml
+ * @param {String} selector - The xpath selector
+ * @param {Object} ns - The namespace map
+ * @param {String} possibleXML - the xml
+ * @param {Object} logger - Optional, used to log XML parsing errors
+ * @returns {Object}
+ */
+function select (selector, ns, possibleXML, logger) {
+    const DOMParser = xmlDom.DOMParser,
+        parser = new DOMParser({
+            errorHandler: (level, message) => {
+                const warn = (logger || {}).warn || (() => {});
+                warn('%s (source: %s)', message, JSON.stringify(possibleXML));
+            }
+        }),
+        doc = parser.parseFromString(possibleXML),
+        selectFn = xpath.useNamespaces(ns || {}),
+        result = xpathSelect(selectFn, selector, doc);
+    let nodeValues;
+
+    if (['number', 'boolean'].indexOf(typeof result) >= 0) {
+        return result;
+    }
+
+    nodeValues = result.map(nodeValue);
+
+    if (nodeValues.length === 0) {
+        return undefined;
+    }
+    else {
+        return nodeValues;
+    }
+}
+
+module.exports = { select };

package/src/mountebank.js

@@ -0,0 +1,245 @@
+'use strict';
+
+const express = require('express'),
+    cors = require('cors'),
+    promClient = require('prom-client'),
+    errorHandler = require('errorhandler'),
+    path = require('path'),
+    middleware = require('./util/middleware'),
+    thisPackage = require('../package.json'),
+    releases = require('../releases.json'),
+    helpers = require('./util/helpers.js'),
+    utilLogger = require('./util/logger.js'),
+    utilIp = require('./util/ip.js'),
+    protocolsModule = require('./models/protocols.js'),
+    imposterRepositoryModule = require('./models/impostersRepository.js'),
+    homeControllerModule = require('./controllers/homeController.js'),
+    impostersControllerModule = require('./controllers/impostersController.js'),
+    imposterControllerModule = require('./controllers/imposterController.js'),
+    logsControllerModule = require('./controllers/logsController.js'),
+    configControllerModule = require('./controllers/configController.js'),
+    feedControllerModule = require('./controllers/feedController.js');
+
+/**
+ * The entry point for mountebank.  This module creates the mountebank server,
+ * configures all middleware and manages all routing
+ * @module
+ */
+
+/**
+ * Creates the mountebank express application
+ * @param {object} options - The command line options
+ * @returns {Object} An object with a close method to stop the server
+ */
+
+function applyDefaults (options) {
+    // Minimal defaults to start bypassing the CLI (e.g. embedding in an express app)
+    const defaults = {
+        port: 2525,
+        ipWhitelist: ['*']
+    };
+    Object.keys(defaults).forEach(key => {
+        options[key] = typeof options[key] === 'undefined' ? defaults[key] : options[key];
+    });
+}
+
+async function createApp (options) {
+    applyDefaults(options);
+
+    const app = express(),
+        hostname = options.host || 'localhost',
+        baseURL = `http://${hostname}:${options.port}`,
+        logger = utilLogger.createLogger(options),
+        isAllowedConnection = utilIp.createIPVerification(options),
+        imposters = imposterRepositoryModule.create(options, logger),
+        protocols = protocolsModule.loadProtocols(options, baseURL, logger, isAllowedConnection, imposters),
+        homeController = homeControllerModule.create(releases),
+        impostersController = impostersControllerModule.create(
+            protocols, imposters, logger, options.allowInjection),
+        imposterController = imposterControllerModule.create(
+            protocols, imposters, logger, options.allowInjection),
+        logfile = options.log.transports.file ? options.log.transports.file.path : false,
+        logsController = logsControllerModule.create(logfile),
+        configController = configControllerModule.create(thisPackage.version, options),
+        feedController = feedControllerModule.create(releases),
+        validateImposterExists = middleware.createImposterValidator(imposters),
+        prometheus = promClient;
+
+    // Clear only matters when bound using directly in-process through JS rather than the CLI
+    prometheus.register.clear();
+    prometheus.collectDefaultMetrics({ prefix: 'mb_' });
+
+    app.use(middleware.useAbsoluteUrls(options.port));
+    app.use(middleware.validateApiKey(options.apikey, logger));
+    app.use(middleware.logger(logger, ':method :url'));
+    app.use(middleware.globals({ port: options.port, version: thisPackage.version }));
+    app.use(middleware.defaultIEtoHTML);
+    app.use(middleware.json(logger));
+    app.use(express.static(path.join(__dirname, 'public')));
+    app.use(express.static(path.join(__dirname, '../node_modules')));
+    app.use(errorHandler());
+    app.use(cors({ origin: options.origin }));
+
+    app.disable('etag');
+    app.disable('x-powered-by');
+    app.set('views', path.join(__dirname, 'views'));
+    app.set('view engine', 'ejs');
+    app.set('json spaces', 2);
+
+    app.get('/', homeController.get);
+    app.get('/imposters', impostersController.get);
+    app.post('/imposters', impostersController.post);
+    app.delete('/imposters', impostersController.del);
+    app.put('/imposters', impostersController.put);
+    app.get('/imposters/:id', validateImposterExists, imposterController.get);
+    app.delete('/imposters/:id', imposterController.del);
+    app.delete('/imposters/:id/savedProxyResponses', validateImposterExists, imposterController.resetProxies);
+    app.delete('/imposters/:id/savedRequests', validateImposterExists, imposterController.resetRequests);
+
+    // deprecated but saved for backwards compatibility
+    app.delete('/imposters/:id/requests', validateImposterExists, imposterController.resetProxies);
+
+    // Changing stubs without restarting imposter
+    app.put('/imposters/:id/stubs', validateImposterExists, imposterController.putStubs);
+    app.put('/imposters/:id/stubs/:stubIndex', validateImposterExists, imposterController.putStub);
+    app.post('/imposters/:id/stubs', validateImposterExists, imposterController.postStub);
+    app.delete('/imposters/:id/stubs/:stubIndex', validateImposterExists, imposterController.deleteStub);
+
+    // Protocol implementation APIs
+    app.post('/imposters/:id/_requests', validateImposterExists, imposterController.postRequest);
+    app.post('/imposters/:id/_requests/:proxyResolutionKey', validateImposterExists, imposterController.postProxyResponse);
+
+    app.get('/logs', logsController.get);
+    app.get('/config', configController.get);
+    app.get('/feed', feedController.getFeed);
+    app.get('/releases', feedController.getReleases);
+    app.get('/releases/:version', feedController.getRelease);
+
+    app.get('/metrics', async function (request, response) {
+        const register = promClient.register;
+        response.set('Content-Type', register.contentType);
+        response.end(await register.metrics());
+    });
+
+    app.get('/sitemap', (request, response) => {
+        response.type('text/plain');
+        response.render('sitemap', { releases: releases });
+    });
+
+    [
+        '/support',
+        '/license',
+        '/faqs',
+        '/docs/gettingStarted',
+        '/docs/mentalModel',
+        '/docs/commandLine',
+        '/docs/communityExtensions',
+        '/docs/security',
+        '/docs/api/overview',
+        '/docs/api/contracts',
+        '/docs/api/mocks',
+        '/docs/api/stubs',
+        '/docs/api/predicates',
+        '/docs/api/xpath',
+        '/docs/api/json',
+        '/docs/api/jsonpath',
+        '/docs/api/proxies',
+        '/docs/api/injection',
+        '/docs/api/behaviors',
+        '/docs/api/errors',
+        '/docs/api/faults',
+        '/docs/protocols/http',
+        '/docs/protocols/https',
+        '/docs/protocols/tcp',
+        '/docs/protocols/smtp',
+        '/docs/protocols/custom'
+    ].forEach(endpoint => {
+        app.get(endpoint, (request, response) => {
+            response.render(endpoint.substring(1));
+        });
+    });
+
+    process.once('exit', () => {
+        imposters.stopAllSync();
+    });
+
+    if (options.allowInjection) {
+        logger.warn(`Running with --allowInjection set. See ${baseURL}/docs/security for security info`);
+    }
+
+    await imposters.loadAll(protocols);
+
+    return app;
+}
+
+/**
+ * Start the mountebank server
+ * @param {function} app - mountebank express application
+ * @param {object} options - The command line options
+ * @returns {Object} An object with a close method to stop the server
+ */
+async function listen (app, options) {
+    const hostname = options.host || 'localhost',
+        baseURL = `http://${hostname}:${options.port}`,
+        logger = utilLogger.createLogger(options),
+        isAllowedConnection = utilIp.createIPVerification(options);
+
+    return new Promise(resolve => {
+        const connections = {},
+            server = app.listen(options.port, options.host, () => {
+                logger.info(`mountebank v${thisPackage.version} now taking orders - point your browser to ${baseURL}/ for help`);
+                logger.debug(`config: ${JSON.stringify({
+                    options: options,
+                    process: {
+                        nodeVersion: process.version,
+                        architecture: process.arch,
+                        platform: process.platform
+                    }
+                })}`);
+
+                resolve({
+                    close: callback => {
+                        server.close(() => {
+                            logger.info('Adios - see you soon?');
+                            callback();
+                        });
+
+                        // Force kill any open connections to prevent process hanging
+                        Object.keys(connections).forEach(socket => {
+                            connections[socket].destroy();
+                        });
+                    }
+                });
+            });
+
+        server.on('connection', socket => {
+            const name = helpers.socketName(socket),
+                ipAddress = socket.remoteAddress;
+            connections[name] = socket;
+
+            socket.on('close', () => {
+                delete connections[name];
+            });
+
+            socket.on('error', error => {
+                logger.error(`${name} transmission error X=> ${JSON.stringify(error)}`);
+            });
+
+            if (!isAllowedConnection(ipAddress, logger)) {
+                socket.destroy();
+            }
+        });
+    });
+}
+
+/**
+ * Creates the mountebank server
+ * @param {object} options - The command line options
+ * @returns {Object} An object with a close method to stop the server
+ */
+async function create (options) {
+    const app = await createApp(options);
+    return listen(app, options);
+}
+
+module.exports = { create, createApp };