@mbtest/mountebank 2.9.2-beta.9050

package/src/models/https/cert/mb-key.pem

@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEpAIBAAKCAQEAzPiVoyRcLURPvvKU1LOhslhSyjBkrGQ1MiRtJ/UIr4STxN36
+L3nCswXUWWVKwIx1j9V8aQy7Kn8txSsw/WxCNmyGmugb90AlIkhIXl7XgZZY5bXe
+EYbqfclp6cJAZg1uBSMVeh5uWjskceNRBnKuCK9K8KUzJB0a2pAipMlQroXD2wHk
+7SZ9o8PUCCQdxtiLFrs4lBZoNkzvdBz1KXqFVRIKDvQfQ7gl90JhQZIt8U5pvR57
+2ewtLUWTOmNmhFqD5c6LBOz3BYw5nfY5kl6NzRA/frQ3OF2qHPYjwaSzAqnug2mQ
+W6h8UhRUurKQSQpanr9PYOOTwtx6l5f0Mc4+1QIDAQABAoIBAA9toq3N/dY2bx47
+WjKMdt5awZiQffNv84Ubss+wJQA5JXpLDxrlul8JUEuOUUsfB3ZVJnEt0STIv+Q4
+dQ6OSImaL6OXVwuMW38yG6hm0Sfi7jwULWv6UMo5D+zVf01vM1nVozc29S17iCm+
+Z4nptenXb/efJ7NPMYdEFCd9M8J/EpvYEMis0/Jtwvlvg7GO1g6fV0BR/HttJM/x
+XBAl9W6LAkL+8/XRJ7iYcCzU6WwUFeCdU/R6kFGngYuMw4r90u6ukWQzuVKXJH7E
+mi4o16UKNzKfnKOyLBbpeJFGF5DhtwoJpHAZVS9bVZQIr6p4ugbvCBuRshlLGDdN
+v9aJfwECgYEA5ZtmxgTgRIHYhLtURDhJo9113C2vPgkbUIxFfKoZPRWkotEYR0M3
+ypgU3mDKn1KMXsrTUq3Uv4+Zvwbym2L3AJCvnyR9FpZoz5U98lLtDDxMSzr9++PA
+dO7QfznQ0L9JDSl8Bav40quuFgwdGdcwvWSFpT5Zzb/fTw+ZfrqfxhUCgYEA5Ig5
+eRAmbk/cmjoNZB0jp8ijJHlvr5QEnXK0cOT9dQ8xk/moNcn0DkSmpaJK/rb3f0+/
+HhOfMnGfABn+7h7g8rnFmwkd9WIxNsQb64+e33NLzdF//MfU5xLE4oHGCTztx8eZ
+ck8RoGB4JvJYcwLt4R/OtL4G6Rfx1JX0pKzthcECgYA2Uyhj3a96RgaGkRQE+BRk
+UveZ2q1Fzj3KNwYR0uUZ0M8dPr+xzLOcmZMGcnw+afeQTgjl3P8jO8Syr+Ai561t
+Us5apvV5rKirxLHdbcVsSa/7dL+3I1Hb2M037OP9H+UW2iPf66p5nekYilEwVfvQ
+M8JzMGdrCOS6/gPhOiKnaQKBgQC9Mcni3+vxB0yqocTUTQtnrELjv2UnBnOLpZqc
+m/b5Ikr5JoaLgVX7Ofp8xY8wsGjVjT+7tqLlMAtiGiNjH007pXBimXmj3FbB8Djt
+G0l71Ae9rOM4cndflbpJiwZYP4jbC/ONHsiI7VSLabawAIzPA3YtS+SMtLYQONUA
+P+mkAQKBgQDRdeTKPPOTF5Md3gdsN4WVdrOkOro+5lCtN9lglRcfrESShV1KtEjz
+WznF3OLO/XFpI30itei1HCZjo+nXSUvsV5t6zBOzQ9tzw2/hgaoH6nooZgdT9r1O
+34YsJhUoDmukCEii8IgRRaZyqS1829xqF8Fw5fgYBr9KgA+FHjpSDw==
+-----END RSA PRIVATE KEY-----

package/src/models/https/httpsServer.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const path = require('path'),
+    fs = require('fs'),
+    https = require('https'),
+    baseHttpServer = require('../http/baseHttpServer.js');
+
+/**
+ * Represents an https imposter
+ * @module
+ */
+
+function createBaseServer (options) {
+    const metadata = {
+            key: options.key || fs.readFileSync(path.join(__dirname, '/cert/mb-key.pem'), 'utf8'),
+            cert: options.cert || fs.readFileSync(path.join(__dirname, '/cert/mb-cert.pem'), 'utf8'),
+            mutualAuth: Boolean(options.mutualAuth),
+            rejectUnauthorized: options.rejectUnauthorized || false,
+            ca: options.ca || null
+        },
+        // client certs will not reject the request.  It does set the request.client.authorized variable
+        // to false for all self-signed certs; use rejectUnauthorized: true and a ca: field set to an array
+        // containing the client cert to see request.client.authorized = true
+        config = {
+            key: metadata.key,
+            cert: metadata.cert,
+            mutualAuth: metadata.mutualAuth,
+            rejectUnauthorized: metadata.rejectUnauthorized,
+            ca: metadata.ca,
+            requestCert: metadata.mutualAuth && metadata.rejectUnauthorized
+        },
+        createNodeServer = () => https.createServer(config);
+
+    if (options.ciphers) {
+        metadata.ciphers = options.ciphers.toUpperCase();
+        config.ciphers = options.ciphers.toUpperCase();
+    }
+
+    return { metadata, createNodeServer };
+}
+
+module.exports = baseHttpServer(createBaseServer);

package/src/models/https/index.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const config = JSON.parse(process.argv[2]),
+    httpsServer = require('./httpsServer.js'),
+    httpProxy = require('../http/httpProxy.js'),
+    mbConnection = require('../mbConnection.js').create(config);
+
+httpsServer.create(config, mbConnection.logger(), mbConnection.getResponse).then(server => {
+    mbConnection.setPort(server.port);
+    mbConnection.setProxy(httpProxy.create(mbConnection.logger()));
+
+    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/imposter.js

@@ -0,0 +1,243 @@
+'use strict';
+
+/**
+ * An imposter represents a protocol listening on a socket.  Most imposter
+ * functionality is in each particular protocol implementation.  This module
+ * exists as a bridge between the API and the protocol, mapping back to pretty
+ * JSON for the end user.
+ * @module
+ */
+
+const prometheus = require('prom-client'),
+    compatibility = require('./compatibility.js'),
+    scopedLogger = require('../util/scopedLogger.js'),
+    helpers = require('../util/helpers.js'),
+    predicates = require('./predicates.js'),
+    imposterPrinter = require('./imposterPrinter.js'),
+    cachedObjects = {};
+
+/**
+ * Create the imposter
+ * @param {Object} Protocol - The protocol factory for creating servers of that protocol
+ * @param {Object} creationRequest - the parsed imposter JSON
+ * @param {Object} baseLogger - the logger
+ * @param {Object} config - command line options
+ * @param {Function} isAllowedConnection - function to determine if the IP address of the requestor is allowed
+ * @returns {Object}
+ */
+async function create (Protocol, creationRequest, baseLogger, config, isAllowedConnection) {
+
+    const metrics = getMetrics();
+
+    function scopeFor (port) {
+        let scope = `${creationRequest.protocol}:${port}`;
+
+        if (creationRequest.name) {
+            scope += ' ' + creationRequest.name;
+        }
+        return scope;
+    }
+
+    const logger = scopedLogger.create(baseLogger, scopeFor(creationRequest.port)),
+        imposterState = {},
+        unresolvedProxies = {},
+        header = helpers.clone(creationRequest);
+
+    // Free up the memory by allowing garbage collection of stubs when using filesystemBackedImpostersRepository
+    delete header.stubs;
+
+    let stubs;
+    let resolver;
+    let encoding;
+    let numberOfRequests = 0;
+
+    compatibility.upcast(creationRequest);
+
+    // If the CLI --mock flag is passed, we record even if the imposter level recordRequests = false
+    const recordRequests = config.recordRequests || creationRequest.recordRequests;
+
+    async function findFirstMatch (request) {
+        const filter = stubPredicates => {
+                return stubPredicates.every(predicate =>
+                    predicates.evaluate(predicate, request, encoding, logger, imposterState));
+            },
+            observePredicateMatchDuration = metrics.predicateMatchDuration.startTimer(),
+            match = await stubs.first(filter);
+
+        observePredicateMatchDuration({ imposter: logger.scopePrefix });
+        if (match.success) {
+            logger.debug(`using predicate match: ${JSON.stringify(match.stub.predicates || {})}`);
+        }
+        else {
+            metrics.noMatchCount.inc({ imposter: logger.scopePrefix });
+            logger.info('no predicate match, using default response');
+        }
+        return match;
+    }
+
+    async function recordMatch (stub, request, response, responseConfig, start) {
+        if (response.proxy) {
+            // Out of process proxying, so we don't have the actual response yet.
+            const parts = response.callbackURL.split('/'),
+                proxyResolutionKey = parts[parts.length - 1];
+
+            unresolvedProxies[proxyResolutionKey] = {
+                recordMatch: proxyResponse => {
+                    return stub.recordMatch(request, proxyResponse, responseConfig, new Date() - start);
+                }
+            };
+        }
+        else if (response.response) {
+            // Out of process responses wrap the result in an outer response object
+            await stub.recordMatch(request, response.response, responseConfig, new Date() - start);
+        }
+        else {
+            // In process resolution
+            await stub.recordMatch(request, response, responseConfig, new Date() - start);
+        }
+    }
+
+    // requestDetails are not stored with the imposter
+    // It was created to pass the raw URL to maintain the exact querystring during http proxying
+    // without having to change the path / query options on the stored request
+    async function getResponseFor (request, requestDetails) {
+        if (!isAllowedConnection(request.ip, logger)) {
+            metrics.blockedIPCount.inc({ imposter: logger.scopePrefix });
+            return { blocked: true, code: 'unauthorized ip address' };
+        }
+
+        const start = new Date();
+
+        metrics.requestCount.inc({ imposter: logger.scopePrefix });
+        numberOfRequests += 1;
+        if (recordRequests) {
+            await stubs.addRequest(request);
+        }
+
+        const match = await findFirstMatch(request),
+            observeResponseGenerationDuration = metrics.responseGenerationDuration.startTimer(),
+            responseConfig = await match.stub.nextResponse();
+
+        logger.debug(`generating response from ${JSON.stringify(responseConfig)}`);
+        const response = await resolver.resolve(responseConfig, request, logger, imposterState, requestDetails);
+        observeResponseGenerationDuration({ imposter: logger.scopePrefix });
+
+        if (config.recordMatches) {
+            await recordMatch(match.stub, request, response, responseConfig, start);
+        }
+        return response;
+    }
+
+    async function getProxyResponseFor (proxyResponse, proxyResolutionKey) {
+        const response = await resolver.resolveProxy(proxyResponse, proxyResolutionKey, logger, imposterState);
+        if (config.recordMatches && unresolvedProxies[String(proxyResolutionKey)].recordMatch) {
+            await unresolvedProxies[String(proxyResolutionKey)].recordMatch(response);
+        }
+        delete unresolvedProxies[String(proxyResolutionKey)];
+        return response;
+    }
+
+    async function resetRequests () {
+        await stubs.deleteSavedRequests();
+        numberOfRequests = 0;
+    }
+
+    function getMetrics () {
+        return metricsAlreadyCreated() ? getCreatedMetrics() : createImposterMetrics();
+    }
+
+    function metricsAlreadyCreated () {
+        return Boolean(cachedObjects.metrics);
+    }
+    function getCreatedMetrics () {
+        return cachedObjects.metrics;
+    }
+
+    function createImposterMetrics () {
+        const impostersMetrics = {
+            predicateMatchDuration: new prometheus.Histogram({
+                name: 'mb_predicate_match_duration_seconds',
+                help: 'Time it takes to match the predicates and select a stub',
+                buckets: [0.01, 0.05, 0.1, 0.2, 0.5, 1],
+                labelNames: ['imposter']
+            }),
+            noMatchCount: new prometheus.Counter({
+                name: 'mb_no_match_total',
+                help: 'Number of times no stub matched the request',
+                labelNames: ['imposter']
+            }),
+            requestCount: new prometheus.Counter({
+                name: 'mb_request_total',
+                help: 'Number of requests to the imposter',
+                labelNames: ['imposter']
+            }),
+            responseGenerationDuration: new prometheus.Histogram({
+                name: 'mb_response_generation_duration_seconds',
+                help: 'Time it takes to generate the response from a stub',
+                buckets: [0.01, 0.05, 0.1, 0.2, 0.5, 1, 3, 5, 10, 30],
+                labelNames: ['imposter']
+            }),
+            blockedIPCount: new prometheus.Counter({
+                name: 'mb_blocked_ip_total',
+                help: 'Number of times a connection was blocked from a non-whitelisted IP address',
+                labelNames: ['imposter']
+            })
+        };
+
+        cachedObjects.metrics = impostersMetrics;
+
+        return cachedObjects.metrics;
+    }
+
+    return new Promise((resolve, reject) => {
+        try {
+            if (!helpers.defined(creationRequest.host) && helpers.defined(config.host)) {
+                creationRequest.host = config.host;
+            }
+
+            Protocol.createServer(creationRequest, logger, getResponseFor).then(server => {
+                if (creationRequest.port !== server.port) {
+                    creationRequest.port = server.port;
+                    logger.changeScope(scopeFor(server.port));
+                }
+                logger.info('Open for business...');
+
+                stubs = server.stubs;
+                resolver = server.resolver;
+                encoding = server.encoding;
+
+                function stop () {
+                    return new Promise(closed => {
+                        server.close(() => {
+                            logger.info('Ciao for now');
+                            closed();
+                        });
+                    });
+                }
+
+                async function loadRequests () {
+                    return recordRequests ? stubs.loadRequests() : [];
+                }
+
+                const printer = imposterPrinter.create(header, server, loadRequests),
+                    toJSON = options => printer.toJSON(numberOfRequests, options);
+
+                return resolve({
+                    port: server.port,
+                    url: '/imposters/' + server.port,
+                    creationRequest: creationRequest,
+                    toJSON,
+                    stop,
+                    getResponseFor,
+                    getProxyResponseFor,
+                    resetRequests
+                });
+            }, reject);
+        }
+        catch (error) {
+            reject(error);
+        }
+    });
+}
+
+module.exports = { create };

package/src/models/imposterPrinter.js

@@ -0,0 +1,120 @@
+'use strict';
+
+const helpers = require('../util/helpers.js');
+
+function create (header, server, loadRequests) {
+    const baseURL = `/imposters/${server.port}`;
+
+    function createHeader (numberOfRequests, options) {
+        const result = {
+            protocol: header.protocol,
+            port: server.port
+        };
+
+        if (header.name) {
+            result.name = header.name;
+        }
+        if (header.defaultResponse) {
+            result.defaultResponse = header.defaultResponse;
+        }
+        if (!options.replayable) {
+            result.numberOfRequests = numberOfRequests;
+        }
+        if (!options.list) {
+            result.recordRequests = Boolean(header.recordRequests);
+
+            Object.keys(server.metadata).forEach(key => {
+                result[key] = server.metadata[key];
+            });
+        }
+        if (header.endOfRequestResolver) {
+            result.endOfRequestResolver = header.endOfRequestResolver;
+        }
+
+        return result;
+    }
+
+    async function addStubsTo (imposter, options) {
+        const newOptions = {};
+        if (!options.replayable) {
+            newOptions.debug = true;
+        }
+
+        imposter.stubs = await server.stubs.toJSON(newOptions);
+        return imposter;
+    }
+
+    function removeNonEssentialInformationFrom (imposter) {
+        imposter.stubs.forEach(stub => {
+            stub.responses.forEach(response => {
+                if (helpers.defined(response.is)) {
+                    delete response.is._proxyResponseTime;
+                }
+            });
+        });
+    }
+
+    async function addRequestsTo (imposter) {
+        imposter.requests = await loadRequests();
+        return imposter;
+    }
+
+    function removeProxiesFrom (imposter) {
+        imposter.stubs.forEach(stub => {
+            // eslint-disable-next-line no-prototype-builtins
+            stub.responses = stub.responses.filter(response => !response.hasOwnProperty('proxy'));
+        });
+        imposter.stubs = imposter.stubs.filter(stub => stub.responses.length > 0);
+    }
+
+    function addLinksTo (imposter) {
+        imposter._links = {
+            self: { href: baseURL },
+            stubs: { href: `${baseURL}/stubs` }
+        };
+
+        if (imposter.stubs) {
+            for (let i = 0; i < imposter.stubs.length; i += 1) {
+                imposter.stubs[i]._links = { self: { href: `${baseURL}/stubs/${i}` } };
+            }
+        }
+    }
+
+    async function toJSON (numberOfRequests, options = {}) {
+        // I consider the order of fields represented important.  They won't matter for parsing,
+        // but it makes a nicer user experience for developers viewing the JSON to keep the most
+        // relevant information at the top. Some of the order of operations in this file represents
+        // that (e.g. keeping the _links at the end), and is tested with some documentation tests.
+        const result = createHeader(numberOfRequests, options);
+
+        options = options || {};
+
+        if (options.list) {
+            addLinksTo(result);
+            return result;
+        }
+
+        if (!options.replayable) {
+            await addRequestsTo(result);
+        }
+
+        await addStubsTo(result, options);
+
+        if (options.replayable) {
+            removeNonEssentialInformationFrom(result);
+        }
+        else {
+            addLinksTo(result);
+        }
+
+        if (options.removeProxies) {
+            removeProxiesFrom(result);
+        }
+
+        return result;
+    }
+
+    return { toJSON };
+}
+
+module.exports = { create };

package/src/models/impostersRepository.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const fs = require('fs-extra'),
+    path = require('path'),
+    fileSystemBackedImpostersRepository = require('./filesystemBackedImpostersRepository.js'),
+    inMemoryImpostersRepository = require('./inMemoryImpostersRepository.js');
+
+/**
+ * An factory abstraction for loading imposters
+ * @module
+ */
+
+/**
+ * Creates the repository based on startup configuration
+ * @param {Object} config - The startup configuration
+ * @param {Object} logger - The logger
+ * @returns {Object} - the repository
+ */
+function create (config, logger) {
+    if (config.impostersRepository) {
+        const filename = path.resolve(path.relative(process.cwd(), config.impostersRepository));
+
+        if (fs.existsSync(filename)) {
+            try {
+                return require(filename).create(config, logger);
+            }
+            catch (e) {
+                logger.error(`An error occured while creating custom impostersRepository:\n ${e}`);
+                return {};
+            }
+        }
+        else {
+            logger.warn(`Imposters Respository ${filename} does not exist. The default will be used`);
+            return this.inMemory();
+        }
+    }
+    else if (config.datadir) {
+        return fileSystemBackedImpostersRepository.create(config, logger);
+    }
+    else {
+        return this.inMemory();
+    }
+}
+
+function inMemory () {
+    return inMemoryImpostersRepository.create();
+}
+
+module.exports = { create, inMemory };