@mbtest/mountebank 2.9.2-beta.9050

package/src/util/combinators.js

@@ -0,0 +1,68 @@
+'use strict';
+
+/**
+ * Helpful combinators
+ * For the non-pedants, a combinator is basically just a function with no free variables.
+ * For the non-pedants, "no free variables" means that the combinator does not have dependencies
+ * on things outside the function (e.g. it only depends on the function parameters).
+ * A strict definition of combinators requires functions as input parameters, but I loosen that here.
+ * That definition really only serves mathematical modeling of state in pure functional terms
+ * @module
+ */
+
+/**
+ * Curries a function parameters, which is to say that it returns a function with reduced arity.
+ * @example
+ * function sum (x, y) { return x + y; }
+ * curry(sum, 1)(2); // returns 3
+ * curry(sum, 1, 2)(); // returns 3
+ * @param {Function} fn - The function to curry
+ * @param {...*} args - The arguments to curry
+ * @returns {Function}
+ */
+function curry (fn) {
+    const args = Array.prototype.slice.call(arguments, 1);
+    return function () {
+        const nextArgs = Array.prototype.slice.call(arguments),
+            allArgs = args.concat(nextArgs);
+
+        return fn.apply(null, allArgs);
+    };
+}
+
+/**
+ * Composes two or more functions
+ * @example
+ * function increment (i) { return i + 1; }
+ * function double (i) { return i * 2; }
+ * function triple (i) { return i * 3; }
+ * combinators.compose(increment, double, triple)(1); // returns 7
+ * @param {...Function} args - The functions to compose
+ * @returns {Function} A single function that represents the composition of the functions provided
+ */
+function compose () {
+    const args = Array.prototype.slice.call(arguments).reverse();
+    return obj => args.reduce((result, F) => F(result), obj);
+}
+
+module.exports = {
+    /**
+     * Returns what was passed in unchanged, occasionally useful as the default transformation function
+     * to avoid special case logic
+     * @param {Object} i - The input
+     * @returns {Object} Exactly what was passed in
+     */
+    identity: i => i,
+    /**
+     * Ignores its parameters, and instead always returns a constant value
+     * @param {Object} k - The constant to return
+     * @returns {Function} - A function that will always return the constant
+     */
+    constant: k => () => k,
+    /**
+     * A function that does nothing, occasionally useful to avoid special case logic
+     */
+    noop: () => {},
+    compose,
+    curry
+};

package/src/util/date.js

@@ -0,0 +1,51 @@
+'use strict';
+
+/** @module */
+
+function toEpochWithoutTime (text) {
+    // be sure to exclude time so we get accurate text
+    const dateTextWithoutTime = new Date(Date.parse(text)).toDateString();
+    return Date.parse(dateTextWithoutTime);
+}
+
+function sameMonth (firstEpoch, secondEpoch) {
+    const first = new Date(firstEpoch),
+        second = new Date(secondEpoch);
+
+    return first.getFullYear() === second.getFullYear() && first.getMonth() === second.getMonth();
+}
+
+/**
+ * Translates the distance between two dates within a month of each other to human readable text
+ * @param {string} thenText - The start date
+ * @param {string} testNowText - Ignore, used for testing purposes only.
+ * @returns {string}
+ */
+function howLongAgo (thenText, testNowText) {
+    const nowText = testNowText ? testNowText : new Date(Date.now()).toISOString(), // testNow is just for testing purposes
+        then = toEpochWithoutTime(thenText),
+        now = toEpochWithoutTime(nowText),
+        millisecondsInDay = 24 * 60 * 60 * 1000,
+        daysAgo = Math.floor((now - then) / millisecondsInDay);
+
+    if (daysAgo === 0) {
+        return 'today';
+    }
+    else if (daysAgo === 1) {
+        return 'yesterday';
+    }
+    else if (daysAgo < 7) {
+        return 'this week';
+    }
+    else if (daysAgo < 14) {
+        return 'last week';
+    }
+    else if (sameMonth(then, now)) {
+        return 'this month';
+    }
+    else {
+        return '';
+    }
+}
+
+module.exports = { howLongAgo };

package/src/util/errors.js

@@ -0,0 +1,55 @@
+'use strict';
+
+/**
+ * Error types returned by the API
+ * @module
+ */
+const inherit = require('./inherit.js'),
+    helpers = require('./helpers.js');
+
+function createError (code, message, options) {
+    const result = inherit.from(Error, { code, message });
+
+    if (options) {
+        Object.keys(options).forEach(key => {
+            result[key] = options[key];
+        });
+    }
+    return result;
+}
+
+function create (code) {
+    return (message, options) => createError(code, message, options);
+}
+
+function createWithMessage (code, message) {
+    return options => createError(code, message, options);
+}
+
+// Produces a JSON.stringify-able Error object
+// (because message is on the prototype, it doesn't show by default)
+function details (error) {
+    const prototypeProperties = {};
+
+    ['message', 'name', 'stack'].forEach(key => {
+        if (error[key]) {
+            prototypeProperties[key] = error[key];
+        }
+    });
+    return helpers.merge(error, prototypeProperties);
+}
+
+module.exports = {
+    ValidationError: create('bad data'),
+    InjectionError: create('invalid injection'),
+    ResourceConflictError: create('resource conflict'),
+    InsufficientAccessError: createWithMessage('insufficient access', 'Run mb in superuser mode if you want access'),
+    InvalidProxyError: create('invalid proxy'),
+    MissingResourceError: create('no such resource'),
+    InvalidJSONError: createWithMessage('invalid JSON', 'Unable to parse body as JSON'),
+    CommunicationError: createWithMessage('communication', 'Error communicating with mountebank'),
+    ProtocolError: create('cannot start server'),
+    DatabaseError: create('corrupted database'),
+    UnauthorizedError: createWithMessage('unauthorized', 'If you set the apiKey option, make sure you are sending the correct apiKey in the x-api-key header.'),
+    details
+};

package/src/util/helpers.js

@@ -0,0 +1,131 @@
+'use strict';
+
+/** @module */
+
+/**
+ * Returns true if obj is a defined value
+ * @param {Object} obj - the value to test
+ * @returns {boolean}
+ */
+function defined (obj) {
+    return typeof obj !== 'undefined';
+}
+
+/**
+ * Returns true if obj is a non-null object
+ * Checking for typeof 'object' without checking for nulls
+ * is a very common source of bugs
+ * @param {Object} obj - the value to test
+ * @returns {boolean}
+ */
+function isObject (obj) {
+    return typeof obj === 'object' && obj !== null;
+}
+
+/**
+ * Returns the text used for logging purposes related to this socket
+ * @param {Object} socket - the socket
+ * @returns {string}
+ */
+function socketName (socket) {
+    let result = socket.remoteAddress;
+    if (socket.remotePort) {
+        result += `:${socket.remotePort}`;
+    }
+    return result;
+}
+
+/**
+ * Returns a deep clone of obj
+ * @param {Object} obj - the object to clone
+ * @returns {Object}
+ */
+function clone (obj) {
+    return JSON.parse(JSON.stringify(obj));
+}
+
+/**
+ * Returns a new object combining the two parameters
+ * @param {Object} defaults - The base object
+ * @param {Object} overrides - The object to merge from.  Where the same property exists in both defaults
+ * and overrides, the values for overrides will be used
+ * @returns {Object}
+ */
+function merge (defaults, overrides) {
+    const result = clone(defaults);
+    Object.keys(overrides).forEach(key => {
+        if (typeof overrides[key] === 'object' && overrides[key] !== null) {
+            result[key] = merge(result[key] || {}, overrides[key]);
+        }
+        else {
+            result[key] = overrides[key];
+        }
+    });
+    return result;
+}
+
+/**
+ * Sets a value of nested key string descriptor inside a Object.
+ * It changes the passed object.
+ * Ex:
+ *    let obj = {a: {b:{c:'initial'}}}
+ *    setNestedKey(obj, ['a', 'b', 'c'], 'changed-value')
+ *    assert(obj === {a: {b:{c:'changed-value'}}})
+ *
+ * @param {Object} obj   Object to set the nested key
+ * @param {Array} path  An array to describe the path(Ex: ['a', 'b', 'c'])
+ * @param {Object} value Any value
+ * @returns {undefined}
+ * from https://stackoverflow.com/a/49754647
+ */
+function setDeep (obj, path, value) {
+    if (path.length === 1) {
+        obj[path] = value;
+        return;
+    }
+    setDeep(obj[path[0]], path.slice(1), value);
+}
+
+function simulateFault (socket, faultConfig, logger) {
+    if (typeof faultConfig === 'undefined') {
+        return false;
+    }
+    if (faultConfig === 'CONNECTION_RESET_BY_PEER') {
+        logger.debug('Closing the connection');
+        socket.destroy();
+        return true;
+    }
+    else if (faultConfig === 'RANDOM_DATA_THEN_CLOSE') {
+        logger.debug('Sending garbage data then closing the connection');
+        socket.write(Buffer.from('Htijy%@tWXJ/hQ#[Q:7G@dH4"gu[QaX&', 'utf-8'));
+        socket.destroy();
+        return true;
+    }
+    else {
+        logger.error('Unexpected fault type [' + faultConfig + '], expected either CONNECTION_RESET_BY_PEER or RANDOM_DATA_THEN_CLOSE');
+        return false;
+    }
+}
+
+/**
+ * Remove specific key and value from object
+ * @param {Object} obj Object to filter
+ * @param {Array|Object|String} filter keys to remove
+ * @returns {Object}
+ */
+
+function objFilter (obj, filter) {
+
+    if (typeof filter === 'string') {
+        delete obj[filter];
+    }
+    else if (Array.isArray(filter)) {
+        filter.filter(keyFilter => obj[keyFilter]).forEach(keyFilter => objFilter(obj, keyFilter));
+    }
+    else {
+        Object.keys(filter).filter(keyFilter => obj[keyFilter]).forEach(keyFilter => objFilter(obj[keyFilter], filter[keyFilter]));
+    }
+    return obj;
+}
+
+module.exports = { defined, isObject, socketName, clone, merge, setDeep, simulateFault, objFilter };

package/src/util/inherit.js

@@ -0,0 +1,28 @@
+'use strict';
+
+/** @module */
+
+/**
+ * Crockford-style prototypical inheritance, which basically allows me to completely
+ * avoid the new and this operators, which I have an unnatural aversion to
+ * @param {Object} proto - the object to inherit from
+ * @param {Object} [obj] - properties to merge into the newly created object as own properties
+ * @returns {Object}
+ */
+function from (proto, obj) {
+    // allow either inherit.from(EventEmitter) or inherit.from({key: 'value'})
+    if (typeof proto === 'function') {
+        proto = new proto();
+    }
+
+    obj = obj || {};
+    function F () {}
+    F.prototype = proto;
+    const result = new F();
+    Object.keys(obj).forEach(key => {
+        result[key] = obj[key];
+    });
+    return result;
+}
+
+module.exports = { from };

package/src/util/ip.js

@@ -0,0 +1,54 @@
+'use strict';
+
+const os = require('os');
+
+function getLocalIPs () {
+    const interfaces = os.networkInterfaces(),
+        result = [];
+
+    Object.keys(interfaces).forEach(name => {
+        interfaces[name].forEach(ip => {
+            if (ip.internal) {
+                result.push(ip.address);
+                if (ip.family === 'IPv4') {
+                    // Prefix for IPv4 address mapped to a compliant IPv6 scheme
+                    result.push(`::ffff:${ip.address}`);
+                }
+            }
+        });
+    });
+    return result;
+}
+
+function ipWithoutZoneId (ip) {
+    return ip.replace(/%\w+/, '').toLowerCase();
+}
+
+function createIPVerification (options) {
+    const allowedIPs = getLocalIPs();
+
+    if (!options.localOnly) {
+        options.ipWhitelist.forEach(ip => { allowedIPs.push(ip.toLowerCase()); });
+    }
+
+    if (allowedIPs.indexOf('*') >= 0) {
+        return () => true;
+    }
+    else {
+        return (ip, logger) => {
+            if (typeof ip === 'undefined') {
+                logger.error('Blocking request because no IP address provided. This is likely a bug in the protocol implementation.');
+                return false;
+            }
+            else {
+                const allowed = allowedIPs.some(allowedIP => allowedIP === ipWithoutZoneId(ip));
+                if (!allowed) {
+                    logger.warn(`Blocking incoming connection from ${ip}. Turn off --localOnly or add to --ipWhitelist to allow`);
+                }
+                return allowed;
+            }
+        };
+    }
+}
+
+module.exports = { createIPVerification };

package/src/util/logger.js

@@ -0,0 +1,83 @@
+'use strict';
+const path = require('path'),
+    fs = require('fs-extra'),
+    winston = require('winston'),
+    scopedLogger = require('./scopedLogger.js');
+
+function initializeLogfile (filename) {
+    // Ensure new logfile on startup so the /logs only shows for this process
+    const extension = path.extname(filename),
+        pattern = new RegExp(`${extension}$`),
+        newFilename = filename.replace(pattern, `1${extension}`);
+
+    if (fs.existsSync(filename)) {
+        fs.renameSync(filename, newFilename);
+    }
+}
+
+function logFormat (config) {
+    const template = config.replace(/\$/g, '') // prevent injection attacks
+        .replace(/%level/g, '${info.level}')
+        .replace(/%message/g, '${info.message}')
+        .replace(/%timestamp/g, '${info.timestamp}');
+
+    // eslint-disable-next-line no-new-func
+    return new Function('info', `return \`${template}\`;`);
+}
+
+function createWinstonFormat (format, config) {
+    const formatters = [format.timestamp()];
+    if (config.colorize) {
+        formatters.push(format.colorize());
+    }
+    if (config.format === 'json') {
+        formatters.push(format.json());
+    }
+    else if (config.format === 'simple') {
+        formatters.push(format.simple());
+    }
+    else {
+        formatters.push(format.printf(logFormat(config.format)));
+    }
+    return format.combine(...formatters);
+}
+
+function createLogger (options) {
+    if (!options.log) {
+        options.log = { level: 'info' };
+    }
+    if (!options.log.transports) {
+        options.log.transports = {
+            file: {
+                path: 'mb.log',
+                format: 'json'
+            }
+        };
+    }
+
+    const winstonLogger = winston.createLogger({ level: options.log.level }),
+        logger = scopedLogger.create(winstonLogger, `[mb:${options.port}] `),
+        consoleConfig = options.log.transports.console,
+        fileConfig = options.log.transports.file;
+
+    if (consoleConfig) {
+        winstonLogger.add(new winston.transports.Console({
+            format: createWinstonFormat(winston.format, consoleConfig)
+        }));
+    }
+    if (fileConfig) {
+        initializeLogfile(fileConfig.path);
+        winstonLogger.add(new winston.transports.File({
+            filename: fileConfig.path,
+            maxsize: '20m',
+            maxFiles: 5,
+            tailable: true,
+            format: createWinstonFormat(winston.format, fileConfig)
+        }));
+    }
+
+    return logger;
+}
+
+module.exports = { createLogger };
+