mirror of
https://github.com/node-red/node-red.git
synced 2025-03-01 10:36:34 +00:00
Remove known unused files
This commit is contained in:
andrew.greene
@@ -1,809 +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 sinon = require('sinon');
|
||||
var NR_TEST_UTILS = require("nr-test-utils");
|
||||
var RedNode = NR_TEST_UTILS.require("@node-red/runtime/lib/nodes/Node");
|
||||
var Log = NR_TEST_UTILS.require("@node-red/util").log;
|
||||
var hooks = NR_TEST_UTILS.require("@node-red/util/lib/hooks");
|
||||
var flows = NR_TEST_UTILS.require("@node-red/runtime/lib/flows");
|
||||
|
||||
describe('Node', function() {
|
||||
describe('#constructor',function() {
|
||||
it('is called with an id and a type',function() {
|
||||
var n = new RedNode({id:'123',type:'abc'});
|
||||
n.should.have.property('id','123');
|
||||
n.should.have.property('type','abc');
|
||||
n.should.not.have.property('name');
|
||||
n.wires.should.be.empty();
|
||||
});
|
||||
|
||||
it('is called with an id, a type and a name',function() {
|
||||
var n = new RedNode({id:'123',type:'abc',name:'barney'});
|
||||
n.should.have.property('id','123');
|
||||
n.should.have.property('type','abc');
|
||||
n.should.have.property('name','barney');
|
||||
n.wires.should.be.empty();
|
||||
});
|
||||
|
||||
it('is called with an id, a type and some wires',function() {
|
||||
var n = new RedNode({id:'123',type:'abc',wires:['123','456']});
|
||||
n.should.have.property('id','123');
|
||||
n.should.have.property('type','abc');
|
||||
n.should.not.have.property('name');
|
||||
n.wires.should.have.length(2);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('#close', function() {
|
||||
it('emits close event when closed',function(done) {
|
||||
var n = new RedNode({id:'123',type:'abc'});
|
||||
n.on('close',function() {
|
||||
done();
|
||||
});
|
||||
n.close();
|
||||
});
|
||||
|
||||
it('returns a promise when provided a callback with a done parameter',function(testdone) {
|
||||
var n = new RedNode({id:'123',type:'abc'});
|
||||
n.on('close',function(done) {
|
||||
setTimeout(function() {
|
||||
done();
|
||||
},50);
|
||||
});
|
||||
var p = n.close();
|
||||
should.exist(p);
|
||||
p.then(function() {
|
||||
testdone();
|
||||
});
|
||||
});
|
||||
it('accepts a callback with "removed" and "done" parameters', function(testdone) {
|
||||
var n = new RedNode({id:'123',type:'abc'});
|
||||
var receivedRemoved;
|
||||
n.on('close',function(removed,done) {
|
||||
receivedRemoved = removed;
|
||||
setTimeout(function() {
|
||||
done();
|
||||
},50);
|
||||
});
|
||||
var p = n.close(true);
|
||||
should.exist(p);
|
||||
(receivedRemoved).should.be.true();
|
||||
p.then(function() {
|
||||
testdone();
|
||||
});
|
||||
})
|
||||
it('allows multiple close handlers to be registered',function(testdone) {
|
||||
var n = new RedNode({id:'123',type:'abc'});
|
||||
var callbacksClosed = 0;
|
||||
n.on('close',function(done) {
|
||||
setTimeout(function() {
|
||||
callbacksClosed++;
|
||||
done();
|
||||
},50);
|
||||
});
|
||||
n.on('close',function(done) {
|
||||
setTimeout(function() {
|
||||
callbacksClosed++;
|
||||
done();
|
||||
},75);
|
||||
});
|
||||
n.on('close',function() {
|
||||
callbacksClosed++;
|
||||
});
|
||||
var p = n.close();
|
||||
should.exist(p);
|
||||
p.then(function() {
|
||||
callbacksClosed.should.eql(3);
|
||||
testdone();
|
||||
}).catch(function(e) {
|
||||
testdone(e);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
|
||||
describe('#receive', function() {
|
||||
it('emits input event when called', function(done) {
|
||||
var n = new RedNode({id:'123',type:'abc'});
|
||||
var message = {payload:"hello world"};
|
||||
n.on('input',function(msg) {
|
||||
should.deepEqual(msg,message);
|
||||
done();
|
||||
});
|
||||
n.receive(message);
|
||||
});
|
||||
|
||||
it('writes metric info with undefined msg', function(done){
|
||||
var n = new RedNode({id:'123',type:'abc'});
|
||||
n.on('input',function(msg) {
|
||||
(typeof msg).should.not.be.equal("undefined");
|
||||
(typeof msg._msgid).should.not.be.equal("undefined");
|
||||
done();
|
||||
});
|
||||
n.receive();
|
||||
});
|
||||
|
||||
it('writes metric info with null msg', function(done){
|
||||
var n = new RedNode({id:'123',type:'abc'});
|
||||
n.on('input',function(msg) {
|
||||
(typeof msg).should.not.be.equal("undefined");
|
||||
(typeof msg._msgid).should.not.be.equal("undefined");
|
||||
done();
|
||||
});
|
||||
n.receive(null);
|
||||
});
|
||||
|
||||
it('handles thrown errors', function(done) {
|
||||
var n = new RedNode({id:'123',type:'abc'});
|
||||
sinon.stub(n,"error").callsFake(function(err,msg) {});
|
||||
var message = {payload:"hello world"};
|
||||
n.on('input',function(msg) {
|
||||
throw new Error("test error");
|
||||
});
|
||||
n.receive(message);
|
||||
setTimeout(function() {
|
||||
n.error.called.should.be.true();
|
||||
n.error.firstCall.args[1].should.equal(message);
|
||||
done();
|
||||
},50);
|
||||
});
|
||||
|
||||
it('calls parent flow handleComplete when callback provided', function(done) {
|
||||
var n = new RedNode({id:'123',type:'abc', _flow: {
|
||||
handleComplete: function(node,msg) {
|
||||
try {
|
||||
msg.should.deepEqual(message);
|
||||
done();
|
||||
} catch(err) {
|
||||
done(err);
|
||||
}
|
||||
}
|
||||
}});
|
||||
|
||||
var message = {payload:"hello world"};
|
||||
n.on('input',function(msg, nodeSend, nodeDone) {
|
||||
nodeDone();
|
||||
});
|
||||
n.receive(message);
|
||||
});
|
||||
|
||||
it('triggers onComplete hook when done callback provided', function(done) {
|
||||
var handleCompleteCalled = false;
|
||||
var hookCalled = false;
|
||||
var n = new RedNode({id:'123',type:'abc', _flow: {
|
||||
handleComplete: function(node,msg) {
|
||||
handleCompleteCalled = true;
|
||||
}
|
||||
}});
|
||||
var hookError;
|
||||
hooks.add("onComplete",function(completeEvent) {
|
||||
hookCalled = true;
|
||||
try {
|
||||
handleCompleteCalled.should.be.false("onComplete should be called before handleComplete")
|
||||
should.not.exist(completeEvent.error);
|
||||
completeEvent.msg.should.deepEqual(message);
|
||||
completeEvent.node.id.should.eql("123");
|
||||
completeEvent.node.node.should.equal(n);
|
||||
} catch(err) {
|
||||
hookError = err;
|
||||
}
|
||||
})
|
||||
var message = {payload:"hello world"};
|
||||
n.on('input',function(msg, nodeSend, nodeDone) {
|
||||
nodeDone();
|
||||
});
|
||||
n.receive(message);
|
||||
setTimeout(function() {
|
||||
if (hookError) {
|
||||
done(hookError);
|
||||
return
|
||||
}
|
||||
try {
|
||||
hookCalled.should.be.true("onComplete hook should be called");
|
||||
handleCompleteCalled.should.be.true("handleComplete should be called");
|
||||
done();
|
||||
} catch(err) {
|
||||
done(err);
|
||||
}
|
||||
})
|
||||
});
|
||||
|
||||
it('triggers onComplete hook when done callback provided - with error', function(done) {
|
||||
var handleCompleteCalled = false;
|
||||
var hookCalled = false;
|
||||
var errorReported = false;
|
||||
var n = new RedNode({id:'123',type:'abc', _flow: {
|
||||
handleComplete: function(node,msg) {
|
||||
handleCompleteCalled = true;
|
||||
}
|
||||
}});
|
||||
var hookError;
|
||||
hooks.add("onComplete",function(completeEvent) {
|
||||
hookCalled = true;
|
||||
try {
|
||||
handleCompleteCalled.should.be.false("onComplete should be called before handleComplete")
|
||||
should.exist(completeEvent.error);
|
||||
completeEvent.error.toString().should.equal("Error: test error")
|
||||
completeEvent.msg.should.deepEqual(message);
|
||||
completeEvent.node.id.should.eql("123");
|
||||
completeEvent.node.node.should.equal(n);
|
||||
} catch(err) {
|
||||
hookError = err;
|
||||
}
|
||||
})
|
||||
var message = {payload:"hello world"};
|
||||
n.on('input',function(msg, nodeSend, nodeDone) {
|
||||
nodeDone(new Error("test error"));
|
||||
});
|
||||
n.error = function(err,msg) {
|
||||
errorReported = true;
|
||||
}
|
||||
n.receive(message);
|
||||
setTimeout(function() {
|
||||
if (hookError) {
|
||||
done(hookError);
|
||||
return
|
||||
}
|
||||
try {
|
||||
hookCalled.should.be.true("onComplete hook should be called");
|
||||
handleCompleteCalled.should.be.false("handleComplete should not be called");
|
||||
done();
|
||||
} catch(err) {
|
||||
done(err);
|
||||
}
|
||||
})
|
||||
});
|
||||
it('logs error if callback provides error', function(done) {
|
||||
var n = new RedNode({id:'123',type:'abc'});
|
||||
sinon.stub(n,"error").callsFake(function(err,msg) {});
|
||||
|
||||
var message = {payload:"hello world"};
|
||||
n.on('input',function(msg, nodeSend, nodeDone) {
|
||||
nodeDone(new Error("test error"));
|
||||
setTimeout(function() {
|
||||
try {
|
||||
n.error.called.should.be.true();
|
||||
n.error.firstCall.args[0].toString().should.equal("Error: test error");
|
||||
n.error.firstCall.args[1].should.equal(message);
|
||||
done();
|
||||
} catch(err) {
|
||||
done(err);
|
||||
}
|
||||
},50);
|
||||
});
|
||||
n.receive(message);
|
||||
});
|
||||
it("triggers hooks when receiving a message", function(done) {
|
||||
var hookErrors = [];
|
||||
var messageReceived = false;
|
||||
var hooksCalled = [];
|
||||
hooks.add("onReceive", function(receiveEvent) {
|
||||
hooksCalled.push("onReceive")
|
||||
try {
|
||||
messageReceived.should.be.false("Message should not have been received before onReceive")
|
||||
receiveEvent.msg.should.be.exactly(message);
|
||||
receiveEvent.destination.id.should.equal("123")
|
||||
receiveEvent.destination.node.should.equal(n)
|
||||
} catch(err) {
|
||||
hookErrors.push(err);
|
||||
}
|
||||
})
|
||||
hooks.add("postReceive", function(receiveEvent) {
|
||||
hooksCalled.push("postReceive")
|
||||
try {
|
||||
messageReceived.should.be.true("Message should have been received before postReceive")
|
||||
receiveEvent.msg.should.be.exactly(message);
|
||||
receiveEvent.destination.id.should.equal("123")
|
||||
receiveEvent.destination.node.should.equal(n)
|
||||
} catch(err) {
|
||||
hookErrors.push(err);
|
||||
}
|
||||
|
||||
})
|
||||
var n = new RedNode({id:'123',type:'abc'});
|
||||
var message = {payload:"hello world"};
|
||||
n.on('input',function(msg) {
|
||||
messageReceived = true;
|
||||
try {
|
||||
should.strictEqual(this,n);
|
||||
hooksCalled.should.eql(["onReceive"])
|
||||
should.deepEqual(msg,message);
|
||||
} catch(err) {
|
||||
hookErrors.push(err)
|
||||
}
|
||||
});
|
||||
n.receive(message);
|
||||
setTimeout(function() {
|
||||
hooks.clear();
|
||||
if (hookErrors.length > 0) {
|
||||
done(hookErrors[0])
|
||||
} else {
|
||||
done();
|
||||
}
|
||||
},10);
|
||||
});
|
||||
describe("errors thrown by hooks are reported", function() {
|
||||
before(function() {
|
||||
hooks.add("onReceive",function(recEvent) {
|
||||
if (recEvent.msg.payload === "trigger-onReceive") {
|
||||
throw new Error("onReceive Error")
|
||||
}
|
||||
})
|
||||
hooks.add("postReceive",function(recEvent) {
|
||||
if (recEvent.msg.payload === "trigger-postReceive") {
|
||||
throw new Error("postReceive Error")
|
||||
}
|
||||
})
|
||||
})
|
||||
after(function() {
|
||||
hooks.clear();
|
||||
})
|
||||
function testHook(hook, msgExpected, done) {
|
||||
var messageReceived = false;
|
||||
var errorReceived;
|
||||
var n = new RedNode({id:'123',type:'abc'});
|
||||
var message = {payload:"trigger-"+hook};
|
||||
n.on('input',function(msg) {
|
||||
messageReceived = true;
|
||||
});
|
||||
n.error = function (err) {
|
||||
errorReceived = err;
|
||||
}
|
||||
|
||||
n.receive(message);
|
||||
|
||||
setTimeout(function() {
|
||||
try {
|
||||
messageReceived.should.equal(msgExpected,`Hook ${hook} messageReceived expected ${msgExpected} actual ${messageReceived}`);
|
||||
should.exist(errorReceived);
|
||||
errorReceived.toString().should.containEql(hook)
|
||||
done()
|
||||
} catch(err) {
|
||||
done(err);
|
||||
}
|
||||
},10);
|
||||
}
|
||||
it("onReceive", function(done) { testHook("onReceive", false, done)})
|
||||
it("postReceive", function(done) { testHook("postReceive", true, done)})
|
||||
})
|
||||
});
|
||||
|
||||
describe("hooks can halt receive", function() {
|
||||
before(function() {
|
||||
hooks.add("onReceive",function(recEvent) {
|
||||
if (recEvent.msg.payload === "trigger-onReceive") {
|
||||
return false;
|
||||
}
|
||||
})
|
||||
})
|
||||
after(function() {
|
||||
hooks.clear();
|
||||
})
|
||||
|
||||
function testHook(hook, msgExpected, done) {
|
||||
var messageReceived = false;
|
||||
var errorReceived;
|
||||
var n = new RedNode({id:'123',type:'abc'});
|
||||
var message = {payload:"trigger-"+hook};
|
||||
n.on('input',function(msg) {
|
||||
messageReceived = true;
|
||||
});
|
||||
n.error = function (err) {
|
||||
errorReceived = err;
|
||||
}
|
||||
|
||||
n.receive(message);
|
||||
|
||||
setTimeout(function() {
|
||||
try {
|
||||
messageReceived.should.equal(msgExpected,`Hook ${hook} messageReceived expected ${msgExpected} actual ${messageReceived}`);
|
||||
should.not.exist(errorReceived);
|
||||
done()
|
||||
} catch(err) {
|
||||
done(err);
|
||||
}
|
||||
},10);
|
||||
}
|
||||
it("onReceive", function(done) { testHook("onReceive", false, done)})
|
||||
})
|
||||
|
||||
|
||||
describe('#send', function() {
|
||||
|
||||
it('emits a single message', function(done) {
|
||||
var flow = {
|
||||
send: (sendEvents) => {
|
||||
try {
|
||||
sendEvents.should.have.length(1);
|
||||
sendEvents[0].msg.should.equal(message);
|
||||
sendEvents[0].destination.should.eql({id:"n2", node: undefined});
|
||||
sendEvents[0].source.should.eql({id:"n1", node: n1, port: 0})
|
||||
done();
|
||||
} catch(err) {
|
||||
done(err);
|
||||
}
|
||||
},
|
||||
};
|
||||
var n1 = new RedNode({_flow:flow,id:'n1',type:'abc',wires:[['n2']]});
|
||||
var message = {payload:"hello world"};
|
||||
n1.send(message);
|
||||
});
|
||||
|
||||
it('emits a message with callback provided send', function(done) {
|
||||
var flow = {
|
||||
handleError: (node,logMessage,msg,reportingNode) => {done(logMessage)},
|
||||
handleComplete: (node,msg) => {},
|
||||
send: (sendEvents) => {
|
||||
try {
|
||||
sendEvents.should.have.length(1);
|
||||
sendEvents[0].msg.should.equal(message);
|
||||
sendEvents[0].destination.should.eql({id:"n2", node: undefined});
|
||||
sendEvents[0].source.should.eql({id:"n1", node: n1, port: 0});
|
||||
sendEvents[0].cloneMessage.should.be.false();
|
||||
done();
|
||||
} catch(err) {
|
||||
done(err);
|
||||
}
|
||||
},
|
||||
};
|
||||
var n1 = new RedNode({_flow:flow,id:'n1',type:'abc',wires:[['n2']]});
|
||||
var message = {payload:"hello world"};
|
||||
n1.on('input',function(msg,nodeSend,nodeDone) {
|
||||
nodeSend(msg);
|
||||
nodeDone();
|
||||
});
|
||||
n1.receive(message);
|
||||
});
|
||||
|
||||
it('emits multiple messages on a single output', function(done) {
|
||||
var flow = {
|
||||
handleError: (node,logMessage,msg,reportingNode) => {done(logMessage)},
|
||||
send: (sendEvents) => {
|
||||
try {
|
||||
sendEvents.should.have.length(2);
|
||||
sendEvents[0].msg.should.equal(messages[0]);
|
||||
sendEvents[0].destination.should.eql({id:"n2", node: undefined});
|
||||
sendEvents[0].source.should.eql({id:"n1", node: n1, port: 0});
|
||||
sendEvents[0].cloneMessage.should.be.false();
|
||||
|
||||
sendEvents[1].msg.should.equal(messages[1]);
|
||||
sendEvents[1].destination.should.eql({id:"n2", node: undefined});
|
||||
sendEvents[1].source.should.eql({id:"n1", node: n1, port: 0});
|
||||
sendEvents[1].cloneMessage.should.be.true();
|
||||
|
||||
done();
|
||||
} catch(err) {
|
||||
done(err);
|
||||
}
|
||||
},
|
||||
};
|
||||
var n1 = new RedNode({_flow:flow,id:'n1',type:'abc',wires:[['n2']]});
|
||||
|
||||
var messages = [
|
||||
{payload:"hello world"},
|
||||
{payload:"hello world again"}
|
||||
];
|
||||
|
||||
n1.send([messages]);
|
||||
});
|
||||
|
||||
it('emits messages to multiple outputs', function(done) {
|
||||
var flow = {
|
||||
handleError: (node,logMessage,msg,reportingNode) => {done(logMessage)},
|
||||
send: (sendEvents) => {
|
||||
try {
|
||||
sendEvents.should.have.length(3);
|
||||
sendEvents[0].msg.should.equal(messages[0]);
|
||||
sendEvents[0].destination.should.eql({id:"n2", node: undefined});
|
||||
sendEvents[0].source.should.eql({id:"n1", node: n1, port: 0});
|
||||
sendEvents[0].cloneMessage.should.be.false();
|
||||
should.exist(sendEvents[0].msg._msgid);
|
||||
sendEvents[1].msg.should.equal(messages[2]);
|
||||
sendEvents[1].destination.should.eql({id:"n4", node: undefined});
|
||||
sendEvents[1].source.should.eql({id:"n1", node: n1, port: 2})
|
||||
sendEvents[1].cloneMessage.should.be.true();
|
||||
should.exist(sendEvents[1].msg._msgid);
|
||||
sendEvents[2].msg.should.equal(messages[2]);
|
||||
sendEvents[2].destination.should.eql({id:"n5", node: undefined});
|
||||
sendEvents[2].source.should.eql({id:"n1", node: n1, port: 2})
|
||||
sendEvents[2].cloneMessage.should.be.true();
|
||||
should.exist(sendEvents[2].msg._msgid);
|
||||
|
||||
sendEvents[0].msg._msgid.should.eql(sendEvents[1].msg._msgid)
|
||||
sendEvents[1].msg._msgid.should.eql(sendEvents[2].msg._msgid)
|
||||
|
||||
done();
|
||||
} catch(err) {
|
||||
done(err);
|
||||
}
|
||||
}
|
||||
};
|
||||
var n1 = new RedNode({_flow:flow, id:'n1',type:'abc',wires:[['n2'],['n3'],['n4','n5']]});
|
||||
var n2 = new RedNode({_flow:flow, id:'n2',type:'abc'});
|
||||
var n3 = new RedNode({_flow:flow, id:'n3',type:'abc'});
|
||||
var n4 = new RedNode({_flow:flow, id:'n4',type:'abc'});
|
||||
var n5 = new RedNode({_flow:flow, id:'n5',type:'abc'});
|
||||
var messages = [
|
||||
{payload:"hello world"},
|
||||
null,
|
||||
{payload:"hello world again"}
|
||||
];
|
||||
|
||||
var rcvdCount = 0;
|
||||
|
||||
n1.send(messages);
|
||||
});
|
||||
|
||||
it('emits no messages', function(done) {
|
||||
var flow = {
|
||||
handleError: (node,logMessage,msg,reportingNode) => {done(logMessage)},
|
||||
getNode: (id) => { return {'n1':n1,'n2':n2}[id]},
|
||||
};
|
||||
var n1 = new RedNode({_flow:flow,id:'n1',type:'abc',wires:[['n2']]});
|
||||
var n2 = new RedNode({_flow:flow,id:'n2',type:'abc'});
|
||||
|
||||
n2.on('input',function(msg) {
|
||||
should.fail(null,null,"unexpected message");
|
||||
});
|
||||
|
||||
setTimeout(function() {
|
||||
done();
|
||||
}, 200);
|
||||
|
||||
n1.send();
|
||||
});
|
||||
|
||||
// it('emits messages without cloning req or res', function(done) {
|
||||
// var flow = {
|
||||
// getNode: (id) => { return {'n1':n1,'n2':n2,'n3':n3}[id]},
|
||||
// send: (node,dst,msg) => { setImmediate(function() { flow.getNode(dst).receive(msg) })}
|
||||
// };
|
||||
// var n1 = new RedNode({_flow:flow,id:'n1',type:'abc',wires:[[['n2'],['n3']]]});
|
||||
// var n2 = new RedNode({_flow:flow,id:'n2',type:'abc'});
|
||||
// var n3 = new RedNode({_flow:flow,id:'n3',type:'abc'});
|
||||
//
|
||||
// var req = {};
|
||||
// var res = {};
|
||||
// var cloned = {};
|
||||
// var message = {payload: "foo", cloned: cloned, req: req, res: res};
|
||||
//
|
||||
// var rcvdCount = 0;
|
||||
//
|
||||
// // first message to be sent, so should not be cloned
|
||||
// n2.on('input',function(msg) {
|
||||
// should.deepEqual(msg, message);
|
||||
// msg.cloned.should.be.exactly(message.cloned);
|
||||
// msg.req.should.be.exactly(message.req);
|
||||
// msg.res.should.be.exactly(message.res);
|
||||
// rcvdCount += 1;
|
||||
// if (rcvdCount == 2) {
|
||||
// done();
|
||||
// }
|
||||
// });
|
||||
//
|
||||
// // second message to be sent, so should be cloned
|
||||
// // message uuids wont match since we've cloned
|
||||
// n3.on('input',function(msg) {
|
||||
// msg.payload.should.equal(message.payload);
|
||||
// msg.cloned.should.not.be.exactly(message.cloned);
|
||||
// msg.req.should.be.exactly(message.req);
|
||||
// msg.res.should.be.exactly(message.res);
|
||||
// rcvdCount += 1;
|
||||
// if (rcvdCount == 2) {
|
||||
// done();
|
||||
// }
|
||||
// });
|
||||
//
|
||||
// n1.send(message);
|
||||
// });
|
||||
|
||||
// it("logs the uuid for all messages sent", function(done) {
|
||||
// var logHandler = {
|
||||
// msgIds:[],
|
||||
// messagesSent: 0,
|
||||
// emit: function(event, msg) {
|
||||
// if (msg.event == "node.abc.send" && msg.level == Log.METRIC) {
|
||||
// this.messagesSent++;
|
||||
// this.msgIds.push(msg.msgid);
|
||||
// (typeof msg.msgid).should.not.be.equal("undefined");
|
||||
// }
|
||||
// }
|
||||
// };
|
||||
//
|
||||
// Log.addHandler(logHandler);
|
||||
// var flow = {
|
||||
// getNode: (id) => { return {'n1':sender,'n2':receiver1,'n3':receiver2}[id]},
|
||||
// send: (node,dst,msg) => { setImmediate(function() { flow.getNode(dst).receive(msg) })}
|
||||
// };
|
||||
//
|
||||
// var sender = new RedNode({_flow:flow,id:'n1',type:'abc', wires:[['n2', 'n3']]});
|
||||
// var receiver1 = new RedNode({_flow:flow,id:'n2',type:'abc'});
|
||||
// var receiver2 = new RedNode({_flow:flow,id:'n3',type:'abc'});
|
||||
// sender.send({"some": "message"});
|
||||
// setTimeout(function() {
|
||||
// try {
|
||||
// logHandler.messagesSent.should.equal(1);
|
||||
// should.exist(logHandler.msgIds[0])
|
||||
// Log.removeHandler(logHandler);
|
||||
// done();
|
||||
// } catch(err) {
|
||||
// Log.removeHandler(logHandler);
|
||||
// done(err);
|
||||
// }
|
||||
// },50)
|
||||
// })
|
||||
});
|
||||
|
||||
|
||||
describe('#log', function() {
|
||||
it('produces a log message', function(done) {
|
||||
var n = new RedNode({id:'123',type:'abc',z:'789', _flow: {log:function(msg) { loginfo = msg;}}});
|
||||
var loginfo = {};
|
||||
n.log("a log message");
|
||||
should.deepEqual({level:Log.INFO, id:n.id,
|
||||
type:n.type, msg:"a log message",z:'789'}, loginfo);
|
||||
done();
|
||||
});
|
||||
it('produces a log message with a name', function(done) {
|
||||
var n = new RedNode({id:'123', type:'abc', name:"barney", z:'789', _flow: {log:function(msg) { loginfo = msg;}}});
|
||||
var loginfo = {};
|
||||
n.log("a log message");
|
||||
should.deepEqual({level:Log.INFO, id:n.id, name: "barney",
|
||||
type:n.type, msg:"a log message",z:'789'}, loginfo);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
describe('#warn', function() {
|
||||
it('produces a warning message', function(done) {
|
||||
var n = new RedNode({id:'123',type:'abc',z:'789', _flow: {log:function(msg) { loginfo = msg;}}});
|
||||
var loginfo = {};
|
||||
n.warn("a warning");
|
||||
should.deepEqual({level:Log.WARN, id:n.id,
|
||||
type:n.type, msg:"a warning",z:'789'}, loginfo);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
describe('#error', function() {
|
||||
it('handles a null error message', function(done) {
|
||||
var flow = {
|
||||
handleError: sinon.stub(),
|
||||
log:sinon.stub()
|
||||
}
|
||||
var n = new RedNode({_flow:flow, id:'123',type:'abc',z:'789'});
|
||||
var message = {a:1};
|
||||
n.error(null,message);
|
||||
|
||||
flow.handleError.called.should.be.true();
|
||||
flow.handleError.args[0][0].should.eql(n);
|
||||
flow.handleError.args[0][1].should.eql("");
|
||||
flow.handleError.args[0][2].should.eql(message);
|
||||
|
||||
done();
|
||||
});
|
||||
|
||||
it('produces an error message', function(done) {
|
||||
var flow = {
|
||||
handleError: sinon.stub(),
|
||||
log:sinon.stub()
|
||||
}
|
||||
var n = new RedNode({_flow:flow, id:'123',type:'abc',z:'789'});
|
||||
var message = {a:2};
|
||||
|
||||
n.error("This is an error",message);
|
||||
|
||||
flow.handleError.called.should.be.true();
|
||||
flow.handleError.args[0][0].should.eql(n);
|
||||
flow.handleError.args[0][1].should.eql("This is an error");
|
||||
flow.handleError.args[0][2].should.eql(message);
|
||||
|
||||
done();
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('#metric', function() {
|
||||
it('produces a metric message', function(done) {
|
||||
var n = new RedNode({id:'123',type:'abc'});
|
||||
var loginfo = {};
|
||||
sinon.stub(Log, 'log').callsFake(function(msg) {
|
||||
loginfo = msg;
|
||||
});
|
||||
var msg = {payload:"foo", _msgid:"987654321"};
|
||||
n.metric("test.metric",msg,"15mb");
|
||||
should.deepEqual({value:"15mb", level:Log.METRIC, nodeid:n.id,
|
||||
event:"node.abc.test.metric",msgid:"987654321"}, loginfo);
|
||||
Log.log.restore();
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
describe('#metric', function() {
|
||||
it('returns metric value if eventname undefined', function(done) {
|
||||
var n = new RedNode({id:'123',type:'abc'});
|
||||
var loginfo = {};
|
||||
sinon.stub(Log, 'log').callsFake(function(msg) {
|
||||
loginfo = msg;
|
||||
});
|
||||
var msg = {payload:"foo", _msgid:"987654321"};
|
||||
var m = n.metric(undefined,msg,"15mb");
|
||||
m.should.be.a.Boolean();
|
||||
Log.log.restore();
|
||||
done();
|
||||
});
|
||||
it('returns not defined if eventname defined', function(done) {
|
||||
var n = new RedNode({id:'123',type:'abc'});
|
||||
var loginfo = {};
|
||||
sinon.stub(Log, 'log').callsFake(function(msg) {
|
||||
loginfo = msg;
|
||||
});
|
||||
var msg = {payload:"foo", _msgid:"987654321"};
|
||||
var m = n.metric("info",msg,"15mb");
|
||||
should(m).be.undefined;
|
||||
Log.log.restore();
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
describe('#status', function() {
|
||||
it('publishes status', function(done) {
|
||||
var flow = {
|
||||
handleStatus: sinon.stub()
|
||||
}
|
||||
var n = new RedNode({_flow:flow,id:'123',type:'abc'});
|
||||
var status = {fill:"green",shape:"dot",text:"connected"};
|
||||
|
||||
n.status(status);
|
||||
|
||||
flow.handleStatus.called.should.be.true();
|
||||
flow.handleStatus.args[0][0].should.eql(n);
|
||||
flow.handleStatus.args[0][1].should.eql(status);
|
||||
done();
|
||||
});
|
||||
it('publishes status for plain string', function(done) {
|
||||
var flow = { handleStatus: sinon.stub() }
|
||||
var n = new RedNode({_flow:flow,id:'123',type:'abc'});
|
||||
n.status("text status");
|
||||
flow.handleStatus.called.should.be.true();
|
||||
flow.handleStatus.args[0][0].should.eql(n);
|
||||
flow.handleStatus.args[0][1].should.eql({text:"text status"});
|
||||
done();
|
||||
});
|
||||
it('publishes status for plain boolean', function(done) {
|
||||
var flow = { handleStatus: sinon.stub() }
|
||||
var n = new RedNode({_flow:flow,id:'123',type:'abc'});
|
||||
n.status(false);
|
||||
flow.handleStatus.called.should.be.true();
|
||||
flow.handleStatus.args[0][0].should.eql(n);
|
||||
flow.handleStatus.args[0][1].should.eql({text:"false"});
|
||||
done();
|
||||
});
|
||||
it('publishes status for plain number', function(done) {
|
||||
var flow = { handleStatus: sinon.stub() }
|
||||
var n = new RedNode({_flow:flow,id:'123',type:'abc'});
|
||||
n.status(123);
|
||||
flow.handleStatus.called.should.be.true();
|
||||
flow.handleStatus.args[0][0].should.eql(n);
|
||||
flow.handleStatus.args[0][1].should.eql({text:"123"});
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
});
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,883 +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 NR_TEST_UTILS = require("nr-test-utils");
|
||||
var LocalFileSystem = NR_TEST_UTILS.require("@node-red/runtime/lib/nodes/context/localfilesystem");
|
||||
|
||||
var resourcesDir = path.resolve(path.join(__dirname,"..","resources","context"));
|
||||
|
||||
var defaultContextBase = "context";
|
||||
|
||||
describe('localfilesystem',function() {
|
||||
|
||||
before(function() {
|
||||
return fs.remove(resourcesDir);
|
||||
});
|
||||
|
||||
describe('#get/set',function() {
|
||||
var context;
|
||||
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);
|
||||
});
|
||||
});
|
||||
|
||||
it('should store property',function(done) {
|
||||
context.get("nodeX","foo",function(err, value){
|
||||
if (err) { return done(err); }
|
||||
should.not.exist(value);
|
||||
context.set("nodeX","foo","test",function(err){
|
||||
if (err) { return done(err); }
|
||||
context.get("nodeX","foo",function(err, value){
|
||||
if (err) { return done(err); }
|
||||
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 store local scope property', function (done) {
|
||||
context.set("abc:def", "foo.bar", "test", function (err) {
|
||||
context.get("abc:def", "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();
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
it('should set/get multiple values', function(done) {
|
||||
context.set("nodeX",["one","two","three"],["test1","test2","test3"], function(err) {
|
||||
context.get("nodeX",["one","two"], function() {
|
||||
Array.prototype.slice.apply(arguments).should.eql([undefined,"test1","test2"])
|
||||
done();
|
||||
});
|
||||
});
|
||||
})
|
||||
it('should set/get multiple values - get unknown', function(done) {
|
||||
context.set("nodeX",["one","two","three"],["test1","test2","test3"], function(err) {
|
||||
context.get("nodeX",["one","two","unknown"], function() {
|
||||
Array.prototype.slice.apply(arguments).should.eql([undefined,"test1","test2",undefined])
|
||||
done();
|
||||
});
|
||||
});
|
||||
})
|
||||
it('should set/get multiple values - single value providd', function(done) {
|
||||
context.set("nodeX",["one","two","three"],"test1", function(err) {
|
||||
context.get("nodeX",["one","two"], function() {
|
||||
Array.prototype.slice.apply(arguments).should.eql([undefined,"test1",null])
|
||||
done();
|
||||
});
|
||||
});
|
||||
})
|
||||
|
||||
it('should throw error if bad key included in multiple keys - get', function(done) {
|
||||
context.set("nodeX",["one","two","three"],["test1","test2","test3"], function(err) {
|
||||
context.get("nodeX",["one",".foo","three"], function(err) {
|
||||
should.exist(err);
|
||||
done();
|
||||
});
|
||||
});
|
||||
})
|
||||
|
||||
it('should throw error if bad key included in multiple keys - set', function(done) {
|
||||
context.set("nodeX",["one",".foo","three"],["test1","test2","test3"], function(err) {
|
||||
should.exist(err);
|
||||
// Check 'one' didn't get set as a result
|
||||
context.get("nodeX","one",function(err,one) {
|
||||
should.not.exist(one);
|
||||
done();
|
||||
})
|
||||
});
|
||||
})
|
||||
|
||||
it('should throw an error when getting a value with invalid key', function (done) {
|
||||
context.set("nodeX","foo","bar",function(err) {
|
||||
context.get("nodeX"," ",function(err,value) {
|
||||
should.exist(err);
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
it('should throw an error when setting a value with invalid key',function (done) {
|
||||
context.set("nodeX"," ","bar",function (err) {
|
||||
should.exist(err);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should throw an error when callback of get() is not a function',function (done) {
|
||||
try {
|
||||
context.get("nodeX","foo","callback");
|
||||
done("should throw an error.");
|
||||
} catch (err) {
|
||||
done();
|
||||
}
|
||||
});
|
||||
|
||||
it('should throw an error when callback of get() is not specified',function (done) {
|
||||
try {
|
||||
context.get("nodeX","foo");
|
||||
done("should throw an error.");
|
||||
} catch (err) {
|
||||
done();
|
||||
}
|
||||
});
|
||||
|
||||
it('should throw an error when callback of set() is not a function',function (done) {
|
||||
try {
|
||||
context.set("nodeX","foo","bar","callback");
|
||||
done("should throw an error.");
|
||||
} catch (err) {
|
||||
done();
|
||||
}
|
||||
});
|
||||
|
||||
it('should not throw an error when callback of set() is not specified', function (done) {
|
||||
try {
|
||||
context.set("nodeX"," ","bar");
|
||||
done();
|
||||
} catch (err) {
|
||||
done("should not throw an error.");
|
||||
}
|
||||
});
|
||||
|
||||
it('should handle empty context file', function (done) {
|
||||
fs.outputFile(path.join(resourcesDir,defaultContextBase,"nodeX","flow.json"),"",function(){
|
||||
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 throw an error when reading corrupt context file', function (done) {
|
||||
fs.outputFile(path.join(resourcesDir, defaultContextBase, "nodeX", "flow.json"),"{abc",function(){
|
||||
context.get("nodeX", "foo", function (err, value) {
|
||||
should.exist(err);
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('#keys',function() {
|
||||
var context;
|
||||
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);
|
||||
});
|
||||
});
|
||||
|
||||
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();
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
it('should throw an error when callback of keys() is not a function', function (done) {
|
||||
try {
|
||||
context.keys("nodeX", "callback");
|
||||
done("should throw an error.");
|
||||
} catch (err) {
|
||||
done();
|
||||
}
|
||||
});
|
||||
|
||||
it('should throw an error when callback of keys() is not specified', function (done) {
|
||||
try {
|
||||
context.keys("nodeX");
|
||||
done("should throw an error.");
|
||||
} catch (err) {
|
||||
done();
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe('#delete',function() {
|
||||
var context;
|
||||
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);
|
||||
});
|
||||
});
|
||||
|
||||
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() {
|
||||
var context;
|
||||
var contextGet;
|
||||
var contextSet;
|
||||
beforeEach(function() {
|
||||
context = LocalFileSystem({dir: resourcesDir, cache: false});
|
||||
contextGet = function(scope,key) {
|
||||
return new Promise((res,rej) => {
|
||||
context.get(scope,key, function(err,value) {
|
||||
if (err) {
|
||||
rej(err);
|
||||
} else {
|
||||
res(value);
|
||||
}
|
||||
})
|
||||
});
|
||||
}
|
||||
contextSet = function(scope,key,value) {
|
||||
return new Promise((res,rej) => {
|
||||
context.set(scope,key,value, function(err) {
|
||||
if (err) {
|
||||
rej(err);
|
||||
} else {
|
||||
res();
|
||||
}
|
||||
})
|
||||
});
|
||||
}
|
||||
return context.open();
|
||||
});
|
||||
|
||||
afterEach(function() {
|
||||
return context.clean([]).then(function(){
|
||||
return context.close().then(function(){
|
||||
return fs.remove(resourcesDir);
|
||||
});
|
||||
});
|
||||
});
|
||||
it('should clean unnecessary context',function(done) {
|
||||
contextSet("global","foo","testGlobal").then(function() {
|
||||
return contextSet("nodeX:flow1","foo","testX");
|
||||
}).then(function() {
|
||||
return contextSet("nodeY:flow2","foo","testY");
|
||||
}).then(function() {
|
||||
return contextGet("nodeX:flow1","foo");
|
||||
}).then(function(value) {
|
||||
value.should.be.equal("testX");
|
||||
}).then(function() {
|
||||
return contextGet("nodeY:flow2","foo");
|
||||
}).then(function(value) {
|
||||
value.should.be.equal("testY");
|
||||
}).then(function() {
|
||||
return context.clean([])
|
||||
}).then(function() {
|
||||
return contextGet("nodeX:flow1","foo");
|
||||
}).then(function(value) {
|
||||
should.not.exist(value);
|
||||
}).then(function() {
|
||||
return contextGet("nodeY:flow2","foo");
|
||||
}).then(function(value) {
|
||||
should.not.exist(value);
|
||||
}).then(function() {
|
||||
return contextGet("global","foo");
|
||||
}).then(function(value) {
|
||||
value.should.eql("testGlobal");
|
||||
}).then(done).catch(done);
|
||||
});
|
||||
|
||||
it('should not clean active context',function(done) {
|
||||
contextSet("global","foo","testGlobal").then(function() {
|
||||
return contextSet("nodeX:flow1","foo","testX");
|
||||
}).then(function() {
|
||||
return contextSet("nodeY:flow2","foo","testY");
|
||||
}).then(function() {
|
||||
return contextGet("nodeX:flow1","foo");
|
||||
}).then(function(value) {
|
||||
value.should.be.equal("testX");
|
||||
}).then(function() {
|
||||
return contextGet("nodeY:flow2","foo");
|
||||
}).then(function(value) {
|
||||
value.should.be.equal("testY");
|
||||
}).then(function() {
|
||||
return context.clean(["flow1","nodeX"])
|
||||
}).then(function() {
|
||||
return contextGet("nodeX:flow1","foo");
|
||||
}).then(function(value) {
|
||||
value.should.be.equal("testX");
|
||||
}).then(function() {
|
||||
return contextGet("nodeY:flow2","foo");
|
||||
}).then(function(value) {
|
||||
should.not.exist(value);
|
||||
}).then(function() {
|
||||
return contextGet("global","foo");
|
||||
}).then(function(value) {
|
||||
value.should.eql("testGlobal");
|
||||
}).then(done).catch(done);
|
||||
});
|
||||
});
|
||||
|
||||
describe('#if cache is enabled',function() {
|
||||
|
||||
var context;
|
||||
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);
|
||||
});
|
||||
});
|
||||
|
||||
|
||||
|
||||
it('should load contexts into the cache',function() {
|
||||
var globalData = {key:"global"};
|
||||
var flowData = {key:"flow"};
|
||||
var nodeData = {key:"node"};
|
||||
return Promise.all([
|
||||
fs.outputFile(path.join(resourcesDir,defaultContextBase,"global","global.json"), JSON.stringify(globalData,null,4), "utf8"),
|
||||
fs.outputFile(path.join(resourcesDir,defaultContextBase,"flow","flow.json"), JSON.stringify(flowData,null,4), "utf8"),
|
||||
fs.outputFile(path.join(resourcesDir,defaultContextBase,"flow","node.json"), JSON.stringify(nodeData,null,4), "utf8")
|
||||
]).then(function(){
|
||||
context = LocalFileSystem({dir: resourcesDir, cache: true});
|
||||
return context.open();
|
||||
}).then(function(){
|
||||
return Promise.all([
|
||||
fs.remove(path.join(resourcesDir,defaultContextBase,"global","global.json")),
|
||||
fs.remove(path.join(resourcesDir,defaultContextBase,"flow","flow.json")),
|
||||
fs.remove(path.join(resourcesDir,defaultContextBase,"flow","node.json"))
|
||||
]);
|
||||
}).then(function(){
|
||||
context.get("global","key").should.be.equal("global");
|
||||
context.get("flow","key").should.be.equal("flow");
|
||||
context.get("node:flow","key").should.be.equal("node");
|
||||
});
|
||||
});
|
||||
|
||||
it('should store property to the cache',function() {
|
||||
context = LocalFileSystem({dir: resourcesDir, cache: true, flushInterval: 1});
|
||||
return context.open().then(function(){
|
||||
return new Promise(function(resolve, reject){
|
||||
context.set("global","foo","bar",function(err){
|
||||
if(err){
|
||||
reject(err);
|
||||
} else {
|
||||
fs.readJson(path.join(resourcesDir,defaultContextBase,"global","global.json")).then(function(data) {
|
||||
// File should not exist as flush hasn't happened
|
||||
reject("File global/global.json should not exist");
|
||||
}).catch(function(err) {
|
||||
setTimeout(function() {
|
||||
fs.readJson(path.join(resourcesDir,defaultContextBase,"global","global.json")).then(function(data) {
|
||||
data.should.eql({foo:'bar'});
|
||||
resolve();
|
||||
}).catch(function(err) {
|
||||
reject(err);
|
||||
});
|
||||
},1100)
|
||||
})
|
||||
}
|
||||
});
|
||||
});
|
||||
}).then(function(){
|
||||
return fs.remove(path.join(resourcesDir,defaultContextBase,"global","global.json"));
|
||||
}).then(function(){
|
||||
context.get("global","foo").should.be.equal("bar");
|
||||
})
|
||||
});
|
||||
|
||||
it('should enumerate context keys in the cache',function() {
|
||||
var globalData = {foo:"bar"};
|
||||
return fs.outputFile(path.join(resourcesDir,defaultContextBase,"global","global.json"), JSON.stringify(globalData,null,4), "utf8").then(function(){
|
||||
context = LocalFileSystem({dir: resourcesDir, cache: true, flushInterval: 2});
|
||||
return context.open()
|
||||
}).then(function(){
|
||||
return fs.remove(path.join(resourcesDir,defaultContextBase,"global","global.json"));
|
||||
}).then(function(){
|
||||
var keys = context.keys("global");
|
||||
keys.should.have.length(1);
|
||||
keys[0].should.equal("foo");
|
||||
return new Promise(function(resolve, reject){
|
||||
context.set("global","foo2","bar2",function(err){
|
||||
if(err){
|
||||
reject(err);
|
||||
} else {
|
||||
resolve();
|
||||
}
|
||||
});
|
||||
});
|
||||
}).then(function(){
|
||||
return fs.remove(path.join(resourcesDir,defaultContextBase,"global","global.json"));
|
||||
}).then(function(){
|
||||
var keys = context.keys("global");
|
||||
keys.should.have.length(2);
|
||||
keys[1].should.equal("foo2");
|
||||
})
|
||||
});
|
||||
|
||||
it('should delete context in the cache',function() {
|
||||
context = LocalFileSystem({dir: resourcesDir, cache: true, flushInterval: 2});
|
||||
return context.open().then(function(){
|
||||
return new Promise(function(resolve, reject){
|
||||
context.set("global","foo","bar",function(err){
|
||||
if(err){
|
||||
reject(err);
|
||||
} else {
|
||||
resolve();
|
||||
}
|
||||
});
|
||||
});
|
||||
}).then(function(){
|
||||
context.get("global","foo").should.be.equal("bar");
|
||||
return context.delete("global");
|
||||
}).then(function(){
|
||||
should.not.exist(context.get("global","foo"))
|
||||
})
|
||||
});
|
||||
|
||||
it('should clean unnecessary context in the cache',function() {
|
||||
var flowAData = {key:"flowA"};
|
||||
var flowBData = {key:"flowB"};
|
||||
return Promise.all([
|
||||
fs.outputFile(path.join(resourcesDir,defaultContextBase,"flowA","flow.json"), JSON.stringify(flowAData,null,4), "utf8"),
|
||||
fs.outputFile(path.join(resourcesDir,defaultContextBase,"flowB","flow.json"), JSON.stringify(flowBData,null,4), "utf8")
|
||||
]).then(function(){
|
||||
context = LocalFileSystem({dir: resourcesDir, cache: true, flushInterval: 2});
|
||||
return context.open();
|
||||
}).then(function(){
|
||||
context.get("flowA","key").should.be.equal("flowA");
|
||||
context.get("flowB","key").should.be.equal("flowB");
|
||||
return context.clean(["flowA"]);
|
||||
}).then(function(){
|
||||
context.get("flowA","key").should.be.equal("flowA");
|
||||
should.not.exist(context.get("flowB","key"));
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('Configuration', function () {
|
||||
var context;
|
||||
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);
|
||||
});
|
||||
});
|
||||
it('should change a base directory', function (done) {
|
||||
var differentBaseContext = LocalFileSystem({
|
||||
base: "contexts2",
|
||||
dir: resourcesDir,
|
||||
cache: false
|
||||
});
|
||||
differentBaseContext.open().then(function () {
|
||||
differentBaseContext.set("node2", "foo2", "bar2", function (err) {
|
||||
differentBaseContext.get("node2", "foo2", function (err, value) {
|
||||
value.should.be.equal("bar2");
|
||||
context.get("node2", "foo2", function(err, value) {
|
||||
should.not.exist(value);
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
it('should use userDir', function (done) {
|
||||
var userDirContext = LocalFileSystem({
|
||||
base: "contexts2",
|
||||
cache: false,
|
||||
settings: {
|
||||
userDir: resourcesDir
|
||||
}
|
||||
});
|
||||
userDirContext.open().then(function () {
|
||||
userDirContext.set("node2", "foo2", "bar2", function (err) {
|
||||
userDirContext.get("node2", "foo2", function (err, value) {
|
||||
value.should.be.equal("bar2");
|
||||
context.get("node2", "foo2", function (err, value) {
|
||||
should.not.exist(value);
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
it('should use NODE_RED_HOME', function (done) {
|
||||
var oldNRH = process.env.NODE_RED_HOME;
|
||||
process.env.NODE_RED_HOME = resourcesDir;
|
||||
fs.ensureDirSync(resourcesDir);
|
||||
fs.writeFileSync(path.join(resourcesDir,".config.json"),"");
|
||||
var nrHomeContext = LocalFileSystem({
|
||||
base: "contexts2",
|
||||
cache: false
|
||||
});
|
||||
try {
|
||||
nrHomeContext.open().then(function () {
|
||||
nrHomeContext.set("node2", "foo2", "bar2", function (err) {
|
||||
nrHomeContext.get("node2", "foo2", function (err, value) {
|
||||
value.should.be.equal("bar2");
|
||||
context.get("node2", "foo2", function (err, value) {
|
||||
should.not.exist(value);
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
} finally {
|
||||
process.env.NODE_RED_HOME = oldNRH;
|
||||
}
|
||||
});
|
||||
|
||||
it('should use HOME_PATH', function (done) {
|
||||
var oldNRH = process.env.NODE_RED_HOME;
|
||||
var oldHOMEPATH = process.env.HOMEPATH;
|
||||
process.env.NODE_RED_HOME = resourcesDir;
|
||||
process.env.HOMEPATH = resourcesDir;
|
||||
var homePath = path.join(resourcesDir, ".node-red");
|
||||
fs.outputFile(path.join(homePath, ".config.json"),"",function(){
|
||||
var homeContext = LocalFileSystem({
|
||||
base: "contexts2",
|
||||
cache: false
|
||||
});
|
||||
try {
|
||||
homeContext.open().then(function () {
|
||||
homeContext.set("node2", "foo2", "bar2", function (err) {
|
||||
homeContext.get("node2", "foo2", function (err, value) {
|
||||
value.should.be.equal("bar2");
|
||||
context.get("node2", "foo2", function (err, value) {
|
||||
should.not.exist(value);
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
} finally {
|
||||
process.env.NODE_RED_HOME = oldNRH;
|
||||
process.env.HOMEPATH = oldHOMEPATH;
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
it('should use HOME_PATH', function (done) {
|
||||
var oldNRH = process.env.NODE_RED_HOME;
|
||||
var oldHOMEPATH = process.env.HOMEPATH;
|
||||
var oldHOME = process.env.HOME;
|
||||
process.env.NODE_RED_HOME = resourcesDir;
|
||||
process.env.HOMEPATH = resourcesDir;
|
||||
process.env.HOME = resourcesDir;
|
||||
var homeContext = LocalFileSystem({
|
||||
base: "contexts2",
|
||||
cache: false
|
||||
});
|
||||
try {
|
||||
homeContext.open().then(function () {
|
||||
homeContext.set("node2", "foo2", "bar2", function (err) {
|
||||
homeContext.get("node2", "foo2", function (err, value) {
|
||||
value.should.be.equal("bar2");
|
||||
context.get("node2", "foo2", function (err, value) {
|
||||
should.not.exist(value);
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
} finally {
|
||||
process.env.NODE_RED_HOME = oldNRH;
|
||||
process.env.HOMEPATH = oldHOMEPATH;
|
||||
process.env.HOME = oldHOME;
|
||||
}
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,321 +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 NR_TEST_UTILS = require("nr-test-utils");
|
||||
|
||||
var Memory = NR_TEST_UTILS.require("@node-red/runtime/lib/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() {
|
||||
describe('sync',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");
|
||||
});
|
||||
|
||||
it('should throw the error if the error occurs', function() {
|
||||
try{
|
||||
context.set("nodeX",".foo","test");
|
||||
should.fail("Error was not thrown");
|
||||
}catch(err){
|
||||
should.exist(err);
|
||||
try{
|
||||
context.get("nodeX",".foo");
|
||||
should.fail("Error was not thrown");
|
||||
}catch(err){
|
||||
should.exist(err);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
it('should get multiple values - all known', function() {
|
||||
context.set("nodeX","one","test1");
|
||||
context.set("nodeX","two","test2");
|
||||
context.set("nodeX","three","test3");
|
||||
context.set("nodeX","four","test4");
|
||||
|
||||
var values = context.get("nodeX",["one","two","four"]);
|
||||
values.should.eql(["test1","test2","test4"])
|
||||
})
|
||||
it('should get multiple values - include unknown', function() {
|
||||
context.set("nodeX","one","test1");
|
||||
context.set("nodeX","two","test2");
|
||||
context.set("nodeX","three","test3");
|
||||
context.set("nodeX","four","test4");
|
||||
|
||||
var values = context.get("nodeX",["one","unknown.with.multiple.levels"]);
|
||||
values.should.eql(["test1",undefined])
|
||||
})
|
||||
it('should throw error if bad key included in multiple keys', function() {
|
||||
context.set("nodeX","one","test1");
|
||||
context.set("nodeX","two","test2");
|
||||
context.set("nodeX","three","test3");
|
||||
context.set("nodeX","four","test4");
|
||||
|
||||
try{
|
||||
var values = context.get("nodeX",["one",".foo","three"]);
|
||||
should.fail("Error was not thrown");
|
||||
}catch(err){
|
||||
should.exist(err);
|
||||
}
|
||||
})
|
||||
|
||||
|
||||
});
|
||||
|
||||
describe('async',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.equal("test");
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
it('should pass the error to callback if the error occurs',function(done) {
|
||||
context.set("nodeX",".foo","test",function(err, value){
|
||||
should.exist(err);
|
||||
context.get("nodeX",".foo",function(err){
|
||||
should.exist(err);
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
it('should get multiple values - all known', function(done) {
|
||||
context.set("nodeX","one","test1");
|
||||
context.set("nodeX","two","test2");
|
||||
context.set("nodeX","three","test3");
|
||||
context.set("nodeX","four","test4");
|
||||
|
||||
context.get("nodeX",["one","two","four"],function() {
|
||||
Array.prototype.slice.apply(arguments).should.eql([undefined,"test1","test2","test4"])
|
||||
done();
|
||||
});
|
||||
})
|
||||
it('should get multiple values - include unknown', function(done) {
|
||||
context.set("nodeX","one","test1");
|
||||
context.set("nodeX","two","test2");
|
||||
context.set("nodeX","three","test3");
|
||||
context.set("nodeX","four","test4");
|
||||
|
||||
context.get("nodeX",["one","unknown"],function() {
|
||||
Array.prototype.slice.apply(arguments).should.eql([undefined,"test1",undefined])
|
||||
done();
|
||||
});
|
||||
})
|
||||
it('should throw error if bad key included in multiple keys', function(done) {
|
||||
context.set("nodeX","one","test1");
|
||||
context.set("nodeX","two","test2");
|
||||
context.set("nodeX","three","test3");
|
||||
context.set("nodeX","four","test4");
|
||||
|
||||
context.get("nodeX",["one",".foo","three"], function(err) {
|
||||
should.exist(err);
|
||||
done();
|
||||
});
|
||||
})
|
||||
});
|
||||
});
|
||||
|
||||
describe('#keys',function() {
|
||||
describe('sync',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");
|
||||
});
|
||||
|
||||
it('should enumerate global context keys', function () {
|
||||
var keys = context.keys("global");
|
||||
keys.should.be.an.Array();
|
||||
keys.should.be.empty();
|
||||
|
||||
context.set("global", "foo", "bar");
|
||||
keys = context.keys("global");
|
||||
keys.should.have.length(1);
|
||||
keys[0].should.equal("foo");
|
||||
|
||||
context.set("global", "abc.def", "bar");
|
||||
keys = context.keys("global");
|
||||
keys.should.have.length(2);
|
||||
keys[1].should.equal("abc");
|
||||
});
|
||||
|
||||
it('should not return specific keys as global context keys', function () {
|
||||
var keys = context.keys("global");
|
||||
|
||||
context.set("global", "set", "bar");
|
||||
context.set("global", "get", "bar");
|
||||
context.set("global", "keys", "bar");
|
||||
keys = context.keys("global");
|
||||
keys.should.have.length(0);
|
||||
});
|
||||
});
|
||||
|
||||
describe('async',function() {
|
||||
it('should enumerate context keys', function(done) {
|
||||
context.keys("nodeX", function(err, keys) {
|
||||
keys.should.be.an.Array();
|
||||
keys.should.be.empty();
|
||||
context.set("nodeX", "foo", "bar", function(err) {
|
||||
context.keys("nodeX", function(err, keys) {
|
||||
keys.should.have.length(1);
|
||||
keys[0].should.equal("foo");
|
||||
context.set("nodeX","abc.def","bar",function(err){
|
||||
context.keys("nodeX",function(err, keys){
|
||||
keys.should.have.length(2);
|
||||
keys[1].should.equal("abc");
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
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"));
|
||||
});
|
||||
});
|
||||
it('should not clean global context', function () {
|
||||
context.set("global", "foo", "abc");
|
||||
context.get("global", "foo").should.equal("abc");
|
||||
|
||||
return context.clean(["global"]).then(function () {
|
||||
should.exist(context.get("global", "foo"));
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
});
|
||||
@@ -1,474 +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 sinon = require("sinon");
|
||||
var util = require("util");
|
||||
|
||||
var NR_TEST_UTILS = require("nr-test-utils");
|
||||
var index = NR_TEST_UTILS.require("@node-red/runtime/lib/nodes/index");
|
||||
var credentials = NR_TEST_UTILS.require("@node-red/runtime/lib/nodes/credentials");
|
||||
var log = NR_TEST_UTILS.require("@node-red/util").log;
|
||||
|
||||
|
||||
describe('red/runtime/nodes/credentials', function() {
|
||||
|
||||
var encryptionDisabledSettings = {
|
||||
get: function(key) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
afterEach(function() {
|
||||
index.clearRegistry();
|
||||
});
|
||||
|
||||
it('loads provided credentials',function() {
|
||||
credentials.init({
|
||||
log: log,
|
||||
settings: encryptionDisabledSettings
|
||||
});
|
||||
|
||||
return credentials.load({"a":{"b":1,"c":2}}).then(function() {
|
||||
credentials.get("a").should.have.property('b',1);
|
||||
credentials.get("a").should.have.property('c',2);
|
||||
});
|
||||
});
|
||||
it('adds a new credential',function() {
|
||||
credentials.init({
|
||||
log: log,
|
||||
settings: encryptionDisabledSettings
|
||||
});
|
||||
return credentials.load({"a":{"b":1,"c":2}}).then(function() {
|
||||
credentials.dirty().should.be.false();
|
||||
should.not.exist(credentials.get("b"));
|
||||
return credentials.add("b",{"foo":"bar"}).then(function() {
|
||||
credentials.get("b").should.have.property("foo","bar");
|
||||
credentials.dirty().should.be.true();
|
||||
});
|
||||
});
|
||||
});
|
||||
it('deletes an existing credential',function() {
|
||||
credentials.init({
|
||||
log: log,
|
||||
settings: encryptionDisabledSettings
|
||||
});
|
||||
return credentials.load({"a":{"b":1,"c":2}}).then(function() {
|
||||
credentials.dirty().should.be.false();
|
||||
credentials.delete("a");
|
||||
should.not.exist(credentials.get("a"));
|
||||
credentials.dirty().should.be.true();
|
||||
});
|
||||
});
|
||||
|
||||
it('exports the credentials, clearing dirty flag', function() {
|
||||
credentials.init({
|
||||
log: log,
|
||||
settings: encryptionDisabledSettings
|
||||
});
|
||||
var creds = {"a":{"b":1,"c":2}};
|
||||
return credentials.load(creds).then(function() {
|
||||
return credentials.add("b",{"foo":"bar"})
|
||||
}).then(function() {
|
||||
credentials.dirty().should.be.true();
|
||||
return credentials.export().then(function(exported) {
|
||||
exported.should.eql(creds);
|
||||
credentials.dirty().should.be.false();
|
||||
})
|
||||
});
|
||||
})
|
||||
|
||||
describe("#clean",function() {
|
||||
it("removes credentials of unknown nodes",function() {
|
||||
credentials.init({
|
||||
log: log,
|
||||
settings: encryptionDisabledSettings,
|
||||
nodes: { getType: () => function(){} }
|
||||
});
|
||||
var creds = {"a":{"b":1,"c":2},"b":{"d":3}};
|
||||
return credentials.load(creds).then(function() {
|
||||
credentials.dirty().should.be.false();
|
||||
should.exist(credentials.get("a"));
|
||||
should.exist(credentials.get("b"));
|
||||
return credentials.clean([{id:"b"}]).then(function() {
|
||||
credentials.dirty().should.be.true();
|
||||
should.not.exist(credentials.get("a"));
|
||||
should.exist(credentials.get("b"));
|
||||
});
|
||||
});
|
||||
});
|
||||
it("extracts credentials of known nodes",function() {
|
||||
credentials.init({
|
||||
log: log,
|
||||
settings: encryptionDisabledSettings,
|
||||
nodes: { getType: () => function(){} }
|
||||
});
|
||||
credentials.register("testNode",{"b":"text","c":"password"})
|
||||
var creds = {"a":{"b":1,"c":2}};
|
||||
var newConfig = [{id:"a",type:"testNode",credentials:{"b":"newBValue","c":"newCValue"}}];
|
||||
return credentials.load(creds).then(function() {
|
||||
credentials.dirty().should.be.false();
|
||||
return credentials.clean(newConfig).then(function() {
|
||||
credentials.dirty().should.be.true();
|
||||
credentials.get("a").should.have.property('b',"newBValue");
|
||||
credentials.get("a").should.have.property('c',"newCValue");
|
||||
should.not.exist(newConfig[0].credentials);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
|
||||
});
|
||||
|
||||
it('warns if a node has no credential definition', function() {
|
||||
credentials.init({
|
||||
log: log,
|
||||
settings: encryptionDisabledSettings,
|
||||
nodes: { getType: () => function(){} }
|
||||
});
|
||||
return credentials.load({}).then(function() {
|
||||
var node = {id:"node",type:"test",credentials:{
|
||||
user1:"newUser",
|
||||
password1:"newPassword"
|
||||
}};
|
||||
sinon.spy(log,"warn");
|
||||
credentials.extract(node);
|
||||
log.warn.called.should.be.true();
|
||||
should.not.exist(node.credentials);
|
||||
log.warn.restore();
|
||||
});
|
||||
})
|
||||
|
||||
it('extract credential updates in the provided node', function(done) {
|
||||
credentials.init({
|
||||
log: log,
|
||||
settings: encryptionDisabledSettings,
|
||||
nodes: { getType: () => function(){} }
|
||||
});
|
||||
var defintion = {
|
||||
user1:{type:"text"},
|
||||
password1:{type:"password"},
|
||||
user2:{type:"text"},
|
||||
password2:{type:"password"},
|
||||
user3:{type:"text"},
|
||||
password3:{type:"password"}
|
||||
|
||||
};
|
||||
credentials.register("test",defintion);
|
||||
var def = credentials.getDefinition("test");
|
||||
defintion.should.eql(def);
|
||||
|
||||
credentials.load({"node":{user1:"abc",password1:"123",user2:"def",password2:"456",user3:"ghi",password3:"789"}}).then(function() {
|
||||
var node = {id:"node",type:"test",credentials:{
|
||||
// user1 unchanged
|
||||
password1:"__PWRD__",
|
||||
user2: "",
|
||||
password2:" ",
|
||||
user3:"newUser",
|
||||
password3:"newPassword"
|
||||
}};
|
||||
credentials.dirty().should.be.false();
|
||||
credentials.extract(node);
|
||||
|
||||
node.should.not.have.a.property("credentials");
|
||||
|
||||
credentials.dirty().should.be.true();
|
||||
var newCreds = credentials.get("node");
|
||||
newCreds.should.have.a.property("user1","abc");
|
||||
newCreds.should.have.a.property("password1","123");
|
||||
newCreds.should.not.have.a.property("user2");
|
||||
newCreds.should.not.have.a.property("password2");
|
||||
newCreds.should.have.a.property("user3","newUser");
|
||||
newCreds.should.have.a.property("password3","newPassword");
|
||||
|
||||
done();
|
||||
});
|
||||
});
|
||||
it('extract ignores node without credentials', function(done) {
|
||||
credentials.init({
|
||||
log: log,
|
||||
settings: encryptionDisabledSettings,
|
||||
nodes: { getType: () => function(){} }
|
||||
});
|
||||
credentials.load({"node":{user1:"abc",password1:"123"}}).then(function() {
|
||||
var node = {id:"node",type:"test"};
|
||||
|
||||
credentials.dirty().should.be.false();
|
||||
credentials.extract(node);
|
||||
credentials.dirty().should.be.false();
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
describe("encryption",function() {
|
||||
var settings = {};
|
||||
var runtime = {
|
||||
log: log,
|
||||
settings: {
|
||||
get: function(key) {
|
||||
return settings[key];
|
||||
},
|
||||
set: function(key,value) {
|
||||
settings[key] = value;
|
||||
return Promise.resolve();
|
||||
},
|
||||
delete: function(key) {
|
||||
delete settings[key];
|
||||
return Promise.resolve();
|
||||
}
|
||||
},
|
||||
nodes: { getType: () => function(){} }
|
||||
}
|
||||
it('migrates to encrypted and generates default key', function(done) {
|
||||
settings = {};
|
||||
credentials.init(runtime);
|
||||
credentials.load({"node":{user1:"abc",password1:"123"}}).then(function() {
|
||||
settings.should.have.a.property("_credentialSecret");
|
||||
settings._credentialSecret.should.have.a.length(64);
|
||||
credentials.dirty().should.be.true();
|
||||
credentials.export().then(function(result) {
|
||||
result.should.have.a.property("$");
|
||||
// reset everything - but with _credentialSecret still set
|
||||
credentials.init(runtime);
|
||||
// load the freshly encrypted version
|
||||
credentials.load(result).then(function() {
|
||||
should.exist(credentials.get("node"));
|
||||
done();
|
||||
})
|
||||
});
|
||||
});
|
||||
});
|
||||
it('uses default key', function(done) {
|
||||
settings = {
|
||||
_credentialSecret: "e3a36f47f005bf2aaa51ce3fc6fcaafd79da8d03f2b1a9281f8fb0a285e6255a"
|
||||
};
|
||||
// {"node":{user1:"abc",password1:"123"}}
|
||||
var cryptedFlows = {"$":"5b89d8209b5158a3c313675561b1a5b5phN1gDBe81Zv98KqS/hVDmc9EKvaKqRIvcyXYvBlFNzzzJtvN7qfw06i"};
|
||||
credentials.init(runtime);
|
||||
credentials.load(cryptedFlows).then(function() {
|
||||
should.exist(credentials.get("node"));
|
||||
credentials.dirty().should.be.false();
|
||||
credentials.add("node",{user1:"def",password1:"456"});
|
||||
credentials.export().then(function(result) {
|
||||
result.should.have.a.property("$");
|
||||
// reset everything - but with _credentialSecret still set
|
||||
credentials.init(runtime);
|
||||
// load the freshly encrypted version
|
||||
credentials.load(result).then(function() {
|
||||
should.exist(credentials.get("node"));
|
||||
credentials.get("node").should.have.a.property("user1","def");
|
||||
credentials.get("node").should.have.a.property("password1","456");
|
||||
done();
|
||||
})
|
||||
});
|
||||
});
|
||||
});
|
||||
it('uses user key', function(done) {
|
||||
settings = {
|
||||
credentialSecret: "e3a36f47f005bf2aaa51ce3fc6fcaafd79da8d03f2b1a9281f8fb0a285e6255a"
|
||||
};
|
||||
// {"node":{user1:"abc",password1:"123"}}
|
||||
var cryptedFlows = {"$":"5b89d8209b5158a3c313675561b1a5b5phN1gDBe81Zv98KqS/hVDmc9EKvaKqRIvcyXYvBlFNzzzJtvN7qfw06i"};
|
||||
credentials.init(runtime);
|
||||
credentials.load(cryptedFlows).then(function() {
|
||||
credentials.dirty().should.be.false();
|
||||
should.exist(credentials.get("node"));
|
||||
credentials.add("node",{user1:"def",password1:"456"});
|
||||
credentials.export().then(function(result) {
|
||||
result.should.have.a.property("$");
|
||||
|
||||
// reset everything - but with _credentialSecret still set
|
||||
credentials.init(runtime);
|
||||
// load the freshly encrypted version
|
||||
credentials.load(result).then(function() {
|
||||
should.exist(credentials.get("node"));
|
||||
credentials.get("node").should.have.a.property("user1","def");
|
||||
credentials.get("node").should.have.a.property("password1","456");
|
||||
done();
|
||||
})
|
||||
});
|
||||
});
|
||||
});
|
||||
it('uses user key - when settings are otherwise unavailable', function(done) {
|
||||
var runtime = {
|
||||
log: log,
|
||||
settings: {
|
||||
get: function(key) {
|
||||
if (key === 'credentialSecret') {
|
||||
return "e3a36f47f005bf2aaa51ce3fc6fcaafd79da8d03f2b1a9281f8fb0a285e6255a";
|
||||
}
|
||||
throw new Error();
|
||||
},
|
||||
set: function(key,value) {
|
||||
throw new Error();
|
||||
}
|
||||
}
|
||||
}
|
||||
// {"node":{user1:"abc",password1:"123"}}
|
||||
var cryptedFlows = {"$":"5b89d8209b5158a3c313675561b1a5b5phN1gDBe81Zv98KqS/hVDmc9EKvaKqRIvcyXYvBlFNzzzJtvN7qfw06i"};
|
||||
credentials.init(runtime);
|
||||
credentials.load(cryptedFlows).then(function() {
|
||||
should.exist(credentials.get("node"));
|
||||
credentials.add("node",{user1:"def",password1:"456"});
|
||||
credentials.export().then(function(result) {
|
||||
result.should.have.a.property("$");
|
||||
|
||||
// reset everything - but with _credentialSecret still set
|
||||
credentials.init(runtime);
|
||||
// load the freshly encrypted version
|
||||
credentials.load(result).then(function() {
|
||||
should.exist(credentials.get("node"));
|
||||
credentials.get("node").should.have.a.property("user1","def");
|
||||
credentials.get("node").should.have.a.property("password1","456");
|
||||
done();
|
||||
})
|
||||
});
|
||||
});
|
||||
});
|
||||
it('migrates from default key to user key', function() {
|
||||
settings = {
|
||||
_credentialSecret: "e3a36f47f005bf2aaa51ce3fc6fcaafd79da8d03f2b1a9281f8fb0a285e6255a",
|
||||
credentialSecret: "aaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbcccccccccccccddddddddddddeeeee"
|
||||
};
|
||||
// {"node":{user1:"abc",password1:"123"}}
|
||||
var cryptedFlows = {"$":"5b89d8209b5158a3c313675561b1a5b5phN1gDBe81Zv98KqS/hVDmc9EKvaKqRIvcyXYvBlFNzzzJtvN7qfw06i"};
|
||||
credentials.init(runtime);
|
||||
return credentials.load(cryptedFlows).then(function() {
|
||||
credentials.dirty().should.be.true();
|
||||
should.exist(credentials.get("node"));
|
||||
return credentials.export().then(function(result) {
|
||||
result.should.have.a.property("$");
|
||||
settings.should.not.have.a.property("_credentialSecret");
|
||||
|
||||
// reset everything - but with _credentialSecret still set
|
||||
credentials.init(runtime);
|
||||
// load the freshly encrypted version
|
||||
return credentials.load(result).then(function() {
|
||||
should.exist(credentials.get("node"));
|
||||
credentials.get("node").should.have.a.property("user1","abc");
|
||||
credentials.get("node").should.have.a.property("password1","123");
|
||||
})
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
it('migrates from default key to user key - unencrypted original', function(done) {
|
||||
settings = {
|
||||
_credentialSecret: "e3a36f47f005bf2aaa51ce3fc6fcaafd79da8d03f2b1a9281f8fb0a285e6255a",
|
||||
credentialSecret: "aaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbcccccccccccccddddddddddddeeeee"
|
||||
};
|
||||
// {"node":{user1:"abc",password1:"123"}}
|
||||
var unencryptedFlows = {"node":{user1:"abc",password1:"123"}};
|
||||
credentials.init(runtime);
|
||||
credentials.load(unencryptedFlows).then(function() {
|
||||
credentials.dirty().should.be.true();
|
||||
should.exist(credentials.get("node"));
|
||||
credentials.export().then(function(result) {
|
||||
result.should.have.a.property("$");
|
||||
settings.should.not.have.a.property("_credentialSecret");
|
||||
|
||||
// reset everything - but with _credentialSecret still set
|
||||
credentials.init(runtime);
|
||||
// load the freshly encrypted version
|
||||
credentials.load(result).then(function() {
|
||||
should.exist(credentials.get("node"));
|
||||
credentials.get("node").should.have.a.property("user1","abc");
|
||||
credentials.get("node").should.have.a.property("password1","123");
|
||||
done();
|
||||
})
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
it('migrates from default key to unencrypted', function(done) {
|
||||
settings = {
|
||||
_credentialSecret: "e3a36f47f005bf2aaa51ce3fc6fcaafd79da8d03f2b1a9281f8fb0a285e6255a",
|
||||
credentialSecret: false
|
||||
};
|
||||
// {"node":{user1:"abc",password1:"123"}}
|
||||
var cryptedFlows = {"$":"5b89d8209b5158a3c313675561b1a5b5phN1gDBe81Zv98KqS/hVDmc9EKvaKqRIvcyXYvBlFNzzzJtvN7qfw06i"};
|
||||
credentials.init(runtime);
|
||||
credentials.load(cryptedFlows).then(function() {
|
||||
credentials.dirty().should.be.true();
|
||||
should.exist(credentials.get("node"));
|
||||
credentials.export().then(function(result) {
|
||||
result.should.not.have.a.property("$");
|
||||
settings.should.not.have.a.property("_credentialSecret");
|
||||
result.should.eql({"node":{user1:"abc",password1:"123"}});
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
it('handles bad default key - resets credentials', function(done) {
|
||||
settings = {
|
||||
_credentialSecret: "badbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadb"
|
||||
};
|
||||
// {"node":{user1:"abc",password1:"123"}}
|
||||
var cryptedFlows = {"$":"5b89d8209b5158a3c313675561b1a5b5phN1gDBe81Zv98KqS/hVDmc9EKvaKqRIvcyXYvBlFNzzzJtvN7qfw06i"};
|
||||
credentials.init(runtime);
|
||||
credentials.load(cryptedFlows).then(function() {
|
||||
// credentials.dirty().should.be.true();
|
||||
// should.not.exist(credentials.get("node"));
|
||||
done();
|
||||
}).catch(function(err) {
|
||||
err.should.have.property('code','credentials_load_failed');
|
||||
done();
|
||||
});
|
||||
});
|
||||
it('handles bad user key - resets credentials', function(done) {
|
||||
settings = {
|
||||
credentialSecret: "badbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadb"
|
||||
};
|
||||
// {"node":{user1:"abc",password1:"123"}}
|
||||
var cryptedFlows = {"$":"5b89d8209b5158a3c313675561b1a5b5phN1gDBe81Zv98KqS/hVDmc9EKvaKqRIvcyXYvBlFNzzzJtvN7qfw06i"};
|
||||
credentials.init(runtime);
|
||||
credentials.load(cryptedFlows).then(function() {
|
||||
// credentials.dirty().should.be.true();
|
||||
// should.not.exist(credentials.get("node"));
|
||||
done();
|
||||
}).catch(function(err) {
|
||||
err.should.have.property('code','credentials_load_failed');
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('handles unavailable settings - leaves creds unencrypted', function(done) {
|
||||
var runtime = {
|
||||
log: log,
|
||||
settings: {
|
||||
get: function(key) {
|
||||
throw new Error();
|
||||
},
|
||||
set: function(key,value) {
|
||||
throw new Error();
|
||||
}
|
||||
},
|
||||
nodes: { getType: () => function(){} }
|
||||
}
|
||||
// {"node":{user1:"abc",password1:"123"}}
|
||||
credentials.init(runtime);
|
||||
credentials.load({"node":{user1:"abc",password1:"123"}}).then(function() {
|
||||
credentials.dirty().should.be.false();
|
||||
should.exist(credentials.get("node"));
|
||||
credentials.export().then(function(result) {
|
||||
result.should.not.have.a.property("$");
|
||||
result.should.have.a.property("node");
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
})
|
||||
})
|
||||
@@ -1,404 +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 sinon = require('sinon');
|
||||
var inherits = require("util").inherits;
|
||||
|
||||
var NR_TEST_UTILS = require("nr-test-utils");
|
||||
var index = NR_TEST_UTILS.require("@node-red/runtime/lib/nodes/index");
|
||||
var flows = NR_TEST_UTILS.require("@node-red/runtime/lib/flows");
|
||||
var registry = NR_TEST_UTILS.require("@node-red/registry")
|
||||
var Node = NR_TEST_UTILS.require("@node-red/runtime/lib/nodes/Node");
|
||||
|
||||
describe("red/nodes/index", function() {
|
||||
before(function() {
|
||||
sinon.stub(index,"startFlows");
|
||||
process.env.NODE_RED_HOME = NR_TEST_UTILS.resolve("node-red");
|
||||
process.env.foo="bar";
|
||||
});
|
||||
after(function() {
|
||||
index.startFlows.restore();
|
||||
delete process.env.NODE_RED_HOME;
|
||||
delete process.env.foo;
|
||||
});
|
||||
|
||||
afterEach(function() {
|
||||
index.clearRegistry();
|
||||
});
|
||||
|
||||
var testFlows = [{"type":"test","id":"tab1","label":"Sheet 1"}];
|
||||
var testCredentials = {"tab1":{"b":1, "c":"2", "d":"$(foo)"}};
|
||||
var storage = {
|
||||
getFlows: function() {
|
||||
return Promise.resolve({red:123,flows:testFlows,credentials:testCredentials});
|
||||
},
|
||||
saveFlows: function(conf) {
|
||||
should.deepEqual(testFlows, conf.flows);
|
||||
return Promise.resolve(123);
|
||||
}
|
||||
};
|
||||
|
||||
var settings = {
|
||||
available: function() { return false },
|
||||
get: function() { return false }
|
||||
};
|
||||
|
||||
var EventEmitter = require('events').EventEmitter;
|
||||
var runtime = {
|
||||
settings: settings,
|
||||
storage: storage,
|
||||
log: {debug:function() {}, warn:function() {}},
|
||||
events: new EventEmitter()
|
||||
};
|
||||
|
||||
function TestNode(n) {
|
||||
this._flow = {getSetting: p => process.env[p]};
|
||||
index.createNode(this, n);
|
||||
this.on("log", function() {
|
||||
// do nothing
|
||||
});
|
||||
}
|
||||
|
||||
it('nodes are initialised with credentials',function(done) {
|
||||
index.init(runtime);
|
||||
index.registerType('test-node-set','test', TestNode);
|
||||
index.loadFlows().then(function() {
|
||||
var testnode = new TestNode({id:'tab1',type:'test',name:'barney'});
|
||||
testnode.credentials.should.have.property('b',1);
|
||||
testnode.credentials.should.have.property('c',"2");
|
||||
testnode.credentials.should.have.property('d',"bar");
|
||||
done();
|
||||
}).catch(function(err) {
|
||||
done(err);
|
||||
});
|
||||
});
|
||||
|
||||
it('flows should be initialised',function(done) {
|
||||
index.init(runtime);
|
||||
index.loadFlows().then(function() {
|
||||
// console.log(testFlows);
|
||||
// console.log(index.getFlows());
|
||||
should.deepEqual(testFlows, index.getFlows().flows);
|
||||
done();
|
||||
}).catch(function(err) {
|
||||
done(err);
|
||||
});
|
||||
|
||||
});
|
||||
describe("registerType", function() {
|
||||
describe("logs deprecated usage", function() {
|
||||
before(function() {
|
||||
sinon.stub(registry,"registerType");
|
||||
});
|
||||
after(function() {
|
||||
registry.registerType.restore();
|
||||
});
|
||||
it("called without node-set name", function() {
|
||||
var runtime = {
|
||||
settings: settings,
|
||||
storage: storage,
|
||||
log: {debug:function() {}, warn:sinon.spy()},
|
||||
events: new EventEmitter()
|
||||
}
|
||||
index.init(runtime);
|
||||
|
||||
index.registerType(/*'test-node-set',*/'test', TestNode, {});
|
||||
runtime.log.warn.called.should.be.true();
|
||||
registry.registerType.called.should.be.true();
|
||||
registry.registerType.firstCall.args[0].should.eql('');
|
||||
registry.registerType.firstCall.args[1].should.eql('test');
|
||||
registry.registerType.firstCall.args[2].should.eql(TestNode);
|
||||
});
|
||||
});
|
||||
describe("extends constructor with Node constructor", function() {
|
||||
var TestNodeConstructor;
|
||||
before(function() {
|
||||
sinon.stub(registry,"registerType");
|
||||
});
|
||||
after(function() {
|
||||
registry.registerType.restore();
|
||||
});
|
||||
beforeEach(function() {
|
||||
TestNodeConstructor = function TestNodeConstructor() {};
|
||||
var runtime = {
|
||||
settings: settings,
|
||||
storage: storage,
|
||||
log: {debug:function() {}, warn:sinon.spy()},
|
||||
events: new EventEmitter()
|
||||
}
|
||||
index.init(runtime);
|
||||
})
|
||||
it('extends a constructor with the Node constructor', function() {
|
||||
TestNodeConstructor.prototype.should.not.be.an.instanceOf(Node);
|
||||
index.registerType('node-set','node-type',TestNodeConstructor);
|
||||
TestNodeConstructor.prototype.should.be.an.instanceOf(Node);
|
||||
});
|
||||
it('does not override a constructor prototype', function() {
|
||||
function Foo(){};
|
||||
inherits(TestNodeConstructor,Foo);
|
||||
TestNodeConstructor.prototype.should.be.an.instanceOf(Foo);
|
||||
TestNodeConstructor.prototype.should.not.be.an.instanceOf(Node);
|
||||
|
||||
index.registerType('node-set','node-type',TestNodeConstructor);
|
||||
|
||||
TestNodeConstructor.prototype.should.be.an.instanceOf(Node);
|
||||
TestNodeConstructor.prototype.should.be.an.instanceOf(Foo);
|
||||
|
||||
index.registerType('node-set','node-type2',TestNodeConstructor);
|
||||
TestNodeConstructor.prototype.should.be.an.instanceOf(Node);
|
||||
TestNodeConstructor.prototype.should.be.an.instanceOf(Foo);
|
||||
});
|
||||
});
|
||||
describe("register credentials definition", function() {
|
||||
var http = require('http');
|
||||
var express = require('express');
|
||||
var app = express();
|
||||
var runtime = NR_TEST_UTILS.require("@node-red/runtime");
|
||||
var credentials = NR_TEST_UTILS.require("@node-red/runtime/lib/nodes/credentials");
|
||||
var localfilesystem = NR_TEST_UTILS.require("@node-red/runtime/lib/storage/localfilesystem");
|
||||
var log = NR_TEST_UTILS.require("@node-red/util").log;
|
||||
var RED = NR_TEST_UTILS.require("node-red/lib/red.js");
|
||||
|
||||
var userDir = path.join(__dirname,".testUserHome");
|
||||
before(function(done) {
|
||||
sinon.stub(log,"log").callsFake(function(){});
|
||||
fs.remove(userDir,function(err) {
|
||||
fs.mkdir(userDir,function() {
|
||||
sinon.stub(index, 'load').callsFake(function() {
|
||||
return new Promise(function(resolve,reject){
|
||||
resolve([]);
|
||||
});
|
||||
});
|
||||
sinon.stub(localfilesystem, 'getCredentials').callsFake(function() {
|
||||
return new Promise(function(resolve,reject) {
|
||||
resolve({"tab1":{"b":1,"c":2}});
|
||||
});
|
||||
}) ;
|
||||
RED.init(http.createServer(function(req,res){app(req,res)}),
|
||||
{userDir: userDir});
|
||||
runtime.start().then(function () {
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
after(function(done) {
|
||||
fs.remove(userDir,function() {
|
||||
runtime.stop().then(function() {
|
||||
index.load.restore();
|
||||
localfilesystem.getCredentials.restore();
|
||||
log.log.restore();
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
it('definition defined',function() {
|
||||
index.registerType('test-node-set','test', TestNode, {
|
||||
credentials: {
|
||||
foo: {type:"test"}
|
||||
}
|
||||
});
|
||||
var testnode = new TestNode({id:'tab1',type:'test',name:'barney', '_alias':'tab1'});
|
||||
index.getCredentialDefinition("test").should.have.property('foo');
|
||||
});
|
||||
});
|
||||
|
||||
describe("register settings definition", function() {
|
||||
beforeEach(function() {
|
||||
sinon.stub(registry,"registerType");
|
||||
})
|
||||
afterEach(function() {
|
||||
registry.registerType.restore();
|
||||
})
|
||||
it('registers valid settings',function() {
|
||||
var runtime = {
|
||||
settings: settings,
|
||||
storage: storage,
|
||||
log: {debug:function() {}, warn:function() {}},
|
||||
events: new EventEmitter()
|
||||
}
|
||||
runtime.settings.registerNodeSettings = sinon.spy();
|
||||
index.init(runtime);
|
||||
|
||||
index.registerType('test-node-set','test', TestNode, {
|
||||
settings: {
|
||||
testOne: {}
|
||||
}
|
||||
});
|
||||
runtime.settings.registerNodeSettings.called.should.be.true();
|
||||
runtime.settings.registerNodeSettings.firstCall.args[0].should.eql('test');
|
||||
runtime.settings.registerNodeSettings.firstCall.args[1].should.eql({testOne: {}});
|
||||
});
|
||||
it('logs invalid settings',function() {
|
||||
var runtime = {
|
||||
settings: settings,
|
||||
storage: storage,
|
||||
log: {debug:function() {}, warn:sinon.spy()},
|
||||
events: new EventEmitter()
|
||||
}
|
||||
runtime.settings.registerNodeSettings = function() { throw new Error("pass");}
|
||||
index.init(runtime);
|
||||
|
||||
index.registerType('test-node-set','test', TestNode, {
|
||||
settings: {
|
||||
testOne: {}
|
||||
}
|
||||
});
|
||||
runtime.log.warn.called.should.be.true();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('allows nodes to be added/removed/enabled/disabled from the registry', function() {
|
||||
var randomNodeInfo = {id:"5678",types:["random"]};
|
||||
|
||||
beforeEach(function() {
|
||||
sinon.stub(registry,"getNodeInfo").callsFake(function(id) {
|
||||
if (id == "test") {
|
||||
return {id:"1234",types:["test"]};
|
||||
} else if (id == "doesnotexist") {
|
||||
return null;
|
||||
} else {
|
||||
return randomNodeInfo;
|
||||
}
|
||||
});
|
||||
sinon.stub(registry,"disableNode").callsFake(function(id) {
|
||||
return Promise.resolve(randomNodeInfo);
|
||||
});
|
||||
});
|
||||
afterEach(function() {
|
||||
registry.getNodeInfo.restore();
|
||||
registry.disableNode.restore();
|
||||
});
|
||||
|
||||
it('allows an unused node type to be disabled',function(done) {
|
||||
index.init(runtime);
|
||||
index.registerType('test-node-set','test', TestNode);
|
||||
index.loadFlows().then(function() {
|
||||
return index.disableNode("5678").then(function(info) {
|
||||
registry.disableNode.calledOnce.should.be.true();
|
||||
registry.disableNode.calledWith("5678").should.be.true();
|
||||
info.should.eql(randomNodeInfo);
|
||||
done();
|
||||
});
|
||||
}).catch(function(err) {
|
||||
done(err);
|
||||
});
|
||||
});
|
||||
|
||||
it('prevents disabling a node type that is in use',function(done) {
|
||||
index.init(runtime);
|
||||
index.registerType('test-node-set','test', TestNode);
|
||||
index.loadFlows().then(function() {
|
||||
/*jshint immed: false */
|
||||
(function() {
|
||||
index.disabledNode("test");
|
||||
}).should.throw();
|
||||
|
||||
done();
|
||||
}).catch(function(err) {
|
||||
done(err);
|
||||
});
|
||||
});
|
||||
|
||||
it('prevents disabling a node type that is unknown',function(done) {
|
||||
index.init(runtime);
|
||||
index.registerType('test-node-set','test', TestNode);
|
||||
index.loadFlows().then(function() {
|
||||
/*jshint immed: false */
|
||||
(function() {
|
||||
index.disableNode("doesnotexist");
|
||||
}).should.throw();
|
||||
|
||||
done();
|
||||
}).catch(function(err) {
|
||||
done(err);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('allows modules to be removed from the registry', function() {
|
||||
var randomNodeInfo = {id:"5678",types:["random"]};
|
||||
var randomModuleInfo = {
|
||||
name:"random",
|
||||
nodes: [randomNodeInfo]
|
||||
};
|
||||
|
||||
before(function() {
|
||||
sinon.stub(registry,"getNodeInfo").callsFake(function(id) {
|
||||
if (id == "node-red/foo") {
|
||||
return {id:"1234",types:["test"]};
|
||||
} else if (id == "doesnotexist") {
|
||||
return null;
|
||||
} else {
|
||||
return randomNodeInfo;
|
||||
}
|
||||
});
|
||||
sinon.stub(registry,"getModuleInfo").callsFake(function(module) {
|
||||
if (module == "node-red") {
|
||||
return {nodes:[{name:"foo"}]};
|
||||
} else if (module == "doesnotexist") {
|
||||
return null;
|
||||
} else {
|
||||
return randomModuleInfo;
|
||||
}
|
||||
});
|
||||
sinon.stub(registry,"removeModule").callsFake(function(id) {
|
||||
return randomModuleInfo;
|
||||
});
|
||||
});
|
||||
after(function() {
|
||||
registry.getNodeInfo.restore();
|
||||
registry.getModuleInfo.restore();
|
||||
registry.removeModule.restore();
|
||||
});
|
||||
|
||||
it('prevents removing a module that is in use',function(done) {
|
||||
index.init(runtime);
|
||||
index.registerType('test-node-set','test', TestNode);
|
||||
index.loadFlows().then(function() {
|
||||
/*jshint immed: false */
|
||||
(function() {
|
||||
index.removeModule("node-red");
|
||||
}).should.throw();
|
||||
|
||||
done();
|
||||
}).catch(function(err) {
|
||||
done(err);
|
||||
});
|
||||
});
|
||||
|
||||
it('prevents removing a module that is unknown',function(done) {
|
||||
index.init(runtime);
|
||||
index.registerType('test-node-set','test', TestNode);
|
||||
index.loadFlows().then(function() {
|
||||
/*jshint immed: false */
|
||||
(function() {
|
||||
index.removeModule("doesnotexist");
|
||||
}).should.throw();
|
||||
|
||||
done();
|
||||
}).catch(function(err) {
|
||||
done(err);
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 393 B |
@@ -1,3 +0,0 @@
|
||||
This file exists just to ensure the 'icons' directory is in the repository.
|
||||
TODO: a future test needs to ensure the right icon files are loaded - this
|
||||
directory can be used for that
|
||||
Reference in New Issue
Block a user