@mbtest/mountebank 2.9.2-beta.9050

package/src/cli/cli.js

@@ -0,0 +1,420 @@
+'use strict';
+
+const fs = require('fs-extra'),
+    yargs = require('yargs'),
+    aliases = {
+        d: 'debug',
+        h: 'host',
+        i: 'allowInjection',
+        l: 'localOnly',
+        m: 'mock',
+        p: 'port',
+        r: 'removeProxies',
+        w: 'ipWhitelist',
+        o: 'origin'
+    },
+    options = {
+        rcfile: {
+            description: 'the startup file ("run commands") containing configuration options',
+            nargs: 1,
+            type: 'string',
+            global: false
+        },
+        port: {
+            default: 2525,
+            description: 'the port to run the mountebank server on',
+            nargs: 1,
+            type: 'number',
+            alias: aliases.p,
+            global: false
+        },
+        host: {
+            description: 'the hostname to bind the mountebank server to',
+            nargs: 1,
+            type: 'string',
+            alias: aliases.h,
+            global: false
+        },
+        configfile: {
+            description: 'file to load imposters from, can be an EJS template',
+            nargs: 1,
+            type: 'string',
+            global: false
+        },
+        noParse: {
+            default: false,
+            description: 'prevent rendering the configfile as an EJS template',
+            type: 'boolean',
+            global: false
+        },
+        formatter: {
+            default: 'mountebank-formatters',
+            description: 'the custom formatter module to interpret --configfile formats and to use during mb save operations',
+            nargs: 1,
+            type: 'string',
+            global: false
+        },
+        datadir: {
+            description: 'the directory to persist all imposter data',
+            nargs: 1,
+            type: 'string',
+            global: false
+        },
+        impostersRepository: {
+            description: 'path to custom imposters repository',
+            nargs: 1,
+            type: 'string',
+            global: false
+        },
+        pidfile: {
+            default: 'mb.pid',
+            description: 'where the pid is stored for the stop command',
+            nargs: 1,
+            type: 'string',
+            global: false
+        },
+        nologfile: {
+            default: false,
+            description: 'prevent logging to the filesystem',
+            type: 'boolean',
+            global: false
+        },
+        logfile: {
+            default: 'mb.log',
+            description: 'path to use for logging',
+            nargs: 1,
+            type: 'string',
+            global: false
+        },
+        loglevel: {
+            default: 'info',
+            description: 'level for logging',
+            nargs: 1,
+            type: 'string',
+            choices: ['debug', 'info', 'warn', 'error'],
+            global: false
+        },
+        log: {
+            description: 'customizable logging configuration',
+            nargs: 1,
+            type: 'string',
+            global: false
+        },
+        allowInjection: {
+            default: false,
+            description: 'set to allow JavaScript injection',
+            type: 'boolean',
+            alias: aliases.i,
+            global: false
+        },
+        localOnly: {
+            default: false,
+            description: 'allow connections only from localhost',
+            type: 'boolean',
+            alias: aliases.l,
+            global: false
+        },
+        ipWhitelist: {
+            default: '*',
+            description: 'pipe-delimited list of allowed IP addresses',
+            alias: aliases.w,
+            global: false
+        },
+        mock: {
+            default: false,
+            description: '[Deprecated] remember requests (use "recordRequests" per imposter instead)',
+            type: 'boolean',
+            alias: aliases.m,
+            global: false
+        },
+        debug: {
+            default: false,
+            description: 'include stub match information in imposter retrievals for debugging purposes',
+            type: 'boolean',
+            alias: aliases.d,
+            global: false
+        },
+        savefile: {
+            default: 'mb.json',
+            description: 'file to save imposters to',
+            nargs: 1,
+            type: 'string',
+            global: false
+        },
+        protofile: {
+            default: 'protocols.json',
+            description: 'file to load custom protocol implementations from',
+            nargs: 1,
+            type: 'string',
+            global: false
+        },
+        removeProxies: {
+            default: false,
+            description: 'removes proxies from the configuration when using the save command',
+            type: 'boolean',
+            alias: aliases.r,
+            global: false
+        },
+        origin: {
+            default: false,
+            description: 'safe origin for CORS requests',
+            type: 'string',
+            global: false
+        },
+        apikey: {
+            description: 'An optional API key. When provided, a user must add an API key to the header.',
+            default: null,
+            type: 'string',
+            global: false
+        }
+    },
+    startOptions = {
+        port: options.port,
+        host: options.host,
+        configfile: options.configfile,
+        noParse: options.noParse,
+        formatter: options.formatter,
+        datadir: options.datadir,
+        impostersRepository: options.impostersRepository,
+        pidfile: options.pidfile,
+        nologfile: options.nologfile,
+        logfile: options.logfile,
+        loglevel: options.loglevel,
+        log: options.log,
+        allowInjection: options.allowInjection,
+        localOnly: options.localOnly,
+        ipWhitelist: options.ipWhitelist,
+        mock: options.mock,
+        debug: options.debug,
+        protofile: options.protofile,
+        origin: options.origin,
+        rcfile: options.rcfile,
+        apikey: options.apikey
+    },
+    argv = yargs
+        .usage('Usage: mb [command=start] [options...]')
+        .command('start', 'Starts the server (default command)', startYargs => {
+            startYargs
+                .usage('Usage: mb [start] [options...]')
+                .help('help')
+                .wrap(null)
+                .options(startOptions)
+                .example('mb start --port 3000 --allowInjection --loglevel debug',
+                    'Starts on port 3000, allowing injections and turning on debug logging')
+                .example("mb --ipWhitelist '192.168.1.20|192.158.1.21'",
+                    'Starts on port 2525 with the given ip whitelist')
+                .epilog('Note on the last example that start is assumed if no command is specified\n\nFor more information, see http://www.mbtest.dev/docs/commandLine');
+        })
+        .command('stop', 'Stops the server', stopYargs => {
+            stopYargs
+                .usage('Usage: mb stop [--pidfile file.pid]')
+                .help('help')
+                .wrap(null)
+                .options({ pidfile: options.pidfile, rcfile: options.rcfile })
+                .example('mb stop', 'Stops the process identified in mb.pid')
+                .example('mb stop --pidfile test.pid', 'Stops the process identified in test.pid')
+                .epilog('For more information, see http://www.mbtest.dev/docs/commandLine');
+        })
+        .command('restart', "Stops the server if it's running and restarts it", restartYargs => {
+            restartYargs
+                .usage('Usage: mb restart [options...]')
+                .help('help')
+                .wrap(null)
+                .options(startOptions)
+                .example('mb restart --port 3000 --allowInjection --loglevel debug',
+                    'Restarts on port 3000, allowing injections and turning on debug logging')
+                .example('mb restart --pidfile test.pid', 'Stops the process identified in test.pid and restarts on port 2525')
+                .epilog('The port does not have to match the currently running instance, but the pidfile must match\n\nFor more information, see http://www.mbtest.dev/docs/commandLine');
+        })
+        .command('save', 'Saves current imposter configuration to a config file', saveYargs => {
+            saveYargs
+                .usage('Usage: mb save [options...]\n\nSaves a snapshot of your configuration, including new responses created by proxies')
+                .help('help')
+                .wrap(null)
+                .options({
+                    port: options.port,
+                    savefile: options.savefile,
+                    formatter: options.formatter,
+                    removeProxies: options.removeProxies,
+                    host: options.host,
+                    rcfile: options.rcfile
+                })
+                .example('mb save --savefile config.json --removeProxies --port 3000',
+                    'Saves the config without proxies into config.json by querying port 3000')
+                .example('mb save', 'Saves the config as is into mb.json by querying port 2525')
+                .epilog('For more information, see http://www.mbtest.dev/docs/commandLine');
+        })
+        .command('replay',
+            'Switches from record mode to replay by removing proxies',
+            replayYargs => {
+                replayYargs
+                    .usage('Usage: mb replay [--port 3000]')
+                    .help('help')
+                    .wrap(null)
+                    .options({ port: options.port, host: options.host, rcfile: options.rcfile })
+                    .example('mb replay --port 3000',
+                        'Resets the configuration of mountebank running on port 3000 to remove all proxies')
+                    .example('mb replay', 'Resets the configuration of mountebank running on port 2525 to remove all proxies')
+                    .epilog('For more information, see http://www.mbtest.dev/docs/commandLine');
+            })
+        .version()
+        .wrap(null)
+        .epilog('mb [command] --help provides more details\n\nFor more information, see http://www.mbtest.dev/docs/commandLine')
+        .argv;
+
+function fixAliases (args) {
+    Object.keys(args).forEach(key => {
+        if (aliases[key]) {
+            args[aliases[key]] = args[key];
+            delete args[key];
+        }
+    });
+}
+
+// Unfortunately, while yargs defaults correctly when the command is present, I couldn't
+// figure out how to make it default when the command is absent, which I need to default to start.
+// You can set what yargs considers to be the default command by .command(['start', '*']), but
+// that changes the help docs in ways I don't want.
+function fixDefaults (args) {
+    if (args._.length === 0) {
+        Object.keys(startOptions).forEach(key => {
+            if (typeof args[key] === 'undefined') {
+                args[key] = startOptions[key].default;
+            }
+        });
+    }
+}
+
+function fixIPWhitelist (command, args) {
+    if (command === 'start' || command === 'restart') {
+        args.ipWhitelist = args.ipWhitelist.split('|');
+    }
+}
+
+function rawArgvIndexFor (key) {
+    // Use raw process.argv to ensure user actually passed the parameter, bypassing
+    // yargs defaulting. Also check alias.
+    let index = process.argv.indexOf(`--${key}`);
+    if (index < 0) {
+        const aliasKeys = Object.keys(aliases);
+        for (let i = 0; i < aliasKeys.length; i += 1) {
+            let alias = aliasKeys[i];
+            if (aliases[alias] === key) {
+                index = process.argv.indexOf(`-${alias}`);
+            }
+        }
+    }
+    return index;
+}
+
+function argIsPassedOnCLI (key) {
+    return rawArgvIndexFor(key) >= 0;
+}
+
+function argvOrDefaultFor (key) {
+    const index = rawArgvIndexFor(key);
+    if (index >= 0) {
+        return process.argv[index + 1];
+    }
+    else {
+        return options[key].default;
+    }
+}
+
+function parseLogConfiguration (args) {
+    // Not defaulted in yargs so we can test yargs value without defaulting interfering.
+    // This is needed for backwards compatibility with older CLI options.
+    const defaultConfig = {
+        level: 'info',
+        transports: {
+            console: {
+                colorize: true,
+                format: '%level: %message'
+            },
+            file: {
+                path: 'mb.log',
+                format: 'json'
+            }
+        }
+    };
+
+    if (typeof args.log === 'string') {
+        try {
+            args.log = JSON.parse(args.log);
+        }
+        catch (ex) {
+            console.error(`Cannot parse --log as JSON: ${ex}`);
+            args.log = defaultConfig;
+        }
+    }
+    else {
+        // Backwards compatibility with older CLI options. Using raw process.argv
+        // to ensure user actually passed the parameter, bypassing yargs defaulting
+        args.log = defaultConfig;
+        args.log.level = argvOrDefaultFor('loglevel');
+        args.log.transports.file.path = argvOrDefaultFor('logfile');
+        if (argIsPassedOnCLI('nologfile')) {
+            delete args.log.transports.file;
+        }
+    }
+
+    // Remove the old values to not confuse users retrieving configuration later
+    delete args.loglevel;
+    delete args.logfile;
+    delete args.nologfile;
+}
+
+// Prevent noise from being logged
+function removeNoise (args) {
+    delete args._;
+    delete args.$0;
+    delete args.version;
+}
+
+function addStartupFile (args) {
+    if (typeof args.rcfile !== 'string' || args.rcfile === '') {
+        return;
+    }
+    if (!fs.existsSync(args.rcfile)) {
+        console.error(`Cannot find rcfile ${args.rcfile}`);
+        return;
+    }
+    try {
+        const rc = JSON.parse(fs.readFileSync(args.rcfile));
+
+        // CLI options take priority over anything in the rcfile.
+        Object.keys(rc).forEach(key => {
+            if (!argIsPassedOnCLI(key)) {
+                args[key] = rc[key];
+            }
+        });
+    }
+    catch (ex) {
+        console.error(`Cannot parse rcfile ${args.rcfile}: ${ex}`);
+    }
+}
+
+function getCommandLineArgs (command, args) {
+    fixAliases(args);
+    fixDefaults(args);
+    fixIPWhitelist(command, args);
+    parseLogConfiguration(args);
+    removeNoise(args);
+    addStartupFile(args);
+    return args;
+}
+
+function error (message) {
+    console.error(`${message}\n`);
+    yargs.showHelp();
+    process.exit(1); // eslint-disable-line no-process-exit
+}
+
+function help () {
+    yargs.showHelp();
+}
+
+const command = argv._.length === 0 ? 'start' : argv._[0],
+    args = getCommandLineArgs(command, argv);
+
+module.exports = { command, args, error, help };

package/src/controllers/configController.js

@@ -0,0 +1,64 @@
+'use strict';
+
+const helpers = require('../util/helpers');
+
+/**
+ * The controller that exposes the mountebank configuration for the running process
+ * @module
+ */
+
+/**
+ * Creates the config controller
+ * @param {string} version - The version of the currently running process
+ * @param {Object} options - The command line options used to start mb
+ * @returns {Object}
+ */
+function create (version, options) {
+    const publicOptions = helpers.clone(options);
+
+    delete publicOptions.version;
+
+    if (!publicOptions.mock) {
+        delete publicOptions.mock; // deprecated
+    }
+
+    // On some OS's, it duplicates camelCase as hypen-case (e.g. noParse and no-parse)
+    // I assume this was a change in yargs at some point
+    for (var prop in publicOptions) {
+        if (prop.indexOf('-') > 0) {
+            delete publicOptions[prop];
+        }
+    }
+
+    /**
+     * The method that responds to GET /config
+     * @memberOf module:controllers/configController#
+     * @param {Object} request - The HTTP request
+     * @param {Object} response - The HTTP response
+     */
+    function get (request, response) {
+        const config = {
+            version,
+            options: publicOptions,
+            process: {
+                nodeVersion: process.version,
+                architecture: process.arch,
+                platform: process.platform,
+                rss: process.memoryUsage().rss,
+                heapTotal: process.memoryUsage().heapTotal,
+                heapUsed: process.memoryUsage().heapUsed,
+                uptime: process.uptime(),
+                cwd: process.cwd()
+            }
+        };
+
+        response.format({
+            json: () => response.send(config),
+            html: () => response.render('config', config)
+        });
+    }
+
+    return { get };
+}
+
+module.exports = { create };

package/src/controllers/feedController.js

@@ -0,0 +1,115 @@
+'use strict';
+
+const path = require('path'),
+    fsExtra = require('fs-extra'),
+    ejs = require('ejs'),
+    helpers = require('../util/helpers.js');
+
+/**
+ * The controller that exposes information about releases
+ * @module
+ */
+
+/**
+ * @param {Object} releases - The object represented in the releases.json file
+ * @param {Object} options - The command line options used to start mountebank
+ * @returns {Object} The controller
+ */
+function create (releases) {
+    const feedReleases = helpers.clone(releases);
+
+    // Init once since we hope many consumers poll the heroku feed and we don't have monitoring
+    feedReleases.reverse();
+
+    function releaseViewFor (version) {
+        return `releases/${version}.ejs`;
+    }
+
+    function releaseFilenameFor (version) {
+        return path.join(__dirname, '/../views/', releaseViewFor(version));
+    }
+
+    function versionInWhitelist (version) {
+        // Prevent path traversal attack like v2.3.0%2f..%2f..%2f_header
+        return feedReleases.some(release => version.toLowerCase() === release.version);
+    }
+
+    /**
+     * The function that responds to GET /feed
+     * @memberOf module:controllers/feedController#
+     * @param {Object} request - The HTTP request
+     * @param {Object} response - The HTTP response
+     */
+    function getFeed (request, response) {
+        const page = parseInt(request.query.page || '1'),
+            nextPage = page + 1,
+            entriesPerPage = 10,
+            hasNextPage = feedReleases.slice((nextPage * entriesPerPage) - 10, entriesPerPage * nextPage).length > 0,
+            config = {
+                host: request.headers.host,
+                releases: feedReleases.slice(page * entriesPerPage - 10, entriesPerPage * page),
+                hasNextPage: hasNextPage,
+                nextLink: `/feed?page=${nextPage}`
+            };
+
+        // I'd prefer putting this as an include in the view, but EJS doesn't support dynamic includes
+        config.releases.forEach(release => {
+            if (!release.view) {
+                const contents = fsExtra.readFileSync(releaseFilenameFor(release.version), { encoding: 'utf8' });
+                release.view = ejs.render(contents, {
+                    host: request.headers.host,
+                    releaseMajorMinor: release.version.replace(/^v(\d+\.\d+).*/, '$1'),
+                    releaseVersion: release.version.replace('v', '')
+                });
+            }
+        });
+
+        response.type('application/atom+xml');
+        response.render('feed', config);
+    }
+
+    /**
+     * The function that responds to GET /releases
+     * @memberOf module:controllers/feedController#
+     * @param {Object} request - The HTTP request
+     * @param {Object} response - The HTTP response
+     */
+    function getReleases (request, response) {
+        response.render('releases', { releases: feedReleases });
+    }
+
+    /**
+     * The function that responds to GET /releases/:version
+     * @memberOf module:controllers/feedController#
+     * @param {Object} request - The HTTP request
+     * @param {Object} response - The HTTP response
+     */
+    function getRelease (request, response) {
+        const version = request.params.version,
+            config = {
+                host: request.headers.host,
+                releaseMajorMinor: version.replace(/^v(\d+\.\d+).*/, '$1'),
+                releaseVersion: version.replace('v', '')
+            };
+
+        if (versionInWhitelist(version) && fsExtra.existsSync(releaseFilenameFor(version))) {
+            response.render('_header', config, (headerError, header) => {
+                if (headerError) { throw headerError; }
+                response.render(releaseViewFor(version), config, (bodyError, body) => {
+                    if (bodyError) { throw bodyError; }
+                    response.render('_footer', config, (footerError, footer) => {
+                        if (footerError) { throw footerError; }
+                        response.send(header + body + footer);
+                    });
+                });
+            });
+        }
+        else {
+            response.status(404).send('No such release');
+        }
+    }
+
+    return { getFeed, getReleases, getRelease };
+}
+
+module.exports = { create };

package/src/controllers/homeController.js

@@ -0,0 +1,58 @@
+'use strict';
+
+const date = require('../util/date.js');
+
+/**
+ * The controller that returns the base mountebank hypermedia
+ * @module
+ */
+
+/**
+ * Creates the home controller
+ * @param {Object} releases - The releases.json file
+ * @returns {Object} The controller
+ */
+function create (releases) {
+    function createNotice (release) {
+        return {
+            version: release.version,
+            when: date.howLongAgo(release.date)
+        };
+    }
+
+    function isRecent (notice) {
+        return notice.when !== '';
+    }
+
+    /**
+     * The function that responds to GET /
+     * @memberOf module:controllers/homeController#
+     * @param {Object} request - the HTTP request
+     * @param {Object} response - the HTTP response
+     */
+    function get (request, response) {
+        const hypermedia = {
+                _links: {
+                    imposters: { href: '/imposters' },
+                    config: { href: '/config' },
+                    logs: { href: '/logs' }
+                }
+            },
+            notices = releases.map(createNotice).filter(isRecent),
+            viewNotices = [];
+
+        if (notices.length > 0) {
+            notices.reverse();
+            viewNotices.push(notices[0]);
+        }
+
+        response.format({
+            json: () => { response.send(hypermedia); },
+            html: () => { response.render('index', { notices: viewNotices }); }
+        });
+    }
+
+    return { get };
+}
+
+module.exports = { create };