index.js

/**
 * Copyright JS Foundation and other contributors, http:https://js.foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http:https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 **/
'use strict';

const path = require("path");
const process = require("process")
const sinon = require("sinon");
const should = require('should');
const fs = require('fs');
require('should-sinon');
const request = require('supertest');
var bodyParser = require("body-parser");
const express = require("express");
const http = require('http');
const stoppable = require('stoppable');
const semver = require('semver');
const EventEmitter = require('events').EventEmitter;

const PROXY_METHODS = ['log', 'status', 'warn', 'error', 'debug', 'trace', 'send'];


// Find the nearest package.json
function findPackageJson(dir) {
    dir = path.resolve(dir || process.cwd())
    const { root } = path.parse(dir)
    if (dir === root) {
        return null
    }
    const packagePath = path.join(dir, 'package.json')
    if (fs.existsSync(packagePath)) {
        return {
            path: packagePath,
            packageJson: JSON.parse(fs.readFileSync(packagePath, 'utf-8'))
        }
    } else {
        return findPackageJson(path.resolve(path.join(dir, '..')))
    }
}

/**
 * Finds the NR runtime path by inspecting environment
 */
function findRuntimePath() {
    const upPkg = findPackageJson()
    // case 1: we're in NR itself
    if (upPkg.packageJson.name === 'node-red') {
        if (checkSemver(upPkg.packageJson.version,"<0.20.0")) {
            return path.join(path.dirname(upPkg.path), upPkg.packageJson.main);
        } else {
            return path.join(path.dirname(upPkg.path),"packages","node_modules","node-red");
        }
    }
    // case 2: NR is resolvable from here
    try {
        return require.resolve('node-red');
    } catch (ignored) {}
    // case 3: NR is installed alongside node-red-node-test-helper
    if ((upPkg.packageJson.dependencies && upPkg.packageJson.dependencies['node-red']) ||
        (upPkg.packageJson.devDependencies && upPkg.packageJson.devDependencies['node-red'])) {
        const dirpath = path.join(path.dirname(upPkg.path), 'node_modules', 'node-red');
        try {
            const pkg = require(path.join(dirpath, 'package.json'));
            return path.join(dirpath, pkg.main);
        } catch (ignored) {}
    }
    // case 4: NR & NRNTH are git repos sat alongside each other
    try {
        const nrpkg = require("../node-red/package.json");
        return "../node-red/packages/node_modules/node-red"
    } catch(ignored) {}
}


// As we have prerelease tags in development version, they need stripping off
// before semver will do a sensible comparison with a range.
function checkSemver(localVersion,testRange) {
    var parts = localVersion.split("-");
    return semver.satisfies(parts[0],testRange);
}

class NodeTestHelper extends EventEmitter {
    constructor() {
        super();

        this._sandbox = sinon.createSandbox();

        this._address = '127.0.0.1';
        this._listenPort = 0; // ephemeral

        this.init();
    }

    _initRuntime(requirePath) {
        try {
            const RED = this._RED = require(requirePath);
            // public runtime API
            this._log = RED.log;
            // access internal Node-RED runtime methods
            let prefix = path.dirname(requirePath);
            if (checkSemver(RED.version(),"<0.20.0")) {
                this._settings = RED.settings;
                this._events = RED.events;
                this._redNodes = RED.nodes;
                this._context = require(path.join(prefix, 'runtime', 'nodes', 'context'));
                this._comms = require(path.join(prefix, 'api', 'editor', 'comms'));
                this.credentials = require(path.join(prefix, 'runtime', 'nodes', 'credentials'));
                // proxy the methods on Node.prototype to both be Sinon spies and asynchronously emit
                // information about the latest call
                this._NodePrototype = require(path.join(prefix, 'runtime', 'nodes', 'Node')).prototype;
            } else {
                if (!fs.existsSync(path.join(prefix, '@node-red/runtime/lib/nodes'))) {
                    // Not in the NR source tree, need to go hunting for the modules....
                    if (fs.existsSync(path.join(prefix,'..','node_modules','@node-red/runtime/lib/nodes'))) {
                        // path/to/node_modules/node-red/lib
                        // path/to/node_modules/node-red/node_modules/@node-red
                        prefix = path.resolve(path.join(prefix,"..","node_modules"));
                    } else if (fs.existsSync(path.join(prefix,'..','..','@node-red/runtime/lib/nodes'))) {
                        // path/to/node_modules/node-red/lib
                        // path/to/node_modules/@node-red
                        prefix = path.resolve(path.join(prefix,"..",".."));
                    } else {
                        throw new Error("Cannot find the NR source tree. Path: '"+prefix+"'. Please raise an issue against node-red/node-red-node-test-helper with full details.");
                    }
                }

                this._redNodes = require(path.join(prefix, '@node-red/runtime/lib/nodes'));
                this._context = require(path.join(prefix, '@node-red/runtime/lib/nodes/context'));
                this._comms = require(path.join(prefix, '@node-red/editor-api/lib/editor/comms'));
                this._registryUtil = require(path.join(prefix, '@node-red/registry/lib/util'));
                this.credentials = require(path.join(prefix, '@node-red/runtime/lib/nodes/credentials'));
                // proxy the methods on Node.prototype to both be Sinon spies and asynchronously emit
                // information about the latest call
                this._NodePrototype = require(path.join(prefix, '@node-red/runtime/lib/nodes/Node')).prototype;
                this._settings = RED.settings;
                this._events = RED.runtime.events;

                this._nodeModules = {
                    'catch': require(path.join(prefix, '@node-red/nodes/core/common/25-catch.js')),
                    'status': require(path.join(prefix, '@node-red/nodes/core/common/25-status.js')),
                    'complete': require(path.join(prefix, '@node-red/nodes/core/common/24-complete.js'))
                }


            }
        } catch (ignored) {
            console.log(ignored);
            // ignore, assume init will be called again by a test script supplying the runtime path
        }
    }

    init(runtimePath, userSettings) {
        runtimePath = runtimePath || findRuntimePath();
        if (runtimePath) {
            this._initRuntime(runtimePath);
            if (userSettings) {
                this.settings(userSettings);
            }
        }
    }

    /**
     * Merges any userSettings with the defaults returned by `RED.settings`. Each
     * invocation of this method will overwrite the previous userSettings to prevent
     * unexpected problems in your tests.
     *
     * This will enable you to replicate your production environment within your tests,
     * for example where you're using the `functionGlobalContext` to enable extra node
     * modules within your functions.
     * @example
     * helper.settings({ functionGlobalContext: { os:require('os') } });
     * @param {Object} userSettings - an object containing the runtime settings
     * @return {Object} custom userSettings merged with default RED.settings
     */
    settings(userSettings) {
        if (userSettings) {
            // to prevent unexpected problems, always merge with the default RED.settings
            this._settings = Object.assign({}, this._RED.settings, userSettings);
        }
        return this._settings;
    }

    load(testNode, testFlow, testCredentials, cb) {
        const log = this._log;
        const logSpy = this._logSpy = this._sandbox.spy(log, 'log');
        logSpy.FATAL = log.FATAL;
        logSpy.ERROR = log.ERROR;
        logSpy.WARN = log.WARN;
        logSpy.INFO = log.INFO;
        logSpy.DEBUG = log.DEBUG;
        logSpy.TRACE = log.TRACE;
        logSpy.METRIC = log.METRIC;

        const self = this;
        PROXY_METHODS.forEach(methodName => {
            const spy = this._sandbox.spy(self._NodePrototype, methodName);
            self._NodePrototype[methodName] = new Proxy(spy, {
                apply: (target, thisArg, args) => {
                    const retval = Reflect.apply(target, thisArg, args);
                    process.nextTick(function(call) { return () => {
                            self._NodePrototype.emit.call(thisArg, `call:${methodName}`, call);
                    }}(spy.lastCall));
                    return retval;
                }
            });
        });


        if (typeof testCredentials === 'function') {
            cb = testCredentials;
            testCredentials = {};
        }
        const conf = {flows:testFlow,credentials:testCredentials|| {}}
        const storage = {
            conf: conf,
            getFlows: function () {
                return Promise.resolve(conf);
            },
            saveFlows: function(conf) {
                storage.conf = conf;
                return Promise.resolve();
            }
        };

        // mock out the runtime plugins api
        const plugins = {
            registerPlugin () {
                return;
            },
            getPlugin () {
                return;
            },
            getPluginsByType () {
                return [];
            }
        }

        // this._settings.logging = {console:{level:'off'}};
        this._settings.available = function() { return false; }

        const redNodes = this._redNodes;
        this._httpAdmin = express();
        this._httpAdmin.use(bodyParser.json({limit:'5mb'}));
        this._httpAdmin.use(bodyParser.urlencoded({limit:'5mb',extended:true}));

        const mockRuntime = {
            nodes: redNodes,
            events: this._events,
            util: this._RED.util,
            settings: this._settings,
            storage: storage,
            plugins: plugins,
            log: this._log,
            nodeApp: express(),
            adminApp: this._httpAdmin,
            library: {register: function() {}},
            get server() { return self._server }
        }
        redNodes.init(mockRuntime);
        redNodes.registerType("helper", function (n) {
            redNodes.createNode(this, n);
        });

        var red;
        if (this._registryUtil) {
            this._registryUtil.init(mockRuntime);
            red = this._registryUtil.createNodeApi({});
            red._ = v=>v;
            red.settings = this._settings;
        } else {
            red = {
                _: v => v
            };
            Object.keys(this._RED).filter(prop => !/^(init|start|stop)$/.test(prop))
                .forEach(prop => {
                    const propDescriptor = Object.getOwnPropertyDescriptor(this._RED, prop);
                    Object.defineProperty(red, prop, propDescriptor);
                });
        }
        const initPromises = []

        let preloadedCoreModules = new Set();
        testFlow.forEach(n => {
            if (this._nodeModules.hasOwnProperty(n.type)) {
                // Go find the 'real' core node module and load it...
                const result = this._nodeModules[n.type](red);
                if (result?.then) {
                    initPromises.push(result)
                }
                preloadedCoreModules.add(this._nodeModules[n.type]);
            }
        })

        if (!Array.isArray(testNode)) {
            testNode = [testNode];
        }
        testNode.forEach(fn => {
            if (!preloadedCoreModules.has(fn)) {
                const result = fn(red);
                if (result?.then) {
                    initPromises.push(result)
                }
            }
        });
        return Promise.all(initPromises)
            .then(() => redNodes.loadFlows())
            .then(() => redNodes.startFlows())
            .then(() => {
                should.deepEqual(testFlow, redNodes.getFlows().flows);
                if(cb) cb();
            });
    }

    unload() {
        // TODO: any other state to remove between tests?
        this._redNodes.clearRegistry();
        this._logSpy && this._logSpy.restore();
        this._sandbox.restore();

        // internal API
        this._context.clean({allNodes:[]});
        return this._redNodes.stopFlows()
    }

    /**
     * Returns a Node by id.
     * @param {string} id - Node ID
     * @returns {Node}
     */
    getNode(id) {
        return this._redNodes.getNode(id);
    }

    clearFlows() {
        return this._redNodes.stopFlows();
    }

    /**
     * Update flows
     * @param {object|object[]} testFlow Flow data to test a node
     * @param {"full"|"flows"|"nodes"} type The type of deploy mode "full", "flows" or "nodes" (defaults to "full") 
     * @param {object} [testCredentials] Optional node credentials
     * @param {function} [cb] Optional callback (not required when called with await)
     * @returns {Promise}
     */
    setFlows(testFlow, type, testCredentials, cb) {
        const helper = this;
        if (typeof testCredentials === 'string' ) {
            cb = testCredentials;
            testCredentials = {};
        }
        if(!type || typeof type != "string") {
            type = "full"
        }
        async function waitStarted() {
            return new Promise((resolve, reject) => {
                let timeover = setTimeout(() => {
                    if (timeover) {
                        timeover = null
                        reject(Error("timeout waiting event"))
                    }
                }, 300);
                function hander() {
                    clearTimeout(timeover)
                    helper._events.off('flows:started', hander)
                    if (timeover) {
                        timeover = null
                        resolve()
                    }
                }
                helper._events.on('flows:started', hander); // call resolve when its done
            });
        }
        return this._redNodes.setFlows(testFlow, testCredentials || {}, type)
            .then(waitStarted)
            .then(() => {
                if(cb) cb();
            });
    }

    request() {
        return request(this._httpAdmin);
    }

    startServer(done) {
        this._app = express();
        const server = stoppable(http.createServer((req, res) => {
            this._app(req, res);
        }), 0);

        this._RED.init(server,{
            logging:{console:{level:'off'}}
        });
        server.listen(this._listenPort, this._address);
        server.on('listening', () => {
            this._port = server.address().port;
            // internal API
            this._comms.start();
            done();
        });
        this._server = server;
    }

    //TODO consider saving TCP handshake/server reinit on start/stop/start sequences
    stopServer(done) {
        if (this._server) {
            try {
                // internal API
                this._comms.stop();
                this._server.stop(done);
            } catch (e) {
                done();
            }
        } else {
            done();
        }
    }

    url() {
        return `http:https://${this._address}:${this._port}`;
    }

    log() {
        return this._logSpy;
    }
}

module.exports = new NodeTestHelper();
module.exports.NodeTestHelper = NodeTestHelper;