Merge branch 'dev' into pr_1789

test/editor/editor_helper.js

@@ -21,7 +21,7 @@ var fs = require('fs-extra');
 var path = require('path');
 var app = express();
 
-var RED = require("../../red/red.js");
+var RED = require("nr-test-utils").require("node-red/lib/red.js");
 
 var utilPage = require("./pageobjects/util/util_page");
 

test/editor/pageobjects/editor/palette_page.js

@@ -17,11 +17,22 @@
 var idMap = {
     // input
     "inject": "#palette_node_inject",
+    "httpin": "#palette_node_http_in",
+    "mqttIn": "#palette_node_mqtt_in",
     // output
     "debug": "#palette_node_debug",
+    "httpResponse": "#palette_node_http_response",
+    "mqttOut": "#palette_node_mqtt_out",
     // function
+    "function": "#palette_node_function",
+    "template": "#palette_node_template",
     "change": "#palette_node_change",
     "range": "#palette_node_range",
+    "httpRequest": "#palette_node_http_request",
+    "html": "#palette_node_html",
+    "json": "#palette_node_json",
+    // storage
+    "filein": "#palette_node_file_in",
 };
 
 function getId(type) {

test/editor/pageobjects/editor/workspace_page.js

@@ -16,7 +16,7 @@
 
  var when = require("when");
 
-var events = require("../../../../red/runtime/events.js");
+var events = require("nr-test-utils").require("@node-red/runtime/lib/events.js");
 
 var palette = require("./palette_page");
 var nodeFactory = require("../nodes/nodefactory_page");
@@ -36,6 +36,7 @@ function addNode(type, x, y) {
 }
 
 function deleteAllNodes() {
+    browser.click('.innerCanvas');
     browser.keys(['Control', 'a', 'a', 'Control']); // call twice to release the keys.
     browser.keys(['Delete']);
 }

test/editor/pageobjects/nodes/core/core/20-inject_page.js

@@ -24,10 +24,10 @@ function injectNode(id) {
 
 util.inherits(injectNode, nodePage);
 
-var payloadType = {
+var payloadTypeList = {
     "flow": 1,
     "global": 2,
-    "string": 3,
+    "str": 3,
     "num": 4,
     "bool": 5,
     "json": 6,
@@ -36,18 +36,43 @@ var payloadType = {
     "env": 9,
 };
 
-injectNode.prototype.setPayload = function(type, value) {
+var repeatTypeList = {
+    "none": 1,
+    "interval": 2,
+    "intervalBetweenTimes": 3,
+    "atASpecificTime": 4,
+};
+
+injectNode.prototype.setPayload = function(payloadType, payload) {
     // Open a payload type list.
     browser.clickWithWait('//*[contains(@class, "red-ui-typedInput-container")]');
     // Select a payload type.
-    var payloadTypeXPath = '//*[@class="red-ui-typedInput-options"]/a[' + payloadType[type] + ']';
+    var payloadTypeXPath = '//*[@class="red-ui-typedInput-options"]/a[' + payloadTypeList[payloadType] + ']';
     browser.clickWithWait(payloadTypeXPath);
-    // Input a value.
-    browser.setValue('//*[@class="red-ui-typedInput-input"]/input', value);
+    if (payload) {
+        // Input a value.
+        browser.setValue('//*[@class="red-ui-typedInput-input"]/input', payload);
+    }
 }
 
-injectNode.prototype.setTopic = function(value) {
-    browser.setValue('#node-input-topic', value);
+injectNode.prototype.setTopic = function(topic) {
+    browser.setValue('#node-input-topic', topic);
+}
+
+injectNode.prototype.setOnce = function(once) {
+    var isChecked = browser.isSelected('#node-input-once');
+    if (isChecked !== once) {
+        browser.clickWithWait('#node-input-once');
+    }
+}
+
+injectNode.prototype.setRepeat = function(repeatType) {
+    var repeatTypeXPath = '//*[@id="inject-time-type-select"]/option[' + repeatTypeList[repeatType] + ']';
+    browser.clickWithWait(repeatTypeXPath);
+}
+
+injectNode.prototype.setRepeatInterval = function(repeat) {
+    browser.setValue('#inject-time-interval-count', repeat);
 }
 
 module.exports = injectNode;

test/editor/pageobjects/nodes/core/core/58-debug_page.js

@@ -24,4 +24,21 @@ function debugNode(id) {
 
 util.inherits(debugNode, nodePage);
 
+debugNode.prototype.setOutput = function(complete) {
+    // Open a payload type list.
+    browser.clickWithWait('//*[contains(@class, "red-ui-typedInput-container")]/button');
+    if (complete !== 'true') {
+        // Select the "msg" type.
+        browser.clickWithWait('//div[@class="red-ui-typedInput-options"][1]/a[1]');
+        // Input the path in msg.
+        browser.clickWithWait('//*[contains(@class, "red-ui-typedInput-input")]/input');
+        browser.keys(['Control', 'a', 'Control']);
+        browser.keys(['Delete']);
+        browser.setValue('//*[contains(@class, "red-ui-typedInput-input")]/input', complete);
+    } else {
+        // Select the "complete msg object" type.
+        browser.clickWithWait('/html/body/div[11]/a[2]');
+    }
+}
+
 module.exports = debugNode;

test/editor/pageobjects/nodes/core/core/80-function_page.js

@@ -0,0 +1,40 @@
+/**
+ * Copyright JS Foundation and other contributors, http://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://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.
+ **/
+
+var util = require("util");
+
+var nodePage = require("../../node_page");
+
+function functionNode(id) {
+    nodePage.call(this, id);
+}
+
+util.inherits(functionNode, nodePage);
+
+functionNode.prototype.setFunction = function(func) {
+    browser.click('#node-input-func-editor');
+    browser.keys(['Control', 'Home', 'Control']);
+    for (var i = 0; i < func.length; i++) {
+        browser.keys([func.charAt(i)]);
+    }
+    // Delete the unnecessary code that ace editor does the autocompletion.
+    browser.keys(['Control', 'Shift', 'End', 'Shift', 'Control']);
+    browser.keys(['Delete']);
+    // Need to wait until ace editor correctly checks the syntax.
+    browser.pause(50);
+}
+
+module.exports = functionNode;

test/editor/pageobjects/nodes/core/core/80-template_page.js

@@ -0,0 +1,46 @@
+/**
+ * Copyright JS Foundation and other contributors, http://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://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.
+ **/
+
+var util = require("util");
+
+var nodePage = require("../../node_page");
+
+function templateNode(id) {
+    nodePage.call(this, id);
+}
+
+util.inherits(templateNode, nodePage);
+
+templateNode.prototype.setSyntax = function(syntax) {
+    browser.selectWithWait('#node-input-syntax', syntax);
+}
+
+templateNode.prototype.setFormat = function(format) {
+    browser.selectWithWait('#node-input-format', format);
+}
+
+templateNode.prototype.setTemplate = function(template) {
+    browser.click('#node-input-template-editor');
+    browser.keys(['Control', 'a', 'Control']); // call twice to release the keys.
+    // Need to add a character one by one since some words such as 'Control' are treated as a special word.
+    for (var i = 0; i < template.length; i++) {
+        browser.keys([template.charAt(i)]);
+    }
+    browser.keys(['Control', 'Shift', 'End', 'Shift', 'Control']);
+    browser.keys(['Delete']);
+}
+
+module.exports = templateNode;

test/editor/pageobjects/nodes/core/io/10-mqttconfig_page.js

@@ -0,0 +1,39 @@
+/**
+ * Copyright JS Foundation and other contributors, http://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://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.
+ **/
+
+function setServer(broker, port) {
+    browser.setValue('#node-config-input-broker', broker);
+    port = port ? port : 1883;
+    browser.setValue('#node-config-input-port', port);
+}
+
+function clickOk() {
+    browser.clickWithWait('#node-config-dialog-ok');
+    // Wait until an config dialog closes.
+    browser.waitForVisible('#node-config-dialog-ok', 2000, true);
+}
+
+function edit() {
+    browser.clickWithWait('#node-input-lookup-broker');
+    // Wait until a config dialog opens.
+    browser.waitForVisible('#node-config-dialog-ok', 2000);
+}
+
+module.exports = {
+    setServer: setServer,
+    clickOk: clickOk,
+    edit: edit
+};

test/editor/pageobjects/nodes/core/io/10-mqttin_page.js

@@ -0,0 +1,35 @@
+/**
+ * Copyright JS Foundation and other contributors, http://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://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.
+ **/
+
+var util = require("util");
+
+var nodePage = require("../../node_page");
+
+function mqttInNode(id) {
+    nodePage.call(this, id);
+}
+
+util.inherits(mqttInNode, nodePage);
+
+mqttInNode.prototype.setTopic = function (topic) {
+    browser.setValue('#node-input-topic', topic);
+}
+
+mqttInNode.prototype.setQoS = function (qos) {
+    browser.selectWithWait('#node-input-qos', qos);
+}
+
+module.exports = mqttInNode;

test/editor/pageobjects/nodes/core/io/10-mqttout_page.js

@@ -0,0 +1,35 @@
+/**
+ * Copyright JS Foundation and other contributors, http://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://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.
+ **/
+
+var util = require("util");
+
+var nodePage = require("../../node_page");
+
+function mqttOutNode(id) {
+    nodePage.call(this, id);
+}
+
+util.inherits(mqttOutNode, nodePage);
+
+mqttOutNode.prototype.setTopic = function(topic) {
+    browser.setValue('#node-input-topic', topic);
+}
+
+mqttOutNode.prototype.setRetain = function (retain) {
+    browser.selectWithWait('#node-input-retain', retain);
+}
+
+module.exports = mqttOutNode;

test/editor/pageobjects/nodes/core/io/21-httpin_page.js

@@ -0,0 +1,35 @@
+/**
+ * Copyright JS Foundation and other contributors, http://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://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.
+ **/
+
+var util = require("util");
+
+var nodePage = require("../../node_page");
+
+function httpinNode(id) {
+    nodePage.call(this, id);
+}
+
+util.inherits(httpinNode, nodePage);
+
+httpinNode.prototype.setMethod = function(method) {
+    browser.selectWithWait('#node-input-method', method);
+}
+
+httpinNode.prototype.setUrl = function(url) {
+    browser.setValue('#node-input-url', url);
+}
+
+module.exports = httpinNode;

test/editor/pageobjects/nodes/core/io/21-httprequest_page.js

@@ -0,0 +1,39 @@
+/**
+ * Copyright JS Foundation and other contributors, http://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://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.
+ **/
+
+var util = require("util");
+
+var nodePage = require("../../node_page");
+
+function httpRequestNode(id) {
+    nodePage.call(this, id);
+}
+
+util.inherits(httpRequestNode, nodePage);
+
+httpRequestNode.prototype.setUrl = function(url) {
+    browser.setValue('#node-input-url', url);
+}
+
+httpRequestNode.prototype.setMethod = function(method) {
+    browser.selectWithWait('#node-input-method', method);
+}
+
+httpRequestNode.prototype.setReturn = function(ret) {
+    browser.selectWithWait('#node-input-ret', ret);
+}
+
+module.exports = httpRequestNode;

test/editor/pageobjects/nodes/core/io/21-httpresponse_page.js

@@ -0,0 +1,27 @@
+/**
+ * Copyright JS Foundation and other contributors, http://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://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.
+ **/
+
+var util = require("util");
+
+var nodePage = require("../../node_page");
+
+function httpResponseNode(id) {
+    nodePage.call(this, id);
+}
+
+util.inherits(httpResponseNode, nodePage);
+
+module.exports = httpResponseNode;

test/editor/pageobjects/nodes/core/logic/15-change_page.js

@@ -24,14 +24,52 @@ function changeNode(id) {
 
 util.inherits(changeNode, nodePage);
 
-function setT(rule, index) {
-    browser.selectByValue('//*[@id="node-input-rule-container"]/li[' + index + ']/div/div[1]/select', rule);
+var totType = {
+    "msg": 1,
+    "flow": 2,
+    "global": 3,
+    "str": 4,
+    "num": 5,
+    "bool": 6,
+    "json": 7,
+    "bin": 8,
+    "date": 9,
+    "jsonata": 10,
+    "env": 11,
+};
+
+var ptType = {
+    "msg": 1,
+    "flow": 2,
+    "global": 3,
+};
+
+function setT(t, index) {
+    browser.selectWithWait('//*[@id="node-input-rule-container"]/li[' + index + ']/div/div[1]/select', t);
 }
 
-changeNode.prototype.ruleSet = function(to, index) {
+// It is better to create a function whose input value is the object type in the future,
+changeNode.prototype.ruleSet = function(p, pt, to, tot, index) {
     index = index ? index : 1;
     setT("set", index);
-    browser.setValue('//*[@id="node-input-rule-container"]/li[' + index + ']/div/div[2]/div[2]/div/input', to);
+    if (pt) {
+        browser.clickWithWait('//*[@id="node-input-rule-container"]/li[' + index + ']/div/div[1]/div/button[1]');
+        var num = 5 * (index - 1) + 1;
+        var ptXPath = '//div[@class="red-ui-typedInput-options"][' + num + ']/a[' + ptType[pt] + ']';
+        browser.clickWithWait(ptXPath);
+    }
+    if (p) {
+        browser.setValue('//*[@id="node-input-rule-container"]/li[' + index + ']/div/div[1]/div/div/input', p);
+    }
+    if (tot) {
+        browser.clickWithWait('//*[@id="node-input-rule-container"]/li[' + index + ']/div/div[2]/div[2]/button[1]');
+        var num = 5 * (index - 1) + 2;
+        var totXPath = '//div[@class="red-ui-typedInput-options"][' + num + ']/a[' + totType[tot] + ']';
+        browser.clickWithWait(totXPath);
+    }
+    if (to) {
+        browser.setValue('//*[@id="node-input-rule-container"]/li[' + index + ']/div/div[2]/div[2]/div/input' , to);
+    }
 }
 
 changeNode.prototype.ruleDelete = function(index) {

test/editor/pageobjects/nodes/core/logic/16-range_page.js

@@ -24,8 +24,8 @@ function rangeNode(id) {
 
 util.inherits(rangeNode, nodePage);
 
-rangeNode.prototype.setAction = function(value) {
-    browser.selectByValue('#node-input-action', value);
+rangeNode.prototype.setAction = function(action) {
+    browser.selectWithWait('#node-input-action', action);
 }
 
 rangeNode.prototype.setRange = function(minin, maxin, minout, maxout) {

test/editor/pageobjects/nodes/core/parsers/70-HTML_page.js

@@ -0,0 +1,31 @@
+/**
+ * Copyright JS Foundation and other contributors, http://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://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.
+ **/
+
+var util = require("util");
+
+var nodePage = require("../../node_page");
+
+function htmlNode(id) {
+    nodePage.call(this, id);
+}
+
+util.inherits(htmlNode, nodePage);
+
+htmlNode.prototype.setSelector = function(tag) {
+    browser.setValue('#node-input-tag', tag);
+}
+
+module.exports = htmlNode;

test/editor/pageobjects/nodes/core/parsers/70-JSON_page.js

@@ -0,0 +1,35 @@
+/**
+ * Copyright JS Foundation and other contributors, http://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://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.
+ **/
+
+var util = require("util");
+
+var nodePage = require("../../node_page");
+
+function jsonNode(id) {
+    nodePage.call(this, id);
+}
+
+util.inherits(jsonNode, nodePage);
+
+jsonNode.prototype.setAction = function (action) {
+    browser.setValue('node-input-action', action);
+}
+
+jsonNode.prototype.setProperty = function(property) {
+    browser.setValue('//*[@id="dialog-form"]/div[2]/div/div/input', property);
+}
+
+module.exports = jsonNode;

test/editor/pageobjects/nodes/core/storage/50-filein_page.js

@@ -0,0 +1,44 @@
+/**
+ * Copyright JS Foundation and other contributors, http://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://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.
+ **/
+
+var util = require("util");
+
+var nodePage = require("../../node_page");
+
+function fileinNode(id) {
+    nodePage.call(this, id);
+}
+
+util.inherits(fileinNode, nodePage);
+
+var formatType = {
+    "utf8": 1,
+    "lines": 2,
+    "": 3,  // a single Buffer object
+    "stream": 4
+};
+
+fileinNode.prototype.setFilename = function(filename) {
+    browser.setValue('#node-input-filename', filename);
+}
+
+fileinNode.prototype.setOutput = function(format) {
+    browser.clickWithWait('#node-input-format');
+    var formatTypeXPath = '//*[@id="node-input-format"]/option[' + formatType[format] + ']';
+    browser.clickWithWait(formatTypeXPath);
+}
+
+module.exports = fileinNode;

test/editor/pageobjects/nodes/nodefactory_page.js

@@ -16,17 +16,39 @@
 
 var injectNode = require('./core/core/20-inject_page');
 var debugNode = require('./core/core/58-debug_page');
+var templateNode = require('./core/core/80-template_page');
+var functionNode = require('./core/core/80-function_page');
+var mqttInNode = require('./core/io/10-mqttin_page');
+var mqttOutNode = require('./core/io/10-mqttout_page');
+var httpinNode = require('./core/io/21-httpin_page');
+var httpResponseNode = require('./core/io/21-httpresponse_page');
 var changeNode = require('./core/logic/15-change_page');
 var rangeNode = require('./core/logic/16-range_page');
+var httpRequestNode = require('./core/io/21-httprequest_page');
+var htmlNode = require('./core/parsers/70-HTML_page');
+var jsonNode = require('./core/parsers/70-JSON_page');
+var fileinNode = require('./core/storage/50-filein_page');
+
 
 var nodeCatalog = {
     // input
     "inject": injectNode,
+    "httpin": httpinNode,
+    "mqttIn":mqttInNode,
     // output
     "debug": debugNode,
+    "httpResponse": httpResponseNode,
+    "mqttOut": mqttOutNode,
     // function
+    "function": functionNode,
+    "template": templateNode,
     "change": changeNode,
     "range": rangeNode,
+    "httpRequest": httpRequestNode,
+    "html": htmlNode,
+    "json":jsonNode,
+    // storage
+    "filein": fileinNode,
 }
 
 function create(type, id) {

test/editor/pageobjects/util/spec_util_page.js

@@ -0,0 +1,23 @@
+/**
+ * Copyright JS Foundation and other contributors, http://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://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.
+ **/
+
+function pause(msec) {
+    browser.pause(msec);
+}
+
+ module.exports = {
+     pause: pause,
+ };

test/editor/pageobjects/util/util_page.js

@@ -38,6 +38,12 @@ function init() {
         var ret = browser.getText(selector);
         return ret;
     }, false);
+
+    browser.addCommand("selectWithWait", function(selector, value) {
+        browser.waitForVisible(selector, 5000);
+        var ret = browser.selectByValue(selector, value);
+        return ret;
+    }, false);
 }
 
  module.exports = {

test/editor/specs/editor/workspace_uispec.js

@@ -19,8 +19,8 @@ var should = require("should");
 var fs = require('fs-extra');
 
 var helper = require("../../editor_helper");
-var debugTab = require('../../pageobjects/workspace/debugTab_page');
-var workspace = require('../../pageobjects/workspace/workspace_page');
+var debugTab = require('../../pageobjects/editor/debugTab_page');
+var workspace = require('../../pageobjects/editor/workspace_page');
 
 var nodeWidth = 200;
 

test/editor/specs/scenario/cookbook_endpoint_uispec.js

@@ -0,0 +1,585 @@
+/**
+ * Copyright JS Foundation and other contributors, http://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://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.
+ **/
+
+var should = require("should");
+
+var helper = require("../../editor_helper");
+var debugTab = require('../../pageobjects/editor/debugTab_page');
+var workspace = require('../../pageobjects/editor/workspace_page');
+
+var nodeWidth = 200;
+var nodeHeight = 100;
+var httpNodeRoot = "/api";
+
+// https://cookbook.nodered.org/
+describe('cookbook', function() {
+    beforeEach(function() {
+        workspace.deleteAllNodes();
+    });
+
+    before(function() {
+        helper.startServer();
+    });
+
+    after(function() {
+        helper.stopServer();
+    });
+
+    describe('HTTP endpoints', function () {
+        it('create an HTTP endpoint', function () {
+            var httpinNode = workspace.addNode("httpin");
+            var templateNode = workspace.addNode("template", nodeWidth);
+            var httpResponseNode = workspace.addNode("httpResponse", nodeWidth * 2);
+
+            httpinNode.edit();
+            httpinNode.setMethod("get");
+            httpinNode.setUrl("/hello");
+            httpinNode.clickOk();
+
+            templateNode.edit();
+            templateNode.setSyntax("mustache");
+            templateNode.setFormat("handlebars");
+            templateNode.setTemplate("<html>\n<head></head>\n<body>\n<h1>Hello World!</h1>\n</body>\n</html>");
+            templateNode.clickOk();
+
+            httpinNode.connect(templateNode);
+            templateNode.connect(httpResponseNode);
+
+            // The code for confirmation starts from here.
+            var injectNode = workspace.addNode("inject", 0, nodeHeight);
+            var httpRequestNode = workspace.addNode("httpRequest", nodeWidth, nodeHeight);
+            var debugNode = workspace.addNode("debug", nodeWidth * 2, nodeHeight);
+
+            httpRequestNode.edit();
+            httpRequestNode.setUrl(helper.url() + httpNodeRoot + '/hello');
+            httpRequestNode.setMethod("GET");
+            httpRequestNode.clickOk();
+
+            injectNode.connect(httpRequestNode);
+            httpRequestNode.connect(debugNode);
+            // The code for confirmation ends here.
+
+            workspace.deploy();
+            debugTab.open();
+            debugTab.clearMessage();
+            injectNode.clickLeftButton();
+            debugTab.getMessage().indexOf('Hello World!').should.not.eql(-1);
+        });
+
+        it('handle query parameters passed to an HTTP endpoint', function () {
+            var httpinNode = workspace.addNode("httpin");
+            var templateNode = workspace.addNode("template", nodeWidth);
+            var httpResponseNode = workspace.addNode("httpResponse", nodeWidth * 2);
+
+            httpinNode.edit();
+            httpinNode.setMethod("get");
+            httpinNode.setUrl("/hello-query");
+            httpinNode.clickOk();
+
+            templateNode.edit();
+            templateNode.setSyntax("mustache");
+            templateNode.setFormat("handlebars");
+            templateNode.setTemplate("<html>\n<head></head>\n<body>\n<h1>Hello {{req.query.name}}!</h1>\n</body>\n</html>");
+            templateNode.clickOk();
+
+            httpinNode.connect(templateNode);
+            templateNode.connect(httpResponseNode);
+
+            // The code for confirmation starts from here.
+            var injectNode = workspace.addNode("inject", 0, nodeHeight);
+            var httpRequestNode = workspace.addNode("httpRequest", nodeWidth, nodeHeight);
+            var debugNode = workspace.addNode("debug", nodeWidth * 2, nodeHeight);
+
+            httpRequestNode.edit();
+            httpRequestNode.setUrl(helper.url() + httpNodeRoot + '/hello-query?name=Nick');
+            httpRequestNode.setMethod("GET");
+            httpRequestNode.clickOk();
+
+            injectNode.connect(httpRequestNode);
+            httpRequestNode.connect(debugNode);
+            // The code for confirmation ends here.
+
+            workspace.deploy();
+            debugTab.open();
+            debugTab.clearMessage();
+            injectNode.clickLeftButton();
+            debugTab.getMessage().indexOf('Hello Nick!').should.not.eql(-1);
+        });
+
+        it('handle url parameters in an HTTP endpoint', function () {
+            var httpinNode = workspace.addNode("httpin");
+            var templateNode = workspace.addNode("template", nodeWidth * 2);
+            var httpResponseNode = workspace.addNode("httpResponse", nodeWidth * 3);
+
+            httpinNode.edit();
+            httpinNode.setMethod("get");
+            httpinNode.setUrl("/hello-param/:name");
+            httpinNode.clickOk();
+
+            templateNode.edit();
+            templateNode.setSyntax("mustache");
+            templateNode.setFormat("handlebars");
+            templateNode.setTemplate("<html>\n<head></head>\n<body>\n<h1>Hello {{req.params.name}}!</h1>\n</body>\n</html>");
+            templateNode.clickOk();
+
+            httpinNode.connect(templateNode);
+            templateNode.connect(httpResponseNode);
+
+            // The code for confirmation starts from here.
+            var injectNode = workspace.addNode("inject", 0, nodeHeight);
+            var httpRequestNode = workspace.addNode("httpRequest", nodeWidth, nodeHeight);
+            var debugNode = workspace.addNode("debug", nodeWidth * 2, nodeHeight);
+
+            httpRequestNode.edit();
+            httpRequestNode.setUrl(helper.url() + httpNodeRoot + '/hello-param/Dave');
+            httpRequestNode.setMethod("GET");
+            httpRequestNode.clickOk();
+
+            injectNode.connect(httpRequestNode);
+            httpRequestNode.connect(debugNode);
+            // The code for confirmation ends here.
+
+            workspace.deploy();
+            debugTab.open();
+            debugTab.clearMessage();
+            injectNode.clickLeftButton();
+            debugTab.getMessage().indexOf('Hello Dave!').should.not.eql(-1);
+        });
+
+        it('access HTTP request headers', function () {
+            var httpinNode = workspace.addNode("httpin");
+            var templateNode = workspace.addNode("template", nodeWidth * 1.5);
+            var httpResponseNode = workspace.addNode("httpResponse", nodeWidth * 2.5);
+
+            httpinNode.edit();
+            httpinNode.setMethod("get");
+            httpinNode.setUrl("/hello-headers");
+            httpinNode.clickOk();
+
+            templateNode.edit();
+            templateNode.setSyntax("mustache");
+            templateNode.setFormat("handlebars");
+            templateNode.setTemplate("<html>\n<head></head>\n<body>\n<h1>User agent: {{req.headers.user-agent}}</h1>\n</body>\n</html>");
+            templateNode.clickOk();
+
+            httpinNode.connect(templateNode);
+            templateNode.connect(httpResponseNode);
+
+            // The code for confirmation starts from here.
+            var injectNode = workspace.addNode("inject", 0, nodeHeight);
+            var changeNode = workspace.addNode("change", nodeWidth, nodeHeight);
+            var httpRequestNode = workspace.addNode("httpRequest", nodeWidth * 2, nodeHeight);
+            var debugNode = workspace.addNode("debug", nodeWidth * 3, nodeHeight);
+
+            changeNode.edit();
+            changeNode.ruleSet("headers", "msg", '{"user-agent":"Mozilla/5.0 (Windows NT 10.0; Win64; x64)"}', "json");
+            changeNode.clickOk();
+
+            httpRequestNode.edit();
+            httpRequestNode.setUrl(helper.url() + httpNodeRoot + '/hello-headers');
+            httpRequestNode.setMethod("GET");
+            httpRequestNode.clickOk();
+
+            injectNode.connect(changeNode);
+            changeNode.connect(httpRequestNode);
+            httpRequestNode.connect(debugNode);
+            // The code for confirmation ends here.
+
+            workspace.deploy();
+            debugTab.open();
+            debugTab.clearMessage();
+            injectNode.clickLeftButton();
+            debugTab.getMessage().indexOf('Mozilla').should.not.eql(-1);
+        });
+
+        it('include data captured in another flow', function () {
+            var injectNodeTimestamp = workspace.addNode("inject");
+            var changeNodeStore = workspace.addNode("change", nodeWidth);
+
+            var httpinNode = workspace.addNode("httpin", 0, nodeHeight);
+            var changeNodeCopy = workspace.addNode("change", nodeWidth * 2, nodeHeight);
+            var templateNode = workspace.addNode("template", nodeWidth * 3, nodeHeight);
+            var httpResponseNode = workspace.addNode("httpResponse", nodeWidth * 4, nodeHeight);
+
+            injectNodeTimestamp.edit();
+            injectNodeTimestamp.setPayload("date");
+            injectNodeTimestamp.clickOk();
+
+            changeNodeStore.edit();
+            changeNodeStore.ruleSet("timestamp", "flow", "payload", "msg");
+            changeNodeStore.clickOk();
+
+            injectNodeTimestamp.connect(changeNodeStore);
+
+            httpinNode.edit();
+            httpinNode.setMethod("get");
+            httpinNode.setUrl("/hello-data");
+            httpinNode.clickOk();
+
+            changeNodeCopy.edit();
+            changeNodeCopy.ruleSet("timestamp", "msg", "timestamp", "flow");
+            changeNodeCopy.clickOk();
+
+            templateNode.edit();
+            templateNode.setSyntax("mustache");
+            templateNode.setFormat("handlebars");
+            templateNode.setTemplate("<html>\n<head></head>\n<body>\n<h1>Time: {{ timestamp }}</h1>\n</body>\n</html>");
+            templateNode.clickOk();
+
+            httpinNode.connect(changeNodeCopy);
+            changeNodeCopy.connect(templateNode);
+            templateNode.connect(httpResponseNode);
+
+            // The code for confirmation starts from here.
+            var injectNodeCheck = workspace.addNode("inject", 0, nodeHeight * 2);
+            var httpRequestNode = workspace.addNode("httpRequest", nodeWidth, nodeHeight * 2);
+            var debugNode = workspace.addNode("debug", nodeWidth * 2, nodeHeight * 2);
+
+            httpRequestNode.edit();
+            httpRequestNode.setMethod("GET");
+            httpRequestNode.setUrl(helper.url() + httpNodeRoot + '/hello-data');
+            httpRequestNode.clickOk();
+
+            injectNodeCheck.connect(httpRequestNode);
+            httpRequestNode.connect(debugNode);
+            // The code for confirmation ends here.
+
+            workspace.deploy();
+            debugTab.open();
+            debugTab.clearMessage();
+            injectNodeTimestamp.clickLeftButton();
+            injectNodeCheck.clickLeftButton();
+            var index = debugTab.getMessage().indexOf('Time: ') + 6;
+            debugTab.getMessage().substring(index, index + 13).should.within(1500000000000, 3000000000000);
+        });
+
+        it('serve JSON content', function () {
+            var httpinNode = workspace.addNode("httpin");
+            var templateNode = workspace.addNode("template", nodeWidth);
+            var changeNode = workspace.addNode("change", nodeWidth * 2);
+            var httpResponseNode = workspace.addNode("httpResponse", nodeWidth * 3);
+
+            httpinNode.edit();
+            httpinNode.setMethod("get");
+            httpinNode.setUrl("/hello-json");
+            httpinNode.clickOk();
+
+            templateNode.edit();
+            templateNode.setSyntax("mustache");
+            templateNode.setFormat("handlebars");
+            templateNode.setTemplate('{ "Hello": "World" }');
+            templateNode.clickOk();
+
+            changeNode.edit();
+            changeNode.ruleSet("headers", "msg", "{}", "json", "1");
+            changeNode.addRule();
+            changeNode.ruleSet("headers.content-type", "msg", "application/json", "str", "2");
+            changeNode.clickOk();
+
+            httpinNode.connect(templateNode);
+            templateNode.connect(changeNode);
+            changeNode.connect(httpResponseNode);
+
+            // The code for confirmation starts from here.
+            var injectNode = workspace.addNode("inject", 0, nodeHeight);
+            var httpRequestNode = workspace.addNode("httpRequest", nodeWidth, nodeHeight);
+            var debugNode = workspace.addNode("debug", nodeWidth * 2, nodeHeight);
+
+            httpRequestNode.edit();
+            httpRequestNode.setMethod("GET");
+            httpRequestNode.setUrl(helper.url() + httpNodeRoot + '/hello-json');
+            httpRequestNode.clickOk();
+
+            debugNode.edit();
+            debugNode.setOutput("headers");
+            debugNode.clickOk();
+
+            injectNode.connect(httpRequestNode);
+            httpRequestNode.connect(debugNode);
+            // The code for confirmation ends here.
+
+            workspace.deploy();
+            debugTab.open();
+            debugTab.clearMessage();
+            injectNode.clickLeftButton();
+            var messages = debugTab.getMessage();
+            var contents = messages.join([separator = ""]);
+            contents.indexOf('application/json').should.not.eql(-1);
+        });
+
+        it('serve a local file', function () {
+            var httpinNode = workspace.addNode("httpin");
+            var fileinNode = workspace.addNode("filein", nodeWidth);
+            var changeNode = workspace.addNode("change", nodeWidth * 2, nodeHeight);
+            var httpResponseNode = workspace.addNode("httpResponse", nodeWidth * 3.5, nodeHeight);
+
+            httpinNode.edit();
+            httpinNode.setMethod("get");
+            httpinNode.setUrl("/hello-file");
+            httpinNode.clickOk();
+
+            fileinNode.edit();
+            fileinNode.setFilename("test/resources/file-in-node/test.txt");
+            fileinNode.setOutput("");
+            fileinNode.clickOk();
+
+            changeNode.edit();
+            changeNode.ruleSet("headers", "msg", "{}", "json");
+            changeNode.addRule();
+            changeNode.ruleSet("headers.content-type", "msg", "text/plain", "str", "2");
+            changeNode.clickOk();
+
+            httpinNode.connect(fileinNode);
+            fileinNode.connect(changeNode);
+            changeNode.connect(httpResponseNode);
+
+            // The code for confirmation starts from here.
+            var injectNode = workspace.addNode("inject", 0, nodeHeight * 2);
+            var httpRequestNode = workspace.addNode("httpRequest", nodeWidth, nodeHeight * 2);
+            var debugNode = workspace.addNode("debug", nodeWidth * 2, nodeHeight * 2);
+
+            httpRequestNode.edit();
+            httpRequestNode.setUrl(helper.url() + httpNodeRoot + '/hello-file');
+            httpRequestNode.setMethod("GET");
+            httpRequestNode.clickOk();
+
+            injectNode.connect(httpRequestNode);
+            httpRequestNode.connect(debugNode);
+            // The code for confirmation ends here.
+
+            workspace.deploy();
+            debugTab.open();
+            debugTab.clearMessage();
+            injectNode.clickLeftButton();
+            debugTab.getMessage().indexOf('Text file').should.not.eql(-1);
+        });
+
+        it('post raw data to a flow', function() {
+            var httpinNode = workspace.addNode("httpin");
+            var templateNode = workspace.addNode("template", nodeWidth * 2);
+            var httpResponseNode = workspace.addNode("httpResponse", nodeWidth * 3);
+
+            httpinNode.edit();
+            httpinNode.setMethod("post");
+            httpinNode.setUrl("/hello-raw");
+            httpinNode.clickOk();
+
+            templateNode.edit();
+            templateNode.setSyntax("mustache");
+            templateNode.setFormat("handlebars");
+            templateNode.setTemplate("<html>\n<head></head>\n<body>\n<h1>Hello {{ payload }}!</h1>\n</body>\n</html>");
+            templateNode.clickOk();
+
+            httpinNode.connect(templateNode);
+            templateNode.connect(httpResponseNode);
+
+            // The code for confirmation starts from here.
+            var injectNode = workspace.addNode("inject", 0, nodeHeight);
+            var httpRequestNode = workspace.addNode("httpRequest", nodeWidth, nodeHeight);
+            var debugNode = workspace.addNode("debug", nodeWidth * 2, nodeHeight);
+
+            injectNode.edit()
+            injectNode.setPayload("str", "Nick");
+            injectNode.clickOk();
+
+            httpRequestNode.edit();
+            httpRequestNode.setUrl(helper.url() + httpNodeRoot + '/hello-raw');
+            httpRequestNode.setMethod("POST");
+            httpRequestNode.clickOk();
+
+            injectNode.connect(httpRequestNode);
+            httpRequestNode.connect(debugNode);
+            // The code for confirmation ends here.
+
+            workspace.deploy();
+            debugTab.open();
+            debugTab.clearMessage();
+            injectNode.clickLeftButton();
+            debugTab.getMessage().indexOf('Hello Nick!').should.not.eql(-1);
+        });
+
+        it('post form data to a flow', function () {
+            var httpinNode = workspace.addNode("httpin");
+            var templateNode = workspace.addNode("template", nodeWidth * 1.5);
+            var httpResponseNode = workspace.addNode("httpResponse", nodeWidth * 2.5);
+
+            httpinNode.edit();
+            httpinNode.setMethod("post");
+            httpinNode.setUrl("/hello-form");
+            httpinNode.clickOk();
+
+            templateNode.edit();
+            templateNode.setSyntax("mustache");
+            templateNode.setFormat("handlebars");
+            templateNode.setTemplate("<html>\n<head></head>\n<body>\n<h1>Hello {{ payload.name }}!</h1>\n</body>\n</html>");
+            templateNode.clickOk();
+
+            httpinNode.connect(templateNode);
+            templateNode.connect(httpResponseNode);
+
+            // The code for confirmation starts from here.
+            var injectNode = workspace.addNode("inject", 0, nodeHeight);
+            var changeNode = workspace.addNode("change", nodeWidth, nodeHeight);
+            var httpRequestNode = workspace.addNode("httpRequest", nodeWidth * 2, nodeHeight);
+            var debugNode = workspace.addNode("debug", nodeWidth * 3, nodeHeight);
+
+            injectNode.edit()
+            injectNode.setPayload("str", "name=Nick");
+            injectNode.clickOk();
+
+            changeNode.edit();
+            changeNode.ruleSet("headers", "msg", '{"content-type":"application/x-www-form-urlencoded"}', "json");
+            changeNode.clickOk();
+
+            httpRequestNode.edit();
+            httpRequestNode.setUrl(helper.url() + httpNodeRoot + '/hello-form');
+            httpRequestNode.setMethod("POST");
+            httpRequestNode.clickOk();
+
+            injectNode.connect(changeNode);
+            changeNode.connect(httpRequestNode);
+            httpRequestNode.connect(debugNode);
+            // The code for confirmation ends here.
+
+            workspace.deploy();
+            debugTab.open();
+            debugTab.clearMessage();
+            injectNode.clickLeftButton();
+            debugTab.getMessage().indexOf('Hello Nick!').should.not.eql(-1);
+        });
+
+        it('post JSON data to a flow', function() {
+            var httpinNode = workspace.addNode("httpin");
+            var templateNode = workspace.addNode("template", nodeWidth * 2);
+            var httpResponseNode = workspace.addNode("httpResponse", nodeWidth * 3);
+
+            httpinNode.edit();
+            httpinNode.setMethod("post");
+            httpinNode.setUrl("/hello-json");
+            httpinNode.clickOk();
+
+            templateNode.edit();
+            templateNode.setSyntax("mustache");
+            templateNode.setFormat("handlebars");
+            templateNode.setTemplate("<html>\n<head></head>\n<body>\n<h1>Hello {{ payload.name }}!</h1>\n</body>\n</html>");
+            templateNode.clickOk();
+
+            httpinNode.connect(templateNode);
+            templateNode.connect(httpResponseNode);
+
+            // The code for confirmation starts from here.
+            var injectNode = workspace.addNode("inject", 0, nodeHeight);
+            var changeNode = workspace.addNode("change", nodeWidth, nodeHeight);
+            var httpRequestNode = workspace.addNode("httpRequest", nodeWidth * 2, nodeHeight);
+            var debugNode = workspace.addNode("debug", nodeWidth * 3, nodeHeight);
+
+            injectNode.edit()
+            injectNode.setPayload("json", '{"name":"Nick"}');
+            injectNode.clickOk();
+
+            changeNode.edit();
+            changeNode.ruleSet("headers", "msg", '{"content-type":"application/json"}', "json");
+            changeNode.clickOk();
+
+            httpRequestNode.edit();
+            httpRequestNode.setUrl(helper.url() + httpNodeRoot + '/hello-json');
+            httpRequestNode.setMethod("POST");
+            httpRequestNode.clickOk();
+
+            injectNode.connect(changeNode);
+            changeNode.connect(httpRequestNode);
+            httpRequestNode.connect(debugNode);
+            // The code for confirmation ends here.
+
+            workspace.deploy();
+            debugTab.open();
+            debugTab.clearMessage();
+            injectNode.clickLeftButton();
+            debugTab.getMessage().indexOf('Hello Nick!').should.not.eql(-1);
+        });
+
+        it('work with cookies', function () {
+            this.timeout(60000);
+
+            var httpinNodeFormat = workspace.addNode("httpin");
+            var functionNodeFormat = workspace.addNode("function", nodeWidth * 1.5);
+            var templateNode = workspace.addNode("template", nodeWidth * 2.5);
+            var httpResponseNode = workspace.addNode("httpResponse", nodeWidth * 3.5);
+
+            var httpinNodeAdd = workspace.addNode("httpin", 0, nodeHeight);
+            var functionNodeAdd = workspace.addNode("function", nodeWidth * 1.5, nodeHeight);
+            var changeNode = workspace.addNode("change", nodeWidth * 2.5, nodeHeight * 1.5);
+
+            var httpinNodeClear = workspace.addNode("httpin", 0, nodeHeight * 2);
+            var functionNodeClear = workspace.addNode("function", nodeWidth * 1.5, nodeHeight * 2);
+
+            httpinNodeFormat.edit();
+            httpinNodeFormat.setMethod("get");
+            httpinNodeFormat.setUrl("/hello-cookie");
+            httpinNodeFormat.clickOk();
+
+            functionNodeFormat.edit();
+            functionNodeFormat.setFunction("msg.payload = JSON.stringify(msg.req.cookies,null,4);\nreturn msg;");
+            functionNodeFormat.clickOk();
+
+            templateNode.edit();
+            templateNode.setSyntax("mustache");
+            templateNode.setFormat("handlebars");
+            templateNode.setTemplate('<html>\n<head></head>\n<body>\n<h1>Cookies</h1>\n<p></p><a href="hello-cookie/add">Add a cookie</a> &bull; <a href="hello-cookie/clear">Clear cookies</a></p>\n<pre>{{ payload }}</pre>\n</body>\n</html>');
+            templateNode.clickOk();
+
+            httpinNodeFormat.connect(functionNodeFormat);
+            functionNodeFormat.connect(templateNode);
+            templateNode.connect(httpResponseNode);
+
+            httpinNodeAdd.edit();
+            httpinNodeAdd.setMethod("get");
+            httpinNodeAdd.setUrl("/hello-cookie/add");
+            httpinNodeAdd.clickOk();
+
+            functionNodeAdd.edit();
+            functionNodeAdd.setFunction('msg.cookies = { };\n msg.cookies["demo-"+(Math.floor(Math.random()*1000))] = Date.now();\nreturn msg;');
+            functionNodeAdd.clickOk();
+
+            changeNode.edit();
+            changeNode.ruleSet("statusCode", "msg", "302", "num");
+            changeNode.addRule();
+            changeNode.ruleSet("headers", "msg", "{}", "json", "2");
+            changeNode.addRule();
+            changeNode.ruleSet("headers.location", "msg", httpNodeRoot + "/hello-cookie", "str", "3");
+            changeNode.clickOk();
+
+            httpinNodeAdd.connect(functionNodeAdd);
+            functionNodeAdd.connect(changeNode);
+            changeNode.connect(httpResponseNode);
+
+            httpinNodeClear.edit();
+            httpinNodeClear.setMethod("get");
+            httpinNodeClear.setUrl("/hello-cookie/clear");
+            httpinNodeClear.clickOk();
+
+            functionNodeClear.edit();
+            functionNodeClear.setFunction("var cookieNames = Object.keys(msg.req.cookies).filter(function(cookieName) { return /^demo-/.test(cookieName);});\nmsg.cookies = {};\n\ncookieNames.forEach(function(cookieName) {\n    msg.cookies[cookieName] = null;\n});\nreturn msg;\n");
+            functionNodeClear.clickOk();
+
+            httpinNodeClear.connect(functionNodeClear);
+            functionNodeClear.connect(changeNode);
+
+            workspace.deploy();
+            // This case cannot be checked since http request node does not transfer cookies when redirected.
+        });
+    });
+});

test/editor/specs/scenario/cookbook_mqtt_uispec.js

@@ -0,0 +1,228 @@
+/**
+ * Copyright JS Foundation and other contributors, http://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://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.
+ **/
+
+var when = require('when');
+var should = require("should");
+var fs = require('fs-extra');
+
+var helper = require("../../editor_helper");
+var debugTab = require('../../pageobjects/editor/debugTab_page');
+var workspace = require('../../pageobjects/editor/workspace_page');
+var specUtil = require('../../pageobjects/util/spec_util_page');
+var mqttConfig = require('../../pageobjects/nodes/core/io/10-mqttconfig_page.js');
+
+var nodeWidth = 200;
+var nodeHeight = 100;
+var httpNodeRoot = "/api";
+
+var mqttServer;
+var mosca = require('mosca');
+var moscaSettings = {
+    port: 1883,
+    persistence: {
+        // Needs for retaining messages.
+        factory: mosca.persistence.Memory
+    }
+};
+
+
+// https://cookbook.nodered.org/
+describe('cookbook', function() {
+    beforeEach(function() {
+        workspace.deleteAllNodes();
+    });
+
+    before(function() {
+        browser.call(function() {
+            return new Promise(function(resolve, reject) {
+                mqttServer = new mosca.Server(moscaSettings, function() {
+                    resolve();
+                });
+            });
+        });
+        helper.startServer();
+    });
+
+    after(function() {
+        browser.call(function() {
+            return new Promise(function(resolve, reject) {
+                mqttServer.close(function() {
+                    resolve();
+                });
+            });
+        });
+        helper.stopServer();
+    });
+
+    describe('MQTT', function() {
+        it('Add an MQTT broker to prepare for UI test', function() {
+            var mqttOutNode = workspace.addNode("mqttOut", nodeWidth);
+
+            mqttOutNode.edit();
+            mqttConfig.edit();
+            mqttConfig.setServer("localhost");
+            mqttConfig.clickOk();
+            mqttOutNode.clickOk();
+
+            workspace.deploy();
+        });
+
+        it('Connect to an MQTT broker', function() {
+            var injectNode = workspace.addNode("inject");
+            var mqttOutNode = workspace.addNode("mqttOut", nodeWidth);
+
+            var mqttInNode = workspace.addNode("mqttIn", 0, nodeHeight);
+            var debugNode = workspace.addNode("debug", nodeWidth * 2, nodeHeight);
+
+            injectNode.edit();
+            injectNode.setPayload("num", 22);
+            injectNode.clickOk();
+
+            mqttOutNode.edit();
+            mqttOutNode.setTopic("sensors/livingroom/temp");
+            mqttOutNode.clickOk();
+
+            injectNode.connect(mqttOutNode);
+
+            mqttInNode.edit();
+            mqttInNode.setTopic("sensors/livingroom/temp");
+            mqttInNode.setQoS("2");
+            mqttInNode.clickOk();
+
+            mqttInNode.connect(debugNode);
+
+            workspace.deploy();
+
+            debugTab.open();
+            debugTab.clearMessage();
+            injectNode.clickLeftButton();
+            debugTab.getMessage().should.eql('"22"');
+        });
+
+        // skip this case since it is same as other cases.
+        it.skip('Publish messages to a topic');
+
+        it('Set the topic of a published message', function() {
+            var injectNode = workspace.addNode("inject");
+            var mqttOutNode = workspace.addNode("mqttOut", nodeWidth * 2);
+
+            injectNode.edit();
+            injectNode.setPayload("num", 22);
+            injectNode.setTopic("sensors/kitchen/temperature");
+            injectNode.clickOk();
+
+            mqttOutNode.edit();
+            mqttOutNode.clickOk();
+
+            injectNode.connect(mqttOutNode);
+
+            // The code for confirmation starts from here.
+            var mqttInNode = workspace.addNode("mqttIn", 0, nodeHeight);
+            var debugNode = workspace.addNode("debug", nodeWidth * 2, nodeHeight);
+
+            mqttInNode.edit();
+            mqttInNode.setTopic("sensors/kitchen/temperature");
+            mqttInNode.clickOk();
+
+            mqttInNode.connect(debugNode);
+            // The code for confirmation ends here.
+
+            workspace.deploy();
+
+            debugTab.open();
+            debugTab.clearMessage();
+            injectNode.clickLeftButton();
+            debugTab.getMessage().should.eql('"22"');
+        });
+
+        it('Publish a retained message to a topic', function() {
+            var injectNode = workspace.addNode("inject");
+            var mqttOutNode = workspace.addNode("mqttOut", nodeWidth);
+
+            injectNode.edit();
+            injectNode.setPayload("num", 22);
+            injectNode.clickOk();
+
+            mqttOutNode.edit();
+            mqttOutNode.setTopic("sensors/livingroom/temp");
+            mqttOutNode.setRetain("true");
+            mqttOutNode.clickOk();
+
+            injectNode.connect(mqttOutNode);
+
+            workspace.deploy();
+            debugTab.open();
+            injectNode.clickLeftButton();
+            debugTab.clearMessage();
+
+            // The code for confirmation starts from here.
+            var mqttInNode = workspace.addNode("mqttIn", 0, nodeHeight);
+            var debugNode = workspace.addNode("debug", nodeWidth * 2, nodeHeight);
+
+            mqttInNode.edit();
+            mqttInNode.setTopic("sensors/livingroom/temp");
+            mqttInNode.clickOk();
+
+            mqttInNode.connect(debugNode);
+            // The code for confirmation ends here.
+
+            workspace.deploy();
+            debugTab.open();
+            debugTab.getMessage().should.eql('"22"');
+        });
+
+        // skip this case since it is same as other cases.
+        it.skip('Subscribe to a topic');
+
+        it('Receive a parsed JSON message', function() {
+            var injectNode = workspace.addNode("inject");
+            var mqttOutNode = workspace.addNode("mqttOut", nodeWidth);
+
+            var mqttInNode = workspace.addNode("mqttIn", 0, nodeHeight);
+            var jsonNode = workspace.addNode("json", nodeWidth, nodeHeight);
+            var debugNode = workspace.addNode("debug", nodeWidth * 2, nodeHeight);
+
+            injectNode.edit();
+            injectNode.setPayload("json", '{"sensor_id": 1234, "temperature": 13 }');
+            injectNode.clickOk();
+
+            mqttOutNode.edit();
+            mqttOutNode.setTopic("sensors/livingroom/temp");
+            mqttOutNode.clickOk();
+
+            injectNode.connect(mqttOutNode);
+
+            mqttInNode.edit();
+            mqttInNode.setTopic("sensors/#");
+            mqttInNode.setQoS("2");
+            mqttInNode.clickOk();
+
+            jsonNode.edit();
+            jsonNode.setProperty("payload");
+            jsonNode.clickOk();
+
+            mqttInNode.connect(jsonNode);
+            jsonNode.connect(debugNode);
+
+            workspace.deploy();
+
+            debugTab.open();
+            debugTab.clearMessage();
+            injectNode.clickLeftButton();
+            debugTab.getMessage().should.eql(['1234', '13']);
+        });
+    });
+});

test/editor/specs/scenario/cookbook_uispec.js

@@ -19,10 +19,13 @@ var should = require("should");
 var fs = require('fs-extra');
 
 var helper = require("../../editor_helper");
-var debugTab = require('../../pageobjects/workspace/debugTab_page');
-var workspace = require('../../pageobjects/workspace/workspace_page');
+var debugTab = require('../../pageobjects/editor/debugTab_page');
+var workspace = require('../../pageobjects/editor/workspace_page');
+var specUtil = require('../../pageobjects/util/spec_util_page');
 
 var nodeWidth = 200;
+var nodeHeight = 100;
+var httpNodeRoot = "/api";
 
 // https://cookbook.nodered.org/
 describe('cookbook', function() {
@@ -45,7 +48,7 @@ describe('cookbook', function() {
             var debugNode = workspace.addNode("debug", nodeWidth * 2);
 
             changeNode.edit();
-            changeNode.ruleSet("Hello World!");
+            changeNode.ruleSet("payload", "msg", "Hello World!");
             changeNode.clickOk();
 
             injectNode.connect(changeNode);
@@ -56,7 +59,7 @@ describe('cookbook', function() {
             debugTab.open();
             debugTab.clearMessage();
             injectNode.clickLeftButton();
-            debugTab.getMessage().should.be.equal('"Hello World!"');
+            debugTab.getMessage().should.eql('"Hello World!"');
         });
 
         it('delete a message property', function() {
@@ -76,7 +79,7 @@ describe('cookbook', function() {
             debugTab.open();
             debugTab.clearMessage();
             injectNode.clickLeftButton();
-            debugTab.getMessage().should.be.equal("undefined");
+            debugTab.getMessage().should.eql("undefined");
         });
 
         it('move a message property', function() {
@@ -100,7 +103,7 @@ describe('cookbook', function() {
             debugTab.open();
             debugTab.clearMessage();
             injectNode.clickLeftButton();
-            debugTab.getMessage().should.be.equal('"Hello"');
+            debugTab.getMessage().should.eql('"Hello"');
         });
 
         it('map a property between different numeric ranges', function() {
@@ -135,11 +138,319 @@ describe('cookbook', function() {
             debugTab.open();
             debugTab.clearMessage();
             injectNode1.clickLeftButton();
-            debugTab.getMessage(1).should.be.equal('0');
+            debugTab.getMessage(1).should.eql('0');
             injectNode2.clickLeftButton();
-            debugTab.getMessage(2).should.be.equal('2.5024437927663734');
+            debugTab.getMessage(2).should.eql('2.5024437927663734');
             injectNode3.clickLeftButton();
-            debugTab.getMessage(3).should.be.equal('5');
+            debugTab.getMessage(3).should.eql('5');
+        });
+    });
+
+    describe('flow control', function() {
+        it('trigger a flow whenever Node-RED starts', function() {
+            var injectNode = workspace.addNode("inject");
+            var debugNode = workspace.addNode("debug", nodeWidth * 2);
+
+            injectNode.edit();
+            injectNode.setPayload("str", "Started!")
+            injectNode.setOnce(true);
+            injectNode.clickOk();
+            injectNode.connect(debugNode);
+
+            debugTab.open();
+            debugTab.clearMessage();
+            workspace.deploy();
+            debugTab.getMessage().should.eql('"Started!"');
+        });
+
+        it('trigger a flow at regular intervals', function() {
+            var injectNode = workspace.addNode("inject");
+            var debugNode = workspace.addNode("debug", nodeWidth * 2);
+
+            injectNode.edit();
+            injectNode.setRepeat("interval");
+            injectNode.setRepeatInterval(1);
+            injectNode.clickOk();
+            injectNode.connect(debugNode);
+
+            workspace.deploy();
+
+            debugTab.open();
+            debugTab.clearMessage();
+            specUtil.pause(1000);
+            var t1 = Number(debugTab.getMessage(1));
+            t1.should.within(1500000000000, 3000000000000);
+            specUtil.pause(1000);
+            debugTab.getMessage(2).should.within(t1 + 1000, 3000000000000);
+        });
+
+        // skip this case since it needs up to one minite.
+        it.skip('trigger a flow at a specific time');
+    });
+
+    describe('HTTP requests', function() {
+        it('simple get request', function() {
+            var injectNode = workspace.addNode("inject");
+            var httpRequetNode = workspace.addNode("httpRequest", nodeWidth);
+            var htmlNode = workspace.addNode("html", nodeWidth * 2);
+            var debugNode = workspace.addNode("debug", nodeWidth * 3);
+
+            httpRequetNode.edit();
+            httpRequetNode.setMethod("GET");
+            httpRequetNode.setUrl(helper.url());
+            httpRequetNode.clickOk();
+
+            htmlNode.edit();
+            htmlNode.setSelector("title");
+            htmlNode.clickOk();
+
+            injectNode.connect(httpRequetNode);
+            httpRequetNode.connect(htmlNode);
+            htmlNode.connect(debugNode);
+
+            workspace.deploy();
+
+            debugTab.open();
+            debugTab.clearMessage();
+            injectNode.clickLeftButton();
+            debugTab.getMessage().should.eql('"Node-RED"');
+        });
+
+        it('set the URL of a request', function() {
+            var injectNode = workspace.addNode("inject");
+            var changeNode = workspace.addNode("change", nodeWidth * 1.5);
+            var httpRequetNode = workspace.addNode("httpRequest", nodeWidth * 2.5);
+            var debugNode = workspace.addNode("debug", nodeWidth * 3.5);
+
+            injectNode.edit();
+            injectNode.setPayload("str", helper.url());
+            injectNode.clickOk();
+
+            changeNode.edit();
+            changeNode.ruleSet("url", "msg", "payload", "msg");
+            changeNode.clickOk();
+
+            injectNode.connect(changeNode);
+            changeNode.connect(httpRequetNode);
+            httpRequetNode.connect(debugNode);
+
+            workspace.deploy();
+
+            debugTab.open();
+            debugTab.clearMessage();
+            injectNode.clickLeftButton();
+            debugTab.getMessage().should.containEql('<title>Node-RED</title>');
+        });
+
+        it('set the URL of a request using a template', function() {
+            var injectNode = workspace.addNode("inject");
+            var changeNode = workspace.addNode("change", nodeWidth * 1.5);
+            var httpRequetNode = workspace.addNode("httpRequest", nodeWidth * 2.5);
+            var debugNode = workspace.addNode("debug", nodeWidth * 3.5);
+
+            injectNode.edit();
+            injectNode.setPayload("str", 'settings');
+            injectNode.clickOk();
+
+            changeNode.edit();
+            changeNode.ruleSet("query", "msg", "payload", "msg");
+            changeNode.clickOk();
+
+            httpRequetNode.edit();
+            httpRequetNode.setUrl(helper.url() + "/{{{query}}}");
+            httpRequetNode.clickOk();
+
+            injectNode.connect(changeNode);
+            changeNode.connect(httpRequetNode);
+            httpRequetNode.connect(debugNode);
+
+            workspace.deploy();
+
+            debugTab.open();
+            debugTab.clearMessage();
+            injectNode.clickLeftButton();
+            debugTab.getMessage().should.containEql('httpNodeRoot');
+        });
+
+        it('set the query string parameters', function() {
+            var injectNode = workspace.addNode("inject");
+            var changeNode = workspace.addNode("change", nodeWidth);
+            var httpRequetNode = workspace.addNode("httpRequest", nodeWidth * 2);
+            var debugNode = workspace.addNode("debug", nodeWidth * 3);
+
+            injectNode.edit();
+            injectNode.setPayload("str", 'Nick');
+            injectNode.clickOk();
+
+            changeNode.edit();
+            changeNode.ruleSet("query", "msg", "payload", "msg");
+            changeNode.clickOk();
+
+            httpRequetNode.edit();
+            httpRequetNode.setUrl(helper.url() + httpNodeRoot + '/set-query?q={{{query}}}');
+            httpRequetNode.clickOk();
+
+            injectNode.connect(changeNode);
+            changeNode.connect(httpRequetNode);
+            httpRequetNode.connect(debugNode);
+
+            // The code for confirmation starts from here.
+            var httpinNode = workspace.addNode("httpin", 0, nodeHeight);
+            var templateNode = workspace.addNode("template", nodeWidth, nodeHeight);
+            var httpResponseNode = workspace.addNode("httpResponse", nodeWidth * 2, nodeHeight);
+
+            httpinNode.edit();
+            httpinNode.setMethod("get");
+            httpinNode.setUrl("/set-query");
+            httpinNode.clickOk();
+
+            templateNode.edit();
+            templateNode.setSyntax("mustache");
+            templateNode.setFormat("handlebars");
+            templateNode.setTemplate("Hello {{req.query.q}}");
+            templateNode.clickOk();
+
+            httpinNode.connect(templateNode);
+            templateNode.connect(httpResponseNode);
+            // The code for confirmation ends here.
+
+            workspace.deploy();
+            debugTab.open();
+            debugTab.clearMessage();
+            injectNode.clickLeftButton();
+            debugTab.getMessage().should.eql('"Hello Nick"');
+        });
+
+        it('get a parsed JSON response', function() {
+            var injectNode = workspace.addNode("inject");
+            var changeNodeSetPost = workspace.addNode("change", nodeWidth);
+            var httpRequetNode = workspace.addNode("httpRequest", nodeWidth * 2);
+            var debugNode = workspace.addNode("debug", nodeWidth * 3);
+
+            injectNode.edit();
+            injectNode.setPayload("str", "json-response");
+            injectNode.clickOk();
+
+            changeNodeSetPost.edit();
+            changeNodeSetPost.ruleSet("post", "msg", "payload", "msg");
+            changeNodeSetPost.clickOk();
+
+            httpRequetNode.edit();
+            httpRequetNode.setMethod("GET");
+            var url = helper.url() + httpNodeRoot + "/{{post}}";
+            httpRequetNode.setUrl(url);
+            httpRequetNode.setReturn("obj");
+            httpRequetNode.clickOk();
+
+            debugNode.edit();
+            debugNode.setOutput("payload.title");
+            debugNode.clickOk();
+
+            injectNode.connect(changeNodeSetPost);
+            changeNodeSetPost.connect(httpRequetNode);
+            httpRequetNode.connect(debugNode);
+
+            // The code for confirmation starts from here.
+            var httpinNode = workspace.addNode("httpin", 0, nodeHeight);
+            var templateNode = workspace.addNode("template", nodeWidth * 1.5, nodeHeight);
+            var changeNodeSetHeader = workspace.addNode("change", nodeWidth * 2.5, nodeHeight);
+            var httpResponseNode = workspace.addNode("httpResponse", nodeWidth * 3.5, nodeHeight);
+
+            httpinNode.edit();
+            httpinNode.setMethod("get");
+            httpinNode.setUrl("/json-response");
+            httpinNode.clickOk();
+
+            templateNode.edit();
+            templateNode.setSyntax("mustache");
+            templateNode.setFormat("handlebars");
+            templateNode.setTemplate('{"title": "Hello"}');
+            templateNode.clickOk();
+
+            changeNodeSetHeader.edit();
+            changeNodeSetHeader.ruleSet("headers", "msg", '{"content-type":"application/json"}', "json");
+            changeNodeSetHeader.clickOk();
+
+            httpinNode.connect(templateNode);
+            templateNode.connect(changeNodeSetHeader);
+            changeNodeSetHeader.connect(httpResponseNode);
+            // The code for confirmation ends here.
+
+            workspace.deploy();
+            debugTab.open();
+            debugTab.clearMessage();
+            injectNode.clickLeftButton();
+            debugTab.getMessage().should.eql('"Hello"');
+        });
+
+        it('get a binary response', function() {
+            var injectNode = workspace.addNode("inject");
+            var httpRequetNode = workspace.addNode("httpRequest", nodeWidth);
+            var debugNode = workspace.addNode("debug", nodeWidth * 2);
+
+            httpRequetNode.edit();
+            httpRequetNode.setMethod("GET");
+            httpRequetNode.setUrl(helper.url() + "/settings");
+            httpRequetNode.setReturn("bin");
+            httpRequetNode.clickOk();
+
+            injectNode.connect(httpRequetNode);
+            httpRequetNode.connect(debugNode);
+
+            workspace.deploy();
+
+            debugTab.open();
+            debugTab.clearMessage();
+            injectNode.clickLeftButton();
+
+            debugTab.getMessage().should.eql(['123', '34', '104', '116', '116', '112', '78', '111', '100', '101']);
+        });
+
+        it('set a request header', function() {
+            var injectNode = workspace.addNode("inject");
+            var functionNode = workspace.addNode("function", nodeWidth);
+            var httpRequetNode = workspace.addNode("httpRequest", nodeWidth * 2);
+            var debugNode = workspace.addNode("debug", nodeWidth * 3);
+
+            functionNode.edit();
+            functionNode.setFunction('msg.payload = "data to post";\nreturn msg;');
+            functionNode.clickOk();
+
+            httpRequetNode.edit();
+            httpRequetNode.setMethod("POST");
+            var url = helper.url() + httpNodeRoot + "/set-header";
+            httpRequetNode.setUrl(url);
+            httpRequetNode.clickOk();
+
+            injectNode.connect(functionNode);
+            functionNode.connect(httpRequetNode);
+            httpRequetNode.connect(debugNode);
+
+            // The code for confirmation starts from here.
+            var httpinNode = workspace.addNode("httpin", 0, nodeHeight);
+            var templateNode = workspace.addNode("template", nodeWidth * 1.5, nodeHeight);
+            var httpResponseNode = workspace.addNode("httpResponse", nodeWidth * 2.5, nodeHeight);
+
+            httpinNode.edit();
+            httpinNode.setMethod("post");
+            httpinNode.setUrl("/set-header");
+            httpinNode.clickOk();
+
+            templateNode.edit();
+            templateNode.setSyntax("mustache");
+            templateNode.setFormat("handlebars");
+            templateNode.setTemplate("{{ payload }}");
+            templateNode.clickOk();
+
+            httpinNode.connect(templateNode);
+            templateNode.connect(httpResponseNode);
+            // The code for confirmation ends here.
+
+            workspace.deploy();
+            debugTab.open();
+            debugTab.clearMessage();
+            injectNode.clickLeftButton();
+            debugTab.getMessage().should.eql('"data to post"');
         });
     });
 });

test/editor/wdio.conf.js

@@ -155,7 +155,7 @@ exports.config = {
     // Options to be passed to Mocha.
     // See the full list at http://mochajs.org/
     mochaOpts: {
-        timeout: 20000,
+        timeout: 60000,
         ui: 'bdd'
     },
     //

test/node_modules/nr-test-utils/index.js

@@ -0,0 +1,31 @@
+/**
+ * Copyright JS Foundation and other contributors, http://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://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.
+ **/
+
+
+const path = require("path");
+const fs = require("fs");
+
+const PACKAGE_ROOT = "../../../packages/node_modules";
+
+module.exports = {
+    require: function(file) {
+        // console.log(path.join(__dirname,PACKAGE_ROOT,file))
+        return require(path.join(PACKAGE_ROOT,file));
+    },
+    resolve: function(file) {
+        return path.resolve(path.join(__dirname,PACKAGE_ROOT,file));
+    }
+}

test/node_modules/nr-test-utils/package.json

@@ -0,0 +1,6 @@
+{
+    "name": "nr-test-utils",
+    "version": "0.20.0",
+    "license": "Apache-2.0",
+    "private": true
+}

test/nodes/core/analysis/72-sentiment_spec.js

@@ -15,7 +15,7 @@
  **/
 
 var should = require("should");
-var sentimentNode = require("../../../../nodes/core/analysis/72-sentiment.js");
+var sentimentNode = require("nr-test-utils").require("@node-red/nodes/core/analysis/72-sentiment.js");
 var helper = require("node-red-node-test-helper");
 
 describe('sentiment Node', function() {

test/nodes/core/core/20-inject_spec.js

@@ -15,23 +15,349 @@
  **/
 
 var should = require("should");
-var injectNode = require("../../../../nodes/core/core/20-inject.js");
+var injectNode = require("nr-test-utils").require("@node-red/nodes/core/core/20-inject.js");
+var Context = require("nr-test-utils").require("@node-red/runtime/lib/nodes/context");
 var helper = require("node-red-node-test-helper");
 
 describe('inject node', function() {
 
-    before(function(done) {
+    beforeEach(function(done) {
         helper.startServer(done);
     });
 
-    after(function(done) {
-        helper.stopServer(done);
+    function initContext(done) {
+        Context.init({
+            contextStorage: {
+                memory0: {
+                    module: "memory"
+                },
+                memory1: {
+                    module: "memory"
+                }
+            }
+        });
+        Context.load().then(function () {
+            done();
+        });
+    }
+
+    afterEach(function(done) {
+        helper.unload().then(function () {
+            return Context.clean({allNodes: {}});
+        }).then(function () {
+            return Context.close();
+        }).then(function () {
+            helper.stopServer(done);
+        });
     });
 
-    afterEach(function() {
-        helper.unload();
+    function basicTest(type, val, rval) {
+	it('inject value ('+type+')', function (done) {
+            var flow = [{id: "n1", type: "inject", topic: "t1", payload: val, payloadType: type, wires: [["n2"]], z: "flow"},
+			{id: "n2", type: "helper"}];
+            helper.load(injectNode, flow, function () {
+		var n1 = helper.getNode("n1");
+		var n2 = helper.getNode("n2");
+		n2.on("input", function (msg) {
+                    try {
+			msg.should.have.property("topic", "t1");
+			if (rval) {
+			    msg.should.have.property("payload");
+			    should.deepEqual(msg.payload, rval);
+			}
+			else {
+			    msg.should.have.property("payload", val);
+			}
+			done();
+                    } catch (err) {
+			done(err);
+                    }
+		});
+		n1.receive({});
+            });
+	});
+    }
+
+    basicTest("num", 10);
+    basicTest("str", "10");
+    basicTest("bool", true);
+    var val_json = '{ "x":"vx", "y":"vy", "z":"vz" }';
+    basicTest("json", val_json, JSON.parse(val_json));
+    var val_buf = "[1,2,3,4,5]";
+    basicTest("bin", val_buf, Buffer.from(JSON.parse(val_buf)));
+
+    it('inject value of environment variable ', function (done) {
+        var flow = [{id: "n1", type: "inject", topic: "t1", payload: "NR_TEST", payloadType: "env", wires: [["n2"]], z: "flow"},
+                    {id: "n2", type: "helper"}];
+        helper.load(injectNode, flow, function () {
+            var n1 = helper.getNode("n1");
+            var n2 = helper.getNode("n2");
+            n2.on("input", function (msg) {
+                try {
+                    msg.should.have.property("topic", "t1");
+                    msg.should.have.property("payload", "foo");
+                    done();
+                } catch (err) {
+                    done(err);
+                }
+            });
+	    process.env.NR_TEST = 'foo';
+            n1.receive({});
+        });
     });
 
+    it('sets the value of flow context property', function (done) {
+        var flow = [{id: "n1", type: "inject", topic: "t1", payload: "flowValue", payloadType: "flow", wires: [["n2"]], z: "flow"},
+                    {id: "n2", type: "helper"}];
+        helper.load(injectNode, flow, function () {
+            var n1 = helper.getNode("n1");
+            var n2 = helper.getNode("n2");
+            n2.on("input", function (msg) {
+                try {
+                    msg.should.have.property("topic", "t1");
+                    msg.should.have.property("payload", "changeMe");
+                    done();
+                } catch (err) {
+                    done(err);
+                }
+            });
+            n1.context().flow.set("flowValue", "changeMe");
+            n1.receive({});
+        });
+    });
+
+    it('sets the value of persistable flow context property', function (done) {
+        var flow = [{id: "n1", type: "inject", topic: "t1", payload: "#:(memory0)::flowValue", payloadType: "flow", wires: [["n2"]], z: "flow"},
+                    {id: "n2", type: "helper"}];
+        helper.load(injectNode, flow, function () {
+            initContext(function () {
+                var n1 = helper.getNode("n1");
+                var n2 = helper.getNode("n2");
+                n2.on("input", function (msg) {
+                    try {
+                        msg.should.have.property("topic", "t1");
+                        msg.should.have.property("payload", "changeMe");
+                        done();
+                    } catch (err) {
+                        done(err);
+                    }
+                });
+                n1.context().flow.set("flowValue", "changeMe", "memory0", function (err) {
+                    n1.receive({});
+                });
+            });
+        });
+    });
+
+    it('sets the value of two persistable flow context property', function (done) {
+        var flow = [{id: "n0", z: "flow", type: "inject", topic: "t0", payload: "#:(memory0)::val", payloadType: "flow", wires: [["n2"]]},
+                    {id: "n1", z: "flow", type: "inject", topic: "t1", payload: "#:(memory1)::val", payloadType: "flow", wires: [["n2"]]},
+                    {id: "n2", z: "flow", type: "helper"}];
+        helper.load(injectNode, flow, function () {
+            initContext(function () {
+                var n0 = helper.getNode("n0");
+                var n1 = helper.getNode("n1");
+                var n2 = helper.getNode("n2");
+                var count = 0;
+                n2.on("input", function (msg) {
+                    try {
+                        msg.should.have.property("topic");
+                        if (msg.topic === "t0") {
+                            msg.should.have.property("payload", "foo");
+                        }
+                        else if (msg.topic === "t1") {
+                            msg.should.have.property("payload", "bar");
+                        }
+                        else {
+                            done(new Error("unexpected message"));
+                        }
+                        count++;
+                        if (count === 2) {
+                            done();
+                        }
+                    } catch (err) {
+                        done(err);
+                    }
+                });
+                var global = n0.context().flow;
+                global.set("val", "foo", "memory0", function (err) {
+                    global.set("val", "bar", "memory1", function (err) {
+                        n0.receive({});
+                        n1.receive({});
+                    });
+                });
+            });
+        });
+    });
+
+    it('sets the value of global context property', function (done) {
+        var flow = [{id: "n1", type: "inject", topic: "t1", payload: "globalValue", payloadType: "global", wires: [["n2"]]},
+                    {id: "n2", type: "helper"}];
+        helper.load(injectNode, flow, function () {
+            var n1 = helper.getNode("n1");
+            var n2 = helper.getNode("n2");
+            n2.on("input", function (msg) {
+                try {
+                    msg.should.have.property("topic", "t1");
+                    msg.should.have.property("payload", "changeMe");
+                    done();
+                } catch (err) {
+                    done(err);
+                }
+            });
+            n1.context().global.set("globalValue", "changeMe");
+            n1.receive({});
+        });
+    });
+
+    it('sets the value of persistable global context property', function (done) {
+        var flow = [{id: "n1", z: "flow", type: "inject", topic: "t1", payload: "#:(memory1)::val", payloadType: "global", wires: [["n2"]]},
+                    {id: "n2", z: "flow", type: "helper"}];
+        helper.load(injectNode, flow, function () {
+            initContext(function () {
+                var n1 = helper.getNode("n1");
+                var n2 = helper.getNode("n2");
+                n2.on("input", function (msg) {
+                    try {
+                        msg.should.have.property("topic", "t1");
+                        msg.should.have.property("payload", "foo");
+                        done();
+                    } catch (err) {
+                        done(err);
+                    }
+                });
+                var global = n1.context().global;
+                global.set("val", "foo", "memory1", function (err) {
+                    n1.receive({});
+                });
+            });
+        });
+    });
+
+    it('sets the value of two persistable global context property', function (done) {
+        var flow = [{id: "n0", z: "flow", type: "inject", topic: "t0", payload: "#:(memory0)::val", payloadType: "global", wires: [["n2"]]},
+                    {id: "n1", z: "flow", type: "inject", topic: "t1", payload: "#:(memory1)::val", payloadType: "global", wires: [["n2"]]},
+                    {id: "n2", z: "flow", type: "helper"}];
+        helper.load(injectNode, flow, function () {
+            initContext(function () {
+                var n0 = helper.getNode("n0");
+                var n1 = helper.getNode("n1");
+                var n2 = helper.getNode("n2");
+                var count = 0;
+                n2.on("input", function (msg) {
+                    try {
+                        msg.should.have.property("topic");
+                        if (msg.topic === "t0") {
+                            msg.should.have.property("payload", "foo");
+                        }
+                        else if (msg.topic === "t1") {
+                            msg.should.have.property("payload", "bar");
+                        }
+                        else {
+                            done(new Error("unexpected message"));
+                        }
+                        count++;
+                        if (count === 2) {
+                            done();
+                        }
+                    } catch (err) {
+                        done(err);
+                    }
+                });
+                var global = n0.context().global;
+                global.set("val", "foo", "memory0", function (err) {
+                    global.set("val", "bar", "memory1", function (err) {
+                        n0.receive({});
+                        n1.receive({});
+                    });
+                });
+            });
+        });
+    });
+
+    it('sets the value of persistable flow & global context property', function (done) {
+        var flow = [{id: "n0", z: "flow", type: "inject", topic: "t0", payload: "#:(memory0)::val", payloadType: "flow", wires: [["n2"]]},
+                    {id: "n1", z: "flow", type: "inject", topic: "t1", payload: "#:(memory1)::val", payloadType: "global", wires: [["n2"]]},
+                    {id: "n2", z: "flow", type: "helper"}];
+        helper.load(injectNode, flow, function () {
+            initContext(function () {
+                var n0 = helper.getNode("n0");
+                var n1 = helper.getNode("n1");
+                var n2 = helper.getNode("n2");
+                var count = 0;
+                n2.on("input", function (msg) {
+                    try {
+                        msg.should.have.property("topic");
+                        if (msg.topic === "t0") {
+                            msg.should.have.property("payload", "foo");
+                        }
+                        else if (msg.topic === "t1") {
+                            msg.should.have.property("payload", "bar");
+                        }
+                        else {
+                            done(new Error("unexpected message"));
+                        }
+                        count++;
+                        if (count === 2) {
+                            done();
+                        }
+                    } catch (err) {
+                        done(err);
+                    }
+                });
+                var context = n0.context();
+                var flow = context.flow;
+                var global = context.global;
+                flow.set("val", "foo", "memory0", function (err) {
+                    global.set("val", "bar", "memory1", function (err) {
+                        n0.receive({});
+                        n1.receive({});
+                    });
+                });
+            });
+        });
+    });
+
+    it('sets the value of two persistable global context property', function (done) {
+        var flow = [{id: "n0", z: "flow", type: "inject", topic: "t0", payload: "#:(memory0)::val", payloadType: "global", wires: [["n2"]]},
+                    {id: "n1", z: "flow", type: "inject", topic: "t1", payload: "#:(memory1)::val", payloadType: "global", wires: [["n2"]]},
+                    {id: "n2", z: "flow", type: "helper"}];
+        helper.load(injectNode, flow, function () {
+            initContext(function () {
+                var n0 = helper.getNode("n0");
+                var n1 = helper.getNode("n1");
+                var n2 = helper.getNode("n2");
+                var count = 0;
+                n2.on("input", function (msg) {
+                    try {
+                        msg.should.have.property("topic");
+                        if (msg.topic === "t0") {
+                            msg.should.have.property("payload", "foo");
+                        }
+                        else if (msg.topic === "t1") {
+                            msg.should.have.property("payload", "bar");
+                        }
+                        else {
+                            done(new Error("unexpected message"));
+                        }
+                        count++;
+                        if (count === 2) {
+                            done();
+                        }
+                    } catch (err) {
+                        done(err);
+                    }
+                });
+                var global = n0.context().global;
+                global.set("val", "foo", "memory0", function (err) {
+                    global.set("val", "bar", "memory1", function (err) {
+                        n0.receive({});
+                        n1.receive({});
+                    });
+                });
+            });
+        });
+    });
     it('should inject once with default delay property', function(done) {
         helper.load(injectNode, [{id:"n1", type:"inject", topic: "t1",
                     payload:"",payloadType:"date",

test/nodes/core/core/25-catch_spec.js

@@ -15,7 +15,7 @@
  **/
 
 var should = require("should");
-var catchNode = require("../../../../nodes/core/core/25-catch.js");
+var catchNode = require("nr-test-utils").require("@node-red/nodes/core/core/25-catch.js");
 var helper = require("node-red-node-test-helper");
 
 describe('catch Node', function() {

test/nodes/core/core/25-status_spec.js

@@ -15,7 +15,7 @@
  **/
 
 var should = require("should");
-var catchNode = require("../../../../nodes/core/core/25-status.js");
+var catchNode = require("nr-test-utils").require("@node-red/nodes/core/core/25-status.js");
 var helper = require("node-red-node-test-helper");
 
 describe('status Node', function() {

test/nodes/core/core/58-debug_spec.js

@@ -15,7 +15,7 @@
  **/
 
 var should = require("should");
-var debugNode = require("../../../../nodes/core/core/58-debug.js");
+var debugNode = require("nr-test-utils").require("@node-red/nodes/core/core/58-debug.js");
 var helper = require("node-red-node-test-helper");
 var WebSocket = require('ws');
 
@@ -411,7 +411,7 @@ describe('debug node', function() {
                     data:{
                         id:"n1",
                         msg:JSON.stringify({
-                            __encoded__: true,
+                            __enc__: true,
                             type: "array",
                             data: Array(1000).fill("X"),
                             length: 1001
@@ -438,7 +438,7 @@ describe('debug node', function() {
                         id:"n1",
                         msg:JSON.stringify({
                             foo:{
-                                __encoded__: true,
+                                __enc__: true,
                                 type: "array",
                                 data: Array(1000).fill("X"),
                                 length: 1001
@@ -489,7 +489,7 @@ describe('debug node', function() {
                             foo:{
                                 type: "Buffer",
                                 data: Array(1000).fill(88),
-                                __encoded__: true,
+                                __enc__: true,
                                 length: 1001
                             }
                         },null," "),

test/nodes/core/core/60-link_spec.js

@@ -15,7 +15,7 @@
  **/
 
 var should = require("should");
-var linkNode = require("../../../../nodes/core/core/60-link.js");
+var linkNode = require("nr-test-utils").require("@node-red/nodes/core/core/60-link.js");
 var helper = require("node-red-node-test-helper");
 
 describe('link Node', function() {

test/nodes/core/core/75-exec_spec.js

@@ -17,7 +17,7 @@
 var should = require("should");
 var sinon = require("sinon");
 var helper = require("node-red-node-test-helper");
-var execNode = require("../../../../nodes/core/core/75-exec.js");
+var execNode = require("nr-test-utils").require("@node-red/nodes/core/core/75-exec.js");
 var osType = require("os").type();
 
 var child_process = require('child_process');

test/nodes/core/core/80-template_spec.js

@@ -15,7 +15,8 @@
  **/
 
 var should = require("should");
-var templateNode = require("../../../../nodes/core/core/80-template.js");
+var templateNode = require("nr-test-utils").require("@node-red/nodes/core/core/80-template.js");
+var Context = require("nr-test-utils").require("@node-red/runtime/lib/nodes/context");
 var helper = require("node-red-node-test-helper");
 
 describe('template node', function() {
@@ -28,8 +29,35 @@ describe('template node', function() {
         helper.stopServer(done);
     });
 
+    beforeEach(function(done) {
+        done();
+    });
+
+    function initContext(done) {
+        Context.init({
+            contextStorage: {
+		memory0: { // do not use (for excluding effect fallback)
+		    module: "memory"
+		},
+                memory1: {
+                    module: "memory"
+                },
+                memory2: {
+                    module: "memory"
+                }
+            }
+        });
+        Context.load().then(function () {
+            done();
+        });
+    }
+
     afterEach(function() {
-        helper.unload();
+        helper.unload().then(function () {
+            return Context.clean({allNodes:{}});
+        }).then(function () {
+            return Context.close();
+        });
     });
 
 
@@ -116,7 +144,6 @@ describe('template node', function() {
         });
     });
 
-
     it('should modify payload from flow context', function(done) {
         var flow = [{id:"n1",z:"t1", type:"template", field:"payload", template:"payload={{flow.value}}",wires:[["n2"]]},{id:"n2",z:"t1",type:"helper"}];
         helper.load(templateNode, flow, function() {
@@ -132,6 +159,91 @@ describe('template node', function() {
         });
     });
 
+    it('should modify payload from persistable flow context', function(done) {
+        var flow = [{id:"n1",z:"t1", type:"template", field:"payload", template:"payload={{flow[memory1].value}}",wires:[["n2"]]},{id:"n2",z:"t1",type:"helper"}];
+        helper.load(templateNode, flow, function() {
+            initContext(function () {
+                var n1 = helper.getNode("n1");
+                var n2 = helper.getNode("n2");
+                n2.on("input", function(msg) {
+                    msg.should.have.property('topic', 'bar');
+                    msg.should.have.property('payload', 'payload=foo');
+                    done();
+                });
+                n1.context().flow.set("value","foo","memory1",function (err) {
+                    n1.receive({payload:"foo",topic: "bar"});
+                });
+            });
+        });
+    });
+
+    it('should handle nested context tags - property not set', function(done) {
+        // This comes from the Coursera Node-RED course and is a good example of
+        // multiple conditional tags
+        var template = `{{#flow.time}}time={{flow.time}}{{/flow.time}}{{^flow.time}}!time{{/flow.time}}{{#flow.random}}random={{flow.random}}randomtime={{flow.randomtime}}{{/flow.random}}{{^flow.random}}!random{{/flow.random}}`;
+        var flow = [{id:"n1",z:"t1", type:"template", field:"payload", template:template,wires:[["n2"]]},{id:"n2",z:"t1",type:"helper"}];
+        helper.load(templateNode, flow, function() {
+            initContext(function() {
+                var n1 = helper.getNode("n1");
+                var n2 = helper.getNode("n2");
+                n2.on("input", function(msg) {
+                    try {
+                        msg.should.have.property('topic', 'bar');
+                        msg.should.have.property('payload', '!time!random');
+                        done();
+                    } catch(err) {
+                        done(err);
+                    }
+                });
+                n1.receive({payload:"foo",topic: "bar"});
+            });
+        });
+    })
+    it('should handle nested context tags - property set', function(done) {
+        // This comes from the Coursera Node-RED course and is a good example of
+        // multiple conditional tags
+        var template = `{{#flow.time}}time={{flow.time}}{{/flow.time}}{{^flow.time}}!time{{/flow.time}}{{#flow.random}}random={{flow.random}}randomtime={{flow.randomtime}}{{/flow.random}}{{^flow.random}}!random{{/flow.random}}`;
+        var flow = [{id:"n1",z:"t1", type:"template", field:"payload", template:template,wires:[["n2"]]},{id:"n2",z:"t1",type:"helper"}];
+        helper.load(templateNode, flow, function() {
+            initContext(function() {
+                var n1 = helper.getNode("n1");
+                var n2 = helper.getNode("n2");
+                n2.on("input", function(msg) {
+                    try {
+                        msg.should.have.property('topic', 'bar');
+                        msg.should.have.property('payload', 'time=123random=456randomtime=789');
+                        done();
+                    } catch(err) {
+                        done(err);
+                    }
+                });
+                n1.context().flow.set(["time","random","randomtime"],["123","456","789"],function (err) {
+                    n1.receive({payload:"foo",topic: "bar"});
+                });
+            });
+        });
+    })
+
+    it('should modify payload from two persistable flow context', function(done) {
+        var flow = [{id:"n1",z:"t1", type:"template", field:"payload", template:"payload={{flow[memory1].value}}/{{flow[memory2].value}}",wires:[["n2"]]},{id:"n2",z:"t1",type:"helper"}];
+        helper.load(templateNode, flow, function() {
+            initContext(function() {
+                var n1 = helper.getNode("n1");
+                var n2 = helper.getNode("n2");
+                n2.on("input", function(msg) {
+                    msg.should.have.property('topic', 'bar');
+                    msg.should.have.property('payload', 'payload=foo/bar');
+                    done();
+                });
+                n1.context().flow.set("value","foo","memory1",function (err) {
+                    n1.context().flow.set("value","bar","memory2",function (err) {
+                        n1.receive({payload:"foo",topic: "bar"});
+                    });
+                });
+            });
+        });
+    });
+
     it('should modify payload from global context', function(done) {
         var flow = [{id:"n1",z:"t1", type:"template", field:"payload", template:"payload={{global.value}}",wires:[["n2"]]},{id:"n2",z:"t1",type:"helper"}];
         helper.load(templateNode, flow, function() {
@@ -147,6 +259,64 @@ describe('template node', function() {
         });
     });
 
+    it('should modify payload from persistable global context', function(done) {
+        var flow = [{id:"n1",z:"t1", type:"template", field:"payload", template:"payload={{global[memory1].value}}",wires:[["n2"]]},{id:"n2",z:"t1",type:"helper"}];
+        helper.load(templateNode, flow, function() {
+            initContext(function () {
+                var n1 = helper.getNode("n1");
+                var n2 = helper.getNode("n2");
+                n2.on("input", function(msg) {
+                    msg.should.have.property('topic', 'bar');
+                    msg.should.have.property('payload', 'payload=foo');
+                    done();
+                });
+                n1.context().global.set("value","foo","memory1", function (err) {
+                    n1.receive({payload:"foo",topic: "bar"});
+                });
+            });
+        });
+    });
+
+    it('should modify payload from two persistable global context', function(done) {
+        var flow = [{id:"n1",z:"t1", type:"template", field:"payload", template:"payload={{global[memory1].value}}/{{global[memory2].value}}",wires:[["n2"]]},{id:"n2",z:"t1",type:"helper"}];
+        helper.load(templateNode, flow, function() {
+            initContext(function () {
+                var n1 = helper.getNode("n1");
+                var n2 = helper.getNode("n2");
+                n2.on("input", function(msg) {
+                    msg.should.have.property('topic', 'bar');
+                    msg.should.have.property('payload', 'payload=foo/bar');
+                    done();
+                });
+                n1.context().global.set("value","foo","memory1", function (err) {
+                    n1.context().global.set("value","bar","memory2", function (err) {
+                        n1.receive({payload:"foo",topic: "bar"});
+                    });
+                });
+            });
+        });
+    });
+
+    it('should modify payload from persistable flow & global context', function(done) {
+        var flow = [{id:"n1",z:"t1", type:"template", field:"payload", template:"payload={{flow[memory1].value}}/{{global[memory1].value}}",wires:[["n2"]]},{id:"n2",z:"t1",type:"helper"}];
+        helper.load(templateNode, flow, function() {
+            initContext(function () {
+                var n1 = helper.getNode("n1");
+                var n2 = helper.getNode("n2");
+                n2.on("input", function(msg) {
+                    msg.should.have.property('topic', 'bar');
+                    msg.should.have.property('payload', 'payload=foo/bar');
+                    done();
+                });
+                n1.context().flow.set("value","foo","memory1", function (err) {
+                    n1.context().global.set("value","bar","memory1", function (err) {
+                        n1.receive({payload:"foo",topic: "bar"});
+                    });
+                });
+            });
+        });
+    });
+
     it('should handle missing node context', function(done) {
         // this is artificial test because in flow there is missing z property (probably never happen in real usage)
         var flow = [{id:"n1",type:"template", field:"payload", template:"payload={{flow.value}},{{global.value}}",wires:[["n2"]]},{id:"n2",type:"helper"}];
@@ -206,6 +376,27 @@ describe('template node', function() {
         });
     });
 
+    it('should modify persistable flow context', function(done) {
+        var flow = [{id:"n1",z:"t1", type:"template", field:"#:(memory1)::payload", fieldType:"flow", template:"payload={{payload}}",wires:[["n2"]]},{id:"n2",z:"t1",type:"helper"}];
+        helper.load(templateNode, flow, function() {
+            initContext(function () {
+                var n1 = helper.getNode("n1");
+                var n2 = helper.getNode("n2");
+                n2.on("input", function(msg) {
+                    // mesage is intact
+                    msg.should.have.property('topic', 'bar');
+                    msg.should.have.property('payload', 'foo');
+                    // result is in flow context
+                    n2.context().flow.get("payload", "memory1", function (err, val) {
+                        val.should.equal("payload=foo");
+                        done();
+                    });
+                });
+                n1.receive({payload:"foo",topic: "bar"});
+            });
+        });
+    });
+
     it('should modify global context', function(done) {
         var flow = [{id:"n1",z:"t1", type:"template", field:"payload", fieldType:"global", template:"payload={{payload}}",wires:[["n2"]]},{id:"n2",z:"t1",type:"helper"}];
         helper.load(templateNode, flow, function() {
@@ -223,6 +414,27 @@ describe('template node', function() {
         });
     });
 
+    it('should modify persistable global context', function(done) {
+        var flow = [{id:"n1",z:"t1", type:"template", field:"#:(memory1)::payload", fieldType:"global", template:"payload={{payload}}",wires:[["n2"]]},{id:"n2",z:"t1",type:"helper"}];
+        helper.load(templateNode, flow, function() {
+            initContext(function () {
+                var n1 = helper.getNode("n1");
+                var n2 = helper.getNode("n2");
+                n2.on("input", function(msg) {
+                    // mesage is intact
+                    msg.should.have.property('topic', 'bar');
+                    msg.should.have.property('payload', 'foo');
+                    // result is in global context
+                    n2.context().global.get("payload", "memory1", function (err, val) {
+                        val.should.equal("payload=foo");
+                        done();
+                    });
+                });
+                n1.receive({payload:"foo",topic: "bar"});
+            });
+        });
+    });
+
     it('should handle if the field isn\'t set', function(done) {
         var flow = [{id:"n1", type:"template", template: "payload={{payload}}",wires:[["n2"]]},{id:"n2",type:"helper"}];
         helper.load(templateNode, flow, function() {
@@ -264,6 +476,7 @@ describe('template node', function() {
             n1.receive({payload:{A:"abc"}});
         });
     });
+
     it('should raise error if passed bad template', function(done) {
         var flow = [{id:"n1", type:"template", field: "payload", template: "payload={{payload",wires:[["n2"]]},{id:"n2",type:"helper"}];
         helper.load(templateNode, flow, function() {

test/nodes/core/core/89-delay_spec.js

@@ -16,7 +16,7 @@
 
 var should = require("should");
 
-var delayNode = require("../../../../nodes/core/core/89-delay.js");
+var delayNode = require("nr-test-utils").require("@node-red/nodes/core/core/89-delay.js");
 var helper = require("node-red-node-test-helper");
 
 var GRACE_PERCENTAGE=10;
@@ -572,4 +572,150 @@ describe('delay Node', function() {
             delayNode1.receive({payload:4,topic:"A"});  //  and nothing on second
         });
     });
+
+    it('can flush delay queue', function(done) {
+        this.timeout(2000);
+        var flow = [{"id":"delayNode1","type":"delay","name":"delayNode","pauseType":"delay","timeout":1,"timeoutUnits":"seconds","rate":2,"rateUnits":"second","randomFirst":"1","randomLast":"5","randomUnits":"seconds","drop":false,"wires":[["helperNode1"]]},
+                    {id:"helperNode1", type:"helper", wires:[]}];
+        helper.load(delayNode, flow, function() {
+            var delayNode1 = helper.getNode("delayNode1");
+            var helperNode1 = helper.getNode("helperNode1");
+            var t = Date.now();
+            var c = 0;
+            helperNode1.on("input", function(msg) {
+                msg.should.have.a.property('payload');
+                msg.should.have.a.property('topic');
+                try {
+                    if (msg.topic === "foo") {
+                        msg.payload.should.equal(1);
+                        (Date.now() - t).should.be.approximately(0,100);
+                        c = c + 1;
+                    }
+                    else {
+                        if (msg.topic === "bar") {
+                            msg.payload.should.equal(1);
+                            (Date.now() - t).should.be.approximately(0,100);
+                            c = c + 1;
+                        }
+                    }
+                    if (c === 5) { done(); }
+                } catch(e) {
+                    done(e);
+                }
+            });
+
+            // send test messages
+            delayNode1.receive({payload:1,topic:"foo"});            // send something with blank topic
+            setImmediate( function() { delayNode1.receive({payload:1,topic:"bar"}); }  );          // send something with blank topic
+            setImmediate( function() { delayNode1.receive({payload:1,topic:"bar"}); }  );          // send something with blank topic
+            setImmediate( function() { delayNode1.receive({payload:1,topic:"bar"}); }  );          // send something with blank topic
+            setImmediate( function() { delayNode1.receive({payload:1,topic:"bar"}); }  );          // send something with blank topic
+            setImmediate( function() { delayNode1.receive({flush:true});  });          // reset the queue
+        });
+    });
+
+    it('can reset delay queue', function(done) {
+        this.timeout(2000);
+        var flow = [{"id":"delayNode1","type":"delay","name":"delayNode","pauseType":"delay","timeout":1,"timeoutUnits":"seconds","rate":2,"rateUnits":"second","randomFirst":"1","randomLast":"5","randomUnits":"seconds","drop":false,"wires":[["helperNode1"]]},
+                    {id:"helperNode1", type:"helper", wires:[]}];
+        helper.load(delayNode, flow, function() {
+            var delayNode1 = helper.getNode("delayNode1");
+            var helperNode1 = helper.getNode("helperNode1");
+            var t = Date.now();
+            var c = 0;
+            helperNode1.on("input", function(msg) {
+                c = c + 1;
+            });
+
+            setTimeout( function() {
+                if (c === 0) { done(); }
+            }, 700);
+
+            // send test messages
+            delayNode1.receive({payload:1,topic:"foo"});            // send something with blank topic
+            setImmediate( function() { delayNode1.receive({payload:1,topic:"bar"}); }  );          // send something with blank topic
+            setImmediate( function() { delayNode1.receive({payload:1,topic:"bar"}); }  );          // send something with blank topic
+            setImmediate( function() { delayNode1.receive({payload:1,topic:"bar"}); }  );          // send something with blank topic
+            setImmediate( function() { delayNode1.receive({payload:1,topic:"bar"}); }  );          // send something with blank topic
+            setImmediate( function() { delayNode1.receive({reset:true});  });          // reset the queue
+        });
+    });
+
+    it('can flush rate limit queue', function(done) {
+        this.timeout(2000);
+        var flow = [{"id":"delayNode1","type":"delay","name":"delayNode","pauseType":"rate","timeout":1,"timeoutUnits":"seconds","rate":2,"rateUnits":"second","randomFirst":"1","randomLast":"5","randomUnits":"seconds","drop":false,"wires":[["helperNode1"]]},
+                    {id:"helperNode1", type:"helper", wires:[]}];
+        helper.load(delayNode, flow, function() {
+            var delayNode1 = helper.getNode("delayNode1");
+            var helperNode1 = helper.getNode("helperNode1");
+            var t = Date.now();
+            var c = 0;
+            helperNode1.on("input", function(msg) {
+                msg.should.have.a.property('payload');
+                msg.should.have.a.property('topic');
+                try {
+                    if (msg.topic === "foo") {
+                        msg.payload.should.equal(1);
+                        (Date.now() - t).should.be.approximately(0,100);
+                        c = c + 1;
+                    }
+                    else {
+                        if (msg.topic === "bar") {
+                            msg.payload.should.equal(1);
+                            (Date.now() - t).should.be.approximately(0,100);
+                            c = c + 1;
+                        }
+                    }
+                    if (c === 5) { done(); }
+                } catch(e) {
+                    done(e);
+                }
+            });
+
+            // send test messages
+            delayNode1.receive({payload:1,topic:"foo"});            // send something with blank topic
+            setImmediate( function() { delayNode1.receive({payload:1,topic:"bar"}); }  );          // send something with blank topic
+            setImmediate( function() { delayNode1.receive({payload:1,topic:"bar"}); }  );          // send something with blank topic
+            setImmediate( function() { delayNode1.receive({payload:1,topic:"bar"}); }  );          // send something with blank topic
+            setImmediate( function() { delayNode1.receive({payload:1,topic:"bar"}); }  );          // send something with blank topic
+            setImmediate( function() { delayNode1.receive({flush:true});  });          // reset the queue
+        });
+    });
+
+    it('can reset rate limit queue', function(done) {
+        this.timeout(2000);
+        var flow = [{"id":"delayNode1","type":"delay","name":"delayNode","pauseType":"rate","timeout":1,"timeoutUnits":"seconds","rate":2,"rateUnits":"second","randomFirst":"1","randomLast":"5","randomUnits":"seconds","drop":false,"wires":[["helperNode1"]]},
+                    {id:"helperNode1", type:"helper", wires:[]}];
+        helper.load(delayNode, flow, function() {
+            var delayNode1 = helper.getNode("delayNode1");
+            var helperNode1 = helper.getNode("helperNode1");
+            var t = Date.now();
+            var c = 0;
+            helperNode1.on("input", function(msg) {
+                msg.should.have.a.property('payload');
+                msg.should.have.a.property('topic');
+                try {
+                    if (msg.topic === "foo") {
+                        msg.payload.should.equal(1);
+                        (Date.now() - t).should.be.approximately(0,100);
+                        c = c + 1;
+                    }
+                } catch(e) {
+                    done(e);
+                }
+            });
+
+            setTimeout( function() {
+                if (c === 1) { done(); }
+            }, 700);
+
+            // send test messages
+            delayNode1.receive({payload:1,topic:"foo"});            // send something with blank topic
+            setImmediate( function() { delayNode1.receive({payload:1,topic:"bar"}); }  );          // send something with blank topic
+            setImmediate( function() { delayNode1.receive({payload:1,topic:"bar"}); }  );          // send something with blank topic
+            setImmediate( function() { delayNode1.receive({payload:1,topic:"bar"}); }  );          // send something with blank topic
+            setImmediate( function() { delayNode1.receive({payload:1,topic:"bar"}); }  );          // send something with blank topic
+            setImmediate( function() { delayNode1.receive({reset:true});  });          // reset the queue
+        });
+    });
 });

test/nodes/core/core/89-trigger_spec.js

@@ -17,8 +17,9 @@
 var should = require("should");
 var sinon = require("sinon");
 var helper = require("node-red-node-test-helper");
-var triggerNode = require("../../../../nodes/core/core/89-trigger.js");
-var RED = require("../../../../red/red.js");
+var triggerNode = require("nr-test-utils").require("@node-red/nodes/core/core/89-trigger.js");
+var Context = require("nr-test-utils").require("@node-red/runtime/lib/nodes/context");
+var RED = require("nr-test-utils").require("node-red/lib/red");
 
 describe('trigger node', function() {
 
@@ -26,8 +27,31 @@ describe('trigger node', function() {
         helper.startServer(done);
     });
 
+    function initContext(done) {
+        Context.init({
+            contextStorage: {
+                memory0: {
+                    module: "memory"
+                },
+                memory1: {
+                    module: "memory"
+                },
+                memory2: {
+                    module: "memory"
+                }
+            }
+        });
+        Context.load().then(function () {
+            done();
+        });
+    }
+
     afterEach(function(done) {
-        helper.unload().then(function() {
+        helper.unload().then(function () {
+            return Context.clean({allNodes: {}});
+        }).then(function () {
+            return Context.close();
+        }).then(function () {
             helper.stopServer(done);
         });
     });
@@ -75,6 +99,74 @@ describe('trigger node', function() {
         });
     });
 
+    function basicTest(type, val, rval) {
+        it('should output 1st value when triggered ('+type+')', function(done) {
+            var flow = [{"id":"n1", "type":"trigger", "name":"triggerNode", op1:val, op1type:type, op2:"", op2type:"null", duration:"20", wires:[["n2"]] },
+                        {id:"n2", type:"helper"} ];
+            process.env[val] = rval;
+            helper.load(triggerNode, flow, function() {
+                var n1 = helper.getNode("n1");
+                var n2 = helper.getNode("n2");
+                n2.on("input", function(msg) {
+                    try {
+			if (rval) {
+			    msg.should.have.property("payload");
+			    should.deepEqual(msg.payload, rval);
+			}
+			else {
+			    msg.should.have.property("payload", val);
+			}
+                        delete process.env[val];
+                        done();
+                    }
+                    catch(err) { done(err); }
+                });
+                n1.emit("input", {payload:null});
+            });
+        });
+
+        it('should output 2st value when triggered ('+type+')', function(done) {
+            var flow = [{"id":"n1", "type":"trigger", "name":"triggerNode", op1:"foo", op1type:"str", op2:val, op2type:type, duration:"20", wires:[["n2"]] },
+                        {id:"n2", type:"helper"} ];
+            process.env[val] = rval;
+            helper.load(triggerNode, flow, function() {
+                var n1 = helper.getNode("n1");
+                var n2 = helper.getNode("n2");
+                var c = 0;
+                n2.on("input", function(msg) {
+                    try {
+                        if (c === 0) {
+			    msg.should.have.property("payload", "foo");
+                            c++;
+                        }
+                        else {
+			    if (rval) {
+			        msg.should.have.property("payload");
+			        should.deepEqual(msg.payload, rval);
+			    }
+			    else {
+			        msg.should.have.property("payload", val);
+			    }
+                            delete process.env[val];
+                            done();
+                        }
+                    }
+                    catch(err) { done(err); }
+                });
+                n1.emit("input", {payload:null});
+            });
+        });
+    }
+
+    basicTest("num", 10);
+    basicTest("str", "10");
+    basicTest("bool", true);
+    var val_json = '{ "x":"vx", "y":"vy", "z":"vz" }';
+    basicTest("json", val_json, JSON.parse(val_json));
+    var val_buf = "[1,2,3,4,5]";
+    basicTest("bin", val_buf, Buffer.from(JSON.parse(val_buf)));
+    basicTest("env", "NR-TEST", "env-val");
+
     it('should output 1 then 0 when triggered (default)', function(done) {
         var flow = [{"id":"n1", "type":"trigger", "name":"triggerNode", duration:"20", wires:[["n2"]] },
             {id:"n2", type:"helper"} ];
@@ -312,7 +404,159 @@ describe('trigger node', function() {
             });
             n1.emit("input", {payload:null});
         });
+    });
 
+    it('should be able to return things from persistable flow and global context variables', function (done) {
+        var flow = [{"id": "n1", "type": "trigger", "name": "triggerNode", "op1": "#:(memory1)::foo", "op1type": "flow",
+                     "op2": "#:(memory1)::bar", "op2type": "global", "duration": "20", "wires": [["n2"]], "z": "flow" },
+                    {"id": "n2", "type": "helper"}];
+        helper.load(triggerNode, flow, function () {
+            initContext(function () {
+                var n1 = helper.getNode("n1");
+                var n2 = helper.getNode("n2");
+                var c = 0;
+                n2.on("input", function (msg) {
+                    try {
+                        if (c === 0) {
+                            msg.should.have.a.property("payload", "foo");
+                            c += 1;
+                        } else {
+                            msg.should.have.a.property("payload", "bar");
+                            done();
+                        }
+                    } catch (err) {
+                        done(err);
+                    }
+                });
+                var context = n1.context();
+                var flow = context.flow;
+                var global = context.global;
+                flow.set("foo", "foo", "memory1", function (err) {
+                    global.set("bar", "bar", "memory1", function (err) {
+                        n1.emit("input", { payload: null });
+                    });
+                });
+            });
+        });
+    });
+
+    it('should be able to return things from multiple persistable global context variables', function (done) {
+        var flow = [{"id": "n1", "z": "flow", "type": "trigger",
+                     "duration": "20", "wires": [["n2"]],
+                     "op1": "#:(memory1)::val", "op1type": "global",
+                     "op2": "#:(memory2)::val", "op2type": "global"
+                    },
+                    {"id": "n2", "type": "helper"}];
+        helper.load(triggerNode, flow, function () {
+            initContext(function () {
+                var n1 = helper.getNode("n1");
+                var n2 = helper.getNode("n2");
+                var count = 0;
+                n2.on("input", function (msg) {
+                    try {
+                        if (count === 0) {
+                            msg.should.have.a.property("payload", "foo");
+                        }
+                        else {
+                            msg.should.have.a.property("payload", "bar");
+                        }
+                        count++;
+                        if (count === 1) {
+                            done();
+                        }
+                    }
+                    catch (err) {
+                        done(err);
+                    }
+                });
+                var global = n1.context().global;
+                global.set("val", "foo", "memory1", function (err) {
+                    global.set("val", "bar", "memory2", function (err) {
+                        n1.emit("input", { payload: null });
+                    });
+                });
+            });
+        });
+    });
+
+    it('should be able to return things from multiple persistable flow context variables', function (done) {
+        var flow = [{"id": "n1", "z": "flow", "type": "trigger",
+                     "duration": "20", "wires": [["n2"]],
+                     "op1": "#:(memory1)::val", "op1type": "flow",
+                     "op2": "#:(memory2)::val", "op2type": "flow"
+                    },
+                    {"id": "n2", "type": "helper"}];
+        helper.load(triggerNode, flow, function () {
+            initContext(function () {
+                var n1 = helper.getNode("n1");
+                var n2 = helper.getNode("n2");
+                var count = 0;
+                n2.on("input", function (msg) {
+                    try {
+                        if (count === 0) {
+                            msg.should.have.a.property("payload", "foo");
+                        }
+                        else {
+                            msg.should.have.a.property("payload", "bar");
+                        }
+                        count++;
+                        if (count === 1) {
+                            done();
+                        }
+                    }
+                    catch (err) {
+                        done(err);
+                    }
+                });
+                var flow = n1.context().flow;
+                flow.set("val", "foo", "memory1", function (err) {
+                    flow.set("val", "bar", "memory2", function (err) {
+                        n1.emit("input", { payload: null });
+                    });
+                });
+            });
+        });
+    });
+
+    it('should be able to return things from multiple persistable flow & global context variables', function (done) {
+        var flow = [{"id": "n1", "z": "flow", "type": "trigger",
+                     "duration": "20", "wires": [["n2"]],
+                     "op1": "#:(memory1)::val", "op1type": "flow",
+                     "op2": "#:(memory2)::val", "op2type": "global"
+                    },
+                    {"id": "n2", "type": "helper"}];
+        helper.load(triggerNode, flow, function () {
+            initContext(function () {
+                var n1 = helper.getNode("n1");
+                var n2 = helper.getNode("n2");
+                var count = 0;
+                n2.on("input", function (msg) {
+                    try {
+                        if (count === 0) {
+                            msg.should.have.a.property("payload", "foo");
+                        }
+                        else {
+                            msg.should.have.a.property("payload", "bar");
+                        }
+                        count++;
+                        if (count === 1) {
+                            done();
+                        }
+                    }
+                    catch (err) {
+                        done(err);
+                    }
+                });
+                var context = n1.context();
+                var flow = context.flow;
+                var global = context.flow;
+                flow.set("val", "foo", "memory1", function (err) {
+                    global.set("val", "bar", "memory2", function (err) {
+                        n1.emit("input", { payload: null });
+                    });
+                });
+            });
+        });
     });
 
     it('should be able to not output anything on first trigger', function(done) {
@@ -433,7 +677,7 @@ describe('trigger node', function() {
                     }
                     else {
                         msg.should.have.a.property("payload", "World");
-                        (Date.now() - ss).should.be.greaterThan(150);
+                        (Date.now() - ss).should.be.greaterThan(149);
                         done();
                     }
                 }

test/nodes/core/core/90-comment_spec.js

@@ -15,7 +15,7 @@
  **/
 
 var should = require("should");
-var commentNode = require("../../../../nodes/core/core/90-comment.js");
+var commentNode = require("nr-test-utils").require("@node-red/nodes/core/core/90-comment.js");
 var helper = require("node-red-node-test-helper");
 
 describe('comment Node', function() {

test/nodes/core/core/98-unknown_spec.js

@@ -15,7 +15,7 @@
  **/
 
 var should = require("should");
-var unknown = require("../../../../nodes/core/core/98-unknown.js");
+var unknown = require("nr-test-utils").require("@node-red/nodes/core/core/98-unknown.js");
 var helper = require("node-red-node-test-helper");
 
 describe('unknown Node', function() {

test/nodes/core/hardware/36-rpi-gpio_spec.js

@@ -15,7 +15,8 @@
  **/
 
 var should = require("should");
-var rpi = require("../../../../nodes/core/hardware/36-rpi-gpio.js");
+var rpiNode = require("nr-test-utils").require("@node-red/nodes/core/hardware/36-rpi-gpio.js");
+var statusNode = require("nr-test-utils").require("@node-red/nodes/core/core/25-status.js");
 var helper = require("node-red-node-test-helper");
 var fs = require("fs");
 
@@ -50,7 +51,7 @@ describe('RPI GPIO Node', function() {
 
     it('should load Input node', function(done) {
         var flow = [{id:"n1", type:"rpi-gpio in", name:"rpi-gpio in" }];
-        helper.load(rpi, flow, function() {
+        helper.load(rpiNode, flow, function() {
             var n1 = helper.getNode("n1");
             n1.should.have.property('name', 'rpi-gpio in');
             try {
@@ -69,7 +70,7 @@ describe('RPI GPIO Node', function() {
 
     it('should load Output node', function(done) {
         var flow = [{id:"n1", type:"rpi-gpio out", name:"rpi-gpio out" }];
-        helper.load(rpi, flow, function() {
+        helper.load(rpiNode, flow, function() {
             var n1 = helper.getNode("n1");
             n1.should.have.property('name', 'rpi-gpio out');
             try {
@@ -86,4 +87,68 @@ describe('RPI GPIO Node', function() {
         });
     });
 
+
+    it('should read a dummy value high (not on Pi)', function(done) {
+        var flow = [{id:"n1", type:"rpi-gpio in", pin:"7", intype:"up", debounce:"25", read:true, wires:[["n2"]] },
+        {id:"n2", type:"helper"}];
+        helper.load(rpiNode, flow, function() {
+            var n1 = helper.getNode("n1");
+            var n2 = helper.getNode("n2");
+            n2.on("input", function(msg) {
+                try {
+                    msg.should.have.property('topic', 'pi/7');
+                    msg.should.have.property('payload', 1);
+                    done();
+                } catch(err) {
+                    done(err);
+                }
+            });
+        });
+    });
+
+    it('should read a dummy value low (not on Pi)', function(done) {
+        var flow = [{id:"n1", type:"rpi-gpio in", pin:"11", intype:"down", debounce:"25", read:true, wires:[["n2"]] },
+        {id:"n2", type:"helper"}];
+        helper.load(rpiNode, flow, function() {
+            var n1 = helper.getNode("n1");
+            var n2 = helper.getNode("n2");
+            n2.on("input", function(msg) {
+                try {
+                    msg.should.have.property('topic', 'pi/11');
+                    msg.should.have.property('payload', 0);
+                    done();
+                } catch(err) {
+                    done(err);
+                }
+            });
+        });
+    });
+
+    it('should be able preset out to a dummy value (not on Pi)', function(done) {
+        var flow = [{id:"n1", type:"rpi-gpio out", pin:"7", out:"out", level:"0", set:true, freq:"", wires:[], z:"1"},
+        {id:"n2", type:"status", scope:null, wires:[["n3"]], z:"1"},
+        {id:"n3", type:"helper", z:"1"}];
+        helper.load([rpiNode,statusNode], flow, function() {
+            var n1 = helper.getNode("n1");
+            var n2 = helper.getNode("n2");
+            var n3 = helper.getNode("n3");
+            var count = 0;
+            n3.on("input", function(msg) {
+                // Only check the first status message received as it may get a
+                // 'closed' status as the test is tidied up.
+                if (count === 0) {
+                    count++;
+                    try {
+                        msg.should.have.property('status');
+                        msg.status.should.have.property('text', "rpi-gpio.status.na");
+                        done();
+                    } catch(err) {
+                        done(err);
+                    }
+                }
+            });
+            n1.receive({payload:"1"});
+        });
+    });
+
 });

test/nodes/core/io/21-httprequest_spec.js

@@ -22,12 +22,13 @@ var express = require("express");
 var bodyParser = require('body-parser');
 var stoppable = require('stoppable');
 var helper = require("node-red-node-test-helper");
-var httpRequestNode = require("../../../../nodes/core/io/21-httprequest.js");
-var tlsNode = require("../../../../nodes/core/io/05-tls.js");
+var httpRequestNode = require("nr-test-utils").require("@node-red/nodes/core/io/21-httprequest.js");
+var tlsNode = require("nr-test-utils").require("@node-red/nodes/core/io/05-tls.js");
+var httpProxyNode = require("nr-test-utils").require("@node-red/nodes/core/io/06-httpproxy.js");
 var hashSum = require("hash-sum");
 var httpProxy = require('http-proxy');
 var cookieParser = require('cookie-parser');
-var RED = require("../../../../red/red.js");
+var RED = require("nr-test-utils").require("node-red/lib/red");
 var fs = require('fs-extra');
 var auth = require('basic-auth');
 
@@ -46,6 +47,9 @@ describe('HTTP Request Node', function() {
     var preEnvNoProxyLowerCase;
     var preEnvNoProxyUpperCase;
 
+    //rediect cookie variables
+    var receivedCookies = {};
+
     function startServer(done) {
         testPort += 1;
         testServer = stoppable(http.createServer(testApp));
@@ -98,42 +102,21 @@ describe('HTTP Request Node', function() {
         return "https://localhost:"+testSslPort+url;
     }
 
+    function getDifferentTestURL(url) {
+        return "http://127.0.0.1:"+testPort+url;
+    }
+
     function getSslTestURLWithoutProtocol(url) {
         return "localhost:"+testSslPort+url;
     }
 
-    function saveProxySetting() {
-        preEnvHttpProxyLowerCase = process.env.http_proxy;
-        preEnvHttpProxyUpperCase = process.env.HTTP_PROXY;
-        preEnvNoProxyLowerCase = process.env.no_proxy;
-        preEnvNoProxyUpperCase = process.env.NO_PROXY;
+    function deleteProxySetting() {
         delete process.env.http_proxy;
         delete process.env.HTTP_PROXY;
         delete process.env.no_proxy;
         delete process.env.NO_PROXY;
     }
 
-    function restoreProxySetting() {
-        process.env.http_proxy = preEnvHttpProxyLowerCase;
-        process.env.HTTP_PROXY = preEnvHttpProxyUpperCase;
-        // On Windows, if environment variable of NO_PROXY that includes lower cases
-        // such as No_Proxy is replaced with NO_PROXY.
-        process.env.no_proxy = preEnvNoProxyLowerCase;
-        process.env.NO_PROXY = preEnvNoProxyUpperCase;
-        if (preEnvHttpProxyLowerCase == undefined){
-            delete process.env.http_proxy;
-        }
-        if (preEnvHttpProxyUpperCase == undefined){
-            delete process.env.HTTP_PROXY;
-        }
-        if (preEnvNoProxyLowerCase == undefined){
-            delete process.env.no_proxy;
-        }
-        if (preEnvNoProxyUpperCase == undefined){
-            delete process.env.NO_PROXY;
-        }
-    }
-
     before(function(done) {
         testApp = express();
         testApp.use(bodyParser.raw({type:"*/*"}));
@@ -207,6 +190,24 @@ describe('HTTP Request Node', function() {
         testApp.options('/*', function(req,res) {
             res.status(200).end();
         });
+        testApp.get('/redirectToSameDomain', function(req, res) {
+            var key = req.headers.host + req.url;
+            receivedCookies[key] = req.cookies;
+            res.cookie('redirectToSameDomainCookie','same1');
+            res.redirect(getTestURL('/redirectReturn'));
+        });
+        testApp.get('/redirectToDifferentDomain', function(req, res) {
+            var key = req.headers.host + req.url;
+            receivedCookies[key] = req.cookies;
+            res.cookie('redirectToDifferentDomain','different1');
+            res.redirect(getDifferentTestURL('/redirectReturn'));
+        });
+        testApp.get('/redirectReturn', function(req, res) {
+            var key = req.headers.host + req.url;
+            receivedCookies[key] = req.cookies;
+            res.cookie('redirectReturn','return1');
+            res.status(200).end();
+        });
         startServer(function(err) {
             if (err) {
                 done(err);
@@ -225,7 +226,35 @@ describe('HTTP Request Node', function() {
         });
     });
 
+
+    beforeEach(function() {
+        preEnvHttpProxyLowerCase = process.env.http_proxy;
+        preEnvHttpProxyUpperCase = process.env.HTTP_PROXY;
+        preEnvNoProxyLowerCase = process.env.no_proxy;
+        preEnvNoProxyUpperCase = process.env.NO_PROXY;
+        process.env.no_proxy = 'localhost';
+        process.env.NO_PROXY = 'localhost';
+    });
+
     afterEach(function() {
+        process.env.http_proxy = preEnvHttpProxyLowerCase;
+        process.env.HTTP_PROXY = preEnvHttpProxyUpperCase;
+        // On Windows, if environment variable of NO_PROXY that includes lower cases
+        // such as No_Proxy is replaced with NO_PROXY.
+        process.env.no_proxy = preEnvNoProxyLowerCase;
+        process.env.NO_PROXY = preEnvNoProxyUpperCase;
+        if (preEnvHttpProxyLowerCase == undefined) {
+            delete process.env.http_proxy;
+        }
+        if (preEnvHttpProxyUpperCase == undefined) {
+            delete process.env.HTTP_PROXY;
+        }
+        if (preEnvNoProxyLowerCase == undefined) {
+            delete process.env.no_proxy;
+        }
+        if (preEnvNoProxyUpperCase == undefined) {
+            delete process.env.NO_PROXY;
+        }
         helper.unload();
     });
 
@@ -1060,13 +1089,12 @@ describe('HTTP Request Node', function() {
         it('should use http_proxy', function(done) {
             var flow = [{id:"n1",type:"http request",wires:[["n2"]],method:"POST",ret:"obj",url:getTestURL('/postInspect')},
                 {id:"n2", type:"helper"}];
-            saveProxySetting();
+            deleteProxySetting();
             process.env.http_proxy = "http://localhost:" + testProxyPort;
             helper.load(httpRequestNode, flow, function() {
                 var n1 = helper.getNode("n1");
                 var n2 = helper.getNode("n2");
                 n2.on("input", function(msg) {
-                    restoreProxySetting();
                     try {
                         msg.should.have.property('statusCode',200);
                         msg.payload.should.have.property('headers');
@@ -1083,13 +1111,12 @@ describe('HTTP Request Node', function() {
         it('should use http_proxy when environment variable is invalid', function(done) {
             var flow = [{id:"n1",type:"http request",wires:[["n2"]],method:"POST",ret:"obj",url:getTestURL('/postInspect')},
                 {id:"n2", type:"helper"}];
-            saveProxySetting();
+            deleteProxySetting();
             process.env.http_proxy = "invalidvalue";
             helper.load(httpRequestNode, flow, function() {
                 var n1 = helper.getNode("n1");
                 var n2 = helper.getNode("n2");
                 n2.on("input", function(msg) {
-                    restoreProxySetting();
                     try {
                         msg.should.have.property('statusCode',200);
                         msg.payload.should.have.property('headers');
@@ -1106,13 +1133,12 @@ describe('HTTP Request Node', function() {
         it('should use HTTP_PROXY', function(done) {
             var flow = [{id:"n1",type:"http request",wires:[["n2"]],method:"POST",ret:"obj",url:getTestURL('/postInspect')},
                 {id:"n2", type:"helper"}];
-            saveProxySetting();
+            deleteProxySetting();
             process.env.HTTP_PROXY = "http://localhost:" + testProxyPort;
             helper.load(httpRequestNode, flow, function() {
                 var n1 = helper.getNode("n1");
                 var n2 = helper.getNode("n2");
                 n2.on("input", function(msg) {
-                    restoreProxySetting();
                     try {
                         msg.should.have.property('statusCode',200);
                         msg.payload.should.have.property('headers');
@@ -1129,14 +1155,13 @@ describe('HTTP Request Node', function() {
         it('should use no_proxy', function(done) {
             var flow = [{id:"n1",type:"http request",wires:[["n2"]],method:"POST",ret:"obj",url:getTestURL('/postInspect')},
                 {id:"n2", type:"helper"}];
-            saveProxySetting();
+            deleteProxySetting();
             process.env.http_proxy = "http://localhost:" + testProxyPort;
             process.env.no_proxy = "foo,localhost";
             helper.load(httpRequestNode, flow, function() {
                 var n1 = helper.getNode("n1");
                 var n2 = helper.getNode("n2");
                 n2.on("input", function(msg) {
-                    restoreProxySetting();
                     try {
                         msg.should.have.property('statusCode',200);
                         msg.payload.headers.should.not.have.property('x-testproxy-header','foobar');
@@ -1152,14 +1177,87 @@ describe('HTTP Request Node', function() {
         it('should use NO_PROXY', function(done) {
             var flow = [{id:"n1",type:"http request",wires:[["n2"]],method:"POST",ret:"obj",url:getTestURL('/postInspect')},
                 {id:"n2", type:"helper"}];
-            saveProxySetting();
+            deleteProxySetting();
             process.env.HTTP_PROXY = "http://localhost:" + testProxyPort;
             process.env.NO_PROXY = "foo,localhost";
             helper.load(httpRequestNode, flow, function() {
                 var n1 = helper.getNode("n1");
                 var n2 = helper.getNode("n2");
                 n2.on("input", function(msg) {
-                    restoreProxySetting();
+                    try {
+                        msg.should.have.property('statusCode',200);
+                        msg.payload.headers.should.not.have.property('x-testproxy-header','foobar');
+                        done();
+                    } catch(err) {
+                        done(err);
+                    }
+                });
+                n1.receive({payload:"foo"});
+            });
+        });
+
+        it('should use http-proxy-config', function(done) {
+            var flow = [
+                {id:"n1",type:"http request",wires:[["n2"]],method:"POST",ret:"obj",url:getTestURL('/postInspect'),proxy:"n3"},
+                {id:"n2",type:"helper"},
+                {id:"n3",type:"http proxy",url:"http://localhost:" + testProxyPort}
+            ];
+            var testNode = [ httpRequestNode, httpProxyNode ];
+            deleteProxySetting();
+            helper.load(testNode, flow, function() {
+                var n1 = helper.getNode("n1");
+                var n2 = helper.getNode("n2");
+                n2.on("input", function(msg) {
+                    try {
+                        msg.should.have.property('statusCode',200);
+                        msg.payload.should.have.property('headers');
+                        msg.payload.headers.should.have.property('x-testproxy-header','foobar');
+                        done();
+                    } catch(err) {
+                        done(err);
+                    }
+                });
+                n1.receive({payload:"foo"});
+            });
+        });
+
+        it('should not use http-proxy-config when invalid url is specified', function(done) {
+            var flow = [
+                {id:"n1",type:"http request",wires:[["n2"]],method:"POST",ret:"obj",url:getTestURL('/postInspect'),proxy:"n3"},
+                {id:"n2", type:"helper"},
+                {id:"n3",type:"http proxy",url:"invalidvalue"}
+            ];
+            var testNode = [ httpRequestNode, httpProxyNode ];
+            deleteProxySetting();
+            helper.load(testNode, flow, function() {
+                var n1 = helper.getNode("n1");
+                var n2 = helper.getNode("n2");
+                n2.on("input", function(msg) {
+                    try {
+                        msg.should.have.property('statusCode',200);
+                        msg.payload.should.have.property('headers');
+                        msg.payload.headers.should.not.have.property('x-testproxy-header','foobar');
+                        done();
+                    } catch(err) {
+                        done(err);
+                    }
+                });
+                n1.receive({payload:"foo"});
+            });
+        });
+
+        it('should use http-proxy-config when valid noproxy is specified', function(done) {
+            var flow = [
+                {id:"n1",type:"http request",wires:[["n2"]],method:"POST",ret:"obj",url:getTestURL('/postInspect'),proxy:"n3"},
+                {id:"n2", type:"helper"},
+                {id:"n3",type:"http proxy",url:"http://localhost:" + testProxyPort,noproxy:["foo","localhost"]}
+            ];
+            var testNode = [ httpRequestNode, httpProxyNode ];
+            deleteProxySetting();
+            helper.load(testNode, flow, function() {
+                var n1 = helper.getNode("n1");
+                var n2 = helper.getNode("n2");
+                n2.on("input", function(msg) {
                     try {
                         msg.should.have.property('statusCode',200);
                         msg.payload.headers.should.not.have.property('x-testproxy-header','foobar');
@@ -1198,13 +1296,12 @@ describe('HTTP Request Node', function() {
         it('should authenticate on proxy server', function(done) {
             var flow = [{id:"n1",type:"http request", wires:[["n2"]],method:"GET",ret:"obj",url:getTestURL('/proxyAuthenticate')},
                 {id:"n2", type:"helper"}];
-            saveProxySetting();
+            deleteProxySetting();
             process.env.http_proxy = "http://foouser:barpassword@localhost:" + testProxyPort;
             helper.load(httpRequestNode, flow, function() {
                 var n1 = helper.getNode("n1");
                 var n2 = helper.getNode("n2");
                 n2.on("input", function(msg) {
-                    restoreProxySetting();
                     try {
                         msg.should.have.property('statusCode',200);
                         msg.payload.should.have.property('user', 'foouser');
@@ -1223,13 +1320,69 @@ describe('HTTP Request Node', function() {
         it('should output an error when proxy authentication was failed', function(done) {
             var flow = [{id:"n1",type:"http request", wires:[["n2"]],method:"GET",ret:"obj",url:getTestURL('/proxyAuthenticate')},
                 {id:"n2", type:"helper"}];
-            saveProxySetting();
+            deleteProxySetting();
             process.env.http_proxy = "http://xxxuser:barpassword@localhost:" + testProxyPort;
             helper.load(httpRequestNode, flow, function() {
                 var n1 = helper.getNode("n1");
                 var n2 = helper.getNode("n2");
                 n2.on("input", function(msg) {
-                    restoreProxySetting();
+                    try {
+                        msg.should.have.property('statusCode',407);
+                        msg.headers.should.have.property('proxy-authenticate', 'BASIC realm="test"');
+                        msg.payload.should.have.property('headers');
+                        msg.payload.headers.should.have.property('x-testproxy-header','foobar');
+                        done();
+                    } catch(err) {
+                        done(err);
+                    }
+                });
+                n1.receive({payload:"foo"});
+            });
+        });
+
+        it('should authenticate on proxy server(http-proxy-config)', function(done) {
+            var flow = [
+                {id:"n1",type:"http request", wires:[["n2"]],method:"GET",ret:"obj",url:getTestURL('/proxyAuthenticate'),proxy:"n3"},
+                {id:"n2", type:"helper"},
+                {id:"n3",type:"http proxy",url:"http://localhost:" + testProxyPort}
+            ];
+            var testNode = [ httpRequestNode, httpProxyNode ];
+            deleteProxySetting();
+            helper.load(testNode, flow, function() {
+                var n1 = helper.getNode("n1");
+                var n2 = helper.getNode("n2");
+                var n3 = helper.getNode("n3");
+                n3.credentials = {username:'foouser', password:'barpassword'};
+                n2.on("input", function(msg) {
+                    try {
+                        msg.should.have.property('statusCode',200);
+                        msg.payload.should.have.property('user', 'foouser');
+                        msg.payload.should.have.property('pass', 'barpassword');
+                        msg.payload.should.have.property('headers');
+                        msg.payload.headers.should.have.property('x-testproxy-header','foobar');
+                        done();
+                    } catch(err) {
+                        done(err);
+                    }
+                });
+                n1.receive({payload:"foo"});
+            });
+        });
+
+        it('should output an error when proxy authentication was failed(http-proxy-config)', function(done) {
+            var flow = [
+                {id:"n1",type:"http request", wires:[["n2"]],method:"GET",ret:"obj",url:getTestURL('/proxyAuthenticate'),proxy:"n3"},
+                {id:"n2", type:"helper"},
+                {id:"n3",type:"http proxy",url:"http://@localhost:" + testProxyPort}
+            ];
+            var testNode = [ httpRequestNode, httpProxyNode ];
+            deleteProxySetting();
+            helper.load(testNode, flow, function() {
+                var n1 = helper.getNode("n1");
+                var n2 = helper.getNode("n2");
+                var n3 = helper.getNode("n3");
+                n3.credentials = {username:'xxxuser', password:'barpassword'};
+                n2.on("input", function(msg) {
                     try {
                         msg.should.have.property('statusCode',407);
                         msg.headers.should.have.property('proxy-authenticate', 'BASIC realm="test"');
@@ -1244,4 +1397,162 @@ describe('HTTP Request Node', function() {
             });
         });
     });
+
+    describe('redirect-cookie', function() {
+        it('should send cookies to the same domain when redirected(no cookies)', function(done) {
+            var flow = [{id:'n1',type:'http request',wires:[['n2']],method:'GET',ret:'obj',url:getTestURL('/redirectToSameDomain')},
+                {id:"n2", type:"helper"}];
+            receivedCookies = {};
+            helper.load(httpRequestNode, flow, function() {
+                var n1 = helper.getNode("n1");
+                var n2 = helper.getNode("n2");
+                n2.on("input", function(msg) {
+                    var cookies1 = receivedCookies['localhost:'+testPort+'/redirectToSameDomain'];
+                    var cookies2 = receivedCookies['localhost:'+testPort+'/redirectReturn'];
+                    if (cookies1 && Object.keys(cookies1).length != 0) {
+                        done(new Error('Invalid cookie(path:/rediectToSame)'));
+                        return;
+                    }
+                    if ((cookies2 && Object.keys(cookies2).length != 1) ||
+                        cookies2['redirectToSameDomainCookie'] !== 'same1') {
+                        done(new Error('Invalid cookie(path:/rediectReurn)'));
+                       return;
+                    }
+                    done();
+                });
+                n1.receive({});
+            });
+        });
+        it('should not send cookies to the different domain when redirected(no cookies)', function(done) {
+            var flow = [{id:'n1',type:'http request',wires:[['n2']],method:'GET',ret:'obj',url:getTestURL('/redirectToDifferentDomain')},
+                {id:"n2", type:"helper"}];
+            receivedCookies = {};
+            helper.load(httpRequestNode, flow, function() {
+                var n1 = helper.getNode("n1");
+                var n2 = helper.getNode("n2");
+                n2.on("input", function(msg) {
+                    var cookies1 = receivedCookies['localhost:'+testPort+'/redirectToSameDomain'];
+                    var cookies2 = receivedCookies['127.0.0.1:'+testPort+'/redirectReturn'];
+                    if (cookies1 && Object.keys(cookies1).length != 0) {
+                        done(new Error('Invalid cookie(path:/rediectToDiffer)'));
+                        return;
+                    }
+                    if (cookies2 && Object.keys(cookies2).length != 0) {
+                        done(new Error('Invalid cookie(path:/rediectReurn)'));
+                        return;
+                    }
+                    done();
+                });
+                n1.receive({});
+            });
+        });
+        it('should send cookies to the same domain when redirected(msg.cookies)', function(done) {
+            var flow = [{id:'n1',type:'http request',wires:[['n2']],method:'GET',ret:'obj',url:getTestURL('/redirectToSameDomain')},
+                {id:"n2", type:"helper"}];
+            receivedCookies = {};
+            helper.load(httpRequestNode, flow, function() {
+                var n1 = helper.getNode("n1");
+                var n2 = helper.getNode("n2");
+                n2.on("input", function(msg) {
+                    var cookies1 = receivedCookies['localhost:'+testPort+'/redirectToSameDomain'];
+                    var cookies2 = receivedCookies['localhost:'+testPort+'/redirectReturn'];
+                    if ((cookies1 && Object.keys(cookies1).length != 1) ||
+                        cookies1['requestCookie'] !== 'request1') {
+                        done(new Error('Invalid cookie(path:/rediectToSame)'));
+                        return;
+                    }
+                    if ((cookies2 && Object.keys(cookies2).length != 2) ||
+                         cookies1['requestCookie'] !== 'request1' ||
+                         cookies2['redirectToSameDomainCookie'] !== 'same1') {
+                        done(new Error('Invalid cookie(path:/rediectReurn)'));
+                        return;
+                    }
+                    done();
+                });
+                n1.receive({
+                    cookies: { requestCookie: 'request1' }
+                });
+            });
+        });
+        it('should not send cookies to the different domain when redirected(msg.cookies)', function(done) {
+            var flow = [{id:'n1',type:'http request',wires:[['n2']],method:'GET',ret:'obj',url:getTestURL('/redirectToDifferentDomain')},
+                {id:"n2", type:"helper"}];
+            receivedCookies = {};
+            helper.load(httpRequestNode, flow, function() {
+                var n1 = helper.getNode("n1");
+                var n2 = helper.getNode("n2");
+                n2.on("input", function(msg) {
+                    var cookies1 = receivedCookies['localhost:'+testPort+'/redirectToDifferentDomain'];
+                    var cookies2 = receivedCookies['127.0.0.1:'+testPort+'/redirectReturn'];
+                    if ((cookies1 && Object.keys(cookies1).length != 1) ||
+                        cookies1['requestCookie'] !== 'request1') {
+                        done(new Error('Invalid cookie(path:/rediectToDiffer)'));
+                        return;
+                    }
+                    if (cookies2 && Object.keys(cookies2).length != 0) {
+                        done(new Error('Invalid cookie(path:/rediectReurn)'));
+                        return;
+                    }
+                    done();
+                });
+                n1.receive({
+                    cookies: { requestCookie: 'request1' }
+                });
+            });
+        });
+        it('should send cookies to the same domain when redirected(msg.headers.cookie)', function(done) {
+            var flow = [{id:'n1',type:'http request',wires:[['n2']],method:'GET',ret:'obj',url:getTestURL('/redirectToSameDomain')},
+                {id:"n2", type:"helper"}];
+            receivedCookies = {};
+            helper.load(httpRequestNode, flow, function() {
+                var n1 = helper.getNode("n1");
+                var n2 = helper.getNode("n2");
+                n2.on("input", function(msg) {
+                    var cookies1 = receivedCookies['localhost:'+testPort+'/redirectToSameDomain'];
+                    var cookies2 = receivedCookies['localhost:'+testPort+'/redirectReturn'];
+                    if ((cookies1 && Object.keys(cookies1).length != 1) ||
+                        cookies1['requestCookie'] !== 'request1') {
+                        done(new Error('Invalid cookie(path:/rediectToSame)'));
+                        return;
+                    }
+                    if ((cookies2 && Object.keys(cookies2).length != 2) ||
+                        cookies1['requestCookie'] !== 'request1' ||
+                        cookies2['redirectToSameDomainCookie'] !== 'same1') {
+                        done(new Error('Invalid cookie(path:/rediectReurn)'));
+                        return;
+                    }
+                    done();
+                });
+                n1.receive({
+                    headers: { cookie: 'requestCookie=request1' }
+                });
+            });
+        });
+        it('should not send cookies to the different domain when redirected(msg.headers.cookie)', function(done) {
+            var flow = [{id:'n1',type:'http request',wires:[['n2']],method:'GET',ret:'obj',url:getTestURL('/redirectToDifferentDomain')},
+                {id:"n2", type:"helper"}];
+            receivedCookies = {};
+            helper.load(httpRequestNode, flow, function() {
+                var n1 = helper.getNode("n1");
+                var n2 = helper.getNode("n2");
+                n2.on("input", function(msg) {
+                    var cookies1 = receivedCookies['localhost:'+testPort+'/redirectToDifferentDomain'];
+                    var cookies2 = receivedCookies['127.0.0.1:'+testPort+'/redirectReturn'];
+                    if ((cookies1 && Object.keys(cookies1).length != 1) ||
+                        cookies1['requestCookie'] !== 'request1') {
+                        done(new Error('Invalid cookie(path:/rediectToDiffer)'));
+                        return;
+                    }
+                    if (cookies2 && Object.keys(cookies2).length != 0) {
+                        done(new Error('Invalid cookie(path:/rediectReurn)'));
+                        return;
+                    }
+                    done();
+                });
+                n1.receive({
+                    headers: { cookie: 'requestCookie=request1' }
+                });
+            });
+        });
+    });
 });

test/nodes/core/io/22-websocket_spec.js

@@ -18,7 +18,7 @@ var ws = require("ws");
 var when = require("when");
 var should = require("should");
 var helper = require("node-red-node-test-helper");
-var websocketNode = require("../../../../nodes/core/io/22-websocket.js");
+var websocketNode = require("nr-test-utils").require("@node-red/nodes/core/io/22-websocket.js");
 
 var sockets = [];
 
@@ -481,7 +481,7 @@ describe('websocket Node', function() {
             });
         });
 
-        it('should feedback', function(done) {
+        it('should NOT feedback more than once', function(done) {
             var flow = [
                 { id: "server", type: "websocket-listener", path: "/ws", wholemsg: "true" },
                 { id: "client", type: "websocket-client", path: getWsUrl("/ws"), wholemsg: "true" },
@@ -497,11 +497,13 @@ describe('websocket Node', function() {
                 });
                 var acc = 0;
                 helper.getNode("output").on("input", function(msg) {
-                    if (acc++ > 20) {
-                        helper.clearFlows();
-                        done();
-                    }
+                    acc = acc + 1;
                 });
+                setTimeout( function() {
+                    acc.should.equal(1);
+                    helper.clearFlows();
+                    done();
+                }, 250);
             });
         });
     });

test/nodes/core/io/23-watch_spec.js

@@ -18,7 +18,7 @@ var fs = require("fs-extra");
 var path = require("path");
 var should = require("should");
 var helper = require("node-red-node-test-helper");
-var watchNode = require("../../../../nodes/core/io/23-watch.js");
+var watchNode = require("nr-test-utils").require("@node-red/nodes/core/io/23-watch.js");
 
 
 describe('watch Node', function() {

test/nodes/core/io/31-tcpin_spec.js

@@ -19,7 +19,7 @@ var should = require("should");
 var stoppable = require('stoppable');
 var helper = require("node-red-node-test-helper");
 
-var tcpinNode = require("../../../../nodes/core/io/31-tcpin.js");
+var tcpinNode = require("nr-test-utils").require("@node-red/nodes/core/io/31-tcpin.js");
 
 
 describe('TCP in Node', function() {

test/nodes/core/io/31-tcprequest_spec.js

@@ -18,7 +18,8 @@ var net = require("net");
 var should = require("should");
 var stoppable = require('stoppable');
 var helper = require("node-red-node-test-helper");
-var tcpinNode = require("../../../../nodes/core/io/31-tcpin.js");
+var tcpinNode = require("nr-test-utils").require("@node-red/nodes/core/io/31-tcpin.js");
+var RED = require("nr-test-utils").require("node-red/lib/red.js");
 
 
 describe('TCP Request Node', function() {
@@ -28,12 +29,12 @@ describe('TCP Request Node', function() {
     function startServer(done) {
         port += 1;
         server = stoppable(net.createServer(function(c) {
-	    c.on('data', function(data) {
-		var rdata = "ACK:"+data.toString();
-		c.write(rdata);
-	    });
+            c.on('data', function(data) {
+                var rdata = "ACK:"+data.toString();
+                c.write(rdata);
+            });
             c.on('error', function(err) {
-		startServer(done);
+                startServer(done);
             });
         })).listen(port, "127.0.0.1", function(err) {
             done();
@@ -58,54 +59,243 @@ describe('TCP Request Node', function() {
             var n2 = helper.getNode("n2");
             n2.on("input", function(msg) {
                 try {
-                    msg.should.have.property('payload', Buffer(val1));
+                    if (typeof val1 === 'object') {
+                        msg.should.have.properties(Object.assign({}, val1, {payload: Buffer(val1.payload)}));
+                    } else {
+                        msg.should.have.property('payload', Buffer(val1));
+                    }
                     done();
                 } catch(err) {
                     done(err);
                 }
             });
-	    if((typeof val0) === 'object') {
-		n1.receive(val0);
-	    } else {
-		n1.receive({payload:val0});
-	    }
+            if((typeof val0) === 'object') {
+                n1.receive(val0);
+            } else {
+                n1.receive({payload:val0});
+            }
         });
     }
 
-    it('should send & recv data', function(done) {
-        var flow = [{id:"n1", type:"tcp request", server:"localhost", port:port, out:"time", splitc: "0", wires:[["n2"]] },
-                    {id:"n2", type:"helper"}];
-	testTCP(flow, "foo", "ACK:foo", done)
+    function testTCPMany(flow, values, result, done) {
+        helper.load(tcpinNode, flow, () => {
+            const n1 = helper.getNode("n1");
+            const n2 = helper.getNode("n2");
+            n2.on("input", msg => {
+                try {
+                    if (typeof result === 'object') {
+                        msg.should.have.properties(Object.assign({}, result, {payload: Buffer(result.payload)}));
+                    } else {
+                        msg.should.have.property('payload', Buffer(result));
+                    }
+                    done();
+                } catch(err) {
+                    done(err);
+                }
+            });
+            values.forEach(value => {
+                n1.receive(typeof value === 'object' ? value : {payload: value});
+            });
+        });
+    }
+
+    describe('single message', function () {
+        it('should send & recv data', function(done) {
+            var flow = [{id:"n1", type:"tcp request", server:"localhost", port:port, out:"time", splitc: "0", wires:[["n2"]] },
+            {id:"n2", type:"helper"}];
+            testTCP(flow, {
+                payload: 'foo',
+                topic: 'bar'
+            }, {
+                payload: 'ACK:foo',
+                topic: 'bar'
+            }, done);
+        });
+
+        it('should retain complete message', function(done) {
+            var flow = [{id:"n1", type:"tcp request", server:"localhost", port:port, out:"time", splitc: "0", wires:[["n2"]] },
+            {id:"n2", type:"helper"}];
+            testTCP(flow, {
+                payload: 'foo',
+                topic: 'bar'
+            }, {
+                payload: 'ACK:foo',
+                topic: 'bar'
+            }, done);
+        });
+
+        it('should send & recv data when specified character received', function(done) {
+            var flow = [{id:"n1", type:"tcp request", server:"localhost", port:port, out:"char", splitc: "0", wires:[["n2"]] },
+            {id:"n2", type:"helper"}];
+            testTCP(flow, {
+                payload: 'foo0bar0',
+                topic: 'bar'
+            }, {
+                payload: 'ACK:foo0',
+                topic: 'bar'
+            }, done);
+        });
+
+        it('should send & recv data after fixed number of chars received', function(done) {
+            var flow = [{id:"n1", type:"tcp request", server:"localhost", port:port, out:"count", splitc: "7", wires:[["n2"]] },
+            {id:"n2", type:"helper"}];
+            testTCP(flow, {
+                payload: 'foo bar',
+                topic: 'bar'
+            }, {
+                payload: 'ACK:foo',
+                topic: 'bar'
+            }, done);
+        });
+
+        it('should send & receive, then keep connection', function(done) {
+            var flow = [{id:"n1", type:"tcp request", server:"localhost", port:port, out:"sit", splitc: "5", wires:[["n2"]] },
+            {id:"n2", type:"helper"}];
+            testTCP(flow, {
+                payload: 'foo',
+                topic: 'bar'
+            }, {
+                payload: 'ACK:foo',
+                topic: 'bar'
+            }, done);
+        });
+
+        it('should send & recv data to/from server:port from msg', function(done) {
+            var flow = [{id:"n1", type:"tcp request", server:"", port:"", out:"time", splitc: "0", wires:[["n2"]] },
+            {id:"n2", type:"helper"}];
+            testTCP(flow, {
+                payload: "foo",
+                host: "localhost",
+                port: port
+            }, {
+                payload: "ACK:foo",
+                host: 'localhost',
+                port: port
+            }, done);
+        });
     });
 
-    it('should send & recv data when specified character received', function(done) {
-        var flow = [{id:"n1", type:"tcp request", server:"localhost", port:port, out:"char", splitc: "0", wires:[["n2"]] },
-                    {id:"n2", type:"helper"}];
-	testTCP(flow, "foo0bar0", "ACK:foo0", done);
-    });
+    describe('many messages', function () {
+        it('should send & recv data', function(done) {
+            var flow = [{id:"n1", type:"tcp request", server:"localhost", port:port, out:"time", splitc: "0", wires:[["n2"]] },
+                        {id:"n2", type:"helper"}];
+            testTCPMany(flow, [{
+                payload: 'f',
+                topic: 'bar'
+            }, {
+                payload: 'o',
+                topic: 'bar'
+            }, {
+                payload: 'o',
+                topic: 'bar'
+            }], {
+                payload: 'ACK:foo',
+                topic: 'bar'
+            }, done);
+        });
 
-    it('should send & recv data after fixed number of chars received', function(done) {
-        var flow = [{id:"n1", type:"tcp request", server:"localhost", port:port, out:"count", splitc: "7", wires:[["n2"]] },
-                    {id:"n2", type:"helper"}];
-	testTCP(flow, "foo bar", "ACK:foo", done);
-    });
+        it('should send & recv data when specified character received', function(done) {
+            var flow = [{id:"n1", type:"tcp request", server:"localhost", port:port, out:"char", splitc: "0", wires:[["n2"]] },
+                        {id:"n2", type:"helper"}];
+            testTCPMany(flow, [{
+                payload: "foo0",
+                topic: 'bar'
+            }, {
+                payload: "bar0",
+                topic: 'bar'
+            }], {
+                payload: "ACK:foo0",
+                topic: 'bar'
+            }, done);
+        });
 
-    it('should send & receive, then keep connection', function(done) {
-        var flow = [{id:"n1", type:"tcp request", server:"localhost", port:port, out:"sit", splitc: "5", wires:[["n2"]] },
-                    {id:"n2", type:"helper"}];
-	testTCP(flow, "foo", "ACK:foo", done);
-    });
+        it('should send & recv data after fixed number of chars received', function(done) {
+            var flow = [{id:"n1", type:"tcp request", server:"localhost", port:port, out:"count", splitc: "7", wires:[["n2"]] },
+                        {id:"n2", type:"helper"}];
+            testTCPMany(flow, [{
+                payload: "fo",
+                topic: 'bar'
+            }, {
+                payload: "ob",
+                topic: 'bar'
+            }, {
+                payload: "ar",
+                topic: 'bar'
+            }], {
+                payload: "ACK:foo",
+                topic: 'bar'
+            }, done);
+        });
 
-    it('should send & close', function(done) {
-        var flow = [{id:"n1", type:"tcp request", server:"localhost", port:port, out:"sit", splitc: "5", wires:[["n2"]] },
-                    {id:"n2", type:"helper"}];
-	testTCP(flow, "foo", "ACK:foo", done);
-    });
+        it('should send & receive, then keep connection', function(done) {
+            var flow = [{id:"n1", type:"tcp request", server:"localhost", port:port, out:"sit", splitc: "5", wires:[["n2"]] },
+                        {id:"n2", type:"helper"}];
+            testTCPMany(flow, [{
+                payload: "foo",
+                topic: 'bar'
+            }, {
+                payload: "bar",
+                topic: 'bar'
+            }, {
+                payload: "baz",
+                topic: 'bar'
+            }], {
+                payload: "ACK:foobarbaz",
+                topic: 'bar'
+            }, done);
+        });
 
-    it('should send & recv data to/from server:port from msg', function(done) {
-        var flow = [{id:"n1", type:"tcp request", server:"", port:"", out:"time", splitc: "0", wires:[["n2"]] },
-                    {id:"n2", type:"helper"}];
-	testTCP(flow, {payload:"foo", host:"localhost", port:port}, "ACK:foo", done)
-    });
+        it('should send & recv data to/from server:port from msg', function(done) {
+            var flow = [{id:"n1", type:"tcp request", server:"", port:"", out:"time", splitc: "0", wires:[["n2"]] },
+                        {id:"n2", type:"helper"}];
+            testTCPMany(flow, [{
+                    payload: "f",
+                    host: "localhost",
+                    port: port
+                },
+                {
+                    payload: "o",
+                    host: "localhost",
+                    port: port
+                },
+                {
+                    payload: "o",
+                    host: "localhost",
+                    port: port
+                }
+            ], {
+                payload: "ACK:foo",
+                host: 'localhost',
+                port: port
+            }, done);
+        });
 
+        it('should limit the queue size', function (done) {
+            RED.settings.tcpMsgQueueSize = 10;
+            var flow = [{id:"n1", type:"tcp request", server:"localhost", port:port, out:"sit", splitc: "5", wires:[["n2"]] },
+                        {id:"n2", type:"helper"}];
+            // create one more msg than is allowed
+            const msgs = new Array(RED.settings.tcpMsgQueueSize + 1).fill('x');
+            const expected = msgs.slice(0, -1);
+            testTCPMany(flow, msgs, "ACK:" + expected.join(''), done);
+        });
+
+        it('should only retain the latest message', function(done) {
+            var flow = [{id:"n1", type:"tcp request", server:"localhost", port:port, out:"time", splitc: "0", wires:[["n2"]] },
+                        {id:"n2", type:"helper"}];
+            testTCPMany(flow, [{
+                payload: 'f',
+                topic: 'bar'
+            }, {
+                payload: 'o',
+                topic: 'baz'
+            }, {
+                payload: 'o',
+                topic: 'quux'
+            }], {
+                payload: 'ACK:foo',
+                topic: 'quux'
+            }, done);
+        });
+    });
 });

test/nodes/core/io/32-udpin_spec.js

@@ -17,7 +17,7 @@
 var dgram = require("dgram");
 var should = require("should");
 var helper = require("node-red-node-test-helper");
-var udpNode = require("../../../../nodes/core/io/32-udp.js");
+var udpNode = require("nr-test-utils").require("@node-red/nodes/core/io/32-udp.js");
 
 
 describe('UDP in Node', function() {

test/nodes/core/io/32-udpout_spec.js

@@ -17,7 +17,7 @@
 var dgram = require("dgram");
 var should = require("should");
 var helper = require("node-red-node-test-helper");
-var udpNode = require("../../../../nodes/core/io/32-udp.js");
+var udpNode = require("nr-test-utils").require("@node-red/nodes/core/io/32-udp.js");
 
 
 describe('UDP out Node', function() {

test/nodes/core/logic/10-switch_spec.js

@@ -16,9 +16,10 @@
 
 var should = require("should");
 
-var switchNode = require("../../../../nodes/core/logic/10-switch.js");
+var switchNode = require("nr-test-utils").require("@node-red/nodes/core/logic/10-switch.js");
 var helper = require("node-red-node-test-helper");
-var RED = require("../../../../red/red.js");
+var RED = require("nr-test-utils").require("node-red/lib/red");
+var Context = require("nr-test-utils").require("@node-red/runtime/lib/nodes/context/");
 
 describe('switch Node', function() {
 
@@ -26,10 +27,31 @@ describe('switch Node', function() {
         helper.startServer(done);
     });
 
+    function initContext(done) {
+        Context.init({
+            contextStorage: {
+                memory0: {
+                    module: "memory"
+                },
+                memory1: {
+                    module: "memory"
+                }
+            }
+        });
+        Context.load().then(function () {
+            done();
+        });
+    }
+
     afterEach(function(done) {
-        helper.unload();
-        RED.settings.nodeMessageBufferMaxLength = 0;
-        helper.stopServer(done);
+        helper.unload().then(function () {
+            return Context.clean({allNodes: {}});
+        }).then(function () {
+            return Context.close();
+        }).then(function () {
+            RED.settings.nodeMessageBufferMaxLength = 0;
+            helper.stopServer(done);
+        });
     });
 
     it('should be loaded with some defaults', function(done) {
@@ -125,7 +147,7 @@ describe('switch Node', function() {
         helper.load(switchNode, flow, function() {
             var switchNode1 = helper.getNode("switchNode1");
             var helperNode1 = helper.getNode("helperNode1");
-            var sid = undefined;
+            var sid;
             var count = 0;
             if (modifier !== undefined) {
                 modifier(switchNode1);
@@ -293,6 +315,102 @@ describe('switch Node', function() {
         genericSwitchTest("istype", "undefined", true, true, undefined, done);
     });
 
+    it('should handle flow context', function (done) {
+        var flow = [{"id": "switchNode1", "type": "switch", "property": "foo", "propertyType": "flow",
+                     "rules": [{"t": "eq", "v": "bar", "vt": "flow"}],
+                     "checkall": "true", "outputs": "1", "wires": [["helperNode1"]], "z": "flow"},
+                     {"id": "helperNode1", "type": "helper", "wires": []}];
+        helper.load(switchNode, flow, function () {
+            var switchNode1 = helper.getNode("switchNode1");
+            var helperNode1 = helper.getNode("helperNode1");
+            helperNode1.on("input", function (msg) {
+                try {
+                    msg.payload.should.equal("value");
+                    done();
+                } catch (err) {
+                    done(err);
+                }
+            });
+            switchNode1.context().flow.set("foo", "flowValue");
+            switchNode1.context().flow.set("bar", "flowValue");
+            switchNode1.receive({payload: "value"});
+        });
+    });
+
+    it('should handle persistable flow context', function (done) {
+        var flow = [{"id": "switchNode1", "type": "switch", "property": "#:(memory1)::foo", "propertyType": "flow",
+                     "rules": [{"t": "eq", "v": "#:(memory1)::bar", "vt": "flow"}],
+                     "checkall": "true", "outputs": "1", "wires": [["helperNode1"]], "z": "flow"},
+                     {"id": "helperNode1", "type": "helper", "wires": []}];
+        helper.load(switchNode, flow, function () {
+            initContext(function () {
+                var switchNode1 = helper.getNode("switchNode1");
+                var helperNode1 = helper.getNode("helperNode1");
+                helperNode1.on("input", function (msg) {
+                    try {
+                        msg.payload.should.equal("value");
+                        done();
+                    } catch (err) {
+                        done(err);
+                    }
+                });
+                switchNode1.context().flow.set("foo", "flowValue", "memory1", function (err) {
+                    switchNode1.context().flow.set("bar", "flowValue", "memory1", function (err) {
+                        switchNode1.receive({payload: "value"});
+                    });
+                });
+            });
+        });
+    });
+
+    it('should handle global context', function (done) {
+        var flow = [{"id": "switchNode1", "type": "switch", "property": "foo", "propertyType": "global",
+                     "rules": [{"t": "eq", "v": "bar", "vt": "global"}],
+                     "checkall": "true", "outputs": "1", "wires": [["helperNode1"]]},
+                     {"id": "helperNode1", "type": "helper", "wires": []}];
+        helper.load(switchNode, flow, function () {
+            var switchNode1 = helper.getNode("switchNode1");
+            var helperNode1 = helper.getNode("helperNode1");
+            helperNode1.on("input", function (msg) {
+                try {
+                    msg.payload.should.equal("value");
+                    done();
+                } catch (err) {
+                    done(err);
+                }
+            });
+            switchNode1.context().global.set("foo", "globalValue");
+            switchNode1.context().global.set("bar", "globalValue");
+            switchNode1.receive({payload: "value"});
+        });
+    });
+
+    it('should handle persistable global context', function (done) {
+        var flow = [{"id": "switchNode1", "type": "switch", "property": "#:(memory1)::foo", "propertyType": "global",
+                     "rules": [{"t": "eq", "v": "#:(memory1)::bar", "vt": "global"}],
+                     "checkall": "true", "outputs": "1", "wires": [["helperNode1"]]},
+                     {"id": "helperNode1", "type": "helper", "wires": []}];
+        helper.load(switchNode, flow, function () {
+            initContext(function () {
+                var switchNode1 = helper.getNode("switchNode1");
+                var helperNode1 = helper.getNode("helperNode1");
+                helperNode1.on("input", function (msg) {
+                    try {
+                        msg.payload.should.equal("foo");
+                        done();
+                    } catch (err) {
+                        done(err);
+                    }
+                });
+                switchNode1.context().global.set("foo", "globalValue", "memory1", function (err) {
+                    switchNode1.context().global.set("bar", "globalValue", "memory1", function (err) {
+                        switchNode1.receive({payload: "foo"});
+                    });
+                });
+            });
+        });
+    });
+
     it('should match regex with ignore-case flag set true', function(done) {
         var flow = [{id:"switchNode1",type:"switch",name:"switchNode",property:"payload",rules:[{"t":"regex","v":"onetwothree","case":true}],checkall:true,outputs:1,wires:[["helperNode1"]]},
                     {id:"helperNode1", type:"helper", wires:[]}];
@@ -333,6 +451,75 @@ describe('switch Node', function() {
         singularSwitchTest(false, true, false, true, done);
     });
 
+    it('should check if payload is empty (string)', function(done) {
+        singularSwitchTest("empty", true, true, "", done);
+    });
+    it('should check if payload is empty (array)', function(done) {
+        singularSwitchTest("empty", true, true, [], done);
+    });
+    it('should check if payload is empty (buffer)', function(done) {
+        singularSwitchTest("empty", true, true, Buffer.alloc(0), done);
+    });
+    it('should check if payload is empty (object)', function(done) {
+        singularSwitchTest("empty", true, true, {}, done);
+    });
+    it('should check if payload is empty (non-empty string)', function(done) {
+        singularSwitchTest("empty", true, false, "1", done);
+    });
+    it('should check if payload is empty (non-empty array)', function(done) {
+        singularSwitchTest("empty", true, false, [1], done);
+    });
+    it('should check if payload is empty (non-empty buffer)', function(done) {
+        singularSwitchTest("empty", true, false, Buffer.alloc(1), done);
+    });
+    it('should check if payload is empty (non-empty object)', function(done) {
+        singularSwitchTest("empty", true, false, {a:1}, done);
+    });
+    it('should check if payload is empty (null)', function(done) {
+        singularSwitchTest("empty", true, false, null, done);
+    });
+    it('should check if payload is empty (undefined)', function(done) {
+        singularSwitchTest("empty", true, false, undefined, done);
+    });
+    it('should check if payload is empty (0)', function(done) {
+        singularSwitchTest("empty", true, false, 0, done);
+    });
+
+    it('should check if payload is not empty (string)', function(done) {
+        singularSwitchTest("nempty", true, !true, "", done);
+    });
+    it('should check if payload is not empty (array)', function(done) {
+        singularSwitchTest("nempty", true, !true, [], done);
+    });
+    it('should check if payload is not empty (buffer)', function(done) {
+        singularSwitchTest("nempty", true, !true, Buffer.alloc(0), done);
+    });
+    it('should check if payload is not empty (object)', function(done) {
+        singularSwitchTest("nempty", true, !true, {}, done);
+    });
+    it('should check if payload is not empty (non-empty string)', function(done) {
+        singularSwitchTest("nempty", true, !false, "1", done);
+    });
+    it('should check if payload is not empty (non-empty array)', function(done) {
+        singularSwitchTest("nempty", true, !false, [1], done);
+    });
+    it('should check if payload is not empty (non-empty buffer)', function(done) {
+        singularSwitchTest("nempty", true, !false, Buffer.alloc(1), done);
+    });
+    it('should check if payload is not empty (non-empty object)', function(done) {
+        singularSwitchTest("nempty", true, !false, {a:1}, done);
+    });
+    it('should check if payload is not empty (null)', function(done) {
+        singularSwitchTest("nempty", true, false, null, done);
+    });
+    it('should check if payload is not empty (undefined)', function(done) {
+        singularSwitchTest("nempty", true, false, undefined, done);
+    });
+    it('should check if payload is not empty (0)', function(done) {
+        singularSwitchTest("nempty", true, false, 0, done);
+    });
+
+
     it('should check input against a previous value', function(done) {
         var flow = [{id:"switchNode1",type:"switch",name:"switchNode",property:"payload",rules:[{ "t": "gt", "v": "", "vt": "prev" }],checkall:true,outputs:1,wires:[["helperNode1"]]},
                     {id:"helperNode1", type:"helper", wires:[]}];
@@ -584,6 +771,53 @@ describe('switch Node', function() {
         customFlowSwitchTest(flow, true, -5, done);
     });
 
+    it('should handle flow and global contexts with JSONata expression', function(done) {
+        var flow = [{id:"switchNode1",type:"switch",name:"switchNode",property:"$abs($flowContext(\"payload\"))",propertyType:"jsonata",rules:[{"t":"btwn","v":"$flowContext(\"vt\")","vt":"jsonata","v2":"$globalContext(\"v2t\")","v2t":"jsonata"}],checkall:true,outputs:1,wires:[["helperNode1"]],z:"flow"},
+                    {id:"helperNode1", type:"helper", wires:[],z:"flow"},
+                    {id:"flow",type:"tab"}];
+        helper.load(switchNode, flow, function() {
+            var switchNode1 = helper.getNode("switchNode1");
+            var helperNode1 = helper.getNode("helperNode1");
+            switchNode1.context().flow.set("payload",-5);
+            switchNode1.context().flow.set("vt",4);
+            switchNode1.context().global.set("v2t",6);
+            helperNode1.on("input", function(msg) {
+                try {
+                    should.equal(msg.payload,"pass");
+                    done();
+                } catch(err) {
+                    done(err);
+                }
+            });
+            switchNode1.receive({payload:"pass"});
+        });
+    });
+
+    it('should handle persistable flow and global contexts with JSONata expression', function(done) {
+        var flow = [{id:"switchNode1",type:"switch",name:"switchNode",property:"$abs($flowContext(\"payload\",\"memory1\"))",propertyType:"jsonata",rules:[{"t":"btwn","v":"$flowContext(\"vt\",\"memory1\")","vt":"jsonata","v2":"$globalContext(\"v2t\",\"memory1\")","v2t":"jsonata"}],checkall:true,outputs:1,wires:[["helperNode1"]],z:"flow"},
+                    {id:"helperNode1", type:"helper", wires:[],z:"flow"},
+                    {id:"flow",type:"tab"}];
+        helper.load(switchNode, flow, function() {
+            initContext(function () {
+                var switchNode1 = helper.getNode("switchNode1");
+                var helperNode1 = helper.getNode("helperNode1");
+                switchNode1.context().flow.set(["payload","vt"],[-7,6],"memory1",function(){
+                    switchNode1.context().global.set("v2t",8,"memory1",function(){
+                        helperNode1.on("input", function(msg) {
+                            try {
+                                should.equal(msg.payload,"pass");
+                                done();
+                            } catch(err) {
+                                done(err);
+                            }
+                        });
+                        switchNode1.receive({payload:"pass"});
+                    });
+                });
+            });
+        });
+    });
+
     it('should take head of message sequence (no repair)', function(done) {
         var flow = [{id:"switchNode1",type:"switch",name:"switchNode",property:"payload",rules:[{"t":"head","v":3}],checkall:false,repair:false,outputs:1,wires:[["helperNode1"]]},
                     {id:"helperNode1", type:"helper", wires:[]}];
@@ -666,9 +900,11 @@ describe('switch Node', function() {
             var vals = new Array(port_count);
             var recv_count = 0;
             for (var id in outs) {
-                var out = outs[id];
-                vals[out.port] = out.vals;
-                recv_count += out.vals.length;
+                if (outs.hasOwnProperty(id)) {
+                    var out = outs[id];
+                    vals[out.port] = out.vals;
+                    recv_count += out.vals.length;
+                }
             }
             var count = 0;
             function check_msg(msg, ix, vf) {
@@ -676,7 +912,7 @@ describe('switch Node', function() {
                     msg.should.have.property("payload");
                     var payload = msg.payload;
                     msg.should.have.property("parts");
-                    vf(payload).should.be.ok;
+                    vf(payload).should.be.ok();
                     var parts = msg.parts;
                     var evals = vals[ix];
                     parts.should.have.property("id");
@@ -703,8 +939,8 @@ describe('switch Node', function() {
                     }
                     var index = parts.index;
                     var eindex = counts[ix];
-                    var eval = evals[eindex];
-                    payload.should.equal(eval);
+                    var value = evals[eindex];
+                    payload.should.equal(value);
                     counts[ix]++;
                     count++;
                     if (count === recv_count) {
@@ -716,18 +952,22 @@ describe('switch Node', function() {
                 }
             }
             for (var id in outs) {
-                (function() {
-                    var node = helper.getNode(id);
-                    var port = outs[id].port;
-                    var vf = outs[id].vf;
-                    node.on("input", function(msg) {
-                        check_msg(msg, port, vf);
-                    });
-                })();
+                if (outs.hasOwnProperty(id)) {
+                    (function() {
+                        var node = helper.getNode(id);
+                        var port = outs[id].port;
+                        var vf = outs[id].vf;
+                        node.on("input", function(msg) {
+                            check_msg(msg, port, vf);
+                        });
+                    })();
+                }
             }
             for(var i in seq_in) {
-                n1.receive({payload:seq_in[i], xindex:i,
-                            parts:{index:i, count:seq_in.length, id:222}});
+                if (seq_in.hasOwnProperty(i)) {
+                    n1.receive({payload:seq_in[i], xindex:i,
+                                parts:{index:i, count:seq_in.length, id:222}});
+                }
             }
         });
     }
@@ -786,9 +1026,9 @@ describe('switch Node', function() {
         var data = [ 1, -2, 2, 0, -1 ];
         var outs = {
             "n2" : { port:0, vals:[1, 2, 0],
-                     vf:function(x) { return(x > 0); } },
+                     vf:function(x) { return(x >= 0); } },
             "n3" : { port:1, vals:[-2, 0, -1],
-                     vf:function(x) { return(x < 0); } },
+                     vf:function(x) { return(x <= 0); } },
             "n4" : { port:2, vals:[],
                      vf:function(x) { return(false); } },
         };

test/nodes/core/logic/15-change_spec.js

@@ -17,7 +17,8 @@
 var should = require("should");
 var sinon = require("sinon");
 
-var changeNode = require("../../../../nodes/core/logic/15-change.js");
+var changeNode = require("nr-test-utils").require("@node-red/nodes/core/logic/15-change.js");
+var Context = require("nr-test-utils").require("@node-red/runtime/lib/nodes/context");
 var helper = require("node-red-node-test-helper");
 
 describe('change Node', function() {
@@ -26,9 +27,30 @@ describe('change Node', function() {
         helper.startServer(done);
     });
 
+    function initContext(done) {
+        Context.init({
+            contextStorage: {
+                memory0: {
+                    module: "memory"
+                },
+                memory1: {
+                    module: "memory"
+                }
+            }
+        });
+        Context.load().then(function () {
+            done();
+        });
+    }
+
     afterEach(function(done) {
-        helper.unload();
-        helper.stopServer(done);
+        helper.unload().then(function () {
+            return Context.clean({allNodes: {}});
+        }).then(function () {
+            return Context.close();
+        }).then(function () {
+            helper.stopServer(done);
+        });
     });
 
     it('should load node with defaults', function(done) {
@@ -56,6 +78,24 @@ describe('change Node', function() {
             done();
         });
     });
+    it('should no-op if there are no rules', function(done) {
+        var flow = [{"id":"changeNode1","type":"change","rules":[],"action":"","property":"","from":"","to":"","reg":false,"name":"changeNode","wires":[["helperNode1"]]},
+                    {id:"helperNode1", type:"helper", wires:[]}];
+        helper.load(changeNode, flow, function() {
+            var changeNode1 = helper.getNode("changeNode1");
+            var helperNode1 = helper.getNode("helperNode1");
+            helperNode1.on("input", function(msg) {
+                try {
+                    msg.should.eql(sentMsg);
+                    done();
+                } catch(err) {
+                    done(err);
+                }
+            });
+            var sentMsg = {payload:"leaveMeAlong"};
+            changeNode1.receive(sentMsg);
+        });
+    });
 
     describe('#set' , function() {
 
@@ -96,6 +136,30 @@ describe('change Node', function() {
             });
         });
 
+        it('sets the value of persistable global context property', function(done) {
+            var flow = [{"id":"changeNode1","type":"change",rules:[{ "t":"set","p":"#:(memory1)::globalValue","pt":"global","to":"changed","tot":"str"}],"name":"changeNode","wires":[["helperNode1"]]},
+                        {id:"helperNode1", type:"helper", wires:[]}];
+            helper.load(changeNode, flow, function() {
+                initContext(function () {
+                    var changeNode1 = helper.getNode("changeNode1");
+                    var helperNode1 = helper.getNode("helperNode1");
+                    helperNode1.on("input", function(msg) {
+                        try {
+                            changeNode1.context().global.get("globalValue", "memory1", function (err, val) {
+                                val.should.equal("changed");
+                                done();
+                            });
+                        } catch(err) {
+                            done(err);
+                        }
+                    });
+                    changeNode1.context().global.set("globalValue","changeMe","memory1", function (err) {
+                        changeNode1.receive({payload:""});
+                    });
+                });
+            });
+        });
+
         it('sets the value and type of the message property', function(done) {
             var flow = [{"id":"changeNode1","type":"change",rules:[{ "t": "set", "p": "payload", "pt": "msg", "to": "12345", "tot": "num" }],"reg":false,"name":"changeNode","wires":[["helperNode1"]]},
                         {id:"helperNode1", type:"helper", wires:[]}];
@@ -300,6 +364,28 @@ describe('change Node', function() {
             });
         });
 
+        it('changes the value to persistable flow context property', function(done) {
+            var flow = [{"id":"changeNode1","type":"change",rules:[{"t":"set","p":"payload","to":"#:(memory1)::flowValue","tot":"flow"}],"name":"changeNode","wires":[["helperNode1"]],"z":"flow"},
+                        {id:"helperNode1", type:"helper", wires:[]}];
+            helper.load(changeNode, flow, function() {
+                initContext(function () {
+                    var changeNode1 = helper.getNode("changeNode1");
+                    var helperNode1 = helper.getNode("helperNode1");
+                    helperNode1.on("input", function(msg) {
+                        try {
+                            msg.payload.should.eql("Hello World!");
+                            done();
+                        } catch(err) {
+                            done(err);
+                        }
+                    });
+                    changeNode1.context().flow.set("flowValue","Hello World!","memory1",function(err) {
+                        changeNode1.receive({payload:""});
+                    });
+                });
+            });
+        });
+
         it('changes the value to global context property', function(done) {
             var flow = [{"id":"changeNode1","type":"change",rules:[{"t":"set","p":"payload","to":"globalValue","tot":"global"}],"name":"changeNode","wires":[["helperNode1"]]},
                         {id:"helperNode1", type:"helper", wires:[]}];
@@ -319,6 +405,28 @@ describe('change Node', function() {
             });
         });
 
+        it('changes the value to persistable global context property', function(done) {
+            var flow = [{"id":"changeNode1","type":"change",rules:[{"t":"set","p":"payload","to":"#:(memory1)::globalValue","tot":"global"}],"name":"changeNode","wires":[["helperNode1"]]},
+                        {id:"helperNode1", type:"helper", wires:[]}];
+            helper.load(changeNode, flow, function() {
+                initContext(function () {
+                    var changeNode1 = helper.getNode("changeNode1");
+                    var helperNode1 = helper.getNode("helperNode1");
+                    helperNode1.on("input", function(msg) {
+                        try {
+                            msg.payload.should.eql("Hello World!");
+                            done();
+                        } catch(err) {
+                            done(err);
+                        }
+                    });
+                    changeNode1.context().global.set("globalValue","Hello World!","memory1", function (err) {
+                        changeNode1.receive({payload:""});
+                    });
+                });
+            });
+        });
+
         it('changes the value to a number', function(done) {
             var flow = [{"id":"changeNode1","type":"change",rules:[{"t":"set","p":"payload","to":"123","tot":"num"}],"name":"changeNode","wires":[["helperNode1"]]},
                         {id:"helperNode1", type:"helper", wires:[]}];
@@ -461,19 +569,106 @@ describe('change Node', function() {
             helper.load(changeNode, flow, function() {
                 var changeNode1 = helper.getNode("changeNode1");
                 var helperNode1 = helper.getNode("helperNode1");
-                sinon.spy(changeNode1,"error");
                 helperNode1.on("input", function(msg) {
                     done("Invalid jsonata expression passed message through");
                 });
+                changeNode1.on("call:error", function(err) {
+                    // Expect error to be called
+                    done();
+                });
                 changeNode1.receive({payload:"Hello World!"});
-                setTimeout(function() {
+            });
+        });
+
+        it('changes the value using flow context with jsonata', function(done) {
+            var flow = [{"id":"changeNode1","type":"change",rules:[{"t":"set","p":"payload","to":"$flowContext(\"foo\")","tot":"jsonata"}],"name":"changeNode","wires":[["helperNode1"]],"z":"flow"},
+                        {id:"helperNode1", type:"helper", wires:[],"z":"flow"},{"id":"flow","type":"tab"}];
+            helper.load(changeNode, flow, function() {
+                var changeNode1 = helper.getNode("changeNode1");
+                var helperNode1 = helper.getNode("helperNode1");
+                changeNode1.context().flow.set("foo","bar");
+                helperNode1.on("input", function(msg) {
                     try {
-                        changeNode1.error.called.should.be.true();
+                        msg.payload.should.eql("bar");
                         done();
                     } catch(err) {
                         done(err);
                     }
-                },50);
+                });
+                changeNode1.receive({payload:"Hello World!"});
+            });
+        });
+
+        it('changes the value using global context with jsonata', function(done) {
+            var flow = [{"id":"changeNode1","type":"change",rules:[{"t":"set","p":"payload","to":"$globalContext(\"foo\")","tot":"jsonata"}],"name":"changeNode","wires":[["helperNode1"]],"z":"flow"},
+                        {id:"helperNode1", type:"helper", wires:[],"z":"flow"},{"id":"flow","type":"tab"}];
+            helper.load(changeNode, flow, function() {
+                var changeNode1 = helper.getNode("changeNode1");
+                var helperNode1 = helper.getNode("helperNode1");
+                changeNode1.context().global.set("foo","bar");
+                helperNode1.on("input", function(msg) {
+                    try {
+                        msg.payload.should.eql("bar");
+                        done();
+                    } catch(err) {
+                        done(err);
+                    }
+                });
+                changeNode1.receive({payload:"Hello World!"});
+            });
+        });
+
+        it('changes the value using persistable flow context with jsonata', function(done) {
+            var flow = [{"id":"changeNode1","type":"change",rules:[{"t":"set","p":"payload","to":"$flowContext(\"foo\",\"memory1\")","tot":"jsonata"}],"name":"changeNode","wires":[["helperNode1"]],"z":"flow"},
+                        {id:"helperNode1", type:"helper", wires:[],"z":"flow"},{"id":"flow","type":"tab"}];
+            helper.load(changeNode, flow, function() {
+                initContext(function () {
+                    var changeNode1 = helper.getNode("changeNode1");
+                    var helperNode1 = helper.getNode("helperNode1");
+                    helperNode1.on("input", function(msg) {
+                        try {
+                            msg.payload.should.eql("bar");
+                            done();
+                        } catch(err) {
+                            done(err);
+                        }
+                    });
+                    changeNode1.context().flow.set("foo","bar","memory1",function(err){
+                        if(err){
+                            done(err);
+                        }else{
+                            changeNode1.context().flow.set("foo","error!");
+                            changeNode1.receive({payload:"Hello World!"});
+                        }
+                    });
+                });
+            });
+        });
+
+        it('changes the value using persistable global context with jsonata', function(done) {
+            var flow = [{"id":"changeNode1","type":"change",rules:[{"t":"set","p":"payload","to":"$globalContext(\"foo\",\"memory1\")","tot":"jsonata"}],"name":"changeNode","wires":[["helperNode1"]],"z":"flow"},
+                        {id:"helperNode1", type:"helper", wires:[],"z":"flow"},{"id":"flow","type":"tab"}];
+            helper.load(changeNode, flow, function() {
+                initContext(function () {
+                    var changeNode1 = helper.getNode("changeNode1");
+                    var helperNode1 = helper.getNode("helperNode1");
+                    helperNode1.on("input", function(msg) {
+                        try {
+                            msg.payload.should.eql("bar");
+                            done();
+                        } catch(err) {
+                            done(err);
+                        }
+                    });
+                    changeNode1.context().global.set("foo","bar","memory1",function(err){
+                        if(err){
+                            done(err);
+                        }else{
+                            changeNode1.context().global.set("foo","error!");
+                            changeNode1.receive({payload:"Hello World!"});
+                        }
+                    });
+                });
             });
         });
 
@@ -716,6 +911,28 @@ describe('change Node', function() {
             });
         });
 
+        it('changes the value using persistable flow context property', function(done) {
+            var flow = [{"id":"changeNode1","type":"change",rules:[{"t":"change","p":"payload","from":"#:(memory1)::topic","to":"123","fromt":"flow","tot":"str"}],"name":"changeNode","wires":[["helperNode1"]],"z":"flow"},
+                        {id:"helperNode1", type:"helper", wires:[]}];
+            helper.load(changeNode, flow, function() {
+                initContext(function () {
+                    var changeNode1 = helper.getNode("changeNode1");
+                    var helperNode1 = helper.getNode("helperNode1");
+                    helperNode1.on("input", function(msg) {
+                        try {
+                            msg.payload.should.equal("abc123abc");
+                            done();
+                        } catch(err) {
+                            done(err);
+                        }
+                    });
+                    changeNode1.context().flow.set("topic","ABC","memory1", function (err) {
+                        changeNode1.receive({payload:"abcABCabc"});
+                    });
+                });
+            });
+        });
+
         it('changes the value using global context property', function(done) {
             var flow = [{"id":"changeNode1","type":"change",rules:[{"t":"change","p":"payload","from":"topic","to":"123","fromt":"global","tot":"str"}],"name":"changeNode","wires":[["helperNode1"]]},
                         {id:"helperNode1", type:"helper", wires:[]}];
@@ -735,6 +952,28 @@ describe('change Node', function() {
             });
         });
 
+        it('changes the value using persistable global context property', function(done) {
+            var flow = [{"id":"changeNode1","type":"change",rules:[{"t":"change","p":"payload","from":"#:(memory1)::topic","to":"123","fromt":"global","tot":"str"}],"name":"changeNode","wires":[["helperNode1"]]},
+                        {id:"helperNode1", type:"helper", wires:[]}];
+            helper.load(changeNode, flow, function() {
+                initContext(function () {
+                    var changeNode1 = helper.getNode("changeNode1");
+                    var helperNode1 = helper.getNode("helperNode1");
+                    helperNode1.on("input", function(msg) {
+                        try {
+                            msg.payload.should.equal("abc123abc");
+                            done();
+                        } catch(err) {
+                            done(err);
+                        }
+                    });
+                    changeNode1.context().global.set("topic","ABC","memory1",function (err) {
+                        changeNode1.receive({payload:"abcABCabc"});
+                    });
+                });
+            });
+        });
+
         it('changes the number using global context property', function(done) {
             var flow = [{"id":"changeNode1","type":"change",rules:[{"t":"change","p":"payload","from":"topic","to":"ABC","fromt":"global","tot":"str"}],"name":"changeNode","wires":[["helperNode1"]]},
                         {id:"helperNode1", type:"helper", wires:[]}];
@@ -754,6 +993,28 @@ describe('change Node', function() {
             });
         });
 
+        it('changes the number using persistable global context property', function(done) {
+            var flow = [{"id":"changeNode1","type":"change",rules:[{"t":"change","p":"payload","from":"#:(memory1)::topic","to":"ABC","fromt":"global","tot":"str"}],"name":"changeNode","wires":[["helperNode1"]]},
+                        {id:"helperNode1", type:"helper", wires:[]}];
+            helper.load(changeNode, flow, function() {
+                initContext(function () {
+                    var changeNode1 = helper.getNode("changeNode1");
+                    var helperNode1 = helper.getNode("helperNode1");
+                    helperNode1.on("input", function(msg) {
+                        try {
+                            msg.payload.should.equal("ABC");
+                            done();
+                        } catch(err) {
+                            done(err);
+                        }
+                    });
+                    changeNode1.context().global.set("topic",123,"memory1",function (err) {
+                        changeNode1.receive({payload:123});
+                    });
+                });
+            });
+        });
+
         it('changes the value using number - string payload', function(done) {
             var flow = [{"id":"changeNode1","type":"change",rules:[{"t":"change","p":"payload","from":"123","to":"456","fromt":"num","tot":"str"}],"name":"changeNode","wires":[["helperNode1"]]},
                         {id:"helperNode1", type:"helper", wires:[]}];
@@ -845,6 +1106,30 @@ describe('change Node', function() {
             });
         });
 
+        it('changes the value of the persistable global context', function(done) {
+            var flow = [{"id":"changeNode1","type":"change",rules:[{ "t": "change", "p": "#:(memory1)::payload", "pt": "global", "from": "Hello", "fromt": "str", "to": "Goodbye", "tot": "str" }],"reg":false,"name":"changeNode","wires":[["helperNode1"]],"z":"flow"},
+                        {id:"helperNode1", type:"helper", wires:[],"z":"flow"}];
+            helper.load(changeNode, flow, function() {
+                initContext(function () {
+                    var changeNode1 = helper.getNode("changeNode1");
+                    var helperNode1 = helper.getNode("helperNode1");
+                    helperNode1.on("input", function(msg) {
+                        try {
+                            helperNode1.context().global.get("payload","memory1", function (err, val) {
+                                val.should.equal("Goodbye World!");
+                                done();
+                            });
+                        } catch(err) {
+                            done(err);
+                        }
+                    });
+                    changeNode1.context().global.set("payload","Hello World!","memory1",function (err) {
+                        changeNode1.receive({payload:""});
+                    });
+                });
+            });
+        });
+
         it('changes the value and doesnt change type of the flow context for partial match', function(done) {
             var flow = [{"id":"changeNode1","type":"change",rules:[{ "t": "change", "p": "payload", "pt": "flow", "from": "123", "fromt": "str", "to": "456", "tot": "num" }],"reg":false,"name":"changeNode","wires":[["helperNode1"]],"z":"flow"},
                         {id:"helperNode1", type:"helper", wires:[],"z":"flow"}];
@@ -865,6 +1150,31 @@ describe('change Node', function() {
             });
         });
 
+        it('changes the value and doesnt change type of the persistable flow context for partial match', function(done) {
+            var flow = [{"id":"changeNode1","type":"change",rules:[{ "t": "change", "p": "#:(memory1)::payload", "pt": "flow", "from": "123", "fromt": "str", "to": "456", "tot": "num" }],"reg":false,"name":"changeNode","wires":[["helperNode1"]],"z":"flow"},
+                        {id:"helperNode1", type:"helper", wires:[],"z":"flow"}];
+            helper.load(changeNode, flow, function() {
+                initContext(function () {
+                    var changeNode1 = helper.getNode("changeNode1");
+                    var helperNode1 = helper.getNode("helperNode1");
+                    helperNode1.on("input", function(msg) {
+                        try {
+                            helperNode1.context().flow.get("payload","memory1",function (err,  val) {
+                                val.should.equal("Change456Me");
+                                val.should.be.a.String();
+                                done();
+                            });
+                        } catch(err) {
+                            done(err);
+                        }
+                    });
+                    changeNode1.context().flow.set("payload","Change123Me","memory1",function (err) {
+                        changeNode1.receive({payload:""});
+                    });
+                });
+            });
+        });
+
         it('changes the value and type of the flow context if a complete match', function(done) {
             var flow = [{"id":"changeNode1","type":"change",rules:[{ "t": "change", "p": "payload", "pt": "flow", "from": "123", "fromt": "str", "to": "456", "tot": "num" }],"reg":false,"name":"changeNode","wires":[["helperNode1"]],"z":"flow"},
                         {id:"helperNode1", type:"helper", wires:[],"z":"flow"}];
@@ -885,6 +1195,31 @@ describe('change Node', function() {
             });
         });
 
+        it('changes the value and type of the persistable flow context if a complete match', function(done) {
+            var flow = [{"id":"changeNode1","type":"change",rules:[{ "t": "change", "p": "#:(memory1)::payload", "pt": "flow", "from": "123", "fromt": "str", "to": "456", "tot": "num" }],"reg":false,"name":"changeNode","wires":[["helperNode1"]],"z":"flow"},
+                        {id:"helperNode1", type:"helper", wires:[],"z":"flow"}];
+            helper.load(changeNode, flow, function() {
+                initContext(function () {
+                    var changeNode1 = helper.getNode("changeNode1");
+                    var helperNode1 = helper.getNode("helperNode1");
+                    helperNode1.on("input", function(msg) {
+                        try {
+                            helperNode1.context().flow.get("payload","memory1",function (err, val) {
+                                val.should.be.a.Number();
+                                val.should.equal(456);
+                                done();
+                            });
+                        } catch(err) {
+                            done(err);
+                        }
+                    });
+                    changeNode1.context().flow.set("payload","123","memory1",function (err) {
+                        changeNode1.receive({payload:""});
+                    });
+                });
+            });
+        });
+
         it('changes the value using number - number flow context', function(done) {
             var flow = [{"id":"changeNode1","type":"change",rules:[{ "t": "change", "p": "payload", "pt": "flow", "from": "123", "fromt": "num", "to": "abc", "tot": "str" }],"reg":false,"name":"changeNode","wires":[["helperNode1"]],"z":"flow"},
                         {id:"helperNode1", type:"helper", wires:[],"z":"flow"}];
@@ -904,6 +1239,30 @@ describe('change Node', function() {
             });
         });
 
+        it('changes the value using number - number persistable flow context', function(done) {
+            var flow = [{"id":"changeNode1","type":"change",rules:[{ "t": "change", "p": "#:(memory1)::payload", "pt": "flow", "from": "123", "fromt": "num", "to": "abc", "tot": "str" }],"reg":false,"name":"changeNode","wires":[["helperNode1"]],"z":"flow"},
+                        {id:"helperNode1", type:"helper", wires:[],"z":"flow"}];
+            helper.load(changeNode, flow, function() {
+                initContext(function () {
+                    var changeNode1 = helper.getNode("changeNode1");
+                    var helperNode1 = helper.getNode("helperNode1");
+                    helperNode1.on("input", function(msg) {
+                        try {
+                            helperNode1.context().flow.get("payload","memory1",function (err, val) {
+                                val.should.equal("abc");
+                                done();
+                            });
+                        } catch(err) {
+                            done(err);
+                        }
+                    });
+                    changeNode1.context().flow.set("payload",123,"memory1",function (err) {
+                        changeNode1.receive({payload:""});
+                    });
+                });
+            });
+        });
+
         it('changes the value using boolean - boolean flow context', function(done) {
             var flow = [{"id":"changeNode1","type":"change",rules:[{ "t": "change", "p": "payload", "pt": "flow", "from": "true", "fromt": "bool", "to": "abc", "tot": "str" }],"reg":false,"name":"changeNode","wires":[["helperNode1"]],"z":"flow"},
                         {id:"helperNode1", type:"helper", wires:[],"z":"flow"}];
@@ -923,6 +1282,49 @@ describe('change Node', function() {
             });
         });
 
+        it('changes the value using boolean - boolean persistable flow context', function(done) {
+            var flow = [{"id":"changeNode1","type":"change",rules:[{ "t": "change", "p": "#:(memory1)::payload", "pt": "flow", "from": "true", "fromt": "bool", "to": "abc", "tot": "str" }],"reg":false,"name":"changeNode","wires":[["helperNode1"]],"z":"flow"},
+                        {id:"helperNode1", type:"helper", wires:[],"z":"flow"}];
+            helper.load(changeNode, flow, function() {
+                initContext(function () {
+                    var changeNode1 = helper.getNode("changeNode1");
+                    var helperNode1 = helper.getNode("helperNode1");
+                    helperNode1.on("input", function(msg) {
+                        try {
+                            helperNode1.context().flow.get("payload","memory1",function (err, val) {
+                                val.should.equal("abc");
+                                done();
+                            });
+                        } catch(err) {
+                            done(err);
+                        }
+                    });
+                    changeNode1.context().flow.set("payload",true,"memory1",function (err) {
+                        changeNode1.receive({payload:""});
+                    });
+                });
+            });
+        });
+
+        it('reports invalid fromValue', function(done) {
+            var flow = [{"id":"changeNode1","type":"change",rules:[{"t":"change","p":"payload","from":"null","fromt":"msg","to":"abc","tot":"str"}],"name":"changeNode","wires":[["helperNode1"]]},
+                        {id:"helperNode1", type:"helper", wires:[]}];
+            helper.load(changeNode, flow, function() {
+                var changeNode1 = helper.getNode("changeNode1");
+                setTimeout(function() {
+                    var logEvents = helper.log().args.filter(function (evt) {
+                        return evt[0].type == "change";
+                    });
+                    logEvents.should.have.length(1);
+                    var msg = logEvents[0][0];
+                    msg.should.have.property('level', helper.log().ERROR);
+                    msg.should.have.property('id', 'changeNode1');
+                    done();
+                },25);
+                changeNode1.receive({payload:"",null:null});
+            });
+        });
+
         describe('env var', function() {
             before(function() {
                 process.env.NR_TEST_A = 'foo';
@@ -989,6 +1391,30 @@ describe('change Node', function() {
             });
         });
 
+        it('deletes the value of persistable global context property', function(done) {
+            var flow = [{"id":"changeNode1","type":"change",rules:[{ "t": "delete", "p": "#:(memory1)::globalValue", "pt": "global"}],"name":"changeNode","wires":[["helperNode1"]]},
+                        {id:"helperNode1", type:"helper", wires:[]}];
+            helper.load(changeNode, flow, function() {
+                initContext(function () {
+                    var changeNode1 = helper.getNode("changeNode1");
+                    var helperNode1 = helper.getNode("helperNode1");
+                    helperNode1.on("input", function(msg) {
+                        try {
+                            changeNode1.context().global.get("globalValue","memory1",function(err,val) {
+                                should.equal(undefined);
+                                done();
+                            });
+                        } catch(err) {
+                            done(err);
+                        }
+                    });
+                    changeNode1.context().global.set("globalValue","Hello World!","memory1",function (err) {
+                        changeNode1.receive({payload:""});
+                    });
+                });
+            });
+        });
+
         it('deletes the value of a multi-level message property', function(done) {
             var flow = [{"id":"changeNode1","type":"change","action":"delete","property":"foo.bar","from":"","to":"","reg":false,"name":"changeNode","wires":[["helperNode1"]]},
                         {id:"helperNode1", type:"helper", wires:[]}];
@@ -1156,6 +1582,7 @@ describe('change Node', function() {
                 });
             });
         });
+
         it('applies multiple rules in order', function(done) {
             var flow = [{"id":"changeNode1","type":"change","wires":[["helperNode1"]],
                         rules:[
@@ -1180,5 +1607,101 @@ describe('change Node', function() {
                 });
             });
         });
+
+        it('can access two persistable flow context property', function(done) {
+            var flow = [{"id":"changeNode1", "z":"t1", "type":"change",
+                         "wires":[["helperNode1"]],
+                         rules:[
+                             {"t":"set", "p":"val0", "to":"#:(memory0)::val", "tot":"flow"},
+                             {"t":"set", "p":"val1", "to":"#:(memory1)::val", "tot":"flow"}
+                        ]},
+                        {id:"helperNode1", "z":"t1", type:"helper", wires:[]}];
+            helper.load(changeNode, flow, function() {
+                initContext(function () {
+                    var changeNode1 = helper.getNode("changeNode1");
+                    var helperNode1 = helper.getNode("helperNode1");
+                    helperNode1.on("input", function(msg) {
+                        try {
+                            msg.should.have.property("val0", "foo");
+                            msg.should.have.property("val1", "bar");
+                            done();
+                        } catch(err) {
+                            done(err);
+                        }
+                    });
+                    var flow = changeNode1.context().flow;
+                    flow.set("val", "foo", "memory0", function (err) {
+                        flow.set("val", "bar", "memory1", function (err) {
+                            changeNode1.receive({payload:""});
+                        });
+                    });
+                });
+            });
+        });
+
+        it('can access two persistable global context property', function(done) {
+            var flow = [{"id":"changeNode1", "z":"t1", "type":"change",
+                         "wires":[["helperNode1"]],
+                         rules:[
+                             {"t":"set", "p":"val0", "to":"#:(memory0)::val", "tot":"global"},
+                             {"t":"set", "p":"val1", "to":"#:(memory1)::val", "tot":"global"}
+                         ]},
+                        {id:"helperNode1", "z":"t1", type:"helper", wires:[]}];
+            helper.load(changeNode, flow, function() {
+                initContext(function () {
+                    var changeNode1 = helper.getNode("changeNode1");
+                    var helperNode1 = helper.getNode("helperNode1");
+                    helperNode1.on("input", function(msg) {
+                        try {
+                            msg.should.have.property("val0", "foo");
+                            msg.should.have.property("val1", "bar");
+                            done();
+                        } catch(err) {
+                            done(err);
+                        }
+                    });
+                    var global = changeNode1.context().global;
+                    global.set("val", "foo", "memory0", function (err) {
+                        global.set("val", "bar", "memory1", function (err) {
+                            changeNode1.receive({payload:""});
+                        });
+                    });
+                });
+            });
+        });
+
+        it('can access persistable global & flow context property', function(done) {
+            var flow = [{"id":"changeNode1", "z":"t1", "type":"change",
+                         "wires":[["helperNode1"]],
+                         rules:[
+                             {"t":"set", "p":"val0", "to":"#:(memory0)::val", "tot":"flow"},
+                             {"t":"set", "p":"val1", "to":"#:(memory1)::val", "tot":"global"}
+                         ]},
+                        {id:"helperNode1", "z":"t1", type:"helper", wires:[]}];
+            helper.load(changeNode, flow, function() {
+                initContext(function () {
+                    var changeNode1 = helper.getNode("changeNode1");
+                    var helperNode1 = helper.getNode("helperNode1");
+                    helperNode1.on("input", function(msg) {
+                        try {
+                            msg.should.have.property("val0", "foo");
+                            msg.should.have.property("val1", "bar");
+                            done();
+                        } catch(err) {
+                            done(err);
+                        }
+                    });
+                    var context = changeNode1.context();
+                    var flow = context.flow;
+                    var global = context.global;
+                    flow.set("val", "foo", "memory0", function (err) {
+                        global.set("val", "bar", "memory1", function (err) {
+                            changeNode1.receive({payload:""});
+                        });
+                    });
+                });
+            });
+        });
+
     });
 });

test/nodes/core/logic/16-range_spec.js

@@ -16,7 +16,7 @@
 
 var should = require("should");
 
-var rangeNode = require("../../../../nodes/core/logic/16-range.js");
+var rangeNode = require("nr-test-utils").require("@node-red/nodes/core/logic/16-range.js");
 var helper = require("node-red-node-test-helper");
 
 describe('range Node', function() {
@@ -131,9 +131,8 @@ describe('range Node', function() {
         helper.load(rangeNode, flow, function() {
             var rangeNode1 = helper.getNode("rangeNode1");
             var helperNode1 = helper.getNode("helperNode1");
-
-            var sinon = require('sinon');
-            sinon.stub(rangeNode1, 'log', function(log) {
+            rangeNode1.on("call:log",function(args) {
+                var log = args.args[0];
                 if (log.indexOf("notnumber") > -1) {
                     rangeNode1.log.restore();
                     done();

test/nodes/core/logic/17-split_spec.js

@@ -15,12 +15,13 @@
  **/
 
 var should = require("should");
-var splitNode = require("../../../../nodes/core/logic/17-split.js");
-var joinNode = require("../../../../nodes/core/logic/17-split.js");
+var splitNode = require("nr-test-utils").require("@node-red/nodes/core/logic/17-split.js");
+var joinNode = require("nr-test-utils").require("@node-red/nodes/core/logic/17-split.js");
 var helper = require("node-red-node-test-helper");
-var RED = require("../../../../red/red.js");
+var RED = require("nr-test-utils").require("node-red/lib/red.js");
+var Context = require("nr-test-utils").require("@node-red/runtime/lib/nodes/context");
 
-var TimeoutForErrorCase = 20; 
+var TimeoutForErrorCase = 20;
 
 describe('SPLIT node', function() {
 
@@ -390,17 +391,32 @@ describe('SPLIT node', function() {
 
 describe('JOIN node', function() {
 
-    before(function(done) {
+    beforeEach(function(done) {
         helper.startServer(done);
     });
 
-    after(function(done) {
-        helper.stopServer(done);
-    });
+    function initContext(done) {
+        Context.init({
+            contextStorage: {
+                memory: {
+                    module: "memory"
+                }
+            }
+        });
+        Context.load().then(function () {
+            done();
+        });
+    }
 
-    afterEach(function() {
-        helper.unload();
-        RED.settings.nodeMessageBufferMaxLength = 0;
+    afterEach(function(done) {
+        helper.unload().then(function(){
+            return Context.clean({allNodes:{}});
+        }).then(function(){
+            return Context.close();
+        }).then(function(){
+            RED.settings.nodeMessageBufferMaxLength = 0;
+            helper.stopServer(done);
+        });
     });
 
     it('should be loaded', function(done) {
@@ -587,14 +603,14 @@ describe('JOIN node', function() {
     });
 
     it('should accumulate a merged object', function(done) {
-        var flow = [{id:"n1", type:"join", wires:[["n2"]], build:"merged",mode:"custom",accumulate:true, count:1},
+        var flow = [{id:"n1", type:"join", wires:[["n2"]], build:"merged",mode:"custom",accumulate:true, count:3},
                     {id:"n2", type:"helper"}];
         helper.load(joinNode, flow, function() {
             var n1 = helper.getNode("n1");
             var n2 = helper.getNode("n2");
             var c = 0;
             n2.on("input", function(msg) {
-                if (c === 5) {
+                if (c === 3) {
                     try {
                         msg.should.have.property("payload");
                         msg.payload.should.have.property("a",3);
@@ -616,14 +632,14 @@ describe('JOIN node', function() {
     });
 
     it('should be able to reset an accumulation', function(done) {
-        var flow = [{id:"n1", type:"join", wires:[["n2"]], build:"merged",accumulate:true,mode:"custom", count:1},
+        var flow = [{id:"n1", type:"join", wires:[["n2"]], build:"merged",accumulate:true,mode:"custom", count:3},
                     {id:"n2", type:"helper"}];
         helper.load(joinNode, flow, function() {
             var n1 = helper.getNode("n1");
             var n2 = helper.getNode("n2");
             var c = 0;
             n2.on("input", function(msg) {
-                if (c === 3) {
+                if (c === 1) {
                     try {
                         msg.should.have.property("payload");
                         msg.payload.should.have.property("a",1);
@@ -633,11 +649,20 @@ describe('JOIN node', function() {
                     }
                     catch(e) { done(e) }
                 }
-                if (c === 5) {
+                if (c === 2) {
                     try {
                         msg.should.have.property("payload");
-                        msg.payload.should.have.property("b",2);
-                        msg.payload.should.have.property("c",1);
+                        msg.payload.should.have.property("e",2);
+                        msg.payload.should.have.property("f",1);
+                    }
+                    catch(e) { done(e) }
+                }
+                if (c === 3) {
+                    try {
+                        msg.should.have.property("payload");
+                        msg.payload.should.have.property("g",2);
+                        msg.payload.should.have.property("h",1);
+                        msg.payload.should.have.property("i",3);
                         done();
                     }
                     catch(e) { done(e) }
@@ -648,8 +673,11 @@ describe('JOIN node', function() {
             n1.receive({payload:{b:2}, topic:"b"});
             n1.receive({payload:{c:3}, topic:"c"});
             n1.receive({payload:{d:4}, topic:"d", complete:true});
-            n1.receive({payload:{b:2}, topic:"e"});
-            n1.receive({payload:{c:1}, topic:"f"});
+            n1.receive({payload:{e:2}, topic:"e"});
+            n1.receive({payload:{f:1}, topic:"f", complete:true});
+            n1.receive({payload:{g:2}, topic:"g"});
+            n1.receive({payload:{h:1}, topic:"h"});
+            n1.receive({payload:{i:3}, topic:"i"});
         });
     });
 
@@ -940,6 +968,136 @@ describe('JOIN node', function() {
         });
     });
 
+    it('should reduce messages - count only in last part', function(done) {
+        var flow = [{id:"n1", type:"join", mode:"reduce",
+                     reduceRight:false,
+                     reduceExp:"$A+payload",
+                     reduceInit:"0",
+                     reduceInitType:"num",
+                     reduceFixup:undefined,
+                     wires:[["n2"]]},
+                    {id:"n2", type:"helper"}];
+        helper.load(joinNode, flow, function() {
+            var n1 = helper.getNode("n1");
+            var n2 = helper.getNode("n2");
+            var count = 0;
+            n2.on("input", function(msg) {
+                try {
+                    msg.should.have.property("payload");
+                    msg.payload.should.equal(10);
+                    done();
+                }
+                catch(e) { done(e); }
+            });
+            n1.receive({payload:3, parts:{index:2, id:222}});
+            n1.receive({payload:2, parts:{index:1, id:222}});
+            n1.receive({payload:4, parts:{index:3, count:4,id:222}});
+            n1.receive({payload:1, parts:{index:0, id:222}});
+        });
+    });
+
+    function checkInitTypes(itype, ival, rval, initializer, checker, done) {
+        var flow = [{id:"n1", z:"f0", type:"join", mode:"reduce",
+                     reduceRight:false,
+                     reduceExp:"$A",
+                     reduceInit:ival,
+                     reduceInitType:itype,
+                     reduceFixup:undefined,
+                     wires:[["n2"]]},
+                    {id:"n2", type:"helper"}];
+        if (!initializer) {
+            initializer = (node, cb) => {
+                cb();
+            };
+        }
+        helper.load(joinNode, flow, function() {
+            var n1 = helper.getNode("n1");
+            var n2 = helper.getNode("n2");
+            initializer(n1, function () {
+                n2.on("input", function(msg) {
+                    try {
+                        msg.should.have.property("payload");
+                        checker(msg.payload, rval);
+                        done();
+                    }
+                    catch(e) { done(e); }
+                });
+                n1.receive({payload:3, parts:{index:2, count:4, id:222}});
+                n1.receive({payload:2, parts:{index:1, count:4, id:222}});
+                n1.receive({payload:4, parts:{index:3, count:4, id:222}});
+                n1.receive({payload:1, parts:{index:0, count:4, id:222}});
+            });
+        });
+    }
+
+    function checkInitTypesSimple(itype, val, done) {
+        checkInitTypes(itype, val, val, undefined, should.equal, done);
+    }
+
+    function checkInitTypesComplex(itype, ival, rval, done) {
+        checkInitTypes(itype, ival, rval, undefined, should.deepEqual, done);
+    }
+
+    it('should reduce messages with init types (str)', function(done) {
+        checkInitTypesSimple('str', "xyz", done);
+    });
+
+    it('should reduce messages with init types (num)', function(done) {
+        checkInitTypesSimple('num', 10, done);
+    });
+
+    it('should reduce messages with init types (bool)', function(done) {
+        checkInitTypesSimple('bool', true, done);
+    });
+
+    it('should reduce messages with init types (json)', function(done) {
+        var ival = '{"x":"vx", "y":"vy", "z":"vz"}';
+        var rval = JSON.parse(ival);
+        checkInitTypesComplex('json', ival, rval, done);
+    });
+
+    it('should reduce messages with init types (bin)', function(done) {
+        var ival = "[1,2,3]";
+        var rval = Buffer.from(JSON.parse(ival));
+        checkInitTypesComplex('bin', ival, rval, done);
+    });
+
+    it('should reduce messages with init types (JSONata)', function(done) {
+        var ival = "1+2+3";
+        var rval = 6;
+        checkInitTypesComplex('jsonata', ival, rval, done);
+    });
+
+    it('should reduce messages with init types (env)', function(done) {
+        function init(node, cb) {
+            process.env.NR_XYZ = "nr_xyz";
+            cb();
+        }
+        function fin(err) {
+            delete process.env.NR_XYZ;
+            done(err);
+        }
+        checkInitTypes('env', "NR_XYZ", "nr_xyz", init, should.equal, fin);
+    });
+
+    it('should reduce messages with init types (flow.name)', function(done) {
+        function init(node, cb) {
+            var context = node.context();
+            context.flow.set("foo", "bar");
+            cb();
+        }
+        checkInitTypes('flow', "foo", "bar", init, should.equal, done);
+    });
+
+    it('should reduce messages with init types (global.name)', function(done) {
+        function init(node, cb) {
+            var context = node.context();
+            context.global.set("foo", "bar");
+            cb();
+        }
+        checkInitTypes('global', "foo", "bar", init, should.equal, done);
+    });
+
     it('should reduce messages using $I', function(done) {
         var flow = [{id:"n1", type:"join", mode:"reduce",
                      reduceRight:false,
@@ -1123,7 +1281,147 @@ describe('JOIN node', function() {
         });
     });
 
-    it('should handle invalid JSON expression"', function (done) {
+    it('should reduce messages with flow context', function(done) {
+        var flow = [{id:"n1", type:"join", mode:"reduce",
+                     reduceRight:false,
+                     reduceExp:"$A+(payload*$flowContext(\"two\"))",
+                     reduceInit:"$flowContext(\"one\")",
+                     reduceInitType:"jsonata",
+                     reduceFixup:"$A*$flowContext(\"three\")",
+                     wires:[["n2"]],z:"flow"},
+                    {id:"n2", type:"helper",z:"flow"},
+                    {id:"flow", type:"tab"}];
+        helper.load(joinNode, flow, function() {
+            var n1 = helper.getNode("n1");
+            var n2 = helper.getNode("n2");
+            var count = 0;
+            n2.on("input", function(msg) {
+                try {
+                    msg.should.have.property("payload");
+                    msg.payload.should.equal(((((1+1*2)+2*2)+3*2)+4*2)*3);
+                    done();
+                }
+                catch(e) { done(e); }
+            });
+            n1.context().flow.set("one",1);
+            n1.context().flow.set("two",2);
+            n1.context().flow.set("three",3);
+            n1.receive({payload:3, parts:{index:2, count:4, id:222}});
+            n1.receive({payload:2, parts:{index:1, count:4, id:222}});
+            n1.receive({payload:4, parts:{index:3, count:4, id:222}});
+            n1.receive({payload:1, parts:{index:0, count:4, id:222}});
+        });
+    });
+
+    it('should reduce messages with global context', function(done) {
+        var flow = [{id:"n1", type:"join", mode:"reduce",
+                     reduceRight:false,
+                     reduceExp:"$A+(payload/$globalContext(\"two\"))",
+                     reduceInit:"$globalContext(\"one\")",
+                     reduceInitType:"jsonata",
+                     reduceFixup:"$A*$globalContext(\"three\")",
+                     wires:[["n2"]],z:"flow"},
+                    {id:"n2", type:"helper",z:"flow"},
+                    {id:"flow", type:"tab"}];
+        helper.load(joinNode, flow, function() {
+            var n1 = helper.getNode("n1");
+            var n2 = helper.getNode("n2");
+            var count = 0;
+            n2.on("input", function(msg) {
+                try {
+                    msg.should.have.property("payload");
+                    msg.payload.should.equal(((((1+1/2)+2/2)+3/2)+4/2)*3);
+                    done();
+                }
+                catch(e) { done(e); }
+            });
+            n1.context().global.set("one",1);
+            n1.context().global.set("two",2);
+            n1.context().global.set("three",3);
+            n1.receive({payload:3, parts:{index:2, count:4, id:222}});
+            n1.receive({payload:2, parts:{index:1, count:4, id:222}});
+            n1.receive({payload:4, parts:{index:3, count:4, id:222}});
+            n1.receive({payload:1, parts:{index:0, count:4, id:222}});
+        });
+    });
+
+    it('should reduce messages with persistable flow context', function(done) {
+        var flow = [{id:"n1", type:"join", mode:"reduce",
+                     reduceRight:false,
+                     reduceExp:"$A+(payload*$flowContext(\"two\",\"memory\"))",
+                     reduceInit:"$flowContext(\"one\",\"memory\")",
+                     reduceInitType:"jsonata",
+                     reduceFixup:"$A*$flowContext(\"three\",\"memory\")",
+                     wires:[["n2"]],z:"flow"},
+                    {id:"n2", type:"helper",z:"flow"},
+                    {id:"flow", type:"tab"}];
+        helper.load(joinNode, flow, function() {
+            initContext(function () {
+                var n1 = helper.getNode("n1");
+                var n2 = helper.getNode("n2");
+                    try {
+                    n2.on("input", function(msg) {
+                        try {
+                            msg.should.have.property("payload");
+                            msg.payload.should.equal(((((1+1*2)+2*2)+3*2)+4*2)*3);
+                            done();
+                        }
+                        catch(e) { done(e); }
+                    });
+                    n1.context().flow.set(["one","two","three"],[1,2,3],"memory",function(err){
+                        if(err){
+                            done(err);
+                        } else{
+                            n1.receive({payload:3, parts:{index:2, count:4, id:222}});
+                            n1.receive({payload:2, parts:{index:1, count:4, id:222}});
+                            n1.receive({payload:4, parts:{index:3, count:4, id:222}});
+                            n1.receive({payload:1, parts:{index:0, count:4, id:222}});
+                        }
+                    });
+                }catch(err) {
+                done(err);
+            }
+            });
+        });
+    });
+
+    it('should reduce messages with persistable global context', function(done) {
+        var flow = [{id:"n1", type:"join", mode:"reduce",
+                     reduceRight:false,
+                     reduceExp:"$A+(payload/$globalContext(\"two\",\"memory\"))",
+                     reduceInit:"$globalContext(\"one\",\"memory\")",
+                     reduceInitType:"jsonata",
+                     reduceFixup:"$A*$globalContext(\"three\",\"memory\")",
+                     wires:[["n2"]],z:"flow"},
+                    {id:"n2", type:"helper",z:"flow"},
+                    {id:"flow", type:"tab"}];
+        helper.load(joinNode, flow, function() {
+            initContext(function () {
+                var n1 = helper.getNode("n1");
+                var n2 = helper.getNode("n2");
+                n2.on("input", function(msg) {
+                    try {
+                        msg.should.have.property("payload");
+                        msg.payload.should.equal(((((1+1/2)+2/2)+3/2)+4/2)*3);
+                        done();
+                    }
+                    catch(e) { done(e); }
+                });
+                n1.context().global.set(["one","two","three"],[1,2,3],"memory",function(err){
+                    if(err){
+                        done(err);
+                    } else{
+                        n1.receive({payload:3, parts:{index:2, count:4, id:222}});
+                        n1.receive({payload:2, parts:{index:1, count:4, id:222}});
+                        n1.receive({payload:4, parts:{index:3, count:4, id:222}});
+                        n1.receive({payload:1, parts:{index:0, count:4, id:222}});
+                    }
+                });
+            });
+        });
+    });
+
+    it('should handle invalid JSONata reduce expression - syntax error"', function (done) {
         var flow = [{
             id: "n1", type: "join", mode: "reduce",
             reduceRight: false,
@@ -1147,6 +1445,77 @@ describe('JOIN node', function() {
         });
     });
 
+    it('should handle invalid JSONata reduce expression - runtime error"', function (done) {
+        var flow = [{
+            id: "n1", type: "join", mode: "reduce",
+            reduceRight: false,
+            reduceExp: "$uknown()",
+            reduceInit: "0",
+            reduceInitType: "num",
+            reduceFixup: undefined,
+            wires: [["n2"]]
+        },
+        { id: "n2", type: "helper" }];
+        helper.load(joinNode, flow, function () {
+            var n1 = helper.getNode("n1");
+            var n2 = helper.getNode("n2");
+            setTimeout(function () {
+                done();
+            }, TimeoutForErrorCase);
+            n2.on("input", function (msg) {
+                done(new Error("This path does not go through."));
+            });
+            n1.receive({ payload: "A", parts: { id: 1, type: "string", ch: ",", index: 0, count: 1 } });
+        });
+    });
+
+    it('should handle invalid JSONata fixup expression - syntax err"', function (done) {
+        var flow = [{
+            id: "n1", type: "join", mode: "reduce",
+            reduceRight: false,
+            reduceExp: "$A",
+            reduceInit: "0",
+            reduceInitType: "num",
+            reduceFixup: "invalid expr",
+            wires: [["n2"]]
+        },
+        { id: "n2", type: "helper" }];
+        helper.load(joinNode, flow, function () {
+            var n1 = helper.getNode("n1");
+            var n2 = helper.getNode("n2");
+            setTimeout(function () {
+                done();
+            }, TimeoutForErrorCase);
+            n2.on("input", function (msg) {
+                done(new Error("This path does not go through."));
+            });
+            n1.receive({ payload: "A", parts: { id: 1, type: "string", ch: ",", index: 0, count: 1 } });
+        });
+    });
+    it('should handle invalid JSONata fixup expression - runtime err"', function (done) {
+        var flow = [{
+            id: "n1", type: "join", mode: "reduce",
+            reduceRight: false,
+            reduceExp: "$A",
+            reduceInit: "0",
+            reduceInitType: "num",
+            reduceFixup: "$unknown()",
+            wires: [["n2"]]
+        },
+        { id: "n2", type: "helper" }];
+        helper.load(joinNode, flow, function () {
+            var n1 = helper.getNode("n1");
+            var n2 = helper.getNode("n2");
+            setTimeout(function () {
+                done();
+            }, TimeoutForErrorCase);
+            n2.on("input", function (msg) {
+                done(new Error("This path does not go through."));
+            });
+            n1.receive({ payload: "A", parts: { id: 1, type: "string", ch: ",", index: 0, count: 1 } });
+        });
+    });
+
     it('should concat payload when group.type is array', function (done) {
         var flow = [{ id: "n1", type: "join", wires: [["n2"]], build: "array", mode: "auto" },
                     { id: "n2", type: "helper" }];

test/nodes/core/logic/18-sort_spec.js

@@ -15,23 +15,35 @@
  **/
 
 var should = require("should");
-var sortNode = require("../../../../nodes/core/logic/18-sort.js");
+var sortNode = require("nr-test-utils").require("@node-red/nodes/core/logic/18-sort.js");
 var helper = require("node-red-node-test-helper");
-var RED = require("../../../../red/red.js");
+var RED = require("nr-test-utils").require("node-red/lib/red.js");
+var Context = require("nr-test-utils").require("@node-red/runtime/lib/nodes/context");
 
 describe('SORT node', function() {
 
-    before(function(done) {
+    beforeEach(function(done) {
         helper.startServer(done);
     });
 
-    after(function(done) {
-        helper.stopServer(done);
-    });
+    function initContext(done) {
+        Context.init({
+            contextStorage: {
+                memory: {
+                    module: "memory"
+                }
+            }
+        });
+        Context.load().then(function () {
+            done();
+        });
+    }
 
-    afterEach(function() {
-        helper.unload();
-        RED.settings.nodeMessageBufferMaxLength = 0;
+    afterEach(function(done) {
+        helper.unload().then(function(){
+            RED.settings.nodeMessageBufferMaxLength = 0;
+            helper.stopServer(done);
+        });
     });
 
     it('should be loaded', function(done) {
@@ -48,19 +60,31 @@ describe('SORT node', function() {
         var sort = flow[0];
         sort.target = target;
         sort.targetType = "msg";
-        sort.msgKey = key; 
-        sort.msgKeyType = key_type; 
+        sort.msgKey = key;
+        sort.msgKeyType = key_type;
         helper.load(sortNode, flow, function() {
             var n1 = helper.getNode("n1");
             var n2 = helper.getNode("n2");
             n2.on("input", function(msg) {
-                msg.should.have.property(target);
-                var data = msg[target];
-                data.length.should.equal(data_out.length);
-                for(var i = 0; i < data_out.length; i++) {
-                    data[i].should.equal(data_out[i]);
+                try {
+                    msg.should.have.property(target);
+                    var data = msg[target];
+                    data.length.should.equal(data_out.length);
+                    for(var i = 0; i < data_out.length; i++) {
+                        var data0 = data[i];
+                        var data1 = data_out[i];
+                        if (typeof data0 === "object") {
+                            data0.should.deepEqual(data1);
+                        }
+                        else {
+                            data0.should.equal(data1);
+                        }
+                    }
+                    done();
+                }
+                catch(e) {
+                    console.log(e);
                 }
-                done();
             });
             var msg = {};
             msg[target] = data_in;
@@ -81,6 +105,34 @@ describe('SORT node', function() {
     }
 
     function check_sort1(flow, key, key_type, data_in, data_out, done) {
+        function equals(v0, v1) {
+            var k0 = Object.keys(v0);
+            var k1 = Object.keys(v1);
+
+            if (k0.length === k1.length) {
+                for (var i = 0; i < k0.length; i++) {
+                    var k = k0[i];
+                    if (!v1.hasOwnProperty(k) ||
+                        (v0[k] !== v1[k])) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            return false;
+        }
+        function indexOf(a, v) {
+            for(var i = 0; i < a.length; i++) {
+                var av = a[i];
+                if ((typeof v === 'object') && equals(v, av)) {
+                    return i;
+                }
+                else if (v === av) {
+                    return i;
+                }
+            }
+            return -1;
+        }
         var sort = flow[0];
         var prop = (key_type === "msg") ? key : "payload";
         sort.targetType = "seq";
@@ -95,7 +147,7 @@ describe('SORT node', function() {
                 msg.should.have.property("parts");
                 msg.parts.should.have.property("count", data_out.length);
                 var data = msg[prop];
-                var index = data_out.indexOf(data);
+                var index = indexOf(data_out, data);
                 msg.parts.should.have.property("index", index);
                 count++;
                 if (count === data_out.length) {
@@ -124,7 +176,6 @@ describe('SORT node', function() {
         check_sort1(flow, exp, "jsonata", data_in, data_out, done);
     }
 
-
     (function() {
         var flow = [{id:"n1", type:"sort", order:"ascending", as_num:false, wires:[["n2"]]},
                     {id:"n2", type:"helper"}];
@@ -213,7 +264,7 @@ describe('SORT node', function() {
             check_sort1C(flow, "$substring(payload,1)", data_in, data_out, done);
         });
     })();
-    
+
     (function() {
         var flow = [{id:"n1", type:"sort", order:"descending", as_num:false, wires:[["n2"]]},
                         {id:"n2", type:"helper"}];
@@ -227,6 +278,152 @@ describe('SORT node', function() {
         });
     })();
 
+    (function() {
+        var flow = [{id:"n1", type:"sort", order:"ascending", as_num:true, wires:[["n2"]]},
+                    {id:"n2", type:"helper"}];
+        var conv = function(x) {
+            return x.map(function(v) { return { val:v }; });
+        };
+        var data_in  = conv([ "200", "4", "30", "1000" ]);
+        var data_out = conv([ "4", "30", "200", "1000" ]);
+        it('should sort payload of objects', function(done) {
+            check_sort0C(flow, "val", data_in, data_out, done);
+        });
+    })();
+
+    it('should sort payload by context (exp, not number, ascending)', function(done) {
+        var flow = [{id:"n1", type:"sort", target:"data", targetType:"msg", msgKey:"$flowContext($)", msgKeyType:"jsonata", order:"ascending", as_num:false, wires:[["n2"]],z:"flow"},
+                    {id:"n2", type:"helper",z:"flow"},
+                    {id:"flow", type:"tab"}];
+        var data_in  = [ "first", "second", "third", "fourth" ];
+        var data_out = [ "second", "third", "first", "fourth" ];
+        helper.load(sortNode, flow, function() {
+            var n1 = helper.getNode("n1");
+            var n2 = helper.getNode("n2");
+            n1.context()["flow"].set("first","3");
+            n1.context()["flow"].set("second","1");
+            n1.context()["flow"].set("third","2");
+            n1.context()["flow"].set("fourth","4");
+            n2.on("input", function(msg) {
+                msg.should.have.property("data");
+                var data = msg["data"];
+                data.length.should.equal(data_out.length);
+                for(var i = 0; i < data_out.length; i++) {
+                    data[i].should.equal(data_out[i]);
+                }
+                done();
+            });
+            var msg = {};
+            msg["data"] = data_in;
+            n1.receive(msg);
+        });
+    });
+
+    it('should sort message group by context (exp, not number, ascending)', function(done) {
+        var flow = [{id:"n1", type:"sort", target:"data", targetType:"seq", seqKey:"$globalContext(payload)", seqKeyType:"jsonata", order:"ascending", as_num:false, wires:[["n2"]],z:"flow"},
+                    {id:"n2", type:"helper",z:"flow"},
+                    {id:"flow", type:"tab"}];
+        var data_in  = [ "first", "second", "third", "fourth" ];
+        var data_out = [ "second", "fourth", "third", "first" ];
+        helper.load(sortNode, flow, function() {
+            var n1 = helper.getNode("n1");
+            var n2 = helper.getNode("n2");
+            var count = 0;
+            n1.context()["global"].set("first","4");
+            n1.context()["global"].set("second","1");
+            n1.context()["global"].set("third","3");
+            n1.context()["global"].set("fourth","2");
+            n2.on("input", function(msg) {
+                try {
+                    msg.should.have.property("payload");
+                    msg.should.have.property("parts");
+                    msg.parts.should.have.property("count", data_out.length);
+                    var data = msg["payload"];
+                    var index = data_out.indexOf(data);
+                    msg.parts.should.have.property("index", index);
+                    count++;
+                    if (count === data_out.length) {
+                        done();
+                    }
+                }
+                catch(e) {
+                    done(e);
+                }
+            });
+            var len = data_in.length;
+            for(var i = 0; i < len; i++) {
+                var parts = { id: "X", index: i, count: len };
+                var msg = {parts: parts};
+                msg["payload"] = data_in[i];
+                n1.receive(msg);
+            }
+        });
+    });
+
+    it('should sort payload by persistable context (exp, not number, descending)', function(done) {
+        var flow = [{id:"n1", type:"sort", target:"data", targetType:"msg", msgKey:"$globalContext($,\"memory\")", msgKeyType:"jsonata", order:"descending", as_num:false, wires:[["n2"]],z:"flow"},
+                    {id:"n2", type:"helper",z:"flow"},
+                    {id:"flow", type:"tab"}];
+        var data_in  = [ "first", "second", "third", "fourth" ];
+        var data_out = [ "fourth", "first", "third", "second" ];
+        helper.load(sortNode, flow, function() {
+            initContext(function(){
+                var n1 = helper.getNode("n1");
+                var n2 = helper.getNode("n2");
+                n1.context()["global"].set(["first","second","third","fourth"],["3","1","2","4"],"memory",function(){
+                    n2.on("input", function(msg) {
+                        msg.should.have.property("data");
+                        var data = msg["data"];
+                        data.length.should.equal(data_out.length);
+                        for(var i = 0; i < data_out.length; i++) {
+                            data[i].should.equal(data_out[i]);
+                        }
+                        done();
+                    });
+                    var msg = {};
+                    msg["data"] = data_in;
+                    n1.receive(msg);
+                });
+            });
+        });
+    });
+
+    it('should sort message group by persistable context (exp, not number, descending)', function(done) {
+        var flow = [{id:"n1", type:"sort", target:"data", targetType:"seq", seqKey:"$flowContext(payload,\"memory\")", seqKeyType:"jsonata", order:"descending", as_num:false, wires:[["n2"]],z:"flow"},
+                    {id:"n2", type:"helper",z:"flow"},
+                    {id:"flow", type:"tab"}];
+        var data_in  = [ "first", "second", "third", "fourth" ];
+        var data_out = [ "first", "third", "fourth", "second" ];
+        helper.load(sortNode, flow, function() {
+            initContext(function(){
+                var n1 = helper.getNode("n1");
+                var n2 = helper.getNode("n2");
+                var count = 0;
+                n1.context()["flow"].set(["first","second","third","fourth"],["4","1","3","2"],"memory",function(){
+                    n2.on("input", function(msg) {
+                        msg.should.have.property("payload");
+                        msg.should.have.property("parts");
+                        msg.parts.should.have.property("count", data_out.length);
+                        var data = msg["payload"];
+                        var index = data_out.indexOf(data);
+                        msg.parts.should.have.property("index", index);
+                        count++;
+                        if (count === data_out.length) {
+                            done();
+                        }
+                    });
+                    var len = data_in.length;
+                    for(var i = 0; i < len; i++) {
+                        var parts = { id: "X", index: i, count: len };
+                        var msg = {parts: parts};
+                        msg["payload"] = data_in[i];
+                        n1.receive(msg);
+                    }
+                });
+            });
+        });
+    });
+
     it('should handle JSONata script error', function(done) {
         var flow = [{id:"n1", type:"sort", order:"ascending", as_num:false, target:"payload", targetType:"seq", seqKey:"$unknown()", seqKeyType:"jsonata", wires:[["n2"]]},
                     {id:"n2", type:"helper"}];
@@ -248,7 +445,7 @@ describe('SORT node', function() {
             n1.receive(msg1);
         });
     });
-    
+
     it('should handle too many pending messages', function(done) {
         var flow = [{id:"n1", type:"sort", order:"ascending", as_num:false, target:"payload", targetType:"seq", seqKey:"payload", seqKeyType:"msg", wires:[["n2"]]},
                     {id:"n2", type:"helper"}];

test/nodes/core/logic/19-batch_spec.js

@@ -15,9 +15,9 @@
  **/
 
 var should = require("should");
-var batchNode = require("../../../../nodes/core/logic/19-batch.js");
+var batchNode = require("nr-test-utils").require("@node-red/nodes/core/logic/19-batch.js");
 var helper = require("node-red-node-test-helper");
-var RED = require("../../../../red/red.js");
+var RED = require("nr-test-utils").require("node-red/lib/red.js");
 
 describe('BATCH node', function() {
     this.timeout(8000);

test/nodes/core/parsers/70-CSV_spec.js

@@ -15,7 +15,7 @@
  **/
 
 var should = require("should");
-var csvNode = require("../../../../nodes/core/parsers/70-CSV.js");
+var csvNode = require("nr-test-utils").require("@node-red/nodes/core/parsers/70-CSV.js");
 var helper = require("node-red-node-test-helper");
 
 describe('CSV node', function() {

test/nodes/core/parsers/70-HTML_spec.js

@@ -18,7 +18,7 @@ var should = require("should");
 var path = require("path");
 var fs = require('fs-extra');
 
-var htmlNode = require("../../../../nodes/core/parsers/70-HTML.js");
+var htmlNode = require("nr-test-utils").require("@node-red/nodes/core/parsers/70-HTML.js");
 var helper = require("node-red-node-test-helper");
 
 describe('html node', function() {

test/nodes/core/parsers/70-JSON_spec.js

@@ -15,7 +15,7 @@
  **/
 
 var should = require("should");
-var jsonNode = require("../../../../nodes/core/parsers/70-JSON.js");
+var jsonNode = require("nr-test-utils").require("@node-red/nodes/core/parsers/70-JSON.js");
 var helper = require("node-red-node-test-helper");
 
 describe('JSON node', function() {
@@ -265,6 +265,23 @@ describe('JSON node', function() {
         });
     });
 
+    it('should pass an object if provided a valid object and schema and action is object', function(done) {
+        var flow = [{id:"jn1",type:"json",action:"obj",wires:[["jn2"]]},
+                    {id:"jn2", type:"helper"}];
+        helper.load(jsonNode, flow, function() {
+            var jn1 = helper.getNode("jn1");
+            var jn2 = helper.getNode("jn2");
+            jn2.on("input", function(msg) {
+                should.equal(msg.payload.number, 3);
+                should.equal(msg.payload.string, "allo");
+                done();
+            });
+            var obj =  {"number": 3, "string": "allo"};
+            var schema = {title: "testSchema", type: "object", properties: {number: {type: "number"}, string: {type: "string" }}};
+            jn1.receive({payload:obj, schema:schema});
+        });
+    });
+
     it('should pass a string if provided a valid object and schema', function(done) {
         var flow = [{id:"jn1",type:"json",wires:[["jn2"]]},
                     {id:"jn2", type:"helper"}];
@@ -281,6 +298,22 @@ describe('JSON node', function() {
         });
     });
 
+    it('should pass a string if provided a valid JSON string and schema and action is string', function(done) {
+        var flow = [{id:"jn1",type:"json",action:"str",wires:[["jn2"]]},
+                    {id:"jn2", type:"helper"}];
+        helper.load(jsonNode, flow, function() {
+            var jn1 = helper.getNode("jn1");
+            var jn2 = helper.getNode("jn2");
+            jn2.on("input", function(msg) {
+                should.equal(msg.payload, '{"number":3,"string":"allo"}');
+                done();
+            });
+            var jsonString =  '{"number":3,"string":"allo"}';
+            var schema = {title: "testSchema", type: "object", properties: {number: {type: "number"}, string: {type: "string" }}};
+            jn1.receive({payload:jsonString, schema:schema});
+        });
+    });
+
     it('should log an error if passed an invalid object and valid schema', function(done) {
         var flow = [{id:"jn1",type:"json",wires:[["jn2"]]},
                     {id:"jn2", type:"helper"}];
@@ -305,6 +338,78 @@ describe('JSON node', function() {
         });
     });
 
+    it('should log an error if passed an invalid object and valid schema and action is object', function(done) {
+        var flow = [{id:"jn1",type:"json",action:"obj",wires:[["jn2"]]},
+                    {id:"jn2", type:"helper"}];
+        helper.load(jsonNode, flow, function() {
+            try {
+                var jn1 = helper.getNode("jn1");
+                var jn2 = helper.getNode("jn2");
+                var schema = {title: "testSchema", type: "object", properties: {number: {type: "number"}, string: {type: "string" }}};
+                var obj =  {"number": "foo", "string": 3};
+                jn1.receive({payload:obj, schema:schema});
+                var logEvents = helper.log().args.filter(function(evt) {
+                    return evt[0].type == "json";
+                });
+                logEvents.should.have.length(1);
+                logEvents[0][0].should.have.a.property('msg');
+                logEvents[0][0].msg.should.equal("json.errors.schema-error: data.number should be number, data.string should be string");
+                logEvents[0][0].should.have.a.property('level',helper.log().ERROR);
+                done();
+            } catch(err) {
+                done(err);
+            }
+        });
+    });
+
+    it('should log an error if passed an invalid JSON string and valid schema', function(done) {
+        var flow = [{id:"jn1",type:"json",wires:[["jn2"]]},
+                    {id:"jn2", type:"helper"}];
+        helper.load(jsonNode, flow, function() {
+            try {
+                var jn1 = helper.getNode("jn1");
+                var jn2 = helper.getNode("jn2");
+                var schema = {title: "testSchema", type: "object", properties: {number: {type: "number"}, string: {type: "string" }}};
+                var jsonString =  '{"number":"Hello","string":3}';
+                jn1.receive({payload:jsonString, schema:schema});
+                var logEvents = helper.log().args.filter(function(evt) {
+                    return evt[0].type == "json";
+                });
+                logEvents.should.have.length(1);
+                logEvents[0][0].should.have.a.property('msg');
+                logEvents[0][0].msg.should.equal("json.errors.schema-error: data.number should be number, data.string should be string");
+                logEvents[0][0].should.have.a.property('level',helper.log().ERROR);
+                done();
+            } catch(err) {
+                done(err);
+            }
+        });
+    });
+
+    it('should log an error if passed an invalid JSON string and valid schema and action is string', function(done) {
+        var flow = [{id:"jn1",type:"json",action:"str",wires:[["jn2"]]},
+                    {id:"jn2", type:"helper"}];
+        helper.load(jsonNode, flow, function() {
+            try {
+                var jn1 = helper.getNode("jn1");
+                var jn2 = helper.getNode("jn2");
+                var schema = {title: "testSchema", type: "object", properties: {number: {type: "number"}, string: {type: "string" }}};
+                var jsonString =  '{"number":"Hello","string":3}';
+                jn1.receive({payload:jsonString, schema:schema});
+                var logEvents = helper.log().args.filter(function(evt) {
+                    return evt[0].type == "json";
+                });
+                logEvents.should.have.length(1);
+                logEvents[0][0].should.have.a.property('msg');
+                logEvents[0][0].msg.should.equal("json.errors.schema-error: data.number should be number, data.string should be string");
+                logEvents[0][0].should.have.a.property('level',helper.log().ERROR);
+                done();
+            } catch(err) {
+                done(err);
+            }
+        });
+    });
+
     it('should log an error if passed a valid object and invalid schema', function(done) {
         var flow = [{id:"jn1",type:"json",wires:[["jn2"]]},
                     {id:"jn2", type:"helper"}];

test/nodes/core/parsers/70-XML_spec.js

@@ -15,7 +15,7 @@
  **/
 
 var should = require("should");
-var xmlNode = require("../../../../nodes/core/parsers/70-XML.js");
+var xmlNode = require("nr-test-utils").require("@node-red/nodes/core/parsers/70-XML.js");
 var helper = require("node-red-node-test-helper");
 
 describe('XML node', function() {

test/nodes/core/parsers/70-YAML_spec.js

@@ -15,7 +15,7 @@
  **/
 
 var should = require("should");
-var yamlNode = require("../../../../nodes/core/parsers/70-YAML.js");
+var yamlNode = require("nr-test-utils").require("@node-red/nodes/core/parsers/70-YAML.js");
 var helper = require("node-red-node-test-helper");
 
 describe('YAML node', function() {

test/nodes/core/storage/28-tail_spec.js

@@ -19,7 +19,7 @@ var path = require('path');
 var os = require('os');
 var fs = require('fs-extra');
 var sinon = require('sinon');
-var tailNode = require("../../../../nodes/core/storage/28-tail.js");
+var tailNode = require("nr-test-utils").require("@node-red/nodes/core/storage/28-tail.js");
 var helper = require("node-red-node-test-helper");
 
 describe('tail Node', function() {

test/nodes/core/storage/50-file_spec.js

@@ -19,7 +19,7 @@ var path = require('path');
 var fs = require('fs-extra');
 var os = require('os');
 var sinon = require("sinon");
-var fileNode = require("../../../../nodes/core/storage/50-file.js");
+var fileNode = require("nr-test-utils").require("@node-red/nodes/core/storage/50-file.js");
 var helper = require("node-red-node-test-helper");
 
 describe('file Nodes', function() {
@@ -46,82 +46,173 @@ describe('file Nodes', function() {
         it('should be loaded', function(done) {
             var flow = [{id:"fileNode1", type:"file", name: "fileNode", "filename":fileToTest, "appendNewline":true, "overwriteFile":true}];
             helper.load(fileNode, flow, function() {
-                var fileNode1 = helper.getNode("fileNode1");
-                fileNode1.should.have.property('name', 'fileNode');
-                done();
+                try {
+                    var fileNode1 = helper.getNode("fileNode1");
+                    fileNode1.should.have.property('name', 'fileNode');
+                    done();
+                }
+                catch (e) {
+                    done(e);
+                }
             });
         });
 
         it('should write to a file', function(done) {
-            var flow = [{id:"fileNode1", type:"file", name: "fileNode", "filename":fileToTest, "appendNewline":false, "overwriteFile":true}];
+            var flow = [{id:"fileNode1", type:"file", name: "fileNode", "filename":fileToTest, "appendNewline":false, "overwriteFile":true, wires: [["helperNode1"]]},
+                        {id:"helperNode1", type:"helper"}];
             helper.load(fileNode, flow, function() {
                 var n1 = helper.getNode("fileNode1");
-                n1.emit("input", {payload:"test"});
-                setTimeout(function() {
-                    var f = fs.readFileSync(fileToTest);
-                    f.should.have.length(4);
-                    fs.unlinkSync(fileToTest);
-                    done();
-                },wait);
+                var n2 = helper.getNode("helperNode1");
+                n2.on("input", function(msg) {
+                    try {
+                        var f = fs.readFileSync(fileToTest);
+                        f.should.have.length(4);
+                        fs.unlinkSync(fileToTest);
+                        msg.should.have.property("payload", "test");
+                        done();
+                    }
+                    catch (e) {
+                        done(e);
+                    }
+                });
+                n1.receive({payload:"test"});
             });
         });
 
         it('should append to a file and add newline', function(done) {
-            var flow = [{id:"fileNode1", type:"file", name: "fileNode", "filename":fileToTest, "appendNewline":true, "overwriteFile":false}];
+            var flow = [{id:"fileNode1", type:"file", name: "fileNode", "filename":fileToTest, "appendNewline":true, "overwriteFile":false, wires: [["helperNode1"]]},
+                        {id:"helperNode1", type:"helper"}];
             try {
                 fs.unlinkSync(fileToTest);
-            }catch(err) {}
+            } catch(err) {
+            }
             helper.load(fileNode, flow, function() {
                 var n1 = helper.getNode("fileNode1");
-                n1.emit("input", {payload:"test2"});    // string
+                var n2 = helper.getNode("helperNode1");
+                var count = 0;
+                var data = ["test2", true, 999, [2]];
+
+                n2.on("input", function (msg) {
+                    try {
+                        msg.should.have.property("payload");
+                        data.should.containDeep([msg.payload]);
+                        if (count === 3) {
+                            var f = fs.readFileSync(fileToTest).toString();
+                            if (os.type() !== "Windows_NT") {
+                                f.should.have.length(19);
+                                f.should.equal("test2\ntrue\n999\n[2]\n");
+                            }
+                            else {
+                                f.should.have.length(23);
+                                f.should.equal("test2\r\ntrue\r\n999\r\n[2]\r\n");
+                            }
+                            done();
+                        }
+                        count++;
+                    }
+                    catch (e) {
+                        done(e);
+                    }
+                });
+
+                n1.receive({payload:"test2"});    // string
                 setTimeout(function() {
-                    n1.emit("input", {payload:true});       // boolean
+                    n1.receive({payload:true});       // boolean
                 },30);
                 setTimeout(function() {
-                    n1.emit("input", {payload:999});        // number
+                    n1.receive({payload:999});        // number
                 },60);
                 setTimeout(function() {
-                    n1.emit("input", {payload:[2]});        // object (array)
+                    n1.receive({payload:[2]});        // object (array)
                 },90);
-                setTimeout(function() {
-                    var f = fs.readFileSync(fileToTest).toString();
-                    if (os.type() !== "Windows_NT") {
-                        f.should.have.length(19);
-                        f.should.equal("test2\ntrue\n999\n[2]\n");
-                    }
-                    else {
-                        f.should.have.length(23);
-                        f.should.equal("test2\r\ntrue\r\n999\r\n[2]\r\n");
-                    }
-                    done();
-                },wait);
             });
         });
 
         it('should append to a file after it has been deleted ', function(done) {
-            var flow = [{id:"fileNode1", type:"file", name: "fileNode", "filename":fileToTest, "appendNewline":false, "overwriteFile":false}];
+            var flow = [{id:"fileNode1", type:"file", name: "fileNode", "filename":fileToTest, "appendNewline":false, "overwriteFile":false, wires: [["helperNode1"]]},
+                        {id:"helperNode1", type:"helper"}];
             try {
                 fs.unlinkSync(fileToTest);
-            } catch(err) {}
+            } catch(err) {
+            }
             helper.load(fileNode, flow, function() {
                 var n1 = helper.getNode("fileNode1");
-                // Send two messages to the file
-                n1.emit("input", {payload:"one"});
-                n1.emit("input", {payload:"two"});
-                setTimeout(function() {
+                var n2 = helper.getNode("helperNode1");
+                var data = ["one", "two", "three", "four"];
+                var count = 0;
+
+                n2.on("input", function (msg) {
                     try {
-                        // Check they got appended as expected
-                        var f = fs.readFileSync(fileToTest).toString();
-                        f.should.equal("onetwo");
+                        msg.should.have.property("payload");
+                        data.should.containDeep([msg.payload]);
+                        try {
+                            if (count === 1) {
+                                // Check they got appended as expected
+                                var f = fs.readFileSync(fileToTest).toString();
+                                f.should.equal("onetwo");
 
-                        // Delete the file
-                        fs.unlinkSync(fileToTest);
+                                // Delete the file
+                                fs.unlinkSync(fileToTest);
+                                setTimeout(function() {
+                                    // Send two more messages to the file
+                                    n1.receive({payload:"three"});
+                                    n1.receive({payload:"four"});
+                                }, wait);
+                            }
+                            if (count === 3) {
+                                var f = fs.readFileSync(fileToTest).toString();
+                                f.should.equal("threefour");
+                                fs.unlinkSync(fileToTest);
+                                done();
+                            }
+                        } catch(err) {
+                            done(err);
+                        }
+                        count++;
+                    }
+                    catch (e) {
+                        done(e);
+                    }
+                });
 
-                        // Send two more messages to the file
-                        n1.emit("input", {payload:"three"});
-                        n1.emit("input", {payload:"four"});
+                // Send two messages to the file
+                n1.receive({payload:"one"});
+                n1.receive({payload:"two"});
+            });
+        });
 
-                        setTimeout(function() {
+        it('should append to a file after it has been recreated ', function(done) {
+            var flow = [{id:"fileNode1", type:"file", name: "fileNode", "filename":fileToTest, "appendNewline":false, "overwriteFile":false, wires: [["helperNode1"]]},
+                        {id:"helperNode1", type:"helper"}];
+            try {
+                fs.unlinkSync(fileToTest);
+            } catch(err) {
+            }
+            helper.load(fileNode, flow, function() {
+                var n1 = helper.getNode("fileNode1");
+                var n2 = helper.getNode("helperNode1");
+                var data = ["one", "two", "three", "four"];
+                var count = 0;
+
+                n2.on("input", function (msg) {
+                    try {
+                        msg.should.have.property("payload");
+                        data.should.containDeep([msg.payload]);
+                        if (count == 1) {
+                            // Check they got appended as expected
+                            var f = fs.readFileSync(fileToTest).toString();
+                            f.should.equal("onetwo");
+
+                            if (os.type() === "Windows_NT") {
+                                var dummyFile = path.join(resourcesDir,"50-file-test-dummy.txt");
+                                fs.rename(fileToTest, dummyFile, function() {
+                                    recreateTest(n1, dummyFile);
+                                });
+                            } else {
+                                recreateTest(n1, fileToTest);
+                            }
+                        }
+                        if (count == 3) {
                             // Check the file was updated
                             try {
                                 var f = fs.readFileSync(fileToTest).toString();
@@ -131,42 +222,16 @@ describe('file Nodes', function() {
                             } catch(err) {
                                 done(err);
                             }
-                        },wait);
-                    } catch(err) {
-                        done(err);
-                    }
-                },wait);
-            });
-        });
-
-        it('should append to a file after it has been recreated ', function(done) {
-            var flow = [{id:"fileNode1", type:"file", name: "fileNode", "filename":fileToTest, "appendNewline":false, "overwriteFile":false}];
-            try {
-                fs.unlinkSync(fileToTest);
-            } catch(err) {}
-            helper.load(fileNode, flow, function() {
-                var n1 = helper.getNode("fileNode1");
-                // Send two messages to the file
-                n1.emit("input", {payload:"one"});
-                n1.emit("input", {payload:"two"});
-                setTimeout(function() {
-                    try {
-                        // Check they got appended as expected
-                        var f = fs.readFileSync(fileToTest).toString();
-                        f.should.equal("onetwo");
-
-                        if (os.type() === "Windows_NT") {
-                            var dummyFile = path.join(resourcesDir,"50-file-test-dummy.txt");
-                            fs.rename(fileToTest, dummyFile, function() {
-                                recreateTest(n1, dummyFile);
-                            });
-                        } else {
-                            recreateTest(n1, fileToTest);
                         }
                     } catch(err) {
                         done(err);
                     }
-                },wait);
+                    count++;
+                });
+
+                // Send two messages to the file
+                n1.receive({payload:"one"});
+                n1.receive({payload:"two"});
             });
 
             function recreateTest(n1, fileToDelete) {
@@ -177,50 +242,52 @@ describe('file Nodes', function() {
                 fs.writeFileSync(fileToTest,"");
 
                 // Send two more messages to the file
-                n1.emit("input", {payload:"three"});
-                n1.emit("input", {payload:"four"});
-
-                setTimeout(function() {
-                    // Check the file was updated
-                    try {
-                        var f = fs.readFileSync(fileToTest).toString();
-                        f.should.equal("threefour");
-                        fs.unlinkSync(fileToTest);
-                        done();
-                    } catch(err) {
-                        done(err);
-                    }
-                },wait);
+                n1.receive({payload:"three"});
+                n1.receive({payload:"four"});
             }
         });
 
 
         it('should use msg.filename if filename not set in node', function(done) {
-            var flow = [{id:"fileNode1", type:"file", name: "fileNode", "appendNewline":true, "overwriteFile":true}];
+            var flow = [{id:"fileNode1", type:"file", name: "fileNode", "appendNewline":true, "overwriteFile":true, wires: [["helperNode1"]]},
+                        {id:"helperNode1", type:"helper"}];
             helper.load(fileNode, flow, function() {
                 var n1 = helper.getNode("fileNode1");
-                n1.emit("input", {payload:"fine", filename:fileToTest});
-                setTimeout(function() {
-                    var f = fs.readFileSync(fileToTest).toString();
-                    if (os.type() !== "Windows_NT") {
-                        f.should.have.length(5);
-                        f.should.equal("fine\n");
+                var n2 = helper.getNode("helperNode1");
+
+                n2.on("input", function (msg) {
+                    try {
+                        msg.should.have.property("payload", "fine");
+                        msg.should.have.property("filename", fileToTest);
+
+                        var f = fs.readFileSync(fileToTest).toString();
+                        if (os.type() !== "Windows_NT") {
+                            f.should.have.length(5);
+                            f.should.equal("fine\n");
+                        }
+                        else {
+                            f.should.have.length(6);
+                            f.should.equal("fine\r\n");
+                        }
+                        done();
                     }
-                    else {
-                        f.should.have.length(6);
-                        f.should.equal("fine\r\n");
+                    catch (e) {
+                        done(e);
                     }
-                    done();
-                },wait);
+                });
+
+                n1.receive({payload:"fine", filename:fileToTest});
             });
         });
 
         it('should be able to delete the file', function(done) {
-            var flow = [{id:"fileNode1", type:"file", name: "fileNode", "filename":fileToTest, "appendNewline":false, "overwriteFile":"delete"}];
+            var flow = [{id:"fileNode1", type:"file", name: "fileNode", "filename":fileToTest, "appendNewline":false, "overwriteFile":"delete", wires: [["helperNode1"]]},
+                        {id:"helperNode1", type:"helper"}];
             helper.load(fileNode, flow, function() {
                 var n1 = helper.getNode("fileNode1");
-                n1.emit("input", {payload:"fine"});
-                setTimeout(function() {
+                var n2 = helper.getNode("helperNode1");
+
+                n2.on("input", function (msg) {
                     try {
                         var f = fs.readFileSync(fileToTest).toString();
                         f.should.not.equal("fine");
@@ -230,7 +297,9 @@ describe('file Nodes', function() {
                         e.code.should.equal("ENOENT");
                         done();
                     }
-                },wait);
+                });
+
+                n1.receive({payload:"fine"});
             });
         });
 
@@ -394,6 +463,11 @@ describe('file Nodes', function() {
         });
 
         it('should try to create a new directory if asked to do so (append)', function(done) {
+            // fs.writeFileSync of afterEach failed on Windows.
+            if (os.type() === "Windows_NT") {
+                done();
+                return;
+            }
             // Stub file write so we can make writes fail
             var fileToTest2 = path.join(resourcesDir,"file-out-node","50-file-test-file.txt");
             var spy = sinon.stub(fs, "ensureDir", function(arg1,arg2,arg3,arg4) { arg2(null); });
@@ -466,6 +540,93 @@ describe('file Nodes', function() {
             });
         });
 
+        it('should write to multiple files', function(done) {
+            var flow = [{id:"fileNode1", type:"file", name: "fileNode", "appendNewline":true, "overwriteFile":true, "createDir":true, wires: [["helperNode1"]]},
+                        {id:"helperNode1", type:"helper"}];
+            var tmp_path = path.join(resourcesDir, "tmp");
+            var len = 1024*1024*10;
+            var file_count = 5;
+            helper.load(fileNode, flow, function() {
+                var n1 = helper.getNode("fileNode1");
+                var n2 = helper.getNode("helperNode1");
+                var count = 0;
+                n2.on("input", function(msg) {
+                    try {
+                        count++;
+                        if (count == file_count) {
+                            for(var i = 0; i < file_count; i++) {
+                                var name = path.join(tmp_path, String(i));
+                                var f = fs.readFileSync(name);
+                                f.should.have.length(len);
+                                f[0].should.have.equal(i);
+                            }
+                            fs.removeSync(tmp_path);
+                            done();
+                        }
+                    }
+                    catch (e) {
+                        try {
+                            fs.removeSync(tmp_path);
+                        }
+                        catch (e1) {
+                        }
+                        done(e);
+                    }
+                });
+                for(var i = 0; i < file_count; i++) {
+                    var data = new Buffer(len);
+                    data.fill(i);
+                    var name = path.join(tmp_path, String(i));
+                    var msg = {payload:data, filename:name};
+                    n1.receive(msg);
+                }
+            });
+        });
+
+        it('should write to multiple files if node is closed', function(done) {
+            var flow = [{id:"fileNode1", type:"file", name: "fileNode", "appendNewline":true, "overwriteFile":true, "createDir":true, wires: [["helperNode1"]]},
+                        {id:"helperNode1", type:"helper"}];
+            var tmp_path = path.join(resourcesDir, "tmp");
+            var len = 1024*1024*10;
+            var file_count = 5;
+            helper.load(fileNode, flow, function() {
+                var n1 = helper.getNode("fileNode1");
+                var n2 = helper.getNode("helperNode1");
+                var count = 0;
+                n2.on("input", function(msg) {
+                    try {
+                        count++;
+                        if (count == file_count) {
+                            for(var i = 0; i < file_count; i++) {
+                                var name = path.join(tmp_path, String(i));
+                                var f = fs.readFileSync(name);
+                                f.should.have.length(len);
+                                f[0].should.have.equal(i);
+                            }
+                            fs.removeSync(tmp_path);
+                            done();
+                        }
+                    }
+                    catch (e) {
+                        try {
+                            fs.removeSync(tmp_path);
+                        }
+                        catch (e1) {
+                        }
+                        done(e);
+                    }
+                });
+                for(var i = 0; i < file_count; i++) {
+                    var data = new Buffer(len);
+                    data.fill(i);
+                    var name = path.join(tmp_path, String(i));
+                    var msg = {payload:data, filename:name};
+                    n1.receive(msg);
+                }
+                n1.close();
+            });
+        });
+
     });
 
 
@@ -473,6 +634,7 @@ describe('file Nodes', function() {
 
         var resourcesDir = path.join(__dirname,"..","..","..","resources");
         var fileToTest = path.join(resourcesDir,"50-file-test-file.txt");
+        var fileToTest2 = "\t"+path.join(resourcesDir,"50-file-test-file.txt")+"\r\n";
         var wait = 150;
 
         beforeEach(function(done) {
@@ -498,7 +660,7 @@ describe('file Nodes', function() {
 
         it('should read in a file and output a buffer', function(done) {
             var flow = [{id:"fileInNode1", type:"file in", name:"fileInNode", "filename":fileToTest, "format":"", wires:[["n2"]]},
-                    {id:"n2", type:"helper"}];
+                        {id:"n2", type:"helper"}];
             helper.load(fileNode, flow, function() {
                 var n1 = helper.getNode("fileInNode1");
                 var n2 = helper.getNode("n2");
@@ -515,6 +677,27 @@ describe('file Nodes', function() {
 
         it('should read in a file and output a utf8 string', function(done) {
             var flow = [{id:"fileInNode1", type:"file in", name: "fileInNode", "filename":fileToTest, "format":"utf8", wires:[["n2"]]},
+                        {id:"n2", type:"helper"}];
+            helper.load(fileNode, flow, function() {
+                var n1 = helper.getNode("fileInNode1");
+                var n2 = helper.getNode("n2");
+                n2.on("input", function(msg) {
+                    try {
+                        msg.should.have.property('payload');
+                        msg.payload.should.be.a.String();
+                        msg.payload.should.have.length(40)
+                        msg.payload.should.equal("File message line 1\nFile message line 2\n");
+                        done();
+                    } catch(err) {
+                        done(err);
+                    }
+                });
+                n1.receive({payload:""});
+            });
+        });
+
+        it('should read in a file ending in cr and output a utf8 string', function(done) {
+            var flow = [{id:"fileInNode1", type:"file in", name: "fileInNode", "filename":fileToTest2, "format":"utf8", wires:[["n2"]]},
                 {id:"n2", type:"helper"}];
             helper.load(fileNode, flow, function() {
                 var n1 = helper.getNode("fileInNode1");
@@ -536,7 +719,7 @@ describe('file Nodes', function() {
 
         it('should read in a file and output split lines with parts', function(done) {
             var flow = [{id:"fileInNode1", type:"file in", name: "fileInNode", filename:fileToTest, format:"lines", wires:[["n2"]]},
-                {id:"n2", type:"helper"}];
+                        {id:"n2", type:"helper"}];
             helper.load(fileNode, flow, function() {
                 var n1 = helper.getNode("fileInNode1");
                 var n2 = helper.getNode("n2");
@@ -574,7 +757,7 @@ describe('file Nodes', function() {
             var line = data.join("\n");
             fs.writeFileSync(fileToTest, line);
             var flow = [{id:"fileInNode1", type:"file in", name: "fileInNode", filename:fileToTest, format:"lines", wires:[["n2"]]},
-                {id:"n2", type:"helper"}];
+                        {id:"n2", type:"helper"}];
             helper.load(fileNode, flow, function() {
                 var n1 = helper.getNode("fileInNode1");
                 var n2 = helper.getNode("n2");
@@ -607,7 +790,7 @@ describe('file Nodes', function() {
 
         it('should read in a file and output a buffer with parts', function(done) {
             var flow = [{id:"fileInNode1", type:"file in", name: "fileInNode", filename:fileToTest, format:"stream", wires:[["n2"]]},
-                {id:"n2", type:"helper"}];
+                        {id:"n2", type:"helper"}];
             helper.load(fileNode, flow, function() {
                 var n1 = helper.getNode("fileInNode1");
                 var n2 = helper.getNode("n2");

test/red/api/auth/index_spec.js

@@ -1,287 +0,0 @@
-/**
- * Copyright JS Foundation and other contributors, http://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://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.
- **/
-
-var should = require("should");
-var when = require("when");
-var sinon = require("sinon");
-
-var passport = require("passport");
-
-var auth = require("../../../../red/api/auth");
-var Users = require("../../../../red/api/auth/users");
-var Tokens = require("../../../../red/api/auth/tokens");
-
-describe("api/auth/index",function() {
-
-
-
-    describe("ensureClientSecret", function() {
-        before(function() {
-            auth.init({settings:{},log:{audit:function(){}}})
-        });
-        it("leaves client_secret alone if not present",function(done) {
-            var req = {
-                body: {
-                    client_secret: "test_value"
-                }
-            };
-            auth.ensureClientSecret(req,null,function() {
-                req.body.should.have.a.property("client_secret","test_value");
-                done();
-            })
-        });
-        it("applies a default client_secret if not present",function(done) {
-            var req = {
-                body: { }
-            };
-            auth.ensureClientSecret(req,null,function() {
-                req.body.should.have.a.property("client_secret","not_available");
-                done();
-            })
-        });
-    });
-
-    describe("revoke", function() {
-        it("revokes a token", function(done) {
-            var revokeToken = sinon.stub(Tokens,"revoke",function() {
-                return when.resolve();
-            });
-
-            var req = { body: { token: "abcdef" } };
-
-            var res = { status: function(resp) {
-                revokeToken.restore();
-
-                resp.should.equal(200);
-                return {
-                    end: done
-                }
-            }};
-
-            auth.revoke(req,res);
-        });
-    });
-
-    describe("login", function() {
-        beforeEach(function() {
-            sinon.stub(Tokens,"init",function(){});
-            sinon.stub(Users,"init",function(){});
-        });
-        afterEach(function() {
-            Tokens.init.restore();
-            Users.init.restore();
-        });
-        it("returns login details - credentials", function(done) {
-            auth.init({settings:{adminAuth:{type:"credentials"}},log:{audit:function(){}}})
-            auth.login(null,{json: function(resp) {
-                resp.should.have.a.property("type","credentials");
-                resp.should.have.a.property("prompts");
-                resp.prompts.should.have.a.lengthOf(2);
-                done();
-            }});
-        });
-        it("returns login details - none", function(done) {
-            auth.init({settings:{},log:{audit:function(){}}})
-            auth.login(null,{json: function(resp) {
-                resp.should.eql({});
-                done();
-            }});
-        });
-        it("returns login details - strategy", function(done) {
-            auth.init({settings:{adminAuth:{type:"strategy",strategy:{label:"test-strategy",icon:"test-icon"}}},log:{audit:function(){}}})
-            auth.login(null,{json: function(resp) {
-                resp.should.have.a.property("type","strategy");
-                resp.should.have.a.property("prompts");
-                resp.prompts.should.have.a.lengthOf(1);
-                resp.prompts[0].should.have.a.property("type","button");
-                resp.prompts[0].should.have.a.property("label","test-strategy");
-                resp.prompts[0].should.have.a.property("icon","test-icon");
-
-                done();
-            }});
-        });
-
-        it("returns login details - strategy - merged a adminAuth.module object to a adminAuth object", function(done) {
-            auth.init({
-                settings: {
-                    adminAuth: {
-                        type: "strategy",
-                        strategy:{
-                            label:"test-strategy",
-                            icon:"test-icon"
-                        },
-                        tokens: [{
-                            token: "test-token",
-                            user: "test-user",
-                            scope: ["*"]
-                        }]
-                    }
-                },
-                log:{audit:function(){}}
-            });
-            auth.login(null,{json: function(resp) {
-                resp.should.have.a.property("type","strategy");
-                resp.should.have.a.property("prompts");
-                resp.prompts.should.have.a.lengthOf(1);
-                resp.prompts[0].should.have.a.property("type","button");
-                resp.prompts[0].should.have.a.property("label","test-strategy");
-                resp.prompts[0].should.have.a.property("icon","test-icon");
-
-                done();
-            }});
-        });
-
-    });
-
-    describe("init", function() {
-        var spyTokensInit;
-        var spyUsersInit;
-        beforeEach(function() {
-            spyTokensInit = sinon.spy(Tokens,"init");
-            spyUsersInit = sinon.spy(Users,"init");
-        });
-        this.afterEach(function() {
-            spyTokensInit.restore();
-            spyUsersInit.restore();
-        });
-        it("merges an adminAuth object and an adminAuth.module object - module object is null", function(done) {
-            auth.init({
-                settings: {
-                    adminAuth: {
-                        type: "strategy",
-                        strategy:{
-                            label:"test-strategy",
-                            icon:"test-icon"
-                        },
-                        tokens: [{
-                            token: "test-token",
-                            user: "test-user",
-                            scope: ["*"]
-                        }]
-                    }
-                },
-                log:{audit:function(){}}
-            });
-            spyTokensInit.args[0][0].should.have.a.property("type","strategy");
-            spyTokensInit.args[0][0].should.have.a.property("strategy");
-            spyTokensInit.args[0][0].strategy.should.have.a.property("label","test-strategy");
-            spyTokensInit.args[0][0].strategy.should.have.a.property("icon","test-icon");
-            spyTokensInit.args[0][0].should.have.a.property("tokens");
-            spyTokensInit.args[0][0].tokens.should.have.a.lengthOf(1);
-            spyTokensInit.args[0][0].tokens[0].should.have.a.property("token","test-token");
-            spyTokensInit.args[0][0].tokens[0].should.have.a.property("user","test-user");
-            spyTokensInit.args[0][0].tokens[0].should.have.a.property("scope");
-            spyTokensInit.args[0][0].tokens[0].scope.should.have.a.lengthOf(1);
-            spyUsersInit.args[0][0].should.have.a.property("type","strategy");
-            spyUsersInit.args[0][0].should.have.a.property("strategy");
-            spyUsersInit.args[0][0].strategy.should.have.a.property("label","test-strategy");
-            spyUsersInit.args[0][0].strategy.should.have.a.property("icon","test-icon");
-            spyUsersInit.args[0][0].should.have.a.property("tokens");
-            spyUsersInit.args[0][0].tokens.should.have.a.lengthOf(1);
-            spyUsersInit.args[0][0].tokens[0].should.have.a.property("token","test-token");
-            spyUsersInit.args[0][0].tokens[0].should.have.a.property("user","test-user");
-            spyUsersInit.args[0][0].tokens[0].should.have.a.property("scope");
-            spyUsersInit.args[0][0].tokens[0].scope.should.have.a.lengthOf(1);
-            done();
-        });
-        it("merges an adminAuth object and an adminAuth.module object - not conflict", function(done) {
-            auth.init({
-                settings: {
-                    adminAuth: {
-                        module: {
-                            type: "strategy",
-                            strategy:{
-                                label:"test-strategy",
-                                icon:"test-icon"
-                            }
-                        },
-                        tokens: [{
-                            token: "test-token",
-                            user: "test-user",
-                            scope: ["*"]
-                        }]
-                    }
-                },
-                log:{audit:function(){}}
-            });
-            spyTokensInit.args[0][0].should.have.a.property("type","strategy");
-            spyTokensInit.args[0][0].should.have.a.property("strategy");
-            spyTokensInit.args[0][0].strategy.should.have.a.property("label","test-strategy");
-            spyTokensInit.args[0][0].strategy.should.have.a.property("icon","test-icon");
-            spyTokensInit.args[0][0].should.have.a.property("tokens");
-            spyTokensInit.args[0][0].tokens.should.have.a.lengthOf(1);
-            spyTokensInit.args[0][0].tokens[0].should.have.a.property("token","test-token");
-            spyTokensInit.args[0][0].tokens[0].should.have.a.property("user","test-user");
-            spyTokensInit.args[0][0].tokens[0].should.have.a.property("scope");
-            spyTokensInit.args[0][0].tokens[0].scope.should.have.a.lengthOf(1);
-            spyUsersInit.args[0][0].should.have.a.property("type","strategy");
-            spyUsersInit.args[0][0].should.have.a.property("strategy");
-            spyUsersInit.args[0][0].strategy.should.have.a.property("label","test-strategy");
-            spyUsersInit.args[0][0].strategy.should.have.a.property("icon","test-icon");
-            spyUsersInit.args[0][0].should.have.a.property("tokens");
-            spyUsersInit.args[0][0].tokens.should.have.a.lengthOf(1);
-            spyUsersInit.args[0][0].tokens[0].should.have.a.property("token","test-token");
-            spyUsersInit.args[0][0].tokens[0].should.have.a.property("user","test-user");
-            spyUsersInit.args[0][0].tokens[0].should.have.a.property("scope");
-            spyUsersInit.args[0][0].tokens[0].scope.should.have.a.lengthOf(1);
-            done();
-        });
-        it("merges an adminAuth object and an adminAuth.module object - conflict", function(done) {
-            auth.init({
-                settings: {
-                    adminAuth: {
-                        module: {
-                            type: "strategy",
-                            strategy:{
-                                label:"test-strategy",
-                                icon:"test-icon"
-                            }
-                        },
-                        type: "credentials",
-                        tokens: [{
-                            token: "test-token",
-                            user: "test-user",
-                            scope: ["*"]
-                        }]
-                    }
-                },
-                log:{audit:function(){}}
-            });
-            spyTokensInit.args[0][0].should.have.a.property("type","strategy");
-            spyTokensInit.args[0][0].should.have.a.property("strategy");
-            spyTokensInit.args[0][0].strategy.should.have.a.property("label","test-strategy");
-            spyTokensInit.args[0][0].strategy.should.have.a.property("icon","test-icon");
-            spyTokensInit.args[0][0].should.have.a.property("tokens");
-            spyTokensInit.args[0][0].tokens.should.have.a.lengthOf(1);
-            spyTokensInit.args[0][0].tokens[0].should.have.a.property("token","test-token");
-            spyTokensInit.args[0][0].tokens[0].should.have.a.property("user","test-user");
-            spyTokensInit.args[0][0].tokens[0].should.have.a.property("scope");
-            spyTokensInit.args[0][0].tokens[0].scope.should.have.a.lengthOf(1);
-            spyUsersInit.args[0][0].should.have.a.property("type","strategy");
-            spyUsersInit.args[0][0].should.have.a.property("strategy");
-            spyUsersInit.args[0][0].strategy.should.have.a.property("label","test-strategy");
-            spyUsersInit.args[0][0].strategy.should.have.a.property("icon","test-icon");
-            spyUsersInit.args[0][0].should.have.a.property("tokens");
-            spyUsersInit.args[0][0].tokens.should.have.a.lengthOf(1);
-            spyUsersInit.args[0][0].tokens[0].should.have.a.property("token","test-token");
-            spyUsersInit.args[0][0].tokens[0].should.have.a.property("user","test-user");
-            spyUsersInit.args[0][0].tokens[0].should.have.a.property("scope");
-            spyUsersInit.args[0][0].tokens[0].scope.should.have.a.lengthOf(1);
-            done();
-        });
-    });
-
-});

test/red/api/editor/locales_spec.js

@@ -1,122 +0,0 @@
-/**
- * Copyright JS Foundation and other contributors, http://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://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.
- **/
-
-var should = require("should");
-var request = require('supertest');
-var express = require('express');
-var sinon = require('sinon');
-
-var locales = require("../../../../red/api/editor/locales");
-
-describe("api/editor/locales", function() {
-    beforeEach(function() {
-    })
-    afterEach(function() {
-    })
-    describe('get named resource catalog',function() {
-        var app;
-        before(function() {
-            // bit of a mess of internal workings
-            locales.init({
-                i18n: {
-                    i: {
-                        lng: function() { return 'en-US'},
-                        setLng: function(lang,callback) {
-                            if (callback) {
-                                callback();
-                            }
-                        }
-                    },
-                    catalog: function(namespace, lang) {
-                        return {namespace:namespace, lang:lang};
-                    }
-                }
-            });
-            app = express();
-            app.get(/locales\/(.+)\/?$/,locales.get);
-        });
-        it('returns with default language', function(done) {
-            request(app)
-                .get("/locales/message-catalog")
-                .expect(200)
-                .end(function(err,res) {
-                    if (err) {
-                        return done(err);
-                    }
-                    res.body.should.have.property('namespace','message-catalog');
-                    done();
-                });
-        });
-        it('returns with selected language', function(done) {
-            request(app)
-                .get("/locales/message-catalog?lng=fr-FR")
-                .expect(200)
-                .end(function(err,res) {
-                    if (err) {
-                        return done(err);
-                    }
-                    res.body.should.have.property('namespace','message-catalog');
-                    res.body.should.have.property('lang','fr-FR');
-                    done();
-                });
-        });
-    });
-
-    describe('get all node resource catalogs',function() {
-        var app;
-        before(function() {
-            // bit of a mess of internal workings
-            locales.init({
-                i18n: {
-                    catalog: function(namespace, lang) {
-                        return {
-                            "node-red": "should not return",
-                            "test-module-a-id": "test-module-a-catalog",
-                            "test-module-b-id": "test-module-b-catalog",
-                            "test-module-c-id": "test-module-c-catalog"
-                        }[namespace]
-                    }
-                },
-                nodes: {
-                    getNodeList: function() {
-                        return [
-                            {module:"node-red",id:"node-red-id"},
-                            {module:"test-module-a",id:"test-module-a-id"},
-                            {module:"test-module-b",id:"test-module-b-id"}
-                        ];
-                    }
-                }
-            });
-            app = express();
-            app.get("/locales/nodes",locales.getAllNodes);
-        });
-        it('returns with the node catalogs', function(done) {
-            request(app)
-                .get("/locales/nodes")
-                .expect(200)
-                .end(function(err,res) {
-                    if (err) {
-                        return done(err);
-                    }
-                    res.body.should.eql({
-                        'test-module-a-id': 'test-module-a-catalog',
-                        'test-module-b-id': 'test-module-b-catalog'
-                    });
-                    done();
-                });
-        });
-    });
-});

test/red/api/editor/settings_spec.js

@@ -1,283 +0,0 @@
-/**
- * Copyright JS Foundation and other contributors, http://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://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.
- **/
-
-var should = require("should");
-var request = require('supertest');
-var express = require('express');
-var sinon = require('sinon');
-var when = require('when');
-
-var app = express();
-var info = require("../../../../red/api/editor/settings");
-var theme = require("../../../../red/api/editor/theme");
-
-describe("api/editor/settings", function() {
-    describe("settings handler", function() {
-        before(function() {
-            sinon.stub(theme,"settings",function() { return { test: 456 };});
-            app = express();
-            app.get("/settings",info.runtimeSettings);
-            app.get("/settingsWithUser",function(req,res,next) {
-                req.user = {
-                    username: "nick",
-                    permissions: "*",
-                    image: "http://example.com",
-                    anonymous: false,
-                    private: "secret"
-                }
-                next();
-            },info.runtimeSettings);
-        });
-
-        after(function() {
-            theme.settings.restore();
-        });
-
-        it('returns the filtered settings', function(done) {
-            info.init({
-                settings: {
-                    foo: 123,
-                    httpNodeRoot: "testHttpNodeRoot",
-                    version: "testVersion",
-                    paletteCategories :["red","blue","green"],
-                    exportNodeSettings: function(obj) {
-                        obj.testNodeSetting = "helloWorld";
-                    }
-                },
-                nodes: {
-                    paletteEditorEnabled: function() { return true; },
-                    getCredentialKeyType: function() { return "test-key-type"},
-                    listContextStores: function() { return {default: "foo", stores: ["foo","bar"]}}
-                },
-                log: { error: console.error },
-                storage: {}
-            });
-            request(app)
-                .get("/settings")
-                .expect(200)
-                .end(function(err,res) {
-                    if (err) {
-                        return done(err);
-                    }
-                    res.body.should.have.property("httpNodeRoot","testHttpNodeRoot");
-                    res.body.should.have.property("version","testVersion");
-                    res.body.should.have.property("context",{default: "foo", stores: ["foo","bar"]});
-                    res.body.should.have.property("paletteCategories",["red","blue","green"]);
-                    res.body.should.have.property("editorTheme",{test:456});
-                    res.body.should.have.property("testNodeSetting","helloWorld");
-                    res.body.should.not.have.property("foo",123);
-                    res.body.should.have.property("flowEncryptionType","test-key-type");
-                    res.body.should.not.have.property("user");
-                    done();
-                });
-        });
-        it('returns the filtered user in settings', function(done) {
-            info.init({
-                settings: {
-                    foo: 123,
-                    httpNodeRoot: "testHttpNodeRoot",
-                    version: "testVersion",
-                    paletteCategories :["red","blue","green"],
-                    exportNodeSettings: function(obj) {
-                        obj.testNodeSetting = "helloWorld";
-                    }
-                },
-                nodes: {
-                    paletteEditorEnabled: function() { return true; },
-                    getCredentialKeyType: function() { return "test-key-type"},
-                    listContextStores: function() { return {default: "foo", stores: ["foo","bar"]}}
-                },
-                log: { error: console.error },
-                storage: {}
-            });
-            request(app)
-                .get("/settingsWithUser")
-                .expect(200)
-                .end(function(err,res) {
-                    if (err) {
-                        return done(err);
-                    }
-                    res.body.should.have.property("user");
-                    res.body.user.should.have.property("username","nick");
-                    res.body.user.should.have.property("permissions","*");
-                    res.body.user.should.have.property("image","http://example.com");
-                    res.body.user.should.have.property("anonymous",false);
-                    res.body.user.should.not.have.property("private");
-
-                    done();
-                });
-        });
-        it('includes project settings if projects available', function(done) {
-            info.init({
-                settings: {
-                    foo: 123,
-                    httpNodeRoot: "testHttpNodeRoot",
-                    version: "testVersion",
-                    paletteCategories :["red","blue","green"],
-                    exportNodeSettings: function(obj) {
-                        obj.testNodeSetting = "helloWorld";
-                    }
-                },
-                nodes: {
-                    paletteEditorEnabled: function() { return true; },
-                    getCredentialKeyType: function() { return "test-key-type"},
-                    listContextStores: function() { return {default: "foo", stores: ["foo","bar"]}}
-                },
-                log: { error: console.error },
-                storage: {
-                    projects: {
-                        getActiveProject: () => 'test-active-project',
-                        getFlowFilename:  () => 'test-flow-file',
-                        getCredentialsFilename:  () => 'test-creds-file',
-                        getGlobalGitUser: () => {return {name:'foo',email:'foo@example.com'}}
-                    }
-                }
-            });
-            request(app)
-                .get("/settings")
-                .expect(200)
-                .end(function(err,res) {
-                    if (err) {
-                        return done(err);
-                    }
-                    res.body.should.have.property("project","test-active-project");
-                    res.body.should.not.have.property("files");
-                    res.body.should.have.property("git");
-                    res.body.git.should.have.property("globalUser",{name:'foo',email:'foo@example.com'});
-                    done();
-                });
-        });
-        it('includes existing files details if projects enabled but no active project and files exist', function(done) {
-            info.init({
-                settings: {
-                    foo: 123,
-                    httpNodeRoot: "testHttpNodeRoot",
-                    version: "testVersion",
-                    paletteCategories :["red","blue","green"],
-                    exportNodeSettings: function(obj) {
-                        obj.testNodeSetting = "helloWorld";
-                    }
-                },
-                nodes: {
-                    paletteEditorEnabled: function() { return true; },
-                    getCredentialKeyType: function() { return "test-key-type"},
-                    listContextStores: function() { return {default: "foo", stores: ["foo","bar"]}}
-                },
-                log: { error: console.error },
-                storage: {
-                    projects: {
-                        flowFileExists: () => true,
-                        getActiveProject: () => false,
-                        getFlowFilename:  () => 'test-flow-file',
-                        getCredentialsFilename:  () => 'test-creds-file',
-                        getGlobalGitUser: () => {return {name:'foo',email:'foo@example.com'}}
-                    }
-                }
-            });
-            request(app)
-                .get("/settings")
-                .expect(200)
-                .end(function(err,res) {
-                    if (err) {
-                        return done(err);
-                    }
-                    res.body.should.not.have.property("project");
-                    res.body.should.have.property("files");
-                    res.body.files.should.have.property("flow",'test-flow-file');
-                    res.body.files.should.have.property("credentials",'test-creds-file');
-                    res.body.should.have.property("git");
-                    res.body.git.should.have.property("globalUser",{name:'foo',email:'foo@example.com'});
-                    done();
-                });
-        });
-        it('does not include file details if projects enabled but no active project and files do not exist', function(done) {
-            info.init({
-                settings: {
-                    foo: 123,
-                    httpNodeRoot: "testHttpNodeRoot",
-                    version: "testVersion",
-                    paletteCategories :["red","blue","green"],
-                    exportNodeSettings: function(obj) {
-                        obj.testNodeSetting = "helloWorld";
-                    }
-                },
-                nodes: {
-                    paletteEditorEnabled: function() { return true; },
-                    getCredentialKeyType: function() { return "test-key-type"},
-                    listContextStores: function() { return {default: "foo", stores: ["foo","bar"]}}
-                },
-                log: { error: console.error },
-                storage: {
-                    projects: {
-                        flowFileExists: () => false,
-                        getActiveProject: () => false,
-                        getFlowFilename:  () => 'test-flow-file',
-                        getCredentialsFilename:  () => 'test-creds-file',
-                        getGlobalGitUser: () => {return {name:'foo',email:'foo@example.com'}}
-                    }
-                }
-            });
-            request(app)
-                .get("/settings")
-                .expect(200)
-                .end(function(err,res) {
-                    if (err) {
-                        return done(err);
-                    }
-                    res.body.should.not.have.property("project");
-                    res.body.should.not.have.property("files");
-                    res.body.should.have.property("git");
-                    res.body.git.should.have.property("globalUser",{name:'foo',email:'foo@example.com'});
-                    done();
-                });
-        });
-        it('overrides palette editable if runtime says it is disabled', function(done) {
-            info.init({
-                settings: {
-                    httpNodeRoot: "testHttpNodeRoot",
-                    version: "testVersion",
-                    paletteCategories :["red","blue","green"],
-                    exportNodeSettings: function() {}
-                },
-                nodes: {
-                    paletteEditorEnabled: function() { return false; },
-                    getCredentialKeyType: function() { return "test-key-type"},
-                    listContextStores: function() { return {default: "foo", stores: ["foo","bar"]}}
-                },
-                log: { error: console.error },
-                storage: {}
-
-            });
-            request(app)
-                .get("/settings")
-                .expect(200)
-                .end(function(err,res) {
-                    if (err) {
-                        return done(err);
-                    }
-                    res.body.should.have.property("httpNodeRoot","testHttpNodeRoot");
-                    res.body.should.have.property("version","testVersion");
-                    res.body.should.have.property("paletteCategories",["red","blue","green"]);
-                    res.body.should.have.property("editorTheme");
-                    res.body.editorTheme.should.have.property("test",456);
-
-                    res.body.editorTheme.should.have.property("palette",{editable:false});
-                    done();
-                });
-        })
-    });
-
-});

test/red/api/editor/theme_spec.js

@@ -1,111 +0,0 @@
-/**
- * Copyright JS Foundation and other contributors, http://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://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.
- **/
-
-var should = require("should");
-var express = require('express');
-var sinon = require('sinon');
-var when = require('when');
-var fs = require("fs");
-
-var app = express();
-
-var theme = require("../../../../red/api/editor/theme");
-
-describe("api/editor/theme", function() {
-    beforeEach(function() {
-        sinon.stub(fs,"statSync",function() { return true; });
-    });
-    afterEach(function() {
-        theme.init({settings:{}});
-        fs.statSync.restore();
-    });
-    it("applies the default theme", function() {
-        var result = theme.init({settings:{},version:function() { return '123.456'}});
-        should.not.exist(result);
-
-        var context = theme.context();
-        context.should.have.a.property("page");
-        context.page.should.have.a.property("title","Node-RED");
-        context.page.should.have.a.property("favicon","favicon.ico");
-        context.should.have.a.property("header");
-        context.header.should.have.a.property("title","Node-RED");
-        context.header.should.have.a.property("image","red/images/node-red.png");
-        context.should.have.a.property("version","123.456");
-
-        should.not.exist(theme.settings());
-    });
-
-    it("picks up custom theme", function() {
-        theme.init({settings:{
-            editorTheme: {
-                page: {
-                    title: "Test Page Title",
-                    favicon: "/absolute/path/to/theme/icon",
-                    css: "/absolute/path/to/custom/css/file.css",
-                    scripts: "/absolute/path/to/script.js"
-                },
-                header: {
-                    title: "Test Header Title",
-                    image: "/absolute/path/to/header/image" // or null to remove image
-                },
-
-                deployButton: {
-                    type:"simple",
-                    label:"Save",
-                    icon: "/absolute/path/to/deploy/button/image" // or null to remove image
-                },
-
-                menu: { // Hide unwanted menu items by id. see editor/js/main.js:loadEditor for complete list
-                    "menu-item-import-library": false,
-                    "menu-item-export-library": false,
-                    "menu-item-keyboard-shortcuts": false,
-                    "menu-item-help": {
-                        label: "Alternative Help Link Text",
-                        url: "http://example.com"
-                    }
-                },
-
-                userMenu: false, // Hide the user-menu even if adminAuth is enabled
-
-                login: {
-                    image: "/absolute/path/to/login/page/big/image" // a 256x256 image
-                }
-            }
-        }});
-
-        theme.app();
-
-        var context = theme.context();
-        context.should.have.a.property("page");
-        context.page.should.have.a.property("title","Test Page Title");
-        context.should.have.a.property("header");
-        context.header.should.have.a.property("title","Test Header Title");
-        context.page.should.have.a.property("css");
-        context.page.css.should.have.lengthOf(1);
-        context.page.css[0].should.eql('theme/css/file.css');
-
-        context.page.should.have.a.property("scripts");
-        context.page.scripts.should.have.lengthOf(1);
-        context.page.scripts[0].should.eql('theme/scripts/script.js');
-
-        var settings = theme.settings();
-        settings.should.have.a.property("deployButton");
-        settings.should.have.a.property("userMenu");
-        settings.should.have.a.property("menu");
-
-    });
-
-});

test/red/runtime/nodes/context/localfilesystem_spec.js

@@ -1,378 +0,0 @@
-/**
- * Copyright JS Foundation and other contributors, http://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://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.
- **/
-
-var should = require('should');
-var fs = require('fs-extra');
-var path = require("path");
-var LocalFileSystem = require('../../../../../red/runtime/nodes/context/localfilesystem');
-
-var resourcesDir = path.resolve(path.join(__dirname,"..","resources","context"));
-
-describe('localfilesystem',function() {
-    var context;
-
-    before(function() {
-        return fs.remove(resourcesDir);
-    });
-
-    beforeEach(function() {
-        context = LocalFileSystem({dir: resourcesDir, cache: false});
-        return context.open();
-    });
-
-    afterEach(function() {
-        return context.clean([]).then(function(){
-            return context.close().then(function(){
-                return fs.remove(resourcesDir);
-            });
-        });
-    });
-
-    describe('#get/set',function() {
-        it('should store property',function(done) {
-            context.get("nodeX","foo",function(err, value){
-                should.not.exist(value);
-                context.set("nodeX","foo","test",function(err){
-                    context.get("nodeX","foo",function(err, value){
-                        value.should.be.equal("test");
-                        done();
-                    });
-                });
-            });
-        });
-
-        it('should store property - creates parent properties',function(done) {
-            context.set("nodeX","foo.bar","test",function(err){
-                context.get("nodeX","foo",function(err, value){
-                    value.should.be.eql({bar:"test"});
-                    done();
-                });
-            });
-        });
-
-        it('should delete property',function(done) {
-            context.set("nodeX","foo.abc.bar1","test1",function(err){
-                context.set("nodeX","foo.abc.bar2","test2",function(err){
-                    context.get("nodeX","foo.abc",function(err, value){
-                        value.should.be.eql({bar1:"test1",bar2:"test2"});
-                        context.set("nodeX","foo.abc.bar1",undefined,function(err){
-                            context.get("nodeX","foo.abc",function(err, value){
-                                value.should.be.eql({bar2:"test2"});
-                                context.set("nodeX","foo.abc",undefined,function(err){
-                                    context.get("nodeX","foo.abc",function(err, value){
-                                        should.not.exist(value);
-                                        context.set("nodeX","foo",undefined,function(err){
-                                            context.get("nodeX","foo",function(err, value){
-                                                should.not.exist(value);
-                                                done();
-                                            });
-                                        });
-                                    });
-                                });
-                            });
-                        });
-                    });
-                });
-            });
-        });
-
-        it('should not shared context with other scope', function(done) {
-            context.get("nodeX","foo",function(err, value){
-                should.not.exist(value);
-                context.get("nodeY","foo",function(err, value){
-                    should.not.exist(value);
-                    context.set("nodeX","foo","testX",function(err){
-                        context.set("nodeY","foo","testY",function(err){
-                            context.get("nodeX","foo",function(err, value){
-                                value.should.be.equal("testX"),
-                                context.get("nodeY","foo",function(err, value){
-                                    value.should.be.equal("testY");
-                                    done();
-                                });
-                            });
-                        });
-                    });
-                });
-            });
-        });
-
-        it('should store string',function(done) {
-            context.get("nodeX","foo",function(err, value){
-                should.not.exist(value);
-                context.set("nodeX","foo","bar",function(err){
-                    context.get("nodeX","foo",function(err, value){
-                        value.should.be.String();
-                        value.should.be.equal("bar");
-                        context.set("nodeX","foo","1",function(err){
-                            context.get("nodeX","foo",function(err, value){
-                                value.should.be.String();
-                                value.should.be.equal("1");
-                                done();
-                            });
-                        });
-                    });
-                });
-            });
-        });
-
-        it('should store number',function(done) {
-            context.get("nodeX","foo",function(err, value){
-                should.not.exist(value);
-                context.set("nodeX","foo",1,function(err){
-                    context.get("nodeX","foo",function(err, value){
-                        value.should.be.Number();
-                        value.should.be.equal(1);
-                        done();
-                    });
-                });
-            });
-        });
-
-        it('should store null',function(done) {
-            context.get("nodeX","foo",function(err, value){
-                should.not.exist(value);
-                context.set("nodeX","foo",null,function(err){
-                    context.get("nodeX","foo",function(err, value){
-                        should(value).be.null();
-                        done();
-                    });
-                });
-            });
-        });
-
-        it('should store boolean',function(done) {
-            context.get("nodeX","foo",function(err, value){
-                should.not.exist(value);
-                context.set("nodeX","foo",true,function(err){
-                    context.get("nodeX","foo",function(err, value){
-                        value.should.be.Boolean().and.true();
-                        context.set("nodeX","foo",false,function(err){
-                            context.get("nodeX","foo",function(err, value){
-                                value.should.be.Boolean().and.false();
-                                done();
-                            });
-                        });
-                    });
-                });
-            });
-        });
-
-        it('should store object',function(done) {
-            context.get("nodeX","foo",function(err, value){
-                should.not.exist(value);
-                context.set("nodeX","foo",{obj:"bar"},function(err){
-                    context.get("nodeX","foo",function(err, value){
-                        value.should.be.Object();
-                        value.should.eql({obj:"bar"});
-                        done();
-                    });
-                });
-            });
-        });
-
-        it('should store array',function(done) {
-            context.get("nodeX","foo",function(err, value){
-                should.not.exist(value);
-                context.set("nodeX","foo",["a","b","c"],function(err){
-                    context.get("nodeX","foo",function(err, value){
-                        value.should.be.Array();
-                        value.should.eql(["a","b","c"]);
-                        context.get("nodeX","foo[1]",function(err, value){
-                            value.should.be.String();
-                            value.should.equal("b");
-                            done();
-                        });
-                    });
-                });
-            });
-        });
-
-        it('should store array of arrays',function(done) {
-            context.get("nodeX","foo",function(err, value){
-                should.not.exist(value);
-                context.set("nodeX","foo",[["a","b","c"],[1,2,3,4],[true,false]],function(err){
-                    context.get("nodeX","foo",function(err, value){
-                        value.should.be.Array();
-                        value.should.have.length(3);
-                        value[0].should.have.length(3);
-                        value[1].should.have.length(4);
-                        value[2].should.have.length(2);
-                        context.get("nodeX","foo[1]",function(err, value){
-                            value.should.be.Array();
-                            value.should.have.length(4);
-                            value.should.be.eql([1,2,3,4]);
-                            done();
-                        });
-                    });
-                });
-            });
-        });
-
-        it('should store array of objects',function(done) {
-            context.get("nodeX","foo",function(err, value){
-                should.not.exist(value);
-                context.set("nodeX","foo",[{obj:"bar1"},{obj:"bar2"},{obj:"bar3"}],function(err){
-                    context.get("nodeX","foo",function(err, value){
-                        value.should.be.Array();
-                        value.should.have.length(3);
-                        value[0].should.be.Object();
-                        value[1].should.be.Object();
-                        value[2].should.be.Object();
-                        context.get("nodeX","foo[1]",function(err, value){
-                            value.should.be.Object();
-                            value.should.be.eql({obj:"bar2"});
-                            done();
-                        });
-                    });
-                });
-            });
-        });
-    });
-
-    describe('#keys',function() {
-        it('should enumerate context keys', function(done) {
-            context.keys("nodeX",function(err, value){
-                value.should.be.an.Array();
-                value.should.be.empty();
-                context.set("nodeX","foo","bar",function(err){
-                    context.keys("nodeX",function(err, value){
-                        value.should.have.length(1);
-                        value[0].should.equal("foo");
-                        context.set("nodeX","abc.def","bar",function(err){
-                            context.keys("nodeX",function(err, value){
-                                value.should.have.length(2);
-                                value[1].should.equal("abc");
-                                done();
-                            });
-                        });
-                    });
-                });
-            });
-        });
-
-        it('should enumerate context keys in each scopes', function(done) {
-            context.keys("nodeX",function(err, value){
-                value.should.be.an.Array();
-                value.should.be.empty();
-                context.keys("nodeY",function(err, value){
-                    value.should.be.an.Array();
-                    value.should.be.empty();
-                    context.set("nodeX","foo","bar",function(err){
-                        context.set("nodeY","hoge","piyo",function(err){
-                            context.keys("nodeX",function(err, value){
-                                value.should.have.length(1);
-                                value[0].should.equal("foo");
-                                context.keys("nodeY",function(err, value){
-                                    value.should.have.length(1);
-                                    value[0].should.equal("hoge");
-                                    done();
-                                });
-                            });
-                        });
-                    });
-                });
-            });
-        });
-    });
-
-    describe('#delete',function() {
-        it('should delete context',function(done) {
-            context.get("nodeX","foo",function(err, value){
-                should.not.exist(value);
-                context.get("nodeY","foo",function(err, value){
-                    should.not.exist(value);
-                    context.set("nodeX","foo","testX",function(err){
-                        context.set("nodeY","foo","testY",function(err){
-                            context.get("nodeX","foo",function(err, value){
-                                value.should.be.equal("testX");
-                                context.get("nodeY","foo",function(err, value){
-                                    value.should.be.equal("testY");
-                                    context.delete("nodeX").then(function(){
-                                        context.get("nodeX","foo",function(err, value){
-                                            should.not.exist(value);
-                                            context.get("nodeY","foo",function(err, value){
-                                                value.should.be.equal("testY");
-                                                done();
-                                            });
-                                        });
-                                    }).catch(done);
-                                });
-                            });
-                        });
-                    });
-                });
-            });
-        });
-    });
-
-    describe('#clean',function() {
-        it('should clean unnecessary context',function(done) {
-            context.get("nodeX","foo",function(err, value){
-                should.not.exist(value);
-                context.get("nodeY","foo",function(err, value){
-                    should.not.exist(value);
-                    context.set("nodeX","foo","testX",function(err){
-                        context.set("nodeY","foo","testY",function(err){
-                            context.get("nodeX","foo",function(err, value){
-                                value.should.be.equal("testX");
-                                context.get("nodeY","foo",function(err, value){
-                                    value.should.be.equal("testY");
-                                    context.clean([]).then(function(){
-                                        context.get("nodeX","foo",function(err, value){
-                                            should.not.exist(value);
-                                            context.get("nodeY","foo",function(err, value){
-                                                should.not.exist(value);
-                                                done();
-                                            });
-                                        });
-                                    });
-                                });
-                            });
-                        });
-                    });
-                });
-            });
-        });
-
-        it('should not clean active context',function(done) {
-            context.get("nodeX","foo",function(err, value){
-                should.not.exist(value);
-                context.get("nodeY","foo",function(err, value){
-                    should.not.exist(value);
-                    context.set("nodeX","foo","testX",function(err){
-                        context.set("nodeY","foo","testY",function(err){
-                            context.get("nodeX","foo",function(err, value){
-                                value.should.be.equal("testX");
-                                context.get("nodeY","foo",function(err, value){
-                                    value.should.be.equal("testY");
-                                    context.clean(["nodeX"]).then(function(){
-                                        context.get("nodeX","foo",function(err, value){
-                                            value.should.be.equal("testX");
-                                            context.get("nodeY","foo",function(err, value){
-                                                should.not.exist(value);
-                                                done();
-                                            });
-                                        });
-                                    });
-                                });
-                            });
-                        });
-                    });
-                });
-            });
-        });
-    });
-});

test/red/runtime/nodes/context/memory_spec.js

@@ -1,153 +0,0 @@
-/**
- * Copyright JS Foundation and other contributors, http://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://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.
- **/
-
-var should = require('should');
-var Memory = require('../../../../../red/runtime/nodes/context/memory');
-
-describe('memory',function() {
-    var context;
-
-    beforeEach(function() {
-        context = Memory({});
-        return context.open();
-    });
-
-    afterEach(function() {
-        return context.clean([]).then(function(){
-            return context.close();
-        });
-    });
-
-    describe('#get/set',function() {
-        it('should store property',function() {
-            should.not.exist(context.get("nodeX","foo"));
-            context.set("nodeX","foo","test");
-            context.get("nodeX","foo").should.equal("test");
-        });
-
-        it('should store property - creates parent properties',function() {
-            context.set("nodeX","foo.bar","test");
-            context.get("nodeX","foo").should.eql({bar:"test"});
-        });
-
-        it('should delete property',function() {
-            context.set("nodeX","foo.abc.bar1","test1");
-            context.set("nodeX","foo.abc.bar2","test2");
-            context.get("nodeX","foo.abc").should.eql({bar1:"test1",bar2:"test2"});
-            context.set("nodeX","foo.abc.bar1",undefined);
-            context.get("nodeX","foo.abc").should.eql({bar2:"test2"});
-            context.set("nodeX","foo.abc",undefined);
-            should.not.exist(context.get("nodeX","foo.abc"));
-            context.set("nodeX","foo",undefined);
-            should.not.exist(context.get("nodeX","foo"));
-        });
-
-        it('should not shared context with other scope', function() {
-            should.not.exist(context.get("nodeX","foo"));
-            should.not.exist(context.get("nodeY","foo"));
-            context.set("nodeX","foo","testX");
-            context.set("nodeY","foo","testY");
-
-            context.get("nodeX","foo").should.equal("testX");
-            context.get("nodeY","foo").should.equal("testY");
-        });
-    });
-
-    describe('#keys',function() {
-        it('should enumerate context keys', function() {
-            var keys = context.keys("nodeX");
-            keys.should.be.an.Array();
-            keys.should.be.empty();
-
-            context.set("nodeX","foo","bar");
-            keys = context.keys("nodeX");
-            keys.should.have.length(1);
-            keys[0].should.equal("foo");
-
-            context.set("nodeX","abc.def","bar");
-            keys = context.keys("nodeX");
-            keys.should.have.length(2);
-            keys[1].should.equal("abc");
-        });
-
-        it('should enumerate context keys in each scopes', function() {
-            var keysX = context.keys("nodeX");
-            keysX.should.be.an.Array();
-            keysX.should.be.empty();
-
-            var keysY = context.keys("nodeY");
-            keysY.should.be.an.Array();
-            keysY.should.be.empty();
-
-            context.set("nodeX","foo","bar");
-            context.set("nodeY","hoge","piyo");
-            keysX = context.keys("nodeX");
-            keysX.should.have.length(1);
-            keysX[0].should.equal("foo");
-
-            keysY = context.keys("nodeY");
-            keysY.should.have.length(1);
-            keysY[0].should.equal("hoge");
-        });
-
-    });
-
-    describe('#delete',function() {
-        it('should delete context',function() {
-            should.not.exist(context.get("nodeX","foo"));
-            should.not.exist(context.get("nodeY","foo"));
-            context.set("nodeX","foo","abc");
-            context.set("nodeY","foo","abc");
-            context.get("nodeX","foo").should.equal("abc");
-            context.get("nodeY","foo").should.equal("abc");
-
-            return context.delete("nodeX").then(function(){
-                should.not.exist(context.get("nodeX","foo"));
-                should.exist(context.get("nodeY","foo"));
-            });
-        });
-    });
-
-    describe('#clean',function() {
-        it('should clean unnecessary context',function() {
-            should.not.exist(context.get("nodeX","foo"));
-            should.not.exist(context.get("nodeY","foo"));
-            context.set("nodeX","foo","abc");
-            context.set("nodeY","foo","abc");
-            context.get("nodeX","foo").should.equal("abc");
-            context.get("nodeY","foo").should.equal("abc");
-
-            return context.clean([]).then(function(){
-                should.not.exist(context.get("nodeX","foo"));
-                should.not.exist(context.get("nodeY","foo"));
-            });
-        });
-        it('should not clean active context',function() {
-            should.not.exist(context.get("nodeX","foo"));
-            should.not.exist(context.get("nodeY","foo"));
-            context.set("nodeX","foo","abc");
-            context.set("nodeY","foo","abc");
-            context.get("nodeX","foo").should.equal("abc");
-            context.get("nodeY","foo").should.equal("abc");
-
-            return context.clean(["nodeX"]).then(function(){
-                should.exist(context.get("nodeX","foo"));
-                should.not.exist(context.get("nodeY","foo"));
-            });
-        });
-    });
-
-});

test/resources/file-in-node/test.txt

@@ -0,0 +1 @@
+Text file

test/unit/@node-red/editor-api/lib/admin/context_spec.js

@@ -0,0 +1,237 @@
+/**
+ * Copyright JS Foundation and other contributors, http://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://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.
+ **/
+
+var should = require("should");
+var request = require('supertest');
+var express = require('express');
+var bodyParser = require('body-parser');
+var sinon = require('sinon');
+var when = require('when');
+
+var NR_TEST_UTILS = require("nr-test-utils");
+
+var context = NR_TEST_UTILS.require("@node-red/editor-api/lib/admin/context");
+// var Context = require("../../../../red/runtime/nodes/context");
+// var Util = require("../../../../red/runtime/util");
+
+describe("api/admin/context", function() {
+    it.skip("NEEDS TESTS WRITING",function() {});
+});
+/*
+    var app = undefined;
+
+    before(function (done) {
+        var node_context = undefined;
+        app = express();
+        app.use(bodyParser.json());
+        app.get("/context/:scope(global)", context.get);
+        app.get("/context/:scope(global)/*", context.get);
+        app.get("/context/:scope(node|flow)/:id", context.get);
+        app.get("/context/:scope(node|flow)/:id/*", context.get);
+
+        context.init({
+            settings: {
+            },
+            log:{warn:function(){},_:function(){},audit:function(){}},
+            nodes: {
+                listContextStores: Context.listStores,
+                getContext: Context.get,
+                getNode: function(id) {
+                    if (id === 'NID') {
+                        return {
+                            id: 'NID',
+                            context: function () {
+                                return node_context;
+                            }
+                        };
+                    }
+                    return null;
+                }
+            },
+            util: Util
+        });
+
+        Context.init({
+            contextStorage: {
+                memory0: {
+                    module: "memory"
+                },
+                memory1: {
+                    module: "memory"
+                }
+            }
+        });
+        Context.load().then(function () {
+            var ctx = Context.get("NID", "FID");
+            node_context = ctx;
+            ctx.set("foo", "n_v00", "memory0");
+            ctx.set("bar", "n_v01", "memory0");
+            ctx.set("baz", "n_v10", "memory1");
+            ctx.set("bar", "n_v11", "memory1");
+            ctx.flow.set("foo", "f_v00", "memory0");
+            ctx.flow.set("bar", "f_v01", "memory0");
+            ctx.flow.set("baz", "f_v10", "memory1");
+            ctx.flow.set("bar", "f_v11", "memory1");
+            ctx.global.set("foo", "g_v00", "memory0");
+            ctx.global.set("bar", "g_v01", "memory0");
+            ctx.global.set("baz", "g_v10", "memory1");
+            ctx.global.set("bar", "g_v11", "memory1");
+            done();
+        });
+
+    });
+
+    after(function () {
+        Context.clean({allNodes:{}});
+        Context.close();
+    });
+
+    function check_mem(body, mem, name, val) {
+        var mem0 = body[mem];
+        mem0.should.have.property(name);
+        mem0[name].should.deepEqual(val);
+    }
+
+    function check_scope(scope, prefix, id) {
+        describe('# '+scope, function () {
+            var xid = id ? ("/"+id) : "";
+
+            it('should return '+scope+' contexts', function (done) {
+                request(app)
+                    .get('/context/'+scope+xid)
+                    .set('Accept', 'application/json')
+                    .expect(200)
+                    .end(function (err, res) {
+                        if (err) {
+                            return done(err);
+                        }
+                        var body = res.body;
+                        body.should.have.key('memory0', 'memory1');
+                        check_mem(body, 'memory0',
+                                  'foo', {msg:prefix+'_v00', format:'string[5]'});
+                        check_mem(body, 'memory0',
+                                  'bar', {msg:prefix+'_v01', format:'string[5]'});
+                        check_mem(body, 'memory1',
+                                  'baz', {msg:prefix+'_v10', format:'string[5]'});
+                        check_mem(body, 'memory1',
+                                  'bar', {msg:prefix+'_v11', format:'string[5]'});
+                        done();
+                    });
+            });
+
+            it('should return a value from default '+scope+' context', function (done) {
+                request(app)
+                    .get('/context/'+scope+xid+'/foo')
+                    .set('Accept', 'application/json')
+                    .expect(200)
+                    .end(function (err, res) {
+                        if (err) {
+                            return done(err);
+                        }
+                        var body = res.body;
+                        body.should.deepEqual({msg: prefix+'_v00', format: 'string[5]'});
+                        done();
+                    });
+            });
+
+            it('should return a value from specified '+scope+' context', function (done) {
+                request(app)
+                    .get('/context/'+scope+xid+'/bar?store=memory1')
+                    .set('Accept', 'application/json')
+                    .expect(200)
+                    .end(function (err, res) {
+                        if (err) {
+                            return done(err);
+                        }
+                        var body = res.body;
+                        body.should.deepEqual({msg: prefix+'_v11', format: 'string[5]', store: 'memory1'});
+                        done();
+                    });
+            });
+
+            it('should return specified '+scope+' store', function (done) {
+                request(app)
+                    .get('/context/'+scope+xid+'?store=memory1')
+                    .set('Accept', 'application/json')
+                    .expect(200)
+                    .end(function (err, res) {
+                        if (err) {
+                            return done(err);
+                        }
+                        var body = res.body;
+                        body.should.deepEqual({
+                            memory1: {
+                                baz: { msg: prefix+'_v10', format: 'string[5]' },
+                                bar: { msg: prefix+'_v11', format: 'string[5]' }
+                            }
+                        });
+                        done();
+                    });
+            });
+
+            it('should return undefined for unknown key of default '+scope+' store', function (done) {
+                request(app)
+                    .get('/context/'+scope+xid+'/unknown')
+                    .set('Accept', 'application/json')
+                    .expect(200)
+                    .end(function (err, res) {
+                        if (err) {
+                            return done(err);
+                        }
+                        var body = res.body;
+                        body.should.deepEqual({msg:'(undefined)', format:'undefined'});
+                        done();
+
+                    });
+            });
+
+            it('should cause error for unknown '+scope+' store', function (done) {
+                request(app)
+                    .get('/context/'+scope+xid+'?store=unknown')
+                    .set('Accept', 'application/json')
+                    .expect(200)
+                    .end(function (err, res) {
+                        if (err) {
+                            return done();
+                        }
+                        done("unexpected");
+                    });
+            });
+        });
+    }
+
+    check_scope("global", "g", undefined);
+    check_scope("node", "n", "NID");
+    check_scope("flow", "f", "FID");
+
+    describe("# errors", function () {
+        it('should cause error for unknown scope', function (done) {
+            request(app)
+                .get('/context/scope')
+                .set('Accept', 'application/json')
+                .expect(200)
+                .end(function (err, res) {
+                    if (err) {
+                        return done();
+                    }
+                    done("unexpected");
+                });
+        });
+
+    });
+
+});
+*/

test/unit/@node-red/editor-api/lib/admin/flow_spec.js

@@ -21,7 +21,9 @@ var bodyParser = require('body-parser');
 var sinon = require('sinon');
 var when = require('when');
 
-var flow = require("../../../../red/api/admin/flow");
+var NR_TEST_UTILS = require("nr-test-utils");
+
+var flow = NR_TEST_UTILS.require("@node-red/editor-api/lib/admin/flow");
 
 describe("api/admin/flow", function() {
 
@@ -38,18 +40,23 @@ describe("api/admin/flow", function() {
 
     describe("get", function() {
         before(function() {
+            var opts;
             flow.init({
-                settings:{},
-                nodes: {
-                    getFlow: function(id) {
-                        if (id === '123') {
-                            return {id:'123'}
+                flows: {
+                    getFlow: function(_opts) {
+                        opts = _opts;
+                        if (opts.id === '123') {
+                            return Promise.resolve({id:'123'});
                         } else {
-                            return null;
+                            var err = new Error("message");
+                            err.code = "not_found";
+                            err.status = 404;
+                            var p = Promise.reject(err);
+                            p.catch(()=>{});
+                            return p;
                         }
                     }
-                },
-                log:{ audit: sinon.stub() }
+                }
             });
         })
         it('gets a known flow', function(done) {
@@ -75,19 +82,24 @@ describe("api/admin/flow", function() {
     });
 
     describe("add", function() {
+        var opts;
         before(function() {
             flow.init({
-                settings:{},
-                nodes: {
-                    addFlow: function(f) {
-                        if (f.id === "123") {
-                            return when.resolve('123')
+                flows: {
+                    addFlow: function(_opts) {
+                        opts = _opts;
+                        if (opts.flow.id === "123") {
+                            return Promise.resolve('123')
                         } else {
-                            return when.reject(new Error("test error"));
+                            var err = new Error("random error");
+                            err.code = "random_error";
+                            err.status = 400;
+                            var p = Promise.reject(err);
+                            p.catch(()=>{});
+                            return p;
                         }
                     }
-                },
-                log:{ audit: sinon.stub() }
+                }
             });
         })
         it('adds a new flow', function(done) {
@@ -114,8 +126,8 @@ describe("api/admin/flow", function() {
                     if (err) {
                         return done(err);
                     }
-                    res.body.should.has.a.property('error','unexpected_error');
-                    res.body.should.has.a.property('message','Error: test error');
+                    res.body.should.has.a.property('code','random_error');
+                    res.body.should.has.a.property('message','random error');
 
                     done();
                 });
@@ -123,35 +135,29 @@ describe("api/admin/flow", function() {
     })
 
     describe("update", function() {
-        var nodes;
+
+        var opts;
         before(function() {
-            nodes = {
-                updateFlow: function(id,f) {
-                    var err;
-                    if (id === "123") {
-                        return when.resolve()
-                    } else if (id === "unknown") {
-                        err = new Error();
-                        err.code = 404;
-                        throw err;
-                    } else if (id === "unexpected") {
-                        err = new Error();
-                        err.code = 500;
-                        throw err;
-                    } else {
-                        return when.reject(new Error("test error"));
+            flow.init({
+                flows: {
+                    updateFlow: function(_opts) {
+                        opts = _opts;
+                        if (opts.id === "123") {
+                            return Promise.resolve('123')
+                        } else {
+                            var err = new Error("random error");
+                            err.code = "random_error";
+                            err.status = 400;
+                            var p = Promise.reject(err);
+                            p.catch(()=>{});
+                            return p;
+                        }
                     }
                 }
-            };
-            flow.init({
-                settings:{},
-                nodes: nodes,
-                log:{ audit: sinon.stub() }
             });
         })
 
         it('updates an existing flow', function(done) {
-            sinon.spy(nodes,"updateFlow");
             request(app)
                 .put('/flow/123')
                 .set('Accept', 'application/json')
@@ -162,115 +168,79 @@ describe("api/admin/flow", function() {
                         return done(err);
                     }
                     res.body.should.has.a.property('id','123');
-                    nodes.updateFlow.calledOnce.should.be.true();
-                    nodes.updateFlow.lastCall.args[0].should.eql('123');
-                    nodes.updateFlow.lastCall.args[1].should.eql({id:'123'});
-                    nodes.updateFlow.restore();
+                    opts.should.have.property('id','123');
+                    opts.should.have.property('flow',{id:'123'})
                     done();
                 });
         })
 
-        it('404s on an unknown flow', function(done) {
+        it('400 an invalid flow', function(done) {
             request(app)
-                .put('/flow/unknown')
+                .put('/flow/456')
                 .set('Accept', 'application/json')
-                .send({id:'123'})
-                .expect(404)
-                .end(done);
-        })
-
-        it('400 on async update error', function(done) {
-            request(app)
-                .put('/flow/async_error')
-                .set('Accept', 'application/json')
-                .send({id:'123'})
+                .send({id:'456'})
                 .expect(400)
                 .end(function(err,res) {
                     if (err) {
                         return done(err);
                     }
-                    res.body.should.has.a.property('error','unexpected_error');
-                    res.body.should.has.a.property('message','Error: test error');
-                    done();
-                });
-        })
+                    res.body.should.has.a.property('code','random_error');
+                    res.body.should.has.a.property('message','random error');
 
-        it('400 on sync update error', function(done) {
-            request(app)
-                .put('/flow/unexpected')
-                .set('Accept', 'application/json')
-                .send({id:'123'})
-                .expect(400)
-                .end(function(err,res) {
-                    if (err) {
-                        return done(err);
-                    }
-                    res.body.should.has.a.property('error',500);
-                    res.body.should.has.a.property('message','Error');
                     done();
                 });
         })
     })
 
     describe("delete", function() {
-        var nodes;
+
+        var opts;
         before(function() {
-            nodes = {
-                removeFlow: function(id) {
-                    var err;
-                    if (id === "123") {
-                        return when.resolve()
-                    } else if (id === "unknown") {
-                        err = new Error();
-                        err.code = 404;
-                        throw err;
-                    } else if (id === "unexpected") {
-                        err = new Error();
-                        err.code = 500;
-                        throw err;
+            flow.init({
+                flows: {
+                    deleteFlow: function(_opts) {
+                        opts = _opts;
+                        if (opts.id === "123") {
+                            return Promise.resolve()
+                        } else {
+                            var err = new Error("random error");
+                            err.code = "random_error";
+                            err.status = 400;
+                            var p = Promise.reject(err);
+                            p.catch(()=>{});
+                            return p;
+                        }
                     }
                 }
-            };
-            flow.init({
-                settings:{},
-                nodes: nodes,
-                log:{ audit: sinon.stub() }
             });
         })
 
-        it('updates an existing flow', function(done) {
-            sinon.spy(nodes,"removeFlow");
+        it('deletes an existing flow', function(done) {
             request(app)
-                .delete('/flow/123')
+                .del('/flow/123')
+                .set('Accept', 'application/json')
                 .expect(204)
                 .end(function(err,res) {
                     if (err) {
                         return done(err);
                     }
-                    nodes.removeFlow.calledOnce.should.be.true();
-                    nodes.removeFlow.lastCall.args[0].should.eql('123');
-                    nodes.removeFlow.restore();
+                    opts.should.have.property('id','123');
                     done();
                 });
         })
 
-        it('404s on an unknown flow', function(done) {
+        it('400 an invalid flow', function(done) {
             request(app)
-                .delete('/flow/unknown')
-                .expect(404)
-                .end(done);
-        })
-
-        it('400 on remove error', function(done) {
-            request(app)
-                .delete('/flow/unexpected')
+                .del('/flow/456')
+                .set('Accept', 'application/json')
                 .expect(400)
                 .end(function(err,res) {
                     if (err) {
                         return done(err);
                     }
-                    res.body.should.has.a.property('error',500);
-                    res.body.should.has.a.property('message','Error');
+                    res.body.should.has.a.property('code','random_error');
+                    res.body.should.has.a.property('message','random error');
+
                     done();
                 });
         })

test/unit/@node-red/editor-api/lib/admin/flows_spec.js

@@ -19,9 +19,10 @@ var request = require('supertest');
 var express = require('express');
 var bodyParser = require('body-parser');
 var sinon = require('sinon');
-var when = require('when');
 
-var flows = require("../../../../red/api/admin/flows");
+var NR_TEST_UTILS = require("nr-test-utils");
+
+var flows = NR_TEST_UTILS.require("@node-red/editor-api/lib/admin/flows");
 
 describe("api/admin/flows", function() {
 
@@ -36,10 +37,8 @@ describe("api/admin/flows", function() {
 
     it('returns flow - v1', function(done) {
         flows.init({
-            settings: {},
-            log:{warn:function(){},_:function(){},audit:function(){}},
-            nodes:{
-                getFlows: function() { return {rev:"123",flows:[1,2,3]}; }
+            flows:{
+                getFlows: function() { return Promise.resolve({rev:"123",flows:[1,2,3]}); }
             }
         });
         request(app)
@@ -60,10 +59,8 @@ describe("api/admin/flows", function() {
     });
     it('returns flow - v2', function(done) {
         flows.init({
-            settings: {},
-            log:{warn:function(){},_:function(){},audit:function(){}},
-            nodes:{
-                getFlows: function() { return {rev:"123",flows:[1,2,3]}; }
+            flows:{
+                getFlows: function() { return Promise.resolve({rev:"123",flows:[1,2,3]}); }
             }
         });
         request(app)
@@ -104,10 +101,9 @@ describe("api/admin/flows", function() {
             });
     });
     it('sets flows - default - v1', function(done) {
-        var setFlows = sinon.spy(function() { return when.resolve();});
+        var setFlows = sinon.spy(function() { return Promise.resolve();});
         flows.init({
-            log:{warn:function(){},_:function(){},audit:function(){}},
-            nodes:{
+            flows:{
                 setFlows: setFlows
             }
         });
@@ -120,15 +116,14 @@ describe("api/admin/flows", function() {
                     return done(err);
                 }
                 setFlows.calledOnce.should.be.true();
-                setFlows.lastCall.args[1].should.eql('full');
+                setFlows.lastCall.args[0].should.have.property('deploymentType','full');
                 done();
             });
     });
     it('sets flows - non-default - v1', function(done) {
-        var setFlows = sinon.spy(function() { return when.resolve();});
+        var setFlows = sinon.spy(function() { return Promise.resolve();});
         flows.init({
-            log:{warn:function(){},_:function(){},audit:function(){}},
-            nodes:{
+            flows:{
                 setFlows: setFlows
             }
         });
@@ -142,19 +137,22 @@ describe("api/admin/flows", function() {
                     return done(err);
                 }
                 setFlows.calledOnce.should.be.true();
-                setFlows.lastCall.args[1].should.eql('nodes');
+                setFlows.lastCall.args[0].should.have.property('deploymentType','nodes');
                 done();
             });
     });
 
     it('set flows - rejects mismatched revision - v2', function(done) {
-        var setFlows = sinon.spy(function() { return when.resolve();});
-        var getFlows = sinon.spy(function() { return {rev:123,flows:[1,2,3]}});
         flows.init({
-            log:{warn:function(){},_:function(){},audit:function(){}},
-            nodes:{
-                setFlows: setFlows,
-                getFlows: getFlows
+            flows:{
+                setFlows: function() {
+                    var err = new Error("mismatch");
+                    err.code = "version_mismatch";
+                    err.status = 409;
+                    var p = Promise.reject(err);
+                    p.catch(()=>{});
+                    return p;
+                }
             }
         });
         request(app)
@@ -171,54 +169,6 @@ describe("api/admin/flows", function() {
                 done();
             });
     });
-    it('set flows - rev provided - v2', function(done) {
-        var setFlows = sinon.spy(function() { return when.resolve(456);});
-        var getFlows = sinon.spy(function() { return {rev:123,flows:[1,2,3]}});
-        flows.init({
-            log:{warn:function(){},_:function(){},audit:function(){}},
-            nodes:{
-                setFlows: setFlows,
-                getFlows: getFlows
-            }
-        });
-        request(app)
-            .post('/flows')
-            .set('Accept', 'application/json')
-            .set('Node-RED-API-Version','v2')
-            .send({rev:123,flows:[4,5,6]})
-            .expect(200)
-            .end(function(err,res) {
-                if (err) {
-                    return done(err);
-                }
-                res.body.should.have.property("rev",456);
-                done();
-            });
-    });
-    it('set flows - no rev provided - v2', function(done) {
-        var setFlows = sinon.spy(function() { return when.resolve(456);});
-        var getFlows = sinon.spy(function() { return {rev:123,flows:[1,2,3]}});
-        flows.init({
-            log:{warn:function(){},_:function(){},audit:function(){}},
-            nodes:{
-                setFlows: setFlows,
-                getFlows: getFlows
-            }
-        });
-        request(app)
-            .post('/flows')
-            .set('Accept', 'application/json')
-            .set('Node-RED-API-Version','v2')
-            .send({flows:[4,5,6]})
-            .expect(200)
-            .end(function(err,res) {
-                if (err) {
-                    return done(err);
-                }
-                res.body.should.have.property("rev",456);
-                done();
-            });
-    });
     it('sets flow - bad version', function(done) {
         request(app)
             .post('/flows')
@@ -238,11 +188,10 @@ describe("api/admin/flows", function() {
             });
     });
     it('reloads flows', function(done) {
-        var loadFlows = sinon.spy(function() { return when.resolve(); });
+        var setFlows = sinon.spy(function() { return Promise.resolve();});
         flows.init({
-            log:{warn:function(){},_:function(){},audit:function(){}},
-            nodes:{
-                loadFlows: loadFlows
+            flows:{
+                setFlows: setFlows
             }
         });
         request(app)
@@ -254,29 +203,9 @@ describe("api/admin/flows", function() {
                 if (err) {
                     return done(err);
                 }
-                loadFlows.called.should.be.true();
+                setFlows.called.should.be.true();
+                setFlows.lastCall.args[0].should.not.have.property('flows');
                 done();
             });
     });
-
-    it('returns error when set fails', function(done) {
-        flows.init({
-            log:{warn:function(){},_:function(){},audit:function(){}},
-            nodes:{
-                setFlows: function() { return when.reject(new Error("expected error")); }
-            }
-        });
-        request(app)
-            .post('/flows')
-            .set('Accept', 'application/json')
-            .expect(500)
-            .end(function(err,res) {
-                if (err) {
-                    return done(err);
-                }
-                res.body.should.have.property("message","expected error");
-                done();
-            });
-    });
-
 });

test/unit/@node-red/editor-api/lib/admin/index_spec.js

@@ -18,12 +18,14 @@ var should = require("should");
 var sinon = require("sinon");
 var request = require("supertest");
 var express = require("express");
-var adminApi = require("../../../../red/api/admin");
-var auth = require("../../../../red/api/auth");
 
-var nodes = require("../../../../red/api/admin/nodes");
-var flows = require("../../../../red/api/admin/flows");
-var flow = require("../../../../red/api/admin/flow");
+var NR_TEST_UTILS = require("nr-test-utils");
+
+var adminApi = NR_TEST_UTILS.require("@node-red/editor-api/lib/admin");
+var auth = NR_TEST_UTILS.require("@node-red/editor-api/lib/auth");
+var nodes = NR_TEST_UTILS.require("@node-red/editor-api/lib/admin/nodes");
+var flows = NR_TEST_UTILS.require("@node-red/editor-api/lib/admin/flows");
+var flow = NR_TEST_UTILS.require("@node-red/editor-api/lib/admin/flow");
 
 /**
 * Ensure all API routes are correctly mounted, with the expected permissions checks
@@ -66,7 +68,8 @@ describe("api/admin/index", function() {
             sinon.stub(nodes,"delete",stubApp);
             sinon.stub(nodes,"getSet",stubApp);
             sinon.stub(nodes,"putSet",stubApp);
-
+            sinon.stub(nodes,"getModuleCatalog",stubApp);
+            sinon.stub(nodes,"getModuleCatalogs",stubApp);
         });
         after(function() {
             mockList.forEach(function(m) {
@@ -87,6 +90,8 @@ describe("api/admin/index", function() {
             nodes.delete.restore();
             nodes.getSet.restore();
             nodes.putSet.restore();
+            nodes.getModuleCatalog.restore();
+            nodes.getModuleCatalogs.restore();
 
         });
 
@@ -281,5 +286,36 @@ describe("api/admin/index", function() {
                 done();
             })
         });
+
+        it('GET /nodes/messages', function(done) {
+            request(app).get("/nodes/messages").expect(200).end(function(err,res) {
+                if (err) {
+                    return done(err);
+                }
+                permissionChecks.should.have.property('nodes.read',1);
+
+                done();
+            })
+        });
+        it('GET /nodes/module/set/messages', function(done) {
+            request(app).get("/nodes/module/set/messages").expect(200).end(function(err,res) {
+                if (err) {
+                    return done(err);
+                }
+                permissionChecks.should.have.property('nodes.read',1);
+                lastRequest.params.should.have.property(0,'module/set');
+                done();
+            })
+        });
+        it('GET /nodes/@scope/module/set/messages', function(done) {
+            request(app).get("/nodes/@scope/module/set/messages").expect(200).end(function(err,res) {
+                if (err) {
+                    return done(err);
+                }
+                permissionChecks.should.have.property('nodes.read',1);
+                lastRequest.params.should.have.property(0,'@scope/module/set');
+                done();
+            })
+        });
     });
 });

test/unit/@node-red/editor-api/lib/admin/nodes_spec.js

@@ -0,0 +1,479 @@
+/**
+ * Copyright JS Foundation and other contributors, http://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://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.
+ **/
+
+var should = require("should");
+var request = require('supertest');
+var express = require('express');
+var bodyParser = require('body-parser');
+var sinon = require('sinon');
+var when = require('when');
+
+var NR_TEST_UTILS = require("nr-test-utils");
+
+var nodes = NR_TEST_UTILS.require("@node-red/editor-api/lib/admin/nodes");
+var apiUtil = NR_TEST_UTILS.require("@node-red/editor-api/lib/util");
+
+describe("api/admin/nodes", function() {
+
+    var app;
+    before(function() {
+        app = express();
+        app.use(bodyParser.json());
+        app.get("/nodes",nodes.getAll);
+        app.post("/nodes",nodes.post);
+        app.get(/\/nodes\/messages/,nodes.getModuleCatalogs);
+        app.get(/\/nodes\/((@[^\/]+\/)?[^\/]+\/[^\/]+)\/messages/,nodes.getModuleCatalog);
+        app.get(/\/nodes\/((@[^\/]+\/)?[^\/]+)$/,nodes.getModule);
+        app.put(/\/nodes\/((@[^\/]+\/)?[^\/]+)$/,nodes.putModule);
+        app.get(/\/nodes\/((@[^\/]+\/)?[^\/]+)\/([^\/]+)$/,nodes.getSet);
+        app.put(/\/nodes\/((@[^\/]+\/)?[^\/]+)\/([^\/]+)$/,nodes.putSet);
+        app.get("/getIcons",nodes.getIcons);
+        app.delete(/\/nodes\/((@[^\/]+\/)?[^\/]+)$/,nodes.delete);
+        sinon.stub(apiUtil,"determineLangFromHeaders", function() {
+            return "en-US";
+        });
+    });
+    after(function() {
+        apiUtil.determineLangFromHeaders.restore();
+    })
+
+    describe('get nodes', function() {
+        it('returns node list', function(done) {
+            nodes.init({
+                nodes:{
+                    getNodeList: function() {
+                        return Promise.resolve([1,2,3]);
+                    }
+                }
+            });
+            request(app)
+                .get('/nodes')
+                .set('Accept', 'application/json')
+                .expect(200)
+                .end(function(err,res) {
+                    if (err) {
+                        throw err;
+                    }
+                    res.body.should.be.an.Array();
+                    res.body.should.have.lengthOf(3);
+                    done();
+                });
+        });
+
+        it('returns node configs', function(done) {
+            nodes.init({
+                nodes:{
+                    getNodeConfigs: function() {
+                        return Promise.resolve("<script></script>");
+                    }
+                },
+                i18n: {
+                    determineLangFromHeaders: function(){}
+                }
+            });
+            request(app)
+                .get('/nodes')
+                .set('Accept', 'text/html')
+                .expect(200)
+                .expect("<script></script>")
+                .end(function(err,res) {
+                    if (err) {
+                        throw err;
+                    }
+                    done();
+                });
+        });
+
+        it('returns node module info', function(done) {
+            nodes.init({
+                nodes:{
+                    getModuleInfo: function(opts) {
+                        return Promise.resolve({"node-red":{name:"node-red"}}[opts.module]);
+                    }
+                }
+            });
+            request(app)
+                .get('/nodes/node-red')
+                .expect(200)
+                .end(function(err,res) {
+                    if (err) {
+                        throw err;
+                    }
+                    res.body.should.have.property("name","node-red");
+                    done();
+                });
+        });
+
+        it('returns 404 for unknown module', function(done) {
+            nodes.init({
+                nodes:{
+                    getModuleInfo: function(opts) {
+                        var errInstance = new Error("Not Found");
+                        errInstance.code = "not_found";
+                        errInstance.status = 404;
+                        var p = Promise.reject(errInstance);
+                        p.catch(()=>{});
+                        return p;
+                    }
+                }
+            });
+            request(app)
+                .get('/nodes/node-blue')
+                .expect(404)
+                .end(function(err,res) {
+                    if (err) {
+                        throw err;
+                    }
+                    done();
+                });
+        });
+
+        it('returns individual node info', function(done) {
+            nodes.init({
+                nodes:{
+                    getNodeInfo: function(opts) {
+                        return Promise.resolve({"node-red/123":{id:"node-red/123"}}[opts.id]);
+                    }
+                }
+            });
+            request(app)
+                .get('/nodes/node-red/123')
+                .set('Accept', 'application/json')
+                .expect(200)
+                .end(function(err,res) {
+                    if (err) {
+                        throw err;
+                    }
+                    res.body.should.have.property("id","node-red/123");
+                    done();
+                });
+        });
+
+        it('returns individual node configs', function(done) {
+            nodes.init({
+                nodes:{
+                    getNodeConfig: function(opts) {
+                        return Promise.resolve({"node-red/123":"<script></script>"}[opts.id]);
+                    }
+                },
+                i18n: {
+                    determineLangFromHeaders: function(){}
+                }
+            });
+            request(app)
+                .get('/nodes/node-red/123')
+                .set('Accept', 'text/html')
+                .expect(200)
+                .expect("<script></script>")
+                .end(function(err,res) {
+                    if (err) {
+                        throw err;
+                    }
+                    done();
+                });
+        });
+        it('returns 404 for unknown node', function(done) {
+            nodes.init({
+                nodes:{
+                    getNodeInfo: function(opts) {
+                        var errInstance = new Error("Not Found");
+                        errInstance.code = "not_found";
+                        errInstance.status = 404;
+                        var p = Promise.reject(errInstance);
+                        p.catch(()=>{});
+                        return p;
+                    }
+                }
+            });
+            request(app)
+                .get('/nodes/node-red/456')
+                .set('Accept', 'application/json')
+                .expect(404)
+                .end(function(err,res) {
+                    if (err) {
+                        throw err;
+                    }
+                    done();
+                });
+        });
+    });
+
+    describe('install', function() {
+        it('installs the module and returns module info', function(done) {
+            var opts;
+            nodes.init({
+                nodes:{
+                    addModule: function(_opts) {
+                        opts = _opts;
+                        return Promise.resolve({
+                            name:"foo",
+                            nodes:[{id:"123"}]
+                        });
+                    }
+                }
+            });
+            request(app)
+            .post('/nodes')
+            .send({module: 'foo',version:"1.2.3"})
+            .expect(200)
+            .end(function(err,res) {
+                if (err) {
+                    throw err;
+                }
+                res.body.should.have.property("name","foo");
+                res.body.should.have.property("nodes");
+                res.body.nodes[0].should.have.property("id","123");
+                opts.should.have.property("module","foo");
+                opts.should.have.property("version","1.2.3");
+                done();
+            });
+        });
+        it('returns error', function(done) {
+            nodes.init({
+                nodes:{
+                    addModule: function(opts) {
+                        var errInstance = new Error("Message");
+                        errInstance.code = "random_error";
+                        errInstance.status = 400;
+                        var p = Promise.reject(errInstance);
+                        p.catch(()=>{});
+                        return p;
+                    }
+                }
+            });
+            request(app)
+                .post('/nodes')
+                .send({module: 'foo',version:"1.2.3"})
+                .expect(400)
+                .end(function(err,res) {
+                    if (err) {
+                        throw err;
+                    }
+                    res.body.should.have.a.property('code','random_error');
+                    done();
+                });
+        });
+    });
+    describe('delete', function() {
+        it('uninstalls the module', function(done) {
+            var opts;
+            nodes.init({
+                nodes:{
+                    removeModule: function(_opts) {
+                        opts = _opts;
+                        return Promise.resolve();
+                    }
+                }
+            });
+            request(app)
+            .del('/nodes/123')
+            .expect(204)
+            .end(function(err,res) {
+                if (err) {
+                    throw err;
+                }
+                opts.should.have.property("module","123");
+                done();
+            });
+        });
+        it('returns error', function(done) {
+            nodes.init({
+                nodes:{
+                    removeModule: function(opts) {
+                        var errInstance = new Error("Message");
+                        errInstance.code = "random_error";
+                        errInstance.status = 400;
+                        var p = Promise.reject(errInstance);
+                        p.catch(()=>{});
+                        return p;
+                    }
+                }
+            });
+            request(app)
+                .del('/nodes/123')
+                .expect(400)
+                .end(function(err,res) {
+                    if (err) {
+                        throw err;
+                    }
+                    res.body.should.have.a.property('code','random_error');
+                    done();
+                });
+        });
+    });
+
+    describe('enable/disable node set', function() {
+        it('returns 400 for invalid request payload', function(done) {
+            nodes.init({
+                nodes:{
+                    setNodeSetState: function(opts) {return Promise.resolve()}
+                }
+            });
+            request(app)
+                .put('/nodes/node-red/foo')
+                .send({})
+                .expect(400)
+                .end(function(err,res) {
+                    if (err) {
+                        throw err;
+                    }
+                    res.body.should.have.property("code","invalid_request");
+                    res.body.should.have.property("message","Invalid request");
+                    done();
+                });
+        });
+
+        it('sets node state and returns node info', function(done) {
+            var opts;
+            nodes.init({
+                nodes:{
+                    setNodeSetState: function(_opts) {
+                        opts = _opts;
+                        return Promise.resolve({id:"123",enabled: true });
+                    }
+                }
+            });
+
+            request(app)
+                .put('/nodes/node-red/foo')
+                .send({enabled:true})
+                .expect(200)
+                .end(function(err,res) {
+                    if (err) {
+                        throw err;
+                    }
+                    res.body.should.have.property("id","123");
+                    res.body.should.have.property("enabled",true);
+                    opts.should.have.property("enabled",true);
+                    opts.should.have.property("id","node-red/foo");
+
+                    done();
+                });
+        });
+    });
+    describe('enable/disable module' ,function() {
+        it('returns 400 for invalid request payload', function(done) {
+            nodes.init({
+                nodes:{
+                    setModuleState: function(opts) {return Promise.resolve()}
+                }
+            });
+            request(app)
+                .put('/nodes/node-red')
+                .send({})
+                .expect(400)
+                .end(function(err,res) {
+                    if (err) {
+                        throw err;
+                    }
+                    res.body.should.have.property("code","invalid_request");
+                    res.body.should.have.property("message","Invalid request");
+                    done();
+                });
+        });
+        it('sets module state and returns module info', function(done) {
+            var opts;
+            nodes.init({
+                nodes:{
+                    setModuleState: function(_opts) {
+                        opts = _opts;
+                        return Promise.resolve({name:"node-red"});
+                    }
+                }
+            });
+
+            request(app)
+                .put('/nodes/node-red')
+                .send({enabled:true})
+                .expect(200)
+                .end(function(err,res) {
+                    if (err) {
+                        throw err;
+                    }
+                    res.body.should.have.property("name","node-red");
+                    opts.should.have.property("enabled",true);
+                    opts.should.have.property("module","node-red");
+
+                    done();
+                });
+        });
+    });
+
+    describe('get icons', function() {
+        it('returns icon list', function(done) {
+            nodes.init({
+                nodes:{
+                    getIconList: function() {
+                        return Promise.resolve({module:[1,2,3]});
+                    }
+                }
+            });
+            request(app)
+                .get('/getIcons')
+                .expect(200)
+                .end(function(err,res) {
+                    if (err) {
+                        throw err;
+                    }
+                    res.body.should.have.property("module");
+                    res.body.module.should.be.an.Array();
+                    res.body.module.should.have.lengthOf(3);
+                    done();
+                });
+        });
+    });
+
+    describe('get module messages', function() {
+        it('returns message catalog', function(done) {
+            nodes.init({
+                nodes:{
+                    getModuleCatalog: function(opts) {
+                        return Promise.resolve(opts);
+                    }
+                }
+            });
+            request(app)
+                .get('/nodes/module/set/messages')
+                .expect(200)
+                .end(function(err,res) {
+                    if (err) {
+                        throw err;
+                    }
+                    res.body.should.eql({ module: 'module/set' });
+                    done();
+                });
+        });
+        it('returns all node catalogs', function(done) {
+            nodes.init({
+                nodes:{
+                    getModuleCatalogs: function(opts) {
+                        return Promise.resolve({a:1});
+                    }
+                }
+            });
+            request(app)
+                .get('/nodes/messages')
+                .expect(200)
+                .end(function(err,res) {
+                    if (err) {
+                        throw err;
+                    }
+                    res.body.should.eql({a:1});
+                    done();
+                });
+        });
+    })
+});

test/unit/@node-red/editor-api/lib/auth/clients_spec.js

@@ -15,7 +15,8 @@
  **/
 
 var should = require("should");
-var Clients = require("../../../../red/api/auth/clients");
+var NR_TEST_UTILS = require("nr-test-utils");
+var Clients = NR_TEST_UTILS.require("@node-red/editor-api/lib/auth/clients");
 
 describe("api/auth/clients", function() {
     it('finds the known editor client',function(done) {

test/unit/@node-red/editor-api/lib/auth/index_spec.js

@@ -0,0 +1,217 @@
+/**
+ * Copyright JS Foundation and other contributors, http://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://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.
+ **/
+
+var should = require("should");
+var when = require("when");
+var sinon = require("sinon");
+
+var passport = require("passport");
+
+var NR_TEST_UTILS = require("nr-test-utils");
+
+var auth = NR_TEST_UTILS.require("@node-red/editor-api/lib/auth");
+var Users = NR_TEST_UTILS.require("@node-red/editor-api/lib/auth/users");
+var Tokens = NR_TEST_UTILS.require("@node-red/editor-api/lib/auth/tokens");
+var Permissions = NR_TEST_UTILS.require("@node-red/editor-api/lib/auth/permissions");
+
+describe("api/auth/index",function() {
+
+
+
+    describe("ensureClientSecret", function() {
+        before(function() {
+            auth.init({},{})
+        });
+        it("leaves client_secret alone if not present",function(done) {
+            var req = {
+                body: {
+                    client_secret: "test_value"
+                }
+            };
+            auth.ensureClientSecret(req,null,function() {
+                req.body.should.have.a.property("client_secret","test_value");
+                done();
+            })
+        });
+        it("applies a default client_secret if not present",function(done) {
+            var req = {
+                body: { }
+            };
+            auth.ensureClientSecret(req,null,function() {
+                req.body.should.have.a.property("client_secret","not_available");
+                done();
+            })
+        });
+    });
+
+    describe("revoke", function() {
+        it("revokes a token", function(done) {
+            var revokeToken = sinon.stub(Tokens,"revoke",function() {
+                return when.resolve();
+            });
+
+            var req = { body: { token: "abcdef" } };
+
+            var res = { status: function(resp) {
+                revokeToken.restore();
+
+                resp.should.equal(200);
+                return {
+                    end: done
+                }
+            }};
+
+            auth.revoke(req,res);
+        });
+    });
+
+    describe("login", function() {
+        beforeEach(function() {
+            sinon.stub(Tokens,"init",function(){});
+            sinon.stub(Users,"init",function(){});
+        });
+        afterEach(function() {
+            Tokens.init.restore();
+            Users.init.restore();
+        });
+        it("returns login details - credentials", function(done) {
+            auth.init({adminAuth:{type:"credentials"}},{})
+            auth.login(null,{json: function(resp) {
+                resp.should.have.a.property("type","credentials");
+                resp.should.have.a.property("prompts");
+                resp.prompts.should.have.a.lengthOf(2);
+                done();
+            }});
+        });
+        it("returns login details - none", function(done) {
+            auth.init({},{})
+            auth.login(null,{json: function(resp) {
+                resp.should.eql({});
+                done();
+            }});
+        });
+        it("returns login details - strategy", function(done) {
+            auth.init({adminAuth:{type:"strategy",strategy:{label:"test-strategy",icon:"test-icon"}}},{})
+            auth.login(null,{json: function(resp) {
+                resp.should.have.a.property("type","strategy");
+                resp.should.have.a.property("prompts");
+                resp.prompts.should.have.a.lengthOf(1);
+                resp.prompts[0].should.have.a.property("type","button");
+                resp.prompts[0].should.have.a.property("label","test-strategy");
+                resp.prompts[0].should.have.a.property("icon","test-icon");
+
+                done();
+            }});
+        });
+
+    });
+    describe("needsPermission", function() {
+        beforeEach(function() {
+            sinon.stub(Tokens,"init",function(){});
+            sinon.stub(Users,"init",function(){});
+        });
+        afterEach(function() {
+            Tokens.init.restore();
+            Users.init.restore();
+            if (passport.authenticate.restore) {
+                passport.authenticate.restore();
+            }
+            if (Permissions.hasPermission.restore) {
+                Permissions.hasPermission.restore();
+            }
+        });
+
+
+        it('no-ops if adminAuth not set', function(done) {
+            sinon.stub(passport,"authenticate",function(scopes,opts) {
+                return function(req,res,next) {
+                }
+            });
+            auth.init({});
+            var func = auth.needsPermission("foo");
+            func({},{},function() {
+                passport.authenticate.called.should.be.false();
+                done();
+            })
+        });
+        it('skips auth if req.user undefined', function(done) {
+            sinon.stub(passport,"authenticate",function(scopes,opts) {
+                return function(req,res,next) {
+                    next();
+                }
+            });
+            sinon.stub(Permissions,"hasPermission",function(perm) { return true });
+            auth.init({adminAuth:{}});
+            var func = auth.needsPermission("foo");
+            func({user:null},{},function() {
+                try {
+                    passport.authenticate.called.should.be.true();
+                    Permissions.hasPermission.called.should.be.false();
+                    done();
+                } catch(err) {
+                    done(err);
+                }
+            })
+        });
+
+        it('passes for valid user permission', function(done) {
+            sinon.stub(passport,"authenticate",function(scopes,opts) {
+                return function(req,res,next) {
+                    next();
+                }
+            });
+            sinon.stub(Permissions,"hasPermission",function(perm) { return true });
+            auth.init({adminAuth:{}});
+            var func = auth.needsPermission("foo");
+            func({user:true,authInfo: { scope: "read"}},{},function() {
+                try {
+                    passport.authenticate.called.should.be.true();
+                    Permissions.hasPermission.called.should.be.true();
+                    Permissions.hasPermission.lastCall.args[0].should.eql("read");
+                    Permissions.hasPermission.lastCall.args[1].should.eql("foo");
+                    done();
+                } catch(err) {
+                    done(err);
+                }
+            })
+        });
+
+        it('rejects for invalid user permission', function(done) {
+            sinon.stub(passport,"authenticate",function(scopes,opts) {
+                return function(req,res,next) {
+                    next();
+                }
+            });
+            sinon.stub(Permissions,"hasPermission",function(perm) { return false });
+            auth.init({adminAuth:{}});
+            var func = auth.needsPermission("foo");
+            func({user:true,authInfo: { scope: "read"}},{
+                status: function(status) {
+                    return { end: function() {
+                        try {
+                            status.should.eql(401);
+                            done();
+                        } catch(err) {
+                            done(err);
+                        }
+                    }}
+                }
+            },function() {
+                done(new Error("hasPermission unexpected passed"))
+            });
+        });
+    });
+});

test/unit/@node-red/editor-api/lib/auth/permissions_spec.js

@@ -15,7 +15,10 @@
  **/
 
 var should = require("should");
-var permissions = require("../../../../red/api/auth/permissions");
+
+var NR_TEST_UTILS = require("nr-test-utils");
+
+var permissions = NR_TEST_UTILS.require("@node-red/editor-api/lib/auth/permissions");
 
 describe("api/auth/permissions", function() {
     describe("hasPermission", function() {

test/unit/@node-red/editor-api/lib/auth/strategies_spec.js

@@ -18,15 +18,14 @@ var should = require("should");
 var when = require('when');
 var sinon = require('sinon');
 
-var strategies = require("../../../../red/api/auth/strategies");
-var Users = require("../../../../red/api/auth/users");
-var Tokens = require("../../../../red/api/auth/tokens");
-var Clients = require("../../../../red/api/auth/clients");
+var NR_TEST_UTILS = require("nr-test-utils");
+
+var strategies = NR_TEST_UTILS.require("@node-red/editor-api/lib/auth/strategies");
+var Users = NR_TEST_UTILS.require("@node-red/editor-api/lib/auth/users");
+var Tokens = NR_TEST_UTILS.require("@node-red/editor-api/lib/auth/tokens");
+var Clients = NR_TEST_UTILS.require("@node-red/editor-api/lib/auth/clients");
 
 describe("api/auth/strategies", function() {
-    before(function() {
-        strategies.init({log:{audit:function(){}}})
-    });
     describe("Password Token Exchange", function() {
         var userAuthentication;
         afterEach(function() {
@@ -108,7 +107,6 @@ describe("api/auth/strategies", function() {
                 user.should.equal("anon");
                 strategies.anonymousStrategy.success = strategies.anonymousStrategy._success;
                 delete strategies.anonymousStrategy._success;
-                userDefault.restore();
                 done();
             };
             strategies.anonymousStrategy.authenticate({});
@@ -122,11 +120,13 @@ describe("api/auth/strategies", function() {
                 err.should.equal(401);
                 strategies.anonymousStrategy.fail = strategies.anonymousStrategy._fail;
                 delete strategies.anonymousStrategy._fail;
-                userDefault.restore();
                 done();
             };
             strategies.anonymousStrategy.authenticate({});
         });
+        afterEach(function() {
+            Users.default.restore();
+        })
     });
 
     describe("Bearer Strategy", function() {

test/unit/@node-red/editor-api/lib/auth/tokens_spec.js

@@ -18,7 +18,9 @@ var should = require("should");
 var when = require("when");
 var sinon = require("sinon");
 
-var Tokens = require("../../../../red/api/auth/tokens");
+var NR_TEST_UTILS = require("nr-test-utils");
+
+var Tokens = NR_TEST_UTILS.require("@node-red/editor-api/lib/auth/tokens");
 
 
 describe("api/auth/tokens", function() {

test/unit/@node-red/editor-api/lib/auth/users_spec.js

@@ -18,9 +18,14 @@ var should = require("should");
 var when = require('when');
 var sinon = require('sinon');
 
-var Users = require("../../../../red/api/auth/users");
+var NR_TEST_UTILS = require("nr-test-utils");
+
+var Users = NR_TEST_UTILS.require("@node-red/editor-api/lib/auth/users");
 
 describe("api/auth/users", function() {
+    after(function() {
+        Users.init({});
+    })
     describe('Initalised with a credentials object, no anon',function() {
         before(function() {
             Users.init({

test/unit/@node-red/editor-api/lib/editor/comms_spec.js

@@ -24,15 +24,35 @@ var express = require('express');
 var app = express();
 var WebSocket = require('ws');
 
-var comms = require("../../../../red/api/editor/comms");
-var Users = require("../../../../red/api/auth/users");
-var Tokens = require("../../../../red/api/auth/tokens");
+var NR_TEST_UTILS = require("nr-test-utils");
+
+var comms = NR_TEST_UTILS.require("@node-red/editor-api/lib/editor/comms");
+var Users = NR_TEST_UTILS.require("@node-red/editor-api/lib/auth/users");
+var Tokens = NR_TEST_UTILS.require("@node-red/editor-api/lib/auth/tokens");
 
 var address = '127.0.0.1';
 var listenPort = 0; // use ephemeral port
 
 
 describe("api/editor/comms", function() {
+    var connections = [];
+    var mockComms = {
+        addConnection: function(opts) {
+            connections.push(opts.client);
+            return Promise.resolve()
+        },
+        removeConnection: function(opts) {
+            for (var i=0;i<connections.length;i++) {
+                if (connections[i] === opts.client) {
+                    connections.splice(i,1);
+                    break;
+                }
+            }
+            return Promise.resolve()
+        },
+        subscribe: function() { return Promise.resolve()},
+        unsubscribe: function() { return Promise.resolve(); }
+    }
 
     describe("with default keepalive", function() {
         var server;
@@ -41,11 +61,7 @@ describe("api/editor/comms", function() {
         before(function(done) {
             sinon.stub(Users,"default",function() { return when.resolve(null);});
             server = stoppable(http.createServer(function(req,res){app(req,res)}));
-            comms.init(server, {
-                settings:{},
-                log:{warn:function(){},_:function(){},trace:function(){},audit:function(){}},
-                events:{on:function(){},removeListener:function(){}}
-            });
+            comms.init(server, {}, {comms: mockComms});
             server.listen(listenPort, address);
             server.on('listening', function() {
                 port = server.address().port;
@@ -63,9 +79,15 @@ describe("api/editor/comms", function() {
 
         it('accepts connection', function(done) {
             var ws = new WebSocket(url);
+            connections.length.should.eql(0);
             ws.on('open', function() {
-                ws.close();
-                done();
+                try {
+                    connections.length.should.eql(1);
+                    ws.close();
+                    done();
+                } catch(err) {
+                    done(err);
+                }
             });
         });
 
@@ -73,7 +95,8 @@ describe("api/editor/comms", function() {
             var ws = new WebSocket(url);
             ws.on('open', function() {
                 ws.send('{"subscribe":"topic1"}');
-                comms.publish('topic1', 'foo');
+                connections.length.should.eql(1);
+                connections[0].send('topic1', 'foo');
             });
             ws.on('message', function(msg) {
                 msg.should.equal('[{"topic":"topic1","data":"foo"}]');
@@ -82,43 +105,13 @@ describe("api/editor/comms", function() {
             });
         });
 
-        it('publishes retained message for subscription', function(done) {
-            comms.publish('topic2', 'bar', true);
-            var ws = new WebSocket(url);
-            ws.on('open', function() {
-                ws.send('{"subscribe":"topic2"}');
-            });
-            ws.on('message', function(msg) {
-                console.log(msg);
-                msg.should.equal('[{"topic":"topic2","data":"bar"}]');
-                ws.close();
-                done();
-            });
-        });
-
-        it('retained message is deleted by non-retained message', function(done) {
-            comms.publish('topic3', 'retained', true);
-            comms.publish('topic3', 'non-retained');
-            var ws = new WebSocket(url);
-            ws.on('open', function() {
-                ws.send('{"subscribe":"topic3"}');
-                comms.publish('topic3', 'new');
-            });
-            ws.on('message', function(msg) {
-                console.log(msg);
-                msg.should.equal('[{"topic":"topic3","data":"new"}]');
-                ws.close();
-                done();
-            });
-        });
-
         it('malformed messages are ignored',function(done) {
             var ws = new WebSocket(url);
             ws.on('open', function() {
                 ws.send('not json');
                 ws.send('[]');
                 ws.send('{"subscribe":"topic3"}');
-                comms.publish('topic3', 'correct');
+                connections[0].send('topic3', 'correct');
             });
             ws.on('message', function(msg) {
                 console.log(msg);
@@ -127,40 +120,16 @@ describe("api/editor/comms", function() {
                 done();
             });
         });
-
-        // The following test currently fails due to minimum viable
-        // implementation. More test should be written to test topic
-        // matching once this one is passing
-
-        it.skip('receives message on correct topic', function(done) {
-            var ws = new WebSocket(url);
-            ws.on('open', function() {
-                ws.send('{"subscribe":"topic4"}');
-                comms.publish('topic5', 'foo');
-                comms.publish('topic4', 'bar');
-            });
-            ws.on('message', function(msg) {
-                console.log(msg);
-                msg.should.equal('[{"topic":"topic4","data":"bar"}]');
-                ws.close();
-                done();
-            });
-        });
-
-        it('listens for node/status events');
     });
+
     describe("disabled editor", function() {
         var server;
         var url;
         var port;
         before(function(done) {
-            sinon.stub(Users,"default",function() { return when.resolve(null);});
+            sinon.stub(Users,"default",function() { return Promise.resolve(null);});
             server = stoppable(http.createServer(function(req,res){app(req,res)}));
-            comms.init(server, {
-                settings:{disableEditor:true},
-                log:{warn:function(){},_:function(){},trace:function(){},audit:function(){}},
-                events:{on:function(){},removeListener:function(){}}
-            });
+            comms.init(server, {disableEditor:true}, {comms: mockComms});
             server.listen(listenPort, address);
             server.on('listening', function() {
                 port = server.address().port;
@@ -177,12 +146,14 @@ describe("api/editor/comms", function() {
         });
 
         it('rejects websocket connections',function(done) {
+            connections.length.should.eql(0);
             var ws = new WebSocket(url);
             ws.on('open', function() {
                  done(new Error("Socket connection unexpectedly accepted"));
                  ws.close();
             });
             ws.on('error', function() {
+                connections.length.should.eql(0);
                 done();
             });
 
@@ -196,11 +167,7 @@ describe("api/editor/comms", function() {
         before(function(done) {
             sinon.stub(Users,"default",function() { return when.resolve(null);});
             server = stoppable(http.createServer(function(req,res){app(req,res)}));
-            comms.init(server, {
-                settings:{httpAdminRoot:"/adminPath"},
-                log:{warn:function(){},_:function(){},trace:function(){},audit:function(){}},
-                events:{on:function(){},removeListener:function(){}}
-            });
+            comms.init(server, {httpAdminRoot:"/adminPath"}, {comms: mockComms});
             server.listen(listenPort, address);
             server.on('listening', function() {
                 port = server.address().port;
@@ -217,8 +184,10 @@ describe("api/editor/comms", function() {
         });
 
         it('accepts connections',function(done) {
+            connections.length.should.eql(0);
             var ws = new WebSocket(url);
             ws.on('open', function() {
+                connections.length.should.eql(1);
                  ws.close();
                  done();
             });
@@ -236,11 +205,7 @@ describe("api/editor/comms", function() {
         before(function(done) {
             sinon.stub(Users,"default",function() { return when.resolve(null);});
             server = stoppable(http.createServer(function(req,res){app(req,res)}));
-            comms.init(server,{
-                settings:{httpAdminRoot:"/adminPath"},
-                log:{warn:function(){},_:function(){},trace:function(){},audit:function(){}},
-                events:{on:function(){},removeListener:function(){}}
-            });
+            comms.init(server, {httpAdminRoot:"/adminPath/"}, {comms: mockComms});
             server.listen(listenPort, address);
             server.on('listening', function() {
                 port = server.address().port;
@@ -257,8 +222,10 @@ describe("api/editor/comms", function() {
         });
 
         it('accepts connections',function(done) {
+            connections.length.should.eql(0);
             var ws = new WebSocket(url);
             ws.on('open', function() {
+                connections.length.should.eql(1);
                  ws.close();
                  done();
             });
@@ -276,11 +243,7 @@ describe("api/editor/comms", function() {
         before(function(done) {
             sinon.stub(Users,"default",function() { return when.resolve(null);});
             server = stoppable(http.createServer(function(req,res){app(req,res)}));
-            comms.init(server, {
-                settings:{httpAdminRoot:"adminPath"},
-                log:{warn:function(){},_:function(){},trace:function(){},audit:function(){}},
-                events:{on:function(){},removeListener:function(){}}
-            });
+            comms.init(server, {httpAdminRoot:"adminPath"}, {comms: mockComms});
             server.listen(listenPort, address);
             server.on('listening', function() {
                 port = server.address().port;
@@ -297,8 +260,10 @@ describe("api/editor/comms", function() {
         });
 
         it('accepts connections',function(done) {
+            connections.length.should.eql(0);
             var ws = new WebSocket(url);
             ws.on('open', function() {
+                connections.length.should.eql(1);
                  ws.close();
                  done();
             });
@@ -316,11 +281,7 @@ describe("api/editor/comms", function() {
         before(function(done) {
             sinon.stub(Users,"default",function() { return when.resolve(null);});
             server = stoppable(http.createServer(function(req,res){app(req,res)}));
-            comms.init(server, {
-                settings:{webSocketKeepAliveTime: 100},
-                log:{warn:function(){},_:function(){},trace:function(){},audit:function(){}},
-                events:{on:function(){},removeListener:function(){}}
-            });
+            comms.init(server, {webSocketKeepAliveTime: 100}, {comms: mockComms});
             server.listen(listenPort, address);
             server.on('listening', function() {
                 port = server.address().port;
@@ -355,7 +316,7 @@ describe("api/editor/comms", function() {
             ws.on('open', function() {
                 ws.send('{"subscribe":"foo"}');
                 interval = setInterval(function() {
-                    comms.publish('foo', 'bar');
+                    connections[0].send('foo', 'bar');
                 }, 50);
             });
             ws.on('message', function(data) {
@@ -403,11 +364,7 @@ describe("api/editor/comms", function() {
 
 
             server = stoppable(http.createServer(function(req,res){app(req,res)}));
-            comms.init(server,{
-                settings:{adminAuth:{}},
-                log:{warn:function(){},_:function(){},trace:function(){},audit:function(){}},
-                events:{on:function(){},removeListener:function(){}}
-            });
+            comms.init(server, {adminAuth:{}}, {comms: mockComms});
             server.listen(listenPort, address);
             server.on('listening', function() {
                 port = server.address().port;
@@ -447,7 +404,7 @@ describe("api/editor/comms", function() {
                 if (received == 1) {
                     msg.should.equal('{"auth":"ok"}');
                     ws.send('{"subscribe":"foo"}');
-                    comms.publish('foo', 'correct');
+                    connections[0].send('foo', 'correct');
                 } else {
                     msg.should.equal('[{"topic":"foo","data":"correct"}]');
                     ws.close();
@@ -494,11 +451,7 @@ describe("api/editor/comms", function() {
         before(function(done) {
             getDefaultUser = sinon.stub(Users,"default",function() { return when.resolve({permissions:"read"});});
             server = stoppable(http.createServer(function(req,res){app(req,res)}));
-            comms.init(server, {
-                settings:{adminAuth:{}},
-                log:{warn:function(){},_:function(){},trace:function(){},audit:function(){}},
-                events:{on:function(){},removeListener:function(){}}
-            });
+            comms.init(server, {adminAuth:{}}, {comms: mockComms});
             server.listen(listenPort, address);
             server.on('listening', function() {
                 port = server.address().port;
@@ -520,7 +473,7 @@ describe("api/editor/comms", function() {
             ws.on('open', function() {
                 ws.send('{"subscribe":"foo"}');
                 setTimeout(function() {
-                    comms.publish('foo', 'correct');
+                    connections[0].send('foo', 'correct');
                 },200);
             });
             ws.on('message', function(msg) {

test/unit/@node-red/editor-api/lib/editor/credentials_spec.js

@@ -20,7 +20,9 @@ var express = require('express');
 var sinon = require('sinon');
 var when = require('when');
 
-var credentials = require("../../../../red/api/editor/credentials");
+var NR_TEST_UTILS = require("nr-test-utils");
+
+var credentials = NR_TEST_UTILS.require("@node-red/editor-api/lib/editor/credentials");
 
 describe('api/editor/credentials', function() {
     var app;
@@ -29,64 +31,30 @@ describe('api/editor/credentials', function() {
         app = express();
         app.get('/credentials/:type/:id',credentials.get);
         credentials.init({
-            log:{audit:function(){}},
-            nodes:{
-                getCredentials: function(id) {
-                    if (id === "n1") {
-                        return {user1:"abc",password1:"123"};
+            flows: {
+                getNodeCredentials: function(opts) {
+                    if (opts.type === "known-type" && opts.id === "n1") {
+                        return Promise.resolve({
+                            user1:"abc",
+                            has_password1: true
+                        });
                     } else {
-                        return null;
-                    }
-                },
-                getCredentialDefinition:function(type) {
-                    if (type === "known-type") {
-                        return {user1:{type:"text"},password1:{type:"password"}};
-                    } else {
-                        return null;
+                        var err = new Error("message");
+                        err.code = "test_code";
+                        var p = Promise.reject(err);
+                        p.catch(()=>{});
+                        return p;
                     }
                 }
             }
         });
     });
-    it('returns empty credentials if unknown type',function(done) {
-        request(app)
-            .get("/credentials/unknown-type/n1")
-            .expect(200)
-            .expect("Content-Type",/json/)
-            .end(function(err,res) {
-                if (err) {
-                    done(err);
-                } else {
-                    try {
-                        res.body.should.eql({});
-                        done();
-                    } catch(e) {
-                        done(e);
-                    }
-                }
-            })
-    });
-    it('returns empty credentials if none are stored',function(done) {
-        request(app)
-            .get("/credentials/known-type/n2")
-            .expect("Content-Type",/json/)
-            .end(function(err,res) {
-                if (err) {
-                    done(err);
-                } else {
-                    try {
-                        res.body.should.eql({});
-                        done();
-                    } catch(e) {
-                        done(e);
-                    }
-                }
-            })
-    });
+
     it('returns stored credentials',function(done) {
         request(app)
             .get("/credentials/known-type/n1")
             .expect("Content-Type",/json/)
+            .expect(200)
             .end(function(err,res) {
                 if (err) {
                     done(err);
@@ -102,5 +70,26 @@ describe('api/editor/credentials', function() {
                 }
             })
     });
+    it('returns any error',function(done) {
+        request(app)
+            .get("/credentials/unknown-type/n2")
+            .expect("Content-Type",/json/)
+            .expect(500)
+            .end(function(err,res) {
+                if (err) {
+                    done(err);
+                } else {
+                    try {
+                        res.body.should.have.property('code');
+                        res.body.code.should.be.equal("test_code");
+                        res.body.should.have.property('message');
+                        res.body.message.should.be.equal('message');
+                        done();
+                    } catch(e) {
+                        done(e);
+                    }
+                }
+            })
+    });
 
 });

test/unit/@node-red/editor-api/lib/editor/index_spec.js

@@ -18,10 +18,17 @@ var should = require("should");
 var sinon = require("sinon");
 var request = require("supertest");
 var express = require("express");
-var editorApi = require("../../../../red/api/editor");
-var comms = require("../../../../red/api/editor/comms");
-var info = require("../../../../red/api/editor/settings");
-var auth = require("../../../../red/api/auth");
+
+var NR_TEST_UTILS = require("nr-test-utils");
+
+var editorApi = NR_TEST_UTILS.require("@node-red/editor-api/lib/editor");
+var comms = NR_TEST_UTILS.require("@node-red/editor-api/lib/editor/comms");
+var info = NR_TEST_UTILS.require("@node-red/editor-api/lib/editor/settings");
+var auth = NR_TEST_UTILS.require("@node-red/editor-api/lib/auth");
+
+var log = NR_TEST_UTILS.require("@node-red/util").log;
+
+
 var when = require("when");
 
 
@@ -37,9 +44,7 @@ describe("api/editor/index", function() {
             info.init.restore();
         });
         it("disables the editor", function() {
-            var editorApp = editorApi.init({},{
-                settings:{disableEditor:true}
-            });
+            var editorApp = editorApi.init({},{disableEditor:true},{});
             should.not.exist(editorApp);
             comms.init.called.should.be.false();
             info.init.called.should.be.false();
@@ -57,25 +62,23 @@ describe("api/editor/index", function() {
                 return function(req,res,next) { next(); }
             });
             mockList.forEach(function(m) {
-                sinon.stub(require("../../../../red/api/editor/"+m),"init",function(){});
+                sinon.stub(NR_TEST_UTILS.require("@node-red/editor-api/lib/editor/"+m),"init",function(){});
             });
-            sinon.stub(require("../../../../red/api/editor/theme"),"app",function(){ return express()});
+            sinon.stub(NR_TEST_UTILS.require("@node-red/editor-api/lib/editor/theme"),"app",function(){ return express()});
         });
         after(function() {
             mockList.forEach(function(m) {
-                require("../../../../red/api/editor/"+m).init.restore();
+                NR_TEST_UTILS.require("@node-red/editor-api/lib/editor/"+m).init.restore();
             })
-            require("../../../../red/api/editor/theme").app.restore();
+            NR_TEST_UTILS.require("@node-red/editor-api/lib/editor/theme").app.restore();
             auth.needsPermission.restore();
+            log.error.restore();
         });
 
         before(function() {
-            app = editorApi.init({},{
-                log:{audit:function(){},error:function(msg){errors.push(msg)}},
-                settings:{httpNodeRoot:true, httpAdminRoot: true,disableEditor:false,exportNodeSettings:function(){}},
-                events:{on:function(){},removeListener:function(){}},
-                isStarted: function() { return isStarted; },
-                nodes: {paletteEditorEnabled: function() { return false }}
+            sinon.stub(log,"error",function(err) { errors.push(err)})
+            app = editorApi.init({},{httpNodeRoot:true, httpAdminRoot: true,disableEditor:false,exportNodeSettings:function(){}},{
+                isStarted: () => Promise.resolve(isStarted)
             });
         });
         it('serves the editor', function(done) {
@@ -93,9 +96,12 @@ describe("api/editor/index", function() {
         });
         it('serves icons', function(done) {
             request(app)
-            .get("/icons/inject.png")
+            .get("/red/images/icons/node-changed.png")
+            .expect(200)
             .expect("Content-Type", /image\/png/)
-            .expect(200,done)
+            .end(function(err,res) {
+                done(err);
+            });
         });
         it('handles page not there', function(done) {
             request(app)
@@ -117,7 +123,7 @@ describe("api/editor/index", function() {
                 done();
             });
         });
-        // it('GET /settings', function(done) {
+        // it.skip('GET /settings', function(done) {
         //     request(app).get("/settings").expect(200).end(function(err,res) {
         //         if (err) {
         //             return done(err);

test/unit/@node-red/editor-api/lib/editor/library_spec.js

@@ -0,0 +1,304 @@
+/**
+ * Copyright JS Foundation and other contributors, http://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://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.
+ **/
+
+var should = require("should");
+var sinon = require("sinon");
+var request = require('supertest');
+var express = require('express');
+var bodyParser = require('body-parser');
+
+var NR_TEST_UTILS = require("nr-test-utils");
+
+var library = NR_TEST_UTILS.require("@node-red/editor-api/lib/editor/library");
+
+var app;
+
+describe("api/editor/library", function() {
+
+    before(function() {
+        app = express();
+        app.use(bodyParser.json());
+
+        app.get("/library/flows",library.getAll);
+        app.post(/library\/([^\/]+)\/(.*)/,library.saveEntry);
+        app.get(/library\/([^\/]+)(?:$|\/(.*))/,library.getEntry);
+    });
+    after(function() {
+    });
+    it('returns all flows', function(done) {
+        library.init({
+            library: {
+                getEntries: function(opts) {
+                    return Promise.resolve({a:1,b:2});
+                }
+            }
+        });
+        request(app)
+            .get('/library/flows')
+            .expect(200)
+            .end(function(err,res) {
+                if (err) {
+                    return done(err);
+                }
+                res.body.should.have.property('a',1);
+                res.body.should.have.property('b',2);
+                done();
+            });
+    })
+    it('returns an error on all flows', function(done) {
+        library.init({
+            library: {
+                getEntries: function(opts) {
+                    var err = new Error("message");
+                    err.code = "random_error";
+                    err.status = 400;
+                    var p = Promise.reject(err);
+                    p.catch(()=>{});
+                    return p;
+                }
+            }
+        });
+        request(app)
+            .get('/library/flows')
+            .expect(400)
+            .end(function(err,res) {
+                if (err) {
+                    return done(err);
+                }
+                res.body.should.have.property('code');
+                res.body.code.should.be.equal("random_error");
+                res.body.should.have.property('message');
+                res.body.message.should.be.equal("message");
+                done();
+            });
+    });
+
+    it('returns an individual entry - flow type', function(done) {
+        var opts;
+        library.init({
+            library: {
+                getEntry: function(_opts) {
+                    opts = _opts;
+                    return Promise.resolve('{"a":1,"b":2}');
+                }
+            }
+        });
+        request(app)
+            .get('/library/flows/abc')
+            .expect(200)
+            .end(function(err,res) {
+                if (err) {
+                    return done(err);
+                }
+                res.body.should.have.property('a',1);
+                res.body.should.have.property('b',2);
+                opts.should.have.property('type','flows');
+                opts.should.have.property('path','abc');
+                done();
+            });
+    })
+    it('returns a directory listing - flow type', function(done) {
+        var opts;
+        library.init({
+            library: {
+                getEntry: function(_opts) {
+                    opts = _opts;
+                    return Promise.resolve({"a":1,"b":2});
+                }
+            }
+        });
+        request(app)
+            .get('/library/flows/abc/def')
+            .expect(200)
+            .end(function(err,res) {
+                if (err) {
+                    return done(err);
+                }
+                res.body.should.have.property('a',1);
+                res.body.should.have.property('b',2);
+                opts.should.have.property('type','flows');
+                opts.should.have.property('path','abc/def');
+                done();
+            });
+    })
+    it('returns an individual entry - non-flow type', function(done) {
+        var opts;
+        library.init({
+            library: {
+                getEntry: function(_opts) {
+                    opts = _opts;
+                    return Promise.resolve('{"a":1,"b":2}');
+                }
+            }
+        });
+        request(app)
+            .get('/library/non-flow/abc')
+            .expect(200)
+            .end(function(err,res) {
+                if (err) {
+                    return done(err);
+                }
+                opts.should.have.property('type','non-flow');
+                opts.should.have.property('path','abc');
+                res.text.should.eql('{"a":1,"b":2}');
+                done();
+            });
+    })
+    it('returns a directory listing - non-flow type', function(done) {
+        var opts;
+        library.init({
+            library: {
+                getEntry: function(_opts) {
+                    opts = _opts;
+                    return Promise.resolve({"a":1,"b":2});
+                }
+            }
+        });
+        request(app)
+            .get('/library/non-flow/abc/def')
+            .expect(200)
+            .end(function(err,res) {
+                if (err) {
+                    return done(err);
+                }
+                res.body.should.have.property('a',1);
+                res.body.should.have.property('b',2);
+                opts.should.have.property('type','non-flow');
+                opts.should.have.property('path','abc/def');
+                done();
+            });
+    })
+
+    it('returns an error on individual get', function(done) {
+        var opts;
+        library.init({
+            library: {
+                getEntry: function(_opts) {
+                    opts = _opts;
+                    var err = new Error("message");
+                    err.code = "random_error";
+                    err.status = 400;
+                    var p = Promise.reject(err);
+                    p.catch(()=>{});
+                    return p;
+                }
+            }
+        });
+        request(app)
+            .get('/library/flows/123')
+            .expect(400)
+            .end(function(err,res) {
+                if (err) {
+                    return done(err);
+                }
+                opts.should.have.property('type','flows');
+                opts.should.have.property('path','123');
+
+                res.body.should.have.property('code');
+                res.body.code.should.be.equal("random_error");
+                res.body.should.have.property('message');
+                res.body.message.should.be.equal("message");
+                done();
+            });
+    });
+
+
+    it('saves an individual entry - flow type', function(done) {
+        var opts;
+        library.init({
+            library: {
+                saveEntry: function(_opts) {
+                    opts = _opts;
+                    return Promise.resolve();
+                }
+            }
+        });
+        request(app)
+            .post('/library/flows/abc/def')
+            .expect(204)
+            .send({a:1,b:2,c:3})
+            .end(function(err,res) {
+                if (err) {
+                    return done(err);
+                }
+                opts.should.have.property('type','flows');
+                opts.should.have.property('path','abc/def');
+                opts.should.have.property('meta',{});
+                opts.should.have.property('body',JSON.stringify({a:1,b:2,c:3}));
+                done();
+            });
+    })
+
+    it('saves an individual entry - non-flow type', function(done) {
+        var opts;
+        library.init({
+            library: {
+                saveEntry: function(_opts) {
+                    opts = _opts;
+                    return Promise.resolve();
+                }
+            }
+        });
+        request(app)
+            .post('/library/non-flow/abc/def')
+            .expect(204)
+            .send({a:1,b:2,text:"123"})
+            .end(function(err,res) {
+                if (err) {
+                    return done(err);
+                }
+                opts.should.have.property('type','non-flow');
+                opts.should.have.property('path','abc/def');
+                opts.should.have.property('meta',{a:1,b:2});
+                opts.should.have.property('body',"123");
+                done();
+            });
+    })
+
+    it('returns an error on individual save', function(done) {
+        var opts;
+        library.init({
+            library: {
+                saveEntry: function(_opts) {
+                    opts = _opts;
+                    var err = new Error("message");
+                    err.code = "random_error";
+                    err.status = 400;
+                    var p = Promise.reject(err);
+                    p.catch(()=>{});
+                    return p;
+                }
+            }
+        });
+        request(app)
+            .post('/library/non-flow/abc/def')
+            .send({a:1,b:2,text:"123"})
+            .expect(400)
+            .end(function(err,res) {
+                if (err) {
+                    return done(err);
+                }
+                opts.should.have.property('type','non-flow');
+                opts.should.have.property('path','abc/def');
+
+                res.body.should.have.property('code');
+                res.body.code.should.be.equal("random_error");
+                res.body.should.have.property('message');
+                res.body.message.should.be.equal("message");
+                done();
+            });
+    });
+});

test/unit/@node-red/editor-api/lib/editor/locales_spec.js

@@ -0,0 +1,165 @@
+/**
+ * Copyright JS Foundation and other contributors, http://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://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.
+ **/
+
+var should = require("should");
+var request = require('supertest');
+var express = require('express');
+var sinon = require('sinon');
+
+var NR_TEST_UTILS = require("nr-test-utils");
+
+var locales = NR_TEST_UTILS.require("@node-red/editor-api/lib/editor/locales");
+var i18n = NR_TEST_UTILS.require("@node-red/util").i18n;
+
+describe("api/editor/locales", function() {
+    beforeEach(function() {
+    })
+    afterEach(function() {
+    })
+    describe('get named resource catalog',function() {
+        var app;
+        before(function() {
+            // locales.init({
+            //     i18n: {
+            //         i: {
+            //             language: function() { return 'en-US'},
+            //             changeLanguage: function(lang,callback) {
+            //                 if (callback) {
+            //                     callback();
+            //                 }
+            //             },
+            //             getResourceBundle: function(lang, namespace) {
+            //                 return {namespace:namespace, lang:lang};
+            //             }
+            //         },
+            //     }
+            // });
+            locales.init({});
+
+            // bit of a mess of internal workings
+            sinon.stub(i18n.i,'changeLanguage',function(lang,callback) { if (callback) {callback();}});
+            if (i18n.i.getResourceBundle) {
+                sinon.stub(i18n.i,'getResourceBundle',function(lang, namespace) {return {namespace:namespace, lang:lang};});
+            } else {
+                // If i18n.init has not been called, then getResourceBundle isn't
+                // defined - so hardcode a stub
+                i18n.i.getResourceBundle = function(lang, namespace) {return {namespace:namespace, lang:lang};};
+                i18n.i.getResourceBundle.restore = function() { delete i18n.i.getResourceBundle };
+            }
+            app = express();
+            app.get(/locales\/(.+)\/?$/,locales.get);
+        });
+        after(function() {
+            i18n.i.changeLanguage.restore();
+            i18n.i.getResourceBundle.restore();
+        })
+        it('returns with default language', function(done) {
+            request(app)
+                .get("/locales/message-catalog")
+                .expect(200)
+                .end(function(err,res) {
+                    if (err) {
+                        return done(err);
+                    }
+                    res.body.should.have.property('namespace','message-catalog');
+                    done();
+                });
+        });
+        it('returns with selected language', function(done) {
+            request(app)
+                .get("/locales/message-catalog?lng=fr-FR")
+                .expect(200)
+                .end(function(err,res) {
+                    if (err) {
+                        return done(err);
+                    }
+                    res.body.should.have.property('namespace','message-catalog');
+                    res.body.should.have.property('lang','fr-FR');
+                    done();
+                });
+        });
+
+        it('returns for locale defined only with primary tag ', function(done) {
+            var orig = i18n.i.getResourceBundle;
+            i18n.i.getResourceBundle = function (lang, ns) {
+                if (lang === "ja-JP") {
+                    return undefined;
+                }
+                return orig(lang, ns);
+            };
+            request(app)
+                 // returns `ja` instead of `ja-JP`
+                .get("/locales/message-catalog?lng=ja-JP")
+                .expect(200)
+                .end(function(err,res) {
+                    i18n.i.getResourceBundle = orig;
+                    if (err) {
+                        return done(err);
+                    }
+                    res.body.should.have.property('namespace','message-catalog');
+                    res.body.should.have.property('lang','ja');
+                    done();
+                });
+        });
+
+    });
+
+    // describe('get all node resource catalogs',function() {
+    //     var app;
+    //     before(function() {
+    //         // bit of a mess of internal workings
+    //         sinon.stub(i18n,'catalog',function(namespace, lang) {
+    //                     return {
+    //                         "node-red": "should not return",
+    //                         "test-module-a-id": "test-module-a-catalog",
+    //                         "test-module-b-id": "test-module-b-catalog",
+    //                         "test-module-c-id": "test-module-c-catalog"
+    //                     }[namespace]
+    //                 });
+    //         locales.init({
+    //             nodes: {
+    //                 getNodeList: function(opts) {
+    //                     return Promise.resolve([
+    //                         {module:"node-red",id:"node-red-id"},
+    //                         {module:"test-module-a",id:"test-module-a-id"},
+    //                         {module:"test-module-b",id:"test-module-b-id"}
+    //                     ]);
+    //                 }
+    //             }
+    //         });
+    //         app = express();
+    //         app.get("/locales/nodes",locales.getAllNodes);
+    //     });
+    //     after(function() {
+    //         i18n.catalog.restore();
+    //     })
+    //     it('returns with the node catalogs', function(done) {
+    //         request(app)
+    //             .get("/locales/nodes")
+    //             .expect(200)
+    //             .end(function(err,res) {
+    //                 if (err) {
+    //                     return done(err);
+    //                 }
+    //                 res.body.should.eql({
+    //                     'test-module-a-id': 'test-module-a-catalog',
+    //                     'test-module-b-id': 'test-module-b-catalog'
+    //                 });
+    //                 done();
+    //             });
+    //     });
+    // });
+});

test/unit/@node-red/editor-api/lib/editor/projects_spec.js

@@ -14,6 +14,8 @@
  * limitations under the License.
  **/
 
+var NR_TEST_UTILS = require("nr-test-utils");
+
 describe("api/editor/projects", function() {
     it.skip("NEEDS TESTS WRITING",function() {});
 });

test/unit/@node-red/editor-api/lib/editor/settings_spec.js

@@ -0,0 +1,122 @@
+/**
+ * Copyright JS Foundation and other contributors, http://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://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.
+ **/
+
+var should = require("should");
+var request = require('supertest');
+var express = require('express');
+var bodyParser = require("body-parser");
+var sinon = require('sinon');
+
+var app;
+
+var NR_TEST_UTILS = require("nr-test-utils");
+
+var info = NR_TEST_UTILS.require("@node-red/editor-api/lib/editor/settings");
+var theme = NR_TEST_UTILS.require("@node-red/editor-api/lib/editor/theme");
+
+describe("api/editor/settings", function() {
+    before(function() {
+        sinon.stub(theme,"settings",function() { return { test: 456 };});
+        app = express();
+        app.use(bodyParser.json());
+        app.get("/settings",info.runtimeSettings);
+        app.get("/settings/user",function(req,res,next) {req.user = "fred"; next()}, info.userSettings);
+        app.post("/settings/user",function(req,res,next) {req.user = "fred"; next()},info.updateUserSettings);
+    });
+
+    after(function() {
+        theme.settings.restore();
+    });
+
+    it('returns the runtime settings', function(done) {
+        info.init({
+            settings: {
+                getRuntimeSettings: function(opts) {
+                    return Promise.resolve({
+                        a:1,
+                        b:2
+                    })
+                }
+            }
+        });
+        request(app)
+        .get("/settings")
+        .expect(200)
+        .end(function(err,res) {
+            if (err) {
+                return done(err);
+            }
+            res.body.should.have.property("a",1);
+            res.body.should.have.property("b",2);
+            res.body.should.have.property("editorTheme",{test:456});
+            done();
+        });
+    });
+    it('returns the user settings', function(done) {
+        info.init({
+            settings: {
+                getUserSettings: function(opts) {
+                    if (opts.user !== "fred") {
+                        return Promise.reject(new Error("Unknown user"));
+                    }
+                    return Promise.resolve({
+                        c:3,
+                        d:4
+                    })
+                }
+            }
+        });
+        request(app)
+        .get("/settings/user")
+        .expect(200)
+        .end(function(err,res) {
+            if (err) {
+                return done(err);
+            }
+            res.body.should.eql({c:3,d:4});
+            done();
+        });
+    });
+    it('updates the user settings', function(done) {
+        var update;
+        info.init({
+            settings: {
+                updateUserSettings: function(opts) {
+                    if (opts.user !== "fred") {
+                        return Promise.reject(new Error("Unknown user"));
+                    }
+                    update = opts.settings;
+                    return Promise.resolve()
+                }
+            }
+        });
+        request(app)
+        .post("/settings/user")
+        .send({
+            e:4,
+            f:5
+        })
+        .expect(204)
+        .end(function(err,res) {
+            if (err) {
+                return done(err);
+            }
+            update.should.eql({e:4,f:5});
+            done();
+        });
+    });
+
+});

test/unit/@node-red/editor-api/lib/editor/sshkeys_spec.js

@@ -18,83 +18,43 @@ var should = require("should");
 var sinon = require("sinon");
 var request = require("supertest");
 var express = require("express");
-var editorApi = require("../../../../red/api/editor");
-var comms = require("../../../../red/api/editor/comms");
-var info = require("../../../../red/api/editor/settings");
-var auth = require("../../../../red/api/auth");
-var sshkeys = require("../../../../red/api/editor/sshkeys");
-var when = require("when");
+var NR_TEST_UTILS = require("nr-test-utils");
+var sshkeys = NR_TEST_UTILS.require("@node-red/editor-api/lib/editor/sshkeys");
 var bodyParser = require("body-parser");
-var fs = require("fs-extra");
-var fspath = require("path");
 
 
 describe("api/editor/sshkeys", function() {
     var app;
-    var mockList = [
-        'library','theme','locales','credentials','comms'
-    ]
-    var isStarted = true;
-    var errors = [];
-    var session_data = {};
-
     var mockRuntime = {
-        settings:{
-            httpNodeRoot: true,
-            httpAdminRoot: true,
-            disableEditor: false,
-            exportNodeSettings:function(){},
-            storage: {
-                getSessions: function(){
-                    return when.resolve(session_data);
-                },
-                setSessions: function(_session) {
-                    session_data = _session;
-                    return when.resolve();
-                }
-            }
-        },
-        log:{audit:function(){},error:function(msg){errors.push(msg)},trace:function(){}},
-        storage: {
-            projects: {
-                ssh: {
-                    init: function(){},
-                    listSSHKeys: function(){},
-                    getSSHKey: function(){},
-                    generateSSHKey: function(){},
-                    deleteSSHKey: function(){}
-                }
-            }
-        },
-        events:{on:function(){},removeListener:function(){}},
-        isStarted: function() { return isStarted; },
-        nodes: {paletteEditorEnabled: function() { return false }}
-    };
-
+        settings: {
+            getUserKeys: function() {},
+            getUserKey: function() {},
+            generateUserKey: function() {},
+            removeUserKey: function() {}
+        }
+    }
     before(function() {
-        auth.init(mockRuntime);
+        sshkeys.init(mockRuntime);
         app = express();
         app.use(bodyParser.json());
-        app.use(editorApi.init({},mockRuntime));
+        app.use("/settings/user/keys", sshkeys.app());
     });
-    after(function() {
-    })
 
     beforeEach(function() {
-        sinon.stub(mockRuntime.storage.projects.ssh, "listSSHKeys");
-        sinon.stub(mockRuntime.storage.projects.ssh, "getSSHKey");
-        sinon.stub(mockRuntime.storage.projects.ssh, "generateSSHKey");
-        sinon.stub(mockRuntime.storage.projects.ssh, "deleteSSHKey");
+        sinon.stub(mockRuntime.settings, "getUserKeys");
+        sinon.stub(mockRuntime.settings, "getUserKey");
+        sinon.stub(mockRuntime.settings, "generateUserKey");
+        sinon.stub(mockRuntime.settings, "removeUserKey");
     })
     afterEach(function() {
-        mockRuntime.storage.projects.ssh.listSSHKeys.restore();
-        mockRuntime.storage.projects.ssh.getSSHKey.restore();
-        mockRuntime.storage.projects.ssh.generateSSHKey.restore();
-        mockRuntime.storage.projects.ssh.deleteSSHKey.restore();
+        mockRuntime.settings.getUserKeys.restore();
+        mockRuntime.settings.getUserKey.restore();
+        mockRuntime.settings.generateUserKey.restore();
+        mockRuntime.settings.removeUserKey.restore();
     })
 
     it('GET /settings/user/keys --- return empty list', function(done) {
-        mockRuntime.storage.projects.ssh.listSSHKeys.returns(Promise.resolve([]));
+        mockRuntime.settings.getUserKeys.returns(Promise.resolve([]));
         request(app)
         .get("/settings/user/keys")
         .expect(200)
@@ -118,7 +78,7 @@ describe("api/editor/sshkeys", function() {
                 name: elem
             };
         });
-        mockRuntime.storage.projects.ssh.listSSHKeys.returns(Promise.resolve(retList));
+        mockRuntime.settings.getUserKeys.returns(Promise.resolve(retList));
         request(app)
         .get("/settings/user/keys")
         .expect(200)
@@ -139,16 +99,16 @@ describe("api/editor/sshkeys", function() {
         errInstance.code = "test_code";
         var p = Promise.reject(errInstance);
         p.catch(()=>{});
-        mockRuntime.storage.projects.ssh.listSSHKeys.returns(p);
+        mockRuntime.settings.getUserKeys.returns(p);
         request(app)
         .get("/settings/user/keys")
-        .expect(400)
+        .expect(500)
         .end(function(err,res) {
             if (err) {
                 return done(err);
             }
-            res.body.should.have.property('error');
-            res.body.error.should.be.equal(errInstance.code);
+            res.body.should.have.property('code');
+            res.body.code.should.be.equal(errInstance.code);
             res.body.should.have.property('message');
             res.body.message.should.be.equal(errInstance.message);
             done();
@@ -156,7 +116,12 @@ describe("api/editor/sshkeys", function() {
     });
 
     it('GET /settings/user/keys/<key_file_name> --- return 404', function(done) {
-        mockRuntime.storage.projects.ssh.getSSHKey.returns(Promise.resolve(null));
+        var errInstance = new Error("Not Found.");
+        errInstance.code = "not_found";
+        errInstance.status = 404;
+        var p = Promise.reject(errInstance);
+        p.catch(()=>{});
+        mockRuntime.settings.getUserKey.returns(p);
         request(app)
         .get("/settings/user/keys/NOT_REAL")
         .expect(404)
@@ -168,19 +133,19 @@ describe("api/editor/sshkeys", function() {
         });
     });
     it('GET /settings/user/keys --- return Unexpected Error', function(done) {
-        var errInstance = new Error("Messages.....");
+        var errInstance = new Error();
         var p = Promise.reject(errInstance);
         p.catch(()=>{});
-        mockRuntime.storage.projects.ssh.listSSHKeys.returns(p);
+        mockRuntime.settings.getUserKeys.returns(p)
         request(app)
         .get("/settings/user/keys")
-        .expect(400)
+        .expect(500)
         .end(function(err,res) {
             if (err) {
                 return done(err);
             }
-            res.body.should.have.property('error');
-            res.body.error.should.be.equal("unexpected_error");
+            res.body.should.have.property('code');
+            res.body.code.should.be.equal("unexpected_error");
             res.body.should.have.property('message');
             res.body.message.should.be.equal(errInstance.toString());
             done();
@@ -190,7 +155,7 @@ describe("api/editor/sshkeys", function() {
     it('GET /settings/user/keys/<key_file_name> --- return content', function(done) {
         var key_file_name = "test_key";
         var fileContent = "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQD3a+sgtgzSbbliWxmOq5p6+H/mE+0gjWfLWrkIVmHENd1mifV4uCmIHAR2NfuadUYMQ3+bQ90kpmmEKTMYPsyentsKpHQZxTzG7wOCAIpJnbPTHDMxEJhVTaAwEjbVyMSIzTTPfnhoavWIBu0+uMgKDDlBm+RjlgkFlyhXyCN6UwFrIUUMH6Gw+eQHLiooKIl8ce7uDxIlt+9b7hFCU+sQ3kvuse239DZluu6+8buMWqJvrEHgzS9adRFKku8nSPAEPYn85vDi7OgVAcLQufknNgs47KHBAx9h04LeSrFJ/P5J1b//ItRpMOIme+O9d1BR46puzhvUaCHLdvO9czj+OmW+dIm+QIk6lZIOOMnppG72kZxtLfeKT16ur+2FbwAdL9ItBp4BI/YTlBPoa5mLMxpuWfmX1qHntvtGc9wEwS1P7YFfmF3XiK5apxalzrn0Qlr5UmDNbVIqJb1OlbC0w03Z0oktti1xT+R2DGOLWM4lBbpXDHV1BhQ7oYOvbUD8Cnof55lTP0WHHsOHlQc/BGDti1XA9aBX/OzVyzBUYEf0pkimsD0RYo6aqt7QwehJYdlz9x1NBguBffT0s4NhNb9IWr+ASnFPvNl2sw4XH/8U0J0q8ZkMpKkbLM1Zdp1Fv00GF0f5UNRokai6uM3w/ccantJ3WvZ6GtctqytWrw== \n";
-        mockRuntime.storage.projects.ssh.getSSHKey.returns(Promise.resolve(fileContent));
+        mockRuntime.settings.getUserKey.returns(Promise.resolve(fileContent));
         request(app)
         .get("/settings/user/keys/" + key_file_name)
         .expect(200)
@@ -198,7 +163,8 @@ describe("api/editor/sshkeys", function() {
             if (err) {
                 return done(err);
             }
-            mockRuntime.storage.projects.ssh.getSSHKey.called.should.be.true();
+            mockRuntime.settings.getUserKey.called.should.be.true();
+            mockRuntime.settings.getUserKey.firstCall.args[0].should.eql({ user: undefined, id: 'test_key' });
             res.body.should.be.deepEqual({ publickey: fileContent });
             done();
         });
@@ -210,16 +176,16 @@ describe("api/editor/sshkeys", function() {
         errInstance.code = "test_code";
         var p = Promise.reject(errInstance);
         p.catch(()=>{});
-        mockRuntime.storage.projects.ssh.getSSHKey.returns(p);
+        mockRuntime.settings.getUserKey.returns(p);
         request(app)
         .get("/settings/user/keys/" + key_file_name)
-        .expect(400)
+        .expect(500)
         .end(function(err,res) {
             if (err) {
                 return done(err);
             }
-            res.body.should.have.property('error');
-            res.body.error.should.be.equal(errInstance.code);
+            res.body.should.have.property('code');
+            res.body.code.should.be.equal(errInstance.code);
             res.body.should.have.property('message');
             res.body.message.should.be.equal(errInstance.message);
             done();
@@ -231,25 +197,25 @@ describe("api/editor/sshkeys", function() {
         var errInstance = new Error("Messages.....");
         var p = Promise.reject(errInstance);
         p.catch(()=>{});
-        mockRuntime.storage.projects.ssh.getSSHKey.returns(p);
+        mockRuntime.settings.getUserKey.returns(p);
         request(app)
         .get("/settings/user/keys/" + key_file_name)
-        .expect(400)
+        .expect(500)
         .end(function(err,res) {
             if (err) {
                 return done(err);
             }
-            res.body.should.have.property('error');
-            res.body.error.should.be.equal("unexpected_error");
+            res.body.should.have.property('code');
+            res.body.code.should.be.equal("unexpected_error");
             res.body.should.have.property('message');
-            res.body.message.should.be.equal(errInstance.toString());
+            res.body.message.should.be.equal("Messages.....");
             done();
         });
     });
 
     it('POST /settings/user/keys --- success', function(done) {
         var key_file_name = "test_key";
-        mockRuntime.storage.projects.ssh.generateSSHKey.returns(Promise.resolve(key_file_name));
+        mockRuntime.settings.generateUserKey.returns(Promise.resolve(key_file_name));
         request(app)
         .post("/settings/user/keys")
         .send({ name: key_file_name })
@@ -262,41 +228,23 @@ describe("api/editor/sshkeys", function() {
         });
     });
 
-    it('POST /settings/user/keys --- return parameter error', function(done) {
-        var key_file_name = "test_key";
-        mockRuntime.storage.projects.ssh.generateSSHKey.returns(Promise.resolve(key_file_name));
-        request(app)
-        .post("/settings/user/keys")
-        .expect(400)
-        .end(function(err,res) {
-            if (err) {
-                return done(err);
-            }
-            res.body.should.have.property('error');
-            res.body.error.should.be.equal("unexpected_error");
-            res.body.should.have.property('message');
-            res.body.message.should.be.equal("You need to have body or body.name");
-            done();
-        });
-    });
-
     it('POST /settings/user/keys --- return Error', function(done) {
         var key_file_name = "test_key";
         var errInstance = new Error("Messages.....");
         errInstance.code = "test_code";
         var p = Promise.reject(errInstance);
         p.catch(()=>{});
-        mockRuntime.storage.projects.ssh.generateSSHKey.returns(p);
+        mockRuntime.settings.generateUserKey.returns(p);
         request(app)
         .post("/settings/user/keys")
         .send({ name: key_file_name })
-        .expect(400)
+        .expect(500)
         .end(function(err,res) {
             if (err) {
                 return done(err);
             }
-            res.body.should.have.property('error');
-            res.body.error.should.be.equal("test_code");
+            res.body.should.have.property('code');
+            res.body.code.should.be.equal("test_code");
             res.body.should.have.property('message');
             res.body.message.should.be.equal(errInstance.message);
             done();
@@ -308,26 +256,26 @@ describe("api/editor/sshkeys", function() {
         var errInstance = new Error("Messages.....");
         var p = Promise.reject(errInstance);
         p.catch(()=>{});
-        mockRuntime.storage.projects.ssh.generateSSHKey.returns(p);
+        mockRuntime.settings.generateUserKey.returns(p);
         request(app)
         .post("/settings/user/keys")
         .send({ name: key_file_name })
-        .expect(400)
+        .expect(500)
         .end(function(err,res) {
             if (err) {
                 return done(err);
             }
-            res.body.should.have.property('error');
-            res.body.error.should.be.equal("unexpected_error");
+            res.body.should.have.property('code');
+            res.body.code.should.be.equal("unexpected_error");
             res.body.should.have.property('message');
-            res.body.message.should.be.equal(errInstance.toString());
+            res.body.message.should.be.equal("Messages.....");
             done();
         });
     });
 
     it('DELETE /settings/user/keys/<key_file_name> --- success', function(done) {
         var key_file_name = "test_key";
-        mockRuntime.storage.projects.ssh.deleteSSHKey.returns(Promise.resolve(true));
+        mockRuntime.settings.removeUserKey.returns(Promise.resolve(true));
         request(app)
         .delete("/settings/user/keys/" + key_file_name)
         .expect(204)
@@ -346,16 +294,16 @@ describe("api/editor/sshkeys", function() {
         errInstance.code = "test_code";
         var p = Promise.reject(errInstance);
         p.catch(()=>{});
-        mockRuntime.storage.projects.ssh.deleteSSHKey.returns(p);
+        mockRuntime.settings.removeUserKey.returns(p);
         request(app)
         .delete("/settings/user/keys/" + key_file_name)
-        .expect(400)
+        .expect(500)
         .end(function(err,res) {
             if (err) {
                 return done(err);
             }
-            res.body.should.have.property('error');
-            res.body.error.should.be.equal("test_code");
+            res.body.should.have.property('code');
+            res.body.code.should.be.equal("test_code");
             res.body.should.have.property('message');
             res.body.message.should.be.equal(errInstance.message);
             done();
@@ -367,18 +315,18 @@ describe("api/editor/sshkeys", function() {
         var errInstance = new Error("Messages.....");
         var p = Promise.reject(errInstance);
         p.catch(()=>{});
-        mockRuntime.storage.projects.ssh.deleteSSHKey.returns(p);
+        mockRuntime.settings.removeUserKey.returns(p);
         request(app)
         .delete("/settings/user/keys/" + key_file_name)
-        .expect(400)
+        .expect(500)
         .end(function(err,res) {
             if (err) {
                 return done(err);
             }
-            res.body.should.have.property('error');
-            res.body.error.should.be.equal("unexpected_error");
+            res.body.should.have.property('code');
+            res.body.code.should.be.equal("unexpected_error");
             res.body.should.have.property('message');
-            res.body.message.should.be.equal(errInstance.toString());
+            res.body.message.should.be.equal('Messages.....');
             done();
         });
     });

test/unit/@node-red/editor-api/lib/editor/theme_spec.js

@@ -0,0 +1,146 @@
+/**
+ * Copyright JS Foundation and other contributors, http://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://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.
+ **/
+
+var should = require("should");
+var express = require('express');
+var sinon = require('sinon');
+var when = require('when');
+var fs = require("fs");
+
+var app = express();
+
+var NR_TEST_UTILS = require("nr-test-utils");
+
+var theme = NR_TEST_UTILS.require("@node-red/editor-api/lib/editor/theme");
+
+describe("api/editor/theme", function () {
+    beforeEach(function () {
+        sinon.stub(fs, "statSync", function () { return true; });
+    });
+    afterEach(function () {
+        theme.init({settings: {}});
+        fs.statSync.restore();
+    });
+    it("applies the default theme", function () {
+        var result = theme.init({});
+        should.not.exist(result);
+
+        var context = theme.context();
+        context.should.have.a.property("page");
+        context.page.should.have.a.property("title", "Node-RED");
+        context.page.should.have.a.property("favicon", "favicon.ico");
+        context.page.should.have.a.property("tabicon", "red/images/node-red-icon-black.svg");
+        context.should.have.a.property("header");
+        context.header.should.have.a.property("title", "Node-RED");
+        context.header.should.have.a.property("image", "red/images/node-red.png");
+        context.should.have.a.property("asset");
+        context.asset.should.have.a.property("red", "red/red.min.js");
+        context.asset.should.have.a.property("main", "red/main.min.js");
+
+        should.not.exist(theme.settings());
+    });
+
+    it("picks up custom theme", function () {
+        theme.init({
+            editorTheme: {
+                page: {
+                    title: "Test Page Title",
+                    favicon: "/absolute/path/to/theme/favicon",
+                    tabicon: "/absolute/path/to/theme/tabicon",
+                    css: "/absolute/path/to/custom/css/file.css",
+                    scripts: "/absolute/path/to/script.js"
+                },
+                header: {
+                    title: "Test Header Title",
+                    url: "http://nodered.org",
+                    image: "/absolute/path/to/header/image" // or null to remove image
+                },
+
+                deployButton: {
+                    type: "simple",
+                    label: "Save",
+                    icon: "/absolute/path/to/deploy/button/image" // or null to remove image
+                },
+
+                menu: { // Hide unwanted menu items by id. see editor/js/main.js:loadEditor for complete list
+                    "menu-item-import-library": false,
+                    "menu-item-export-library": false,
+                    "menu-item-keyboard-shortcuts": false,
+                    "menu-item-help": {
+                        label: "Alternative Help Link Text",
+                        url: "http://example.com"
+                    }
+                },
+
+                userMenu: false, // Hide the user-menu even if adminAuth is enabled
+
+                login: {
+                    image: "/absolute/path/to/login/page/big/image" // a 256x256 image
+                },
+
+                palette: {
+                    editable: true,
+                    catalogues: ['https://catalogue.nodered.org/catalogue.json'],
+                    theme: [{ category: ".*", type: ".*", color: "#f0f" }]
+                },
+
+                projects: {
+                    enabled: false
+                }
+            }
+        });
+
+        theme.app();
+
+        var context = theme.context();
+        context.should.have.a.property("page");
+        context.page.should.have.a.property("title", "Test Page Title");
+        context.page.should.have.a.property("favicon", "theme/favicon/favicon");
+        context.page.should.have.a.property("tabicon", "theme/tabicon/tabicon");
+        context.should.have.a.property("header");
+        context.header.should.have.a.property("title", "Test Header Title");
+        context.header.should.have.a.property("url", "http://nodered.org");
+        context.header.should.have.a.property("image", "theme/header/image");
+        context.page.should.have.a.property("css");
+        context.page.css.should.have.lengthOf(1);
+        context.page.css[0].should.eql('theme/css/file.css');
+        context.page.should.have.a.property("scripts");
+        context.page.scripts.should.have.lengthOf(1);
+        context.page.scripts[0].should.eql('theme/scripts/script.js');
+        context.should.have.a.property("login");
+        context.login.should.have.a.property("image", "theme/login/image");
+
+        var settings = theme.settings();
+        settings.should.have.a.property("deployButton");
+        settings.deployButton.should.have.a.property("type", "simple");
+        settings.deployButton.should.have.a.property("label", "Save");
+        settings.deployButton.should.have.a.property("icon", "theme/deploy/image");
+        settings.should.have.a.property("userMenu");
+        settings.userMenu.should.be.eql(false);
+        settings.should.have.a.property("menu");
+        settings.menu.should.have.a.property("menu-item-import-library", false);
+        settings.menu.should.have.a.property("menu-item-export-library", false);
+        settings.menu.should.have.a.property("menu-item-keyboard-shortcuts", false);
+        settings.menu.should.have.a.property("menu-item-help", { label: "Alternative Help Link Text", url: "http://example.com" });
+        settings.should.have.a.property("palette");
+        settings.palette.should.have.a.property("editable", true);
+        settings.palette.should.have.a.property("catalogues", ['https://catalogue.nodered.org/catalogue.json']);
+        settings.palette.should.have.a.property("theme", [{ category: ".*", type: ".*", color: "#f0f" }]);
+        settings.should.have.a.property("projects");
+        settings.projects.should.have.a.property("enabled", false);
+    });
+
+});

test/unit/@node-red/editor-api/lib/editor/ui_spec.js

@@ -20,9 +20,9 @@ var express = require("express");
 var fs = require("fs");
 var path = require("path");
 
-var EventEmitter = require('events').EventEmitter;
-var events = new EventEmitter();
-var ui = require("../../../../red/api/editor/ui");
+var NR_TEST_UTILS = require("nr-test-utils");
+
+var ui = NR_TEST_UTILS.require("@node-red/editor-api/lib/editor/ui");
 
 
 describe("api/editor/ui", function() {
@@ -30,10 +30,13 @@ describe("api/editor/ui", function() {
 
     before(function() {
         ui.init({
-            events:events,
             nodes: {
-                getNodeIconPath: function(module,icon) {
-                    return path.resolve(__dirname+'/../../../../public/icons/arrow-in.png');
+                getIcon: function(opts) {
+                    return new Promise(function(resolve,reject) {
+                        fs.readFile(NR_TEST_UTILS.resolve("@node-red/editor-client/src/images/icons/arrow-in.png"), function(err,data) {
+                            resolve(data);
+                        })
+                    });
                 }
             }
         });
@@ -91,7 +94,7 @@ describe("api/editor/ui", function() {
             }
         }
         it('returns the requested icon', function(done) {
-            var defaultIcon = fs.readFileSync(path.resolve(__dirname+'/../../../../public/icons/arrow-in.png'));
+            var defaultIcon = fs.readFileSync(NR_TEST_UTILS.resolve("@node-red/editor-client/src/images/icons/arrow-in.png"));
             request(app)
                 .get("/icons/module/icon.png")
                 .expect("Content-Type", /image\/png/)

test/unit/@node-red/editor-api/lib/index_spec.js

@@ -21,17 +21,18 @@ var express = require("express");
 var when = require("when");
 var fs = require("fs");
 var path = require("path");
-var api = require("../../../red/api");
 
-var apiUtil = require("../../../red/api/util");
-var apiAuth = require("../../../red/api/auth");
-var apiEditor = require("../../../red/api/editor");
-var apiAdmin = require("../../../red/api/admin");
+var NR_TEST_UTILS = require("nr-test-utils");
+
+var api = NR_TEST_UTILS.require("@node-red/editor-api");
+
+var apiAuth = NR_TEST_UTILS.require("@node-red/editor-api/lib/auth");
+var apiEditor = NR_TEST_UTILS.require("@node-red/editor-api/lib/editor");
+var apiAdmin = NR_TEST_UTILS.require("@node-red/editor-api/lib/admin");
 
 
 describe("api/index", function() {
     var beforeEach = function() {
-        sinon.stub(apiUtil,"init",function(){});
         sinon.stub(apiAuth,"init",function(){});
         sinon.stub(apiEditor,"init",function(){
             var app = express();
@@ -48,7 +49,6 @@ describe("api/index", function() {
         });
     };
     var afterEach = function() {
-        apiUtil.init.restore();
         apiAuth.init.restore();
         apiAuth.login.restore();
         apiEditor.init.restore();
@@ -59,18 +59,14 @@ describe("api/index", function() {
     afterEach(afterEach);
 
     it("does not setup admin api if httpAdminRoot is false", function(done) {
-        api.init({},{
-            settings: { httpAdminRoot: false }
-        });
+        api.init({},{ httpAdminRoot: false },{},{});
         should.not.exist(api.adminApp);
         done();
     });
     describe('initalises admin api without adminAuth', function(done) {
         before(function() {
             beforeEach();
-            api.init({},{
-                settings: { }
-            });
+            api.init({},{},{},{});
         });
         after(afterEach);
         it('exposes the editor',function(done) {
@@ -87,9 +83,7 @@ describe("api/index", function() {
     describe('initalises admin api without editor', function(done) {
         before(function() {
             beforeEach();
-            api.init({},{
-                settings: { disableEditor: true }
-            });
+            api.init({},{ disableEditor: true },{},{});
         });
         after(afterEach);
         it('does not expose the editor',function(done) {

test/unit/@node-red/editor-api/lib/util_spec.js

@@ -15,10 +15,16 @@
  **/
 
 var should = require("should");
+var sinon = require("sinon");
 var request = require('supertest');
 var express = require('express');
 
-var apiUtil = require("../../../red/api/util");
+var NR_TEST_UTILS = require("nr-test-utils");
+
+var apiUtil = NR_TEST_UTILS.require("@node-red/editor-api/lib/util");
+
+var log = NR_TEST_UTILS.require("@node-red/util").log;
+var i18n = NR_TEST_UTILS.require("@node-red/util").i18n;
 
 describe("api/util", function() {
     describe("errorHandler", function() {
@@ -27,17 +33,8 @@ describe("api/util", function() {
         var app;
         before(function() {
             app = express();
-            apiUtil.init({
-                log:{
-                    error: function(msg) {
-                        loggedError = msg;
-                    },
-                    audit: function(event) {
-                        loggedEvent = event;
-                    }
-                },
-                i18n:{}
-            })
+            sinon.stub(log,'error',function(msg) {loggedError = msg;});
+            sinon.stub(log,'audit',function(event) {loggedEvent = event;});
             app.get("/tooLarge", function(req,res) {
                 var err = new Error();
                 err.message = "request entity too large";
@@ -49,6 +46,10 @@ describe("api/util", function() {
                 throw err;
             },apiUtil.errorHandler)
         });
+        after(function() {
+            log.error.restore();
+            log.audit.restore();
+        })
         beforeEach(function() {
             loggedError = null;
             loggedEvent = null;
@@ -91,11 +92,13 @@ describe("api/util", function() {
     })
 
     describe('determineLangFromHeaders', function() {
+        var oldDefaultLang;
         before(function() {
-            apiUtil.init({
-                log:{},
-                i18n:{defaultLang:"en-US"}
-            });
+            oldDefaultLang = i18n.defaultLang;
+            i18n.defaultLang = "en-US";
+        })
+        after(function() {
+            i18n.defaultLang = oldDefaultLang;
         })
         it('returns the default lang if non provided', function() {
             apiUtil.determineLangFromHeaders(null).should.eql("en-US");

test/unit/@node-red/registry/lib/deprecated_spec.js

@@ -16,7 +16,9 @@
 
 var should = require("should");
 
-var deprecated = require("../../../../../red/runtime/nodes/registry/deprecated.js");
+var NR_TEST_UTILS = require("nr-test-utils");
+
+var deprecated = NR_TEST_UTILS.require("@node-red/registry/lib/deprecated.js");
 
 describe('deprecated', function() {
     it('should return info on a node',function() {

test/unit/@node-red/registry/lib/index_spec.js

@@ -20,16 +20,15 @@ var path = require("path");
 var when = require("when");
 var fs = require("fs");
 
-var registry = require("../../../../../red/runtime/nodes/registry");
+var NR_TEST_UTILS = require("nr-test-utils");
 
-var installer = require("../../../../../red/runtime/nodes/registry/installer");
-var loader = require("../../../../../red/runtime/nodes/registry/loader");
-var typeRegistry = require("../../../../../red/runtime/nodes/registry/registry");
+var registry = NR_TEST_UTILS.require("@node-red/registry");
 
+var installer = NR_TEST_UTILS.require("@node-red/registry/lib/installer");
+var loader = NR_TEST_UTILS.require("@node-red/registry/lib/loader");
+var typeRegistry = NR_TEST_UTILS.require("@node-red/registry/lib/registry");
 
-
-
-describe('red/nodes/registry/index', function() {
+describe('red/registry/index', function() {
     var stubs = [];
     afterEach(function() {
         while(stubs.length) {
@@ -60,7 +59,7 @@ describe('red/nodes/registry/index', function() {
             registry.addModule("foo").then(function(info) {
                 info.should.eql("info");
                 done();
-            }).otherwise(function(err) { done(err); });
+            }).catch(function(err) { done(err); });
         });
         it('rejects if loader rejects', function(done) {
             stubs.push(sinon.stub(loader,"addModule",function(module) {
@@ -71,7 +70,7 @@ describe('red/nodes/registry/index', function() {
             }));
             registry.addModule("foo").then(function(info) {
                 done(new Error("unexpected resolve"));
-            }).otherwise(function(err) {
+            }).catch(function(err) {
                 err.should.eql("error");
                 done();
             })
@@ -90,7 +89,7 @@ describe('red/nodes/registry/index', function() {
                 typeRegistry.enableNodeSet.called.should.be.true();
                 ns.should.have.a.property('id','node-set');
                 done();
-            }).otherwise(function(err) { done(err); });
+            }).catch(function(err) { done(err); });
         });
 
         it('rejects if node unknown',function() {
@@ -121,7 +120,7 @@ describe('red/nodes/registry/index', function() {
                 ns.should.have.a.property('id','node-set');
                 ns.should.have.a.property('loaded',true);
                 done();
-            }).otherwise(function(err) { done(err); });
+            }).catch(function(err) { done(err); });
         });
 
     });

test/unit/@node-red/registry/lib/installer_spec.js

@@ -21,23 +21,39 @@ var path = require("path");
 var fs = require('fs');
 var EventEmitter = require('events');
 
-var child_process = require('child_process');
-var installer = require("../../../../../red/runtime/nodes/registry/installer");
-var registry = require("../../../../../red/runtime/nodes/registry/index");
-var typeRegistry = require("../../../../../red/runtime/nodes/registry/registry");
+var NR_TEST_UTILS = require("nr-test-utils");
+
+var installer = NR_TEST_UTILS.require("@node-red/registry/lib/installer");
+var registry = NR_TEST_UTILS.require("@node-red/registry/lib/index");
+var typeRegistry = NR_TEST_UTILS.require("@node-red/registry/lib/registry");
 
 describe('nodes/registry/installer', function() {
 
-    before(function() {
-        installer.init({});
+    var mockLog = {
+        log: sinon.stub(),
+        debug: sinon.stub(),
+        trace: sinon.stub(),
+        warn: sinon.stub(),
+        info: sinon.stub(),
+        metric: sinon.stub(),
+        _: function() { return "abc"}
+    }
+
+    beforeEach(function() {
+        installer.init({log:mockLog, settings:{}, events: new EventEmitter(), exec: {
+            run: function() {
+                return Promise.resolve("");
+            }
+        }});
     });
+    function initInstaller(execResult) {
+        installer.init({log:mockLog, settings:{}, events: new EventEmitter(), exec: {
+            run: function() {
+                return execResult;
+            }
+        }});
+    }
     afterEach(function() {
-        if (child_process.spawn.restore) {
-            child_process.spawn.restore();
-        }
-        if (child_process.execFile.restore) {
-            child_process.execFile.restore();
-        }
         if (registry.addModule.restore) {
             registry.addModule.restore();
         }
@@ -62,40 +78,34 @@ describe('nodes/registry/installer', function() {
 
     describe("installs module", function() {
         it("rejects when npm returns a 404", function(done) {
-            sinon.stub(child_process,"spawn",function(cmd,args,opt) {
-                var ee = new EventEmitter();
-                ee.stdout = new EventEmitter();
-                ee.stderr = new EventEmitter();
-                setTimeout(function() {
-                    ee.stderr.emit('data'," 404  this_wont_exist");
-                    ee.emit('close',1);
-                },10)
-                return ee;
-            });
-
-            installer.installModule("this_wont_exist").otherwise(function(err) {
-                err.code.should.be.eql(404);
+            var res = {
+                code: 1,
+                stdout:"",
+                stderr:" 404  this_wont_exist"
+            }
+            var p = Promise.reject(res);
+            p.catch((err)=>{});
+            initInstaller(p)
+            installer.installModule("this_wont_exist").catch(function(err) {
+                err.should.have.property("code",404);
                 done();
             });
         });
         it("rejects when npm does not find specified version", function(done) {
-            sinon.stub(child_process,"spawn",function(cmd,args,opt) {
-                var ee = new EventEmitter();
-                ee.stdout = new EventEmitter();
-                ee.stderr = new EventEmitter();
-                setTimeout(function() {
-                    ee.stderr.emit('data'," version not found: this_wont_exist@0.1.2");
-                    ee.emit('close',1);
-                },10)
-                return ee;
-            });
+            var res = {
+                code: 1,
+                stdout:"",
+                stderr:" version not found: this_wont_exist@0.1.2"
+            }
+            var p = Promise.reject(res);
+            p.catch((err)=>{});
+            initInstaller(p)
             sinon.stub(typeRegistry,"getModuleInfo", function() {
                 return {
                     version: "0.1.1"
                 }
             });
-
-            installer.installModule("this_wont_exist","0.1.2").otherwise(function(err) {
+            installer.installModule("this_wont_exist","0.1.2").catch(function(err) {
                 err.code.should.be.eql(404);
                 done();
             });
@@ -106,40 +116,38 @@ describe('nodes/registry/installer', function() {
                     version: "0.1.1"
                 }
             });
-            installer.installModule("this_wont_exist","0.1.1").otherwise(function(err) {
+            installer.installModule("this_wont_exist","0.1.1").catch(function(err) {
                 err.code.should.be.eql('module_already_loaded');
                 done();
             });
         });
         it("rejects with generic error", function(done) {
-            sinon.stub(child_process,"spawn",function(cmd,args,opt,cb) {
-                var ee = new EventEmitter();
-                ee.stdout = new EventEmitter();
-                ee.stderr = new EventEmitter();
-                setTimeout(function() {
-                    ee.stderr.emit('data'," kaboom!");
-                    ee.emit('close',1);
-                },10)
-                return ee;
-            });
-
+            var res = {
+                code: 1,
+                stdout:"",
+                stderr:" kaboom!"
+            }
+            var p = Promise.reject(res);
+            p.catch((err)=>{});
+            initInstaller(p)
             installer.installModule("this_wont_exist").then(function() {
                 done(new Error("Unexpected success"));
-            }).otherwise(function(err) {
+            }).catch(function(err) {
                 done();
             });
         });
         it("succeeds when module is found", function(done) {
             var nodeInfo = {nodes:{module:"foo",types:["a"]}};
-            sinon.stub(child_process,"spawn",function(cmd,args,opt) {
-                var ee = new EventEmitter();
-                ee.stdout = new EventEmitter();
-                ee.stderr = new EventEmitter();
-                setTimeout(function() {
-                    ee.emit('close',0);
-                },10)
-                return ee;
-            });
+
+            var res = {
+                code: 0,
+                stdout:"",
+                stderr:""
+            }
+            var p = Promise.resolve(res);
+            p.catch((err)=>{});
+            initInstaller(p)
+
             var addModule = sinon.stub(registry,"addModule",function(md) {
                 return when.resolve(nodeInfo);
             });
@@ -150,16 +158,16 @@ describe('nodes/registry/installer', function() {
                 // commsMessages[0].topic.should.equal("node/added");
                 // commsMessages[0].msg.should.eql(nodeInfo.nodes);
                 done();
-            }).otherwise(function(err) {
+            }).catch(function(err) {
                 done(err);
             });
         });
         it("rejects when non-existant path is provided", function(done) {
-            this.timeout(10000);
-            var resourcesDir = path.resolve(path.join(__dirname,"..","resources","local","TestNodeModule","node_modules","NonExistant"));
+            this.timeout(20000);
+            var resourcesDir = path.resolve(path.join(__dirname,"resources","local","TestNodeModule","node_modules","NonExistant"));
             installer.installModule(resourcesDir).then(function() {
                 done(new Error("Unexpected success"));
-            }).otherwise(function(err) {
+            }).catch(function(err) {
                 if (err.hasOwnProperty("code")) {
                     err.code.should.eql(404);
                     done();
@@ -176,20 +184,20 @@ describe('nodes/registry/installer', function() {
             var addModule = sinon.stub(registry,"addModule",function(md) {
                 return when.resolve(nodeInfo);
             });
-            var resourcesDir = path.resolve(path.join(__dirname,"..","resources","local","TestNodeModule","node_modules","TestNodeModule"));
-            sinon.stub(child_process,"spawn",function(cmd,args,opt) {
-                var ee = new EventEmitter();
-                ee.stdout = new EventEmitter();
-                ee.stderr = new EventEmitter();
-                setTimeout(function() {
-                    ee.emit('close',0);
-                },10)
-                return ee;
-            });
+            var resourcesDir = path.resolve(path.join(__dirname,"resources","local","TestNodeModule","node_modules","TestNodeModule"));
+
+            var res = {
+                code: 0,
+                stdout:"",
+                stderr:""
+            }
+            var p = Promise.resolve(res);
+            p.catch((err)=>{});
+            initInstaller(p)
             installer.installModule(resourcesDir).then(function(info) {
                 info.should.eql(nodeInfo);
                 done();
-            }).otherwise(function(err) {
+            }).catch(function(err) {
                 done(err);
             });
         });
@@ -212,13 +220,18 @@ describe('nodes/registry/installer', function() {
             var removeModule = sinon.stub(registry,"removeModule",function(md) {
                 return when.resolve(nodeInfo);
             });
-            sinon.stub(child_process,"execFile",function(cmd,args,opt,cb) {
-                cb(new Error("test_error"),"","");
-            });
+            var res = {
+                code: 1,
+                stdout:"",
+                stderr:"error"
+            }
+            var p = Promise.reject(res);
+            p.catch((err)=>{});
+            initInstaller(p)
 
             installer.uninstallModule("this_wont_exist").then(function() {
                 done(new Error("Unexpected success"));
-            }).otherwise(function(err) {
+            }).catch(function(err) {
                 done();
             });
         });
@@ -230,9 +243,14 @@ describe('nodes/registry/installer', function() {
             var getModuleInfo = sinon.stub(registry,"getModuleInfo",function(md) {
                 return {nodes:[]};
             });
-            sinon.stub(child_process,"execFile",function(cmd,args,opt,cb) {
-                cb(null,"","");
-            });
+            var res = {
+                code: 0,
+                stdout:"",
+                stderr:""
+            }
+            var p = Promise.resolve(res);
+            p.catch((err)=>{});
+            initInstaller(p)
 
             sinon.stub(fs,"statSync", function(fn) { return {}; });
 
@@ -242,7 +260,7 @@ describe('nodes/registry/installer', function() {
                 // commsMessages[0].topic.should.equal("node/removed");
                 // commsMessages[0].msg.should.eql(nodeInfo);
                 done();
-            }).otherwise(function(err) {
+            }).catch(function(err) {
                 done(err);
             });
         });

test/unit/@node-red/registry/lib/library_spec.js

@@ -14,56 +14,49 @@
  * limitations under the License.
  **/
 
-var EventEmitter = require('events').EventEmitter;
-var events = new EventEmitter();
-
 var should = require("should");
 
 var fs = require("fs");
 var path = require("path");
 
-var library = require("../../../../red/runtime/nodes/library")
+var NR_TEST_UTILS = require("nr-test-utils");
+
+var library = NR_TEST_UTILS.require("@node-red/registry/lib/library");
 
 describe("library api", function() {
     it('returns null list when no modules have been registered', function() {
-        library.init({events:events});
+        library.init();
         should.not.exist(library.getExampleFlows());
     });
     it('returns null path when module is not known', function() {
-        library.init({events:events});
+        library.init();
         should.not.exist(library.getExampleFlowPath('foo','bar'));
     });
 
     it('returns a valid example path', function(done) {
-        library.init({events:events});
-        events.emit('node-examples-dir',{
-            name: "test-module",
-            path: path.resolve(__dirname+'/../../../resources/examples')
-        });
-        setTimeout(function() {
+        library.init();
+        library.addExamplesDir("test-module",path.resolve(__dirname+'/resources/examples')).then(function() {
             try {
                 var flows = library.getExampleFlows();
                 flows.should.deepEqual({"d":{"test-module":{"f":["one"]}}});
 
                 var examplePath = library.getExampleFlowPath('test-module','one');
-                examplePath.should.eql(path.resolve(__dirname+'/../../../resources/examples/one.json'))
+                examplePath.should.eql(path.resolve(__dirname+'/resources/examples/one.json'))
 
 
-                events.emit('node-module-uninstalled', 'test-module');
+                library.removeExamplesDir('test-module');
 
-                setTimeout(function() {
-                    try {
-                        should.not.exist(library.getExampleFlows());
-                        should.not.exist(library.getExampleFlowPath('test-module','one'));
-                        done();
-                    } catch(err) {
-                        done(err);
-                    }
-                },20);
+                try {
+                    should.not.exist(library.getExampleFlows());
+                    should.not.exist(library.getExampleFlowPath('test-module','one'));
+                    done();
+                } catch(err) {
+                    done(err);
+                }
             }catch(err) {
                 done(err);
             }
-        },20);
+        });
 
     })
 });

test/unit/@node-red/registry/lib/loader_spec.js

@@ -20,14 +20,16 @@ var sinon = require("sinon");
 var path = require("path");
 var fs = require("fs");
 
-var loader = require("../../../../../red/runtime/nodes/registry/loader");
+var NR_TEST_UTILS = require("nr-test-utils");
 
-var localfilesystem = require("../../../../../red/runtime/nodes/registry/localfilesystem");
-var registry = require("../../../../../red/runtime/nodes/registry/registry");
+var loader = NR_TEST_UTILS.require("@node-red/registry/lib/loader");
 
-var nodes = require("../../../../../red/runtime/nodes/registry");
+var localfilesystem = NR_TEST_UTILS.require("@node-red/registry/lib/localfilesystem");
+var registry = NR_TEST_UTILS.require("@node-red/registry/lib/registry");
 
-var resourcesDir = path.resolve(path.join(__dirname,"..","resources","local"));
+var nodes = NR_TEST_UTILS.require("@node-red/registry");
+
+var resourcesDir = path.resolve(path.join(__dirname,"resources","local"));
 
 describe("red/nodes/registry/loader",function() {
     var stubs = [];
@@ -42,18 +44,12 @@ describe("red/nodes/registry/loader",function() {
             stubs.pop().restore();
         }
     })
-    describe("#init",function() {
-        it("init",function() {
-            loader.init({nodes:nodes,i18n:{defaultLang:"en-US"},events:{on:function(){},removeListener:function(){},log:{info:function(){},_:function(){}}}});
-            localfilesystem.init.called.should.be.true();
-        });
-    });
 
     describe("#load",function() {
         it("load empty set without settings available", function(done) {
             stubs.push(sinon.stub(localfilesystem,"getNodeFiles", function(){ return {};}));
             stubs.push(sinon.stub(registry,"saveNodeList", function(){ return {};}));
-            loader.init({nodes:nodes,i18n:{defaultLang:"en-US"},events:{on:function(){},removeListener:function(){}},log:{info:function(){},_:function(){}},settings:{available:function(){return false;}}});
+            loader.init({nodes:nodes,log:{info:function(){},_:function(){}},settings:{available:function(){return false;}}});
             loader.load("foo",true).then(function() {
                 localfilesystem.getNodeFiles.called.should.be.true();
                 localfilesystem.getNodeFiles.lastCall.args[0].should.eql('foo');
@@ -65,11 +61,11 @@ describe("red/nodes/registry/loader",function() {
         it("load empty set with settings available triggers registery save", function(done) {
             stubs.push(sinon.stub(localfilesystem,"getNodeFiles", function(){ return {};}));
             stubs.push(sinon.stub(registry,"saveNodeList", function(){ return {};}));
-            loader.init({nodes:nodes,i18n:{defaultLang:"en-US"},events:{on:function(){},removeListener:function(){}},log:{info:function(){},_:function(){}},settings:{available:function(){return true;}}});
+            loader.init({nodes:nodes,log:{info:function(){},_:function(){}},settings:{available:function(){return true;}}});
             loader.load("foo",true).then(function() {
                 registry.saveNodeList.called.should.be.true();
                 done();
-            }).otherwise(function(err) {
+            }).catch(function(err) {
                 done(err);
             })
         });
@@ -97,7 +93,7 @@ describe("red/nodes/registry/loader",function() {
             stubs.push(sinon.stub(registry,"getNodeInfo", function(){ return null; }));
 
             stubs.push(sinon.stub(nodes,"registerType"));
-            loader.init({nodes:nodes,i18n:{defaultLang:"en-US"},events:{on:function(){},removeListener:function(){}},log:{info:function(){},_:function(){}},settings:{available:function(){return true;}}});
+            loader.init({nodes:nodes,log:{info:function(){},_:function(){}},settings:{available:function(){return true;}}});
             loader.load().then(function(result) {
                 registry.addModule.called.should.be.true();
                 var module = registry.addModule.lastCall.args[0];
@@ -151,7 +147,7 @@ describe("red/nodes/registry/loader",function() {
             // This module isn't already loaded
             stubs.push(sinon.stub(registry,"getNodeInfo", function(){ return null; }));
             stubs.push(sinon.stub(nodes,"registerType"));
-            loader.init({nodes:nodes,i18n:{defaultLang:"en-US"},events:{on:function(){},removeListener:function(){}},log:{info:function(){},_:function(){}},settings:{available:function(){return true;}}});
+            loader.init({nodes:nodes,log:{info:function(){},_:function(){}},settings:{available:function(){return true;}}});
             loader.load().then(function(result) {
 
                 registry.addModule.called.should.be.true();
@@ -212,7 +208,7 @@ describe("red/nodes/registry/loader",function() {
             stubs.push(sinon.stub(registry,"getNodeInfo", function(){ return null; }));
 
             stubs.push(sinon.stub(nodes,"registerType"));
-            loader.init({nodes:nodes,i18n:{defaultLang:"en-US"},events:{on:function(){},removeListener:function(){}},log:{info:function(){},_:function(){}},settings:{available:function(){return true;}}});
+            loader.init({nodes:nodes,log:{info:function(){},_:function(){}},settings:{available:function(){return true;}}});
             loader.load().then(function(result) {
 
                 registry.addModule.called.should.be.true();
@@ -270,7 +266,7 @@ describe("red/nodes/registry/loader",function() {
             stubs.push(sinon.stub(registry,"getNodeInfo", function(){ return null; }));
 
             stubs.push(sinon.stub(nodes,"registerType"));
-            loader.init({nodes:nodes,i18n:{defaultLang:"en-US"},events:{on:function(){},removeListener:function(){}},log:{info:function(){},_:function(){}},settings:{available:function(){return true;}}});
+            loader.init({nodes:nodes,log:{info:function(){},_:function(){}},settings:{available:function(){return true;}}});
             loader.load().then(function(result) {
                 registry.addModule.called.should.be.true();
                 var module = registry.addModule.lastCall.args[0];
@@ -324,7 +320,7 @@ describe("red/nodes/registry/loader",function() {
             stubs.push(sinon.stub(registry,"getNodeInfo", function(){ return null; }));
 
             stubs.push(sinon.stub(nodes,"registerType"));
-            loader.init({nodes:nodes,i18n:{defaultLang:"en-US"},events:{on:function(){},removeListener:function(){}},log:{info:function(){},_:function(){}},settings:{available:function(){return true;}}});
+            loader.init({nodes:nodes,log:{info:function(){},_:function(){}},settings:{available:function(){return true;}}});
             loader.load().then(function(result) {
                 registry.addModule.called.should.be.true();
                 var module = registry.addModule.lastCall.args[0];
@@ -377,7 +373,7 @@ describe("red/nodes/registry/loader",function() {
             stubs.push(sinon.stub(registry,"getNodeInfo", function(){ return null; }));
 
             stubs.push(sinon.stub(nodes,"registerType"));
-            loader.init({nodes:nodes,i18n:{defaultLang:"en-US"},events:{on:function(){},removeListener:function(){}},log:{info:function(){},_:function(){}},settings:{available:function(){return true;}}});
+            loader.init({nodes:nodes,log:{info:function(){},_:function(){}},settings:{available:function(){return true;}}});
             loader.load().then(function(result) {
 
                 registry.addModule.called.should.be.true();
@@ -412,7 +408,7 @@ describe("red/nodes/registry/loader",function() {
 
     describe("#addModule",function() {
         it("throws error if settings unavailable", function() {
-            loader.init({nodes:nodes,i18n:{defaultLang:"en-US"},events:{on:function(){},removeListener:function(){}},log:{info:function(){},_:function(){}},settings:{available:function(){return false;}}});
+            loader.init({nodes:nodes,log:{info:function(){},_:function(){}},settings:{available:function(){return false;}}});
             /*jshint immed: false */
             (function(){
                 loader.addModule("test-module");
@@ -421,7 +417,7 @@ describe("red/nodes/registry/loader",function() {
 
         it("returns rejected error if module already loaded", function(done) {
             stubs.push(sinon.stub(registry,"getModuleInfo",function(){return{}}));
-            loader.init({nodes:nodes,i18n:{defaultLang:"en-US"},events:{on:function(){},removeListener:function(){}},log:{info:function(){},_:function(){}},settings:{available:function(){return true;}}});
+            loader.init({nodes:nodes,log:{info:function(){},_:function(){}},settings:{available:function(){return true;}}});
 
             loader.addModule("test-module").catch(function(err) {
                 err.code.should.eql("module_already_loaded");
@@ -433,7 +429,7 @@ describe("red/nodes/registry/loader",function() {
             stubs.push(sinon.stub(localfilesystem,"getModuleFiles",function() {
                 throw new Error("failure");
             }));
-            loader.init({nodes:nodes,i18n:{defaultLang:"en-US"},events:{on:function(){},removeListener:function(){}},log:{info:function(){},_:function(){}},settings:{available:function(){return true;}}});
+            loader.init({nodes:nodes,log:{info:function(){},_:function(){}},settings:{available:function(){return true;}}});
             loader.addModule("test-module").catch(function(err) {
                 err.message.should.eql("failure");
                 done();
@@ -465,7 +461,7 @@ describe("red/nodes/registry/loader",function() {
             stubs.push(sinon.stub(registry,"saveNodeList", function(){ return "a node list" }));
             stubs.push(sinon.stub(registry,"addModule", function(){ return }));
             stubs.push(sinon.stub(nodes,"registerType"));
-            loader.init({nodes:nodes,i18n:{defaultLang:"en-US"},events:{on:function(){},removeListener:function(){}},log:{info:function(){},_:function(){}},settings:{available:function(){return true;}}});
+            loader.init({nodes:nodes,log:{info:function(){},_:function(){}},settings:{available:function(){return true;}}});
             loader.addModule("TestNodeModule").then(function(result) {
                 result.should.eql("a node list");
 
@@ -522,7 +518,7 @@ describe("red/nodes/registry/loader",function() {
             stubs.push(sinon.stub(registry,"saveNodeList", function(){ return "a node list" }));
             stubs.push(sinon.stub(registry,"addModule", function(){ return }));
             stubs.push(sinon.stub(nodes,"registerType"));
-            loader.init({log:{"_":function(){},warn:function(){}},nodes:nodes,i18n:{defaultLang:"en-US"},events:{on:function(){},removeListener:function(){}},version: function() { return "0.12.0"}, settings:{available:function(){return true;}}});
+            loader.init({log:{"_":function(){},warn:function(){}},nodes:nodes,version: function() { return "0.12.0"}, settings:{available:function(){return true;}}});
             loader.addModule("TestNodeModule").then(function(result) {
                 result.should.eql("a node list");
                 registry.addModule.called.should.be.false();

test/unit/@node-red/registry/lib/localfilesystem_spec.js

@@ -19,13 +19,21 @@ var when = require("when");
 var sinon = require("sinon");
 var path = require("path");
 
-var localfilesystem = require("../../../../../red/runtime/nodes/registry/localfilesystem");
+var NR_TEST_UTILS = require("nr-test-utils");
 
-var resourcesDir = path.resolve(path.join(__dirname,"..","resources","local"));
-var userDir = path.resolve(path.join(__dirname,"..","resources","userDir"));
-var moduleDir = path.resolve(path.join(__dirname,"..","resources","local","TestNodeModule"));
+var localfilesystem = NR_TEST_UTILS.require("@node-red/registry/lib/localfilesystem");
+
+var resourcesDir = path.resolve(path.join(__dirname,"resources","local"));
+var userDir = path.resolve(path.join(__dirname,"resources","userDir"));
+var moduleDir = path.resolve(path.join(__dirname,"resources","local","TestNodeModule"));
+
+var i18n = NR_TEST_UTILS.require("@node-red/util").i18n;
 
 describe("red/nodes/registry/localfilesystem",function() {
+    beforeEach(function() {
+        stubs.push(sinon.stub(i18n,"registerMessageCatalog", function() { return Promise.resolve(); }));
+    })
+
     var stubs = [];
     afterEach(function() {
         while(stubs.length) {
@@ -46,7 +54,7 @@ describe("red/nodes/registry/localfilesystem",function() {
     }
     describe("#getNodeFiles",function() {
         it("Finds all the node files in the resources tree",function(done) {
-            localfilesystem.init({i18n:{registerMessageCatalog:function(){}},events:{emit:function(){}},settings:{coreNodesDir:resourcesDir}});
+            localfilesystem.init({settings:{coreNodesDir:resourcesDir}});
             var nodeList = localfilesystem.getNodeFiles(true);
             nodeList.should.have.a.property("node-red");
             var nm = nodeList['node-red'];
@@ -54,10 +62,14 @@ describe("red/nodes/registry/localfilesystem",function() {
             nm.should.have.a.property("nodes");
             var nodes = nm.nodes;
             checkNodes(nm.nodes,['TestNode1','MultipleNodes1','NestedNode','TestNode2','TestNode3','TestNode4'],['TestNodeModule']);
+            i18n.registerMessageCatalog.called.should.be.true();
+            i18n.registerMessageCatalog.lastCall.args[0].should.eql('node-red');
+            i18n.registerMessageCatalog.lastCall.args[1].should.eql(path.resolve(path.join(resourcesDir,"locales")));
+            i18n.registerMessageCatalog.lastCall.args[2].should.eql('messages.json');
             done();
         });
         it("Includes node files from settings",function(done) {
-            localfilesystem.init({i18n:{registerMessageCatalog:function(){}},events:{emit:function(){}},settings:{nodesIncludes:['TestNode1.js'],coreNodesDir:resourcesDir}});
+            localfilesystem.init({settings:{nodesIncludes:['TestNode1.js'],coreNodesDir:resourcesDir}});
             var nodeList = localfilesystem.getNodeFiles(true);
             nodeList.should.have.a.property("node-red");
             var nm = nodeList['node-red'];
@@ -67,7 +79,7 @@ describe("red/nodes/registry/localfilesystem",function() {
             done();
         });
         it("Excludes node files from settings",function(done) {
-            localfilesystem.init({i18n:{registerMessageCatalog:function(){}},events:{emit:function(){}},settings:{nodesExcludes:['TestNode1.js'],coreNodesDir:resourcesDir}});
+            localfilesystem.init({settings:{nodesExcludes:['TestNode1.js'],coreNodesDir:resourcesDir}});
             var nodeList = localfilesystem.getNodeFiles(true);
             nodeList.should.have.a.property("node-red");
             var nm = nodeList['node-red'];
@@ -77,7 +89,7 @@ describe("red/nodes/registry/localfilesystem",function() {
             done();
         });
         it("Finds nodes in userDir/nodes",function(done) {
-            localfilesystem.init({i18n:{registerMessageCatalog:function(){}},events:{emit:function(){}},settings:{userDir:userDir,coreNodesDir:__dirname}});
+            localfilesystem.init({settings:{userDir:userDir}});
             var nodeList = localfilesystem.getNodeFiles(true);
             nodeList.should.have.a.property("node-red");
             var nm = nodeList['node-red'];
@@ -88,7 +100,7 @@ describe("red/nodes/registry/localfilesystem",function() {
         });
 
         it("Finds nodes in settings.nodesDir (string)",function(done) {
-            localfilesystem.init({i18n:{registerMessageCatalog:function(){}},events:{emit:function(){}},settings:{nodesDir:userDir,coreNodesDir:__dirname}});
+            localfilesystem.init({settings:{nodesDir:userDir}});
             var nodeList = localfilesystem.getNodeFiles(true);
             nodeList.should.have.a.property("node-red");
             var nm = nodeList['node-red'];
@@ -97,19 +109,19 @@ describe("red/nodes/registry/localfilesystem",function() {
             checkNodes(nm.nodes,['TestNode5'],['TestNode1']);
             done();
         });
-	    it("Finds nodes in settings.nodesDir (string,relative path)",function(done) {
-		    var relativeUserDir = path.join("test","red","runtime","nodes","resources","userDir");
-		    localfilesystem.init({i18n:{registerMessageCatalog:function(){}},events:{emit:function(){}},settings:{nodesDir:relativeUserDir,coreNodesDir:__dirname}});
-		    var nodeList = localfilesystem.getNodeFiles(true);
-		    nodeList.should.have.a.property("node-red");
-		    var nm = nodeList['node-red'];
-		    nm.should.have.a.property('name','node-red');
-		    nm.should.have.a.property("nodes");
-		    checkNodes(nm.nodes,['TestNode5'],['TestNode1']);
-		    done();
-	    });
-	    it("Finds nodes in settings.nodesDir (array)",function(done) {
-            localfilesystem.init({i18n:{registerMessageCatalog:function(){}},events:{emit:function(){}},settings:{nodesDir:[userDir],coreNodesDir:__dirname}});
+        it("Finds nodes in settings.nodesDir (string,relative path)",function(done) {
+            var relativeUserDir = path.join("test","unit","@node-red","registry","lib","resources","userDir");
+            localfilesystem.init({settings:{nodesDir:relativeUserDir}});
+            var nodeList = localfilesystem.getNodeFiles(true);
+            nodeList.should.have.a.property("node-red");
+            var nm = nodeList['node-red'];
+            nm.should.have.a.property('name','node-red');
+            nm.should.have.a.property("nodes");
+            checkNodes(nm.nodes,['TestNode5'],['TestNode1']);
+            done();
+        });
+        it("Finds nodes in settings.nodesDir (array)",function(done) {
+            localfilesystem.init({settings:{nodesDir:[userDir]}});
             var nodeList = localfilesystem.getNodeFiles(true);
             nodeList.should.have.a.property("node-red");
             var nm = nodeList['node-red'];
@@ -128,7 +140,7 @@ describe("red/nodes/registry/localfilesystem",function() {
                 }
                 return _join.apply(null,arguments);
             }));
-            localfilesystem.init({i18n:{registerMessageCatalog:function(){}},events:{emit:function(){}},settings:{coreNodesDir:moduleDir}});
+            localfilesystem.init({settings:{coreNodesDir:moduleDir}});
             var nodeList = localfilesystem.getNodeFiles();
             nodeList.should.have.a.property("node-red");
             var nm = nodeList['node-red'];
@@ -146,6 +158,13 @@ describe("red/nodes/registry/localfilesystem",function() {
             nm.should.have.a.property("nodes");
             checkNodes(nm.nodes,['VersionMismatchMod1','VersionMismatchMod2'],[],'VersionMismatchModule');
 
+            i18n.registerMessageCatalog.called.should.be.true();
+            i18n.registerMessageCatalog.lastCall.args[0].should.eql('node-red');
+            i18n.registerMessageCatalog.lastCall.args[1].should.eql(path.resolve(path.join(moduleDir,"locales")));
+            i18n.registerMessageCatalog.lastCall.args[2].should.eql('messages.json');
+
+
+
             done();
         });
         it.skip("finds locales directory");
@@ -153,57 +172,57 @@ describe("red/nodes/registry/localfilesystem",function() {
         it("scans icon files in the resources tree",function(done) {
             var count = 0;
             localfilesystem.init({
-                i18n:{registerMessageCatalog:function(){}},
-                events:{emit:function(eventName,dir){
-                    if (count === 0) {
-                        eventName.should.equal("node-icon-dir");
-                        dir.name.should.equal("node-red");
-                        dir.icons.should.be.an.Array();
-                        count = 1;
-                    } else if (count === 1) {
-                        done();
-                    }
-                }},
+
+                // events:{emit:function(eventName,dir){
+                //     if (count === 0) {
+                //         eventName.should.equal("node-icon-dir");
+                //         dir.name.should.equal("node-red");
+                //         dir.icons.should.be.an.Array();
+                //         count = 1;
+                //     } else if (count === 1) {
+                //         done();
+                //     }
+                // }},
                 settings:{coreNodesDir:resourcesDir}
             });
             var list = localfilesystem.getNodeFiles(true);
             list.should.have.property("node-red");
             list["node-red"].should.have.property("icons");
-            list["node-red"].icons.should.have.length(2);
-            //list["node-red"].icons[1].should.have.property("path",path.join(__dirname,"resources/local/NestedDirectoryNode/NestedNode/icons"))
-            list["node-red"].icons[1].should.have.property("icons");
-            list["node-red"].icons[1].icons.should.have.length(1);
-            list["node-red"].icons[1].icons[0].should.eql("arrow-in.png");
+            list["node-red"].icons.should.have.length(1);
+            list["node-red"].icons[0].should.have.property("path",path.join(__dirname,"resources/local/NestedDirectoryNode/NestedNode/icons"))
+            list["node-red"].icons[0].should.have.property("icons");
+            list["node-red"].icons[0].icons.should.have.length(1);
+            list["node-red"].icons[0].icons[0].should.eql("arrow-in.png");
             done();
         });
         it("scans icons dir in library",function(done) {
             var count = 0;
             localfilesystem.init({
-                i18n:{registerMessageCatalog:function(){}},
-                events:{emit:function(eventName,dir){
-                    eventName.should.equal("node-icon-dir");
-                    if (count === 0) {
-                        dir.name.should.equal("node-red");
-                        dir.icons.should.be.an.Array();
-                        count = 1;
-                    } else if (count === 1) {
-                        dir.name.should.equal("Library");
-                        dir.icons.should.be.an.Array();
-                        dir.icons.length.should.equal(1);
-                        dir.icons[0].should.be.equal("test_icon.png");
-                        done();
-                    }
-                }},
+                //
+                // events:{emit:function(eventName,dir){
+                //     eventName.should.equal("node-icon-dir");
+                //     if (count === 0) {
+                //         dir.name.should.equal("node-red");
+                //         dir.icons.should.be.an.Array();
+                //         count = 1;
+                //     } else if (count === 1) {
+                //         dir.name.should.equal("Library");
+                //         dir.icons.should.be.an.Array();
+                //         dir.icons.length.should.equal(1);
+                //         dir.icons[0].should.be.equal("test_icon.png");
+                //         done();
+                //     }
+                // }},
                 settings:{userDir:userDir}
             });
             var list = localfilesystem.getNodeFiles(true);
             list.should.have.property("node-red");
             list["node-red"].should.have.property("icons");
-            list["node-red"].icons.should.have.length(2);
-            //list["node-red"].icons[1].should.have.property("path",path.join(__dirname,"resources/userDir/lib/icons"))
-            list["node-red"].icons[1].should.have.property("icons");
-            list["node-red"].icons[1].icons.should.have.length(1);
-            list["node-red"].icons[1].icons[0].should.eql("test_icon.png");
+            list["node-red"].icons.should.have.length(1);
+            list["node-red"].icons[0].should.have.property("path",path.join(__dirname,"resources/userDir/lib/icons"))
+            list["node-red"].icons[0].should.have.property("icons");
+            list["node-red"].icons[0].icons.should.have.length(1);
+            list["node-red"].icons[0].icons[0].should.eql("test_icon.png");
             done();
         });
     });
@@ -218,7 +237,7 @@ describe("red/nodes/registry/localfilesystem",function() {
                 }
                 return _join.apply(null,arguments);
             }));
-            localfilesystem.init({i18n:{registerMessageCatalog:function(){}},events:{emit:function(){}},settings:{coreNodesDir:moduleDir}});
+            localfilesystem.init({settings:{coreNodesDir:moduleDir}});
             var nodeModule = localfilesystem.getModuleFiles('TestNodeModule');
             nodeModule.should.have.a.property('TestNodeModule');
             nodeModule['TestNodeModule'].should.have.a.property('name','TestNodeModule');
@@ -242,7 +261,7 @@ describe("red/nodes/registry/localfilesystem",function() {
                 }
                 return _join.apply(null,arguments);
             }));
-            localfilesystem.init({i18n:{registerMessageCatalog:function(){}},events:{emit:function(){}},settings:{coreNodesDir:moduleDir}});
+            localfilesystem.init({settings:{coreNodesDir:moduleDir}});
             /*jshint immed: false */
             (function(){
                 localfilesystem.getModuleFiles('WontExistModule');
@@ -262,13 +281,13 @@ describe("red/nodes/registry/localfilesystem",function() {
                 return _join.apply(null,arguments);
             }));
             localfilesystem.init({
-                i18n:{registerMessageCatalog:function(){}},
-                events:{emit:function(eventName,dir){
-                    eventName.should.equal("node-icon-dir");
-                    dir.name.should.equal("TestNodeModule");
-                    dir.icons.should.be.an.Array();
-                    done();
-                }},
+
+                // events:{emit:function(eventName,dir){
+                //     eventName.should.equal("node-icon-dir");
+                //     dir.name.should.equal("TestNodeModule");
+                //     dir.icons.should.be.an.Array();
+                //     done();
+                // }},
                 settings:{coreNodesDir:moduleDir}
             });
             var nodeModule = localfilesystem.getModuleFiles('TestNodeModule');

test/unit/@node-red/registry/lib/registry_spec.js

@@ -19,13 +19,12 @@ var when = require("when");
 var sinon = require("sinon");
 var path = require("path");
 
-var typeRegistry = require("../../../../../red/runtime/nodes/registry/registry");
+var NR_TEST_UTILS = require("nr-test-utils");
 
-var Node = require("../../../../../red/runtime/nodes/Node");
+var typeRegistry = NR_TEST_UTILS.require("@node-red/registry/lib/registry");
+var EventEmitter = require('events');
 
-var events = require("../../../../../red/runtime/events");
-
-var inherits = require("util").inherits;
+var events = new EventEmitter();
 
 describe("red/nodes/registry/registry",function() {
 
@@ -86,7 +85,7 @@ describe("red/nodes/registry/registry",function() {
 
     describe('#init/load', function() {
         it('loads initial config', function(done) {
-            typeRegistry.init(settingsWithStorageAndInitialConfig);
+            typeRegistry.init(settingsWithStorageAndInitialConfig,null,events);
             typeRegistry.getNodeList().should.have.lengthOf(0);
             typeRegistry.load();
             typeRegistry.getNodeList().should.have.lengthOf(1);
@@ -123,7 +122,7 @@ describe("red/nodes/registry/registry",function() {
                  }}
             };
             var expected = JSON.parse('{"node-red":{"name":"node-red","nodes":{"sentiment":{"name":"sentiment","types":["sentiment"],"enabled":true,"module":"node-red"},"inject":{"name":"inject","types":["inject"],"enabled":true,"module":"node-red"}}},"testModule":{"name":"testModule","nodes":{"a-module.js":{"name":"a-module.js","types":["example"],"enabled":true,"module":"testModule"}}}}');
-            typeRegistry.init(legacySettings);
+            typeRegistry.init(legacySettings,null,events);
             typeRegistry.load();
             legacySettings.set.calledOnce.should.be.true();
             legacySettings.set.args[0][1].should.eql(expected);
@@ -135,7 +134,7 @@ describe("red/nodes/registry/registry",function() {
     describe.skip('#addNodeSet', function() {
        it('adds a node set for an unknown module', function() {
 
-           typeRegistry.init(settings);
+           typeRegistry.init(settings,null,events);
 
            typeRegistry.getNodeList().should.have.lengthOf(0);
            typeRegistry.getModuleList().should.eql({});
@@ -164,7 +163,7 @@ describe("red/nodes/registry/registry",function() {
 
        it('adds a node set to an existing module', function() {
 
-           typeRegistry.init(settings);
+           typeRegistry.init(settings,null,events);
            typeRegistry.getNodeList().should.have.lengthOf(0);
            typeRegistry.getModuleList().should.eql({});
 
@@ -193,7 +192,7 @@ describe("red/nodes/registry/registry",function() {
        });
 
        it('doesnt add node set types if node set has an error', function() {
-           typeRegistry.init(settings);
+           typeRegistry.init(settings,null,events);
            typeRegistry.getNodeList().should.have.lengthOf(0);
            typeRegistry.getModuleList().should.eql({});
 
@@ -209,7 +208,7 @@ describe("red/nodes/registry/registry",function() {
        });
 
        it('doesnt add node set if type already exists', function() {
-           typeRegistry.init(settings);
+           typeRegistry.init(settings,null,events);
            typeRegistry.getNodeList().should.have.lengthOf(0);
            typeRegistry.getModuleList().should.eql({});
 
@@ -243,7 +242,7 @@ describe("red/nodes/registry/registry",function() {
 
     describe("#enableNodeSet", function() {
         it('throws error if settings unavailable', function() {
-            typeRegistry.init(settings);
+            typeRegistry.init(settings,null,events);
             /*jshint immed: false */
             (function(){
                 typeRegistry.enableNodeSet("test-module/test-name");
@@ -251,7 +250,7 @@ describe("red/nodes/registry/registry",function() {
         });
 
         it('throws error if module unknown', function() {
-            typeRegistry.init(settingsWithStorageAndInitialConfig);
+            typeRegistry.init(settingsWithStorageAndInitialConfig,null,events);
             /*jshint immed: false */
             (function(){
                 typeRegistry.enableNodeSet("test-module/unknown");
@@ -262,7 +261,7 @@ describe("red/nodes/registry/registry",function() {
     });
     describe("#disableNodeSet", function() {
         it('throws error if settings unavailable', function() {
-            typeRegistry.init(settings);
+            typeRegistry.init(settings,null,events);
             /*jshint immed: false */
             (function(){
                 typeRegistry.disableNodeSet("test-module/test-name");
@@ -270,7 +269,7 @@ describe("red/nodes/registry/registry",function() {
         });
 
         it('throws error if module unknown', function() {
-            typeRegistry.init(settingsWithStorageAndInitialConfig);
+            typeRegistry.init(settingsWithStorageAndInitialConfig,null,events);
             /*jshint immed: false */
             (function(){
                 typeRegistry.disableNodeSet("test-module/unknown");
@@ -281,7 +280,7 @@ describe("red/nodes/registry/registry",function() {
 
     describe('#getNodeConfig', function() {
         it('returns nothing for an unregistered type config', function(done) {
-            typeRegistry.init(settings);
+            typeRegistry.init(settings,null,events);
             var config = typeRegistry.getNodeConfig("imaginary-shark");
             (config === null).should.be.true();
             done();
@@ -298,7 +297,8 @@ describe("red/nodes/registry/registry",function() {
         });
         it('saves the list',function(done) {
             var s = stubSettings({},true,{});
-            typeRegistry.init(s);
+            typeRegistry.init(s,null,events);
+
             typeRegistry.addModule({name: "test-module",version:"0.0.1",nodes: {
                 "test-name":testNodeSet1,
                 "test-name-2":testNodeSet2WithError
@@ -326,7 +326,7 @@ describe("red/nodes/registry/registry",function() {
     describe('#removeModule',function() {
         it('throws error for unknown module', function() {
             var s = stubSettings({},true,{});
-            typeRegistry.init(s);
+            typeRegistry.init(s,null,events);
             /*jshint immed: false */
             (function(){
                 typeRegistry.removeModule("test-module/unknown");
@@ -334,7 +334,7 @@ describe("red/nodes/registry/registry",function() {
         });
         it('throws error for unavaiable settings', function() {
             var s = stubSettings({},false,{});
-            typeRegistry.init(s);
+            typeRegistry.init(s,null,events);
             /*jshint immed: false */
             (function(){
                 typeRegistry.removeModule("test-module/unknown");
@@ -342,7 +342,7 @@ describe("red/nodes/registry/registry",function() {
         });
         it('removes a known module', function() {
             var s = stubSettings({},true,{});
-            typeRegistry.init(s);
+            typeRegistry.init(s,null,events);
             typeRegistry.addModule({name: "test-module",version:"0.0.1",nodes: {
                 "test-name":testNodeSet1
             }});
@@ -361,7 +361,7 @@ describe("red/nodes/registry/registry",function() {
         it('returns node config', function() {
             typeRegistry.init(settings,{
                 getNodeHelp: function(config) { return "HE"+config.name+"LP" }
-            });
+            },events);
 
             typeRegistry.addModule({name: "test-module",version:"0.0.1",nodes: {
                 "test-name":{
@@ -390,7 +390,7 @@ describe("red/nodes/registry/registry",function() {
     });
     describe('#getModuleInfo', function() {
         it('returns module info', function() {
-            typeRegistry.init(settings,{});
+            typeRegistry.init(settings,{},events);
             typeRegistry.addModule({name: "test-module",version:"0.0.1",nodes: {
                 "test-name":{
                     id: "test-module/test-name",
@@ -414,7 +414,7 @@ describe("red/nodes/registry/registry",function() {
     });
     describe('#getNodeInfo', function() {
         it('returns node info', function() {
-            typeRegistry.init(settings,{});
+            typeRegistry.init(settings,{},events);
             typeRegistry.addModule({name: "test-module",version:"0.0.1",nodes: {
                 "test-name":{
                     id: "test-module/test-name",
@@ -435,7 +435,7 @@ describe("red/nodes/registry/registry",function() {
     });
     describe('#getFullNodeInfo', function() {
         it('returns node info', function() {
-            typeRegistry.init(settings,{});
+            typeRegistry.init(settings,{},events);
             typeRegistry.addModule({name: "test-module",version:"0.0.1",nodes: {
                 "test-name":{
                     id: "test-module/test-name",
@@ -460,7 +460,7 @@ describe("red/nodes/registry/registry",function() {
     });
     describe('#getNodeList', function() {
         it("returns a filtered list", function() {
-            typeRegistry.init(settings,{});
+            typeRegistry.init(settings,{},events);
             typeRegistry.addModule({name: "test-module",version:"0.0.1",nodes: {
                 "test-name":{
                     id: "test-module/test-name",
@@ -494,8 +494,7 @@ describe("red/nodes/registry/registry",function() {
     describe('#registerNodeConstructor', function() {
         var TestNodeConstructor;
         beforeEach(function() {
-            TestNodeConstructor = function TestNodeConstructor() {
-            };
+            TestNodeConstructor = function TestNodeConstructor() {};
             sinon.stub(events,'emit');
         });
         afterEach(function() {
@@ -518,38 +517,17 @@ describe("red/nodes/registry/registry",function() {
             }).should.throw("node-type already registered");
             events.emit.calledOnce.should.be.true();
         });
-        it('extends a constructor with the Node constructor', function() {
-            TestNodeConstructor.prototype.should.not.be.an.instanceOf(Node);
-            typeRegistry.registerNodeConstructor('node-set','node-type',TestNodeConstructor);
-            TestNodeConstructor.prototype.should.be.an.instanceOf(Node);
-        });
-        it('does not override a constructor\'s prototype', function() {
-            function Foo(){};
-            inherits(TestNodeConstructor,Foo);
-            TestNodeConstructor.prototype.should.be.an.instanceOf(Foo);
-            TestNodeConstructor.prototype.should.not.be.an.instanceOf(Node);
-
-            typeRegistry.registerNodeConstructor('node-set','node-type',TestNodeConstructor);
-
-            TestNodeConstructor.prototype.should.be.an.instanceOf(Node);
-            TestNodeConstructor.prototype.should.be.an.instanceOf(Foo);
-
-            typeRegistry.registerNodeConstructor('node-set','node-type2',TestNodeConstructor);
-            TestNodeConstructor.prototype.should.be.an.instanceOf(Node);
-            TestNodeConstructor.prototype.should.be.an.instanceOf(Foo);
-        });
     });
 
     describe('#getNodeIconPath', function() {
-        it('returns the default icon when getting an unknown icon', function() {
-            var defaultIcon = path.resolve(__dirname+'/../../../../../public/icons/arrow-in.png');
+        it('returns the null when getting an unknown icon', function() {
             var iconPath = typeRegistry.getNodeIconPath('random-module','youwonthaveme.png');
-            iconPath.should.eql(defaultIcon);
+            should.not.exist(iconPath);
         });
 
         it('returns a registered icon' , function() {
-            var testIcon = path.resolve(__dirname+'/../../../../resources/icons/');
-            typeRegistry.init(settings,{});            
+            var testIcon = path.resolve(__dirname+'/resources/userDir/lib/icons/');
+            typeRegistry.init(settings,{},events);
             typeRegistry.addModule({name: "test-module",version:"0.0.1",nodes: {
                 "test-name":{
                     id: "test-module/test-name",
@@ -566,10 +544,10 @@ describe("red/nodes/registry/registry",function() {
             iconPath.should.eql(path.resolve(testIcon+"/test_icon.png"));
         });
 
-        it('returns the debug icon when getting an unknown module', function() {
-            var debugIcon = path.resolve(__dirname+'/../../../../../public/icons/debug.png');
+        it('returns null when getting an unknown module', function() {
+            var debugIcon = path.resolve(__dirname+'/../../../public/icons/debug.png');
             var iconPath = typeRegistry.getNodeIconPath('unknown-module', 'debug.png');
-            iconPath.should.eql(debugIcon);
+            should.not.exist(iconPath);
         });
     });
 
@@ -597,12 +575,6 @@ describe("red/nodes/registry/registry",function() {
             var iconList = typeRegistry.getNodeIcons();
             iconList.should.eql({"test-module":["test_icon.png"]});
         });
-
-        it.skip('returns an icon list of unregistered node module', function() {
-            // events.emit("node-icon-dir",{name:"test-module", path:"", icons:["test_icon1.png", "test_icon2.png"]});
-            var iconList = typeRegistry.getNodeIcons();
-            iconList.should.eql({"test-module":["test_icon1.png","test_icon2.png"]});
-        });
     });
 
 });