@hurenkam/hue-services 0.6.0

package/test/BaseNode_spec.js

@@ -0,0 +1,246 @@
+const helper = require("node-red-node-test-helper");
+const assert = require('assert');
+const sinon = require('sinon');
+const BaseNode = require("../src/nodes/BaseNode");
+
+const testnodes = function(RED) {
+    "use strict";
+
+    const BaseNode = require('../src/nodes/BaseNode');
+    BaseNode.nodeAPI = RED;
+
+    RED.nodes.registerType("BaseNode",BaseNode);
+}
+
+describe('Base Node', function () {
+    beforeEach(()=>{
+        sandbox = sinon.createSandbox();
+    });
+
+    afterEach(function () {
+        helper.unload();
+        sandbox.restore();
+    });
+
+    it('should store config.name property', function (done) {
+
+        var flow = [{
+            id: "n1",
+            type: "BaseNode",
+            name: "base node",
+        }];
+
+        helper.load(testnodes, flow, function () {
+            var n1 = helper.getNode("n1");
+            n1.should.have.property('config');
+
+            var config = n1.config;
+            config.should.have.property('name', 'base node');
+            done();
+        });
+    });
+
+    it('should call onInput(msg) when a message is presented on the input', function (done) {
+        var flow = [{
+            id: "n1",
+            type: "BaseNode",
+            name: "base node",
+        }];
+
+        var payload = { on: { on: true }};
+        var msg = { payload: payload };
+
+        const fake = sandbox.fake((msg) => { 
+            msg.should.have.property('payload',payload);
+            done();
+        });
+        sandbox.replace(BaseNode.prototype,'onInput',fake);
+
+        helper.load(testnodes, flow, function () {
+            var n1 = helper.getNode("n1");
+            n1.receive(msg);
+        });
+    });
+
+    it('should call getStatusFill() when updateStatus() method is called', function (done) {
+        var flow = [{
+            id: "n1",
+            type: "BaseNode",
+            name: "base node",
+        }];
+
+        const fake = sandbox.fake(() => { 
+            done();
+        });
+        sandbox.replace(BaseNode.prototype,'getStatusFill',fake);
+
+        helper.load(testnodes, flow, function () {
+            var n1 = helper.getNode("n1");
+            n1.updateStatus();
+        });
+    });
+
+    it('should call getStatusText() when updateStatus() is called', function (done) {
+        var flow = [{
+            id: "n1",
+            type: "BaseNode",
+            name: "base node",
+        }];
+
+        const fake = sandbox.fake(() => { 
+            done();
+        });
+        sandbox.replace(BaseNode.prototype,'getStatusText',fake);
+
+        helper.load(testnodes, flow, function () {
+            var n1 = helper.getNode("n1");
+            n1.updateStatus();
+        });
+    });
+
+    it('should call getStatusShape() when updateStatus() is called', function (done) {
+        var flow = [{
+            id: "n1",
+            type: "BaseNode",
+            name: "base node",
+        }];
+
+        const fake = sandbox.fake(() => { 
+            done();
+        });
+        sandbox.replace(BaseNode.prototype,'getStatusShape',fake);
+
+        helper.load(testnodes, flow, function () {
+            var n1 = helper.getNode("n1");
+            n1.updateStatus();
+        });
+    });
+
+    it('should call status() with default status when updateStatus() is called', function (done) {
+        var flow = [{
+            id: "n1",
+            type: "BaseNode",
+            name: "base node",
+        }];
+
+        const fakeShape = sandbox.fake(() => null);
+        const fakeText = sandbox.fake(() => null);
+        const fakeFill = sandbox.fake(() => null);
+        const fakeStatus = sandbox.fake(() => { done(); });
+        sandbox.replace(BaseNode.prototype,'getStatusShape',fakeShape);
+        sandbox.replace(BaseNode.prototype,'getStatusText',fakeText);
+        sandbox.replace(BaseNode.prototype,'getStatusFill',fakeFill);
+        sandbox.replace(BaseNode.prototype,'status',fakeStatus);
+
+        helper.load(testnodes, flow, function () {
+            var n1 = helper.getNode("n1");
+            n1.updateStatus();
+        });
+    });
+
+    it('should call status() with correct status when updateStatus() is called', function (done) {
+        var flow = [{
+            id: "n1",
+            type: "BaseNode",
+            name: "base node",
+        }];
+
+        const fakeShape = sandbox.fake(() => { return "ring" });
+        const fakeText = sandbox.fake(() => { return "text" });
+        const fakeFill = sandbox.fake(() => { return "green" });
+        const fakeStatus = sandbox.fake((status) => {
+            status.should.have.property('shape','ring');
+            status.should.have.property('text','text');
+            status.should.have.property('fill','green');
+            done();
+        });
+        sandbox.replace(BaseNode.prototype,'getStatusShape',fakeShape);
+        sandbox.replace(BaseNode.prototype,'getStatusText',fakeText);
+        sandbox.replace(BaseNode.prototype,'getStatusFill',fakeFill);
+        sandbox.replace(BaseNode.prototype,'status',fakeStatus);
+
+        helper.load(testnodes, flow, function () {
+            var n1 = helper.getNode("n1");
+            n1.updateStatus();
+        });
+    });
+
+    it('should default shape to "dot" when updateStatus() is called and fill is defined', function (done) {
+        var flow = [{
+            id: "n1",
+            type: "BaseNode",
+            name: "base node",
+        }];
+
+        const fakeShape = sandbox.fake(() => { return null });
+        const fakeText = sandbox.fake(() => { return null });
+        const fakeFill = sandbox.fake(() => { return "green" });
+        const fakeStatus = sandbox.fake((status) => {
+            status.should.have.property('shape','dot');
+            done();
+        });
+        sandbox.replace(BaseNode.prototype,'getStatusShape',fakeShape);
+        sandbox.replace(BaseNode.prototype,'getStatusText',fakeText);
+        sandbox.replace(BaseNode.prototype,'getStatusFill',fakeFill);
+        sandbox.replace(BaseNode.prototype,'status',fakeStatus);
+
+        helper.load(testnodes, flow, function () {
+            var n1 = helper.getNode("n1");
+            n1.updateStatus();
+        });
+    });
+
+    it('should default fill to "grey" when updateStatus() is called and shape is defined', function (done) {
+        var flow = [{
+            id: "n1",
+            type: "BaseNode",
+            name: "base node",
+        }];
+
+        const fakeShape = sandbox.fake(() => { return "dot" });
+        const fakeText = sandbox.fake(() => { return null });
+        const fakeFill = sandbox.fake(() => { return null });
+        const fakeStatus = sandbox.fake((status) => {
+            status.should.have.property('fill','grey');
+            done();
+        });
+        sandbox.replace(BaseNode.prototype,'getStatusShape',fakeShape);
+        sandbox.replace(BaseNode.prototype,'getStatusText',fakeText);
+        sandbox.replace(BaseNode.prototype,'getStatusFill',fakeFill);
+        sandbox.replace(BaseNode.prototype,'status',fakeStatus);
+
+        helper.load(testnodes, flow, function () {
+            var n1 = helper.getNode("n1");
+            n1.updateStatus();
+        });
+    });
+
+    it('should return name if logid() is called and config.name is set', function (done) {
+        var name = "base node";
+        var flow = [{
+            id: "n1",
+            type: "BaseNode",
+            name: name,
+        }];
+
+        helper.load(testnodes, flow, function () {
+            var n1 = helper.getNode("n1");
+            assert.equal(n1.logid(),name);
+            done();
+        });
+    });
+
+    it('should return id if logid() is called and config.name is not set', function (done) {
+        var id = "n1";
+        var flow = [{
+            id: id,
+            type: "BaseNode",
+        }];
+
+        helper.load(testnodes, flow, function () {
+            var n1 = helper.getNode(id);
+            assert.equal(n1.logid(),id);
+            done();
+        });
+    });
+});

package/test/BaseUI_spec.js

@@ -0,0 +1,17 @@
+//const BaseUI = require("../src/ui/BaseUI.js");
+//import {BaseUI} from "../src/ui/BaseUI"
+
+describe('Base UI', function () {
+    beforeEach(()=>{
+        sandbox = sinon.createSandbox();
+    });
+
+    afterEach(function () {
+        sandbox.restore();
+    });
+
+    it('should store config.name property', function (done) {
+        //var ui = new BaseUI("label","category");
+        done();
+    });
+});

package/test/BridgeConfigNode_spec.js

@@ -0,0 +1,184 @@
+var helper = require("node-red-node-test-helper");
+const assert = require('assert');
+const sinon = require('sinon');
+const axios = require('axios');
+
+var testnodes = function(RED) {
+    "use strict";
+
+    const BaseNode = require('../src/nodes/BaseNode');
+    BaseNode.nodeAPI = RED;
+
+    RED.nodes.registerType("BridgeConfigNode",BridgeConfigNode);
+}
+const BridgeConfigNode = require('../src/nodes/BridgeConfigNode');
+const ClipApi = require('../src/clip/ClipApi');
+
+describe('Bridge Config Node (instance)', function () {
+    beforeEach(()=>{
+        sandbox = sinon.createSandbox();
+    });
+
+    afterEach(function () {
+        sandbox.restore();
+        helper.unload();
+    });
+
+    it('should be loaded', function (done) {
+        const fakeClip = sandbox.fake(() => { return {
+            name: "clip",
+            destructor: function() {}
+        } });
+        sandbox.replace(BridgeConfigNode.prototype,'_constructClip',fakeClip);
+
+        var flow = [{ 
+            id: "n1",
+            type: "BridgeConfigNode",
+            name: "bridge config node",
+        }];
+
+        helper.load(testnodes, flow, function () {
+            var n1 = helper.getNode("n1");
+            var config = n1.config;
+            config.should.have.property('name', 'bridge config node');
+            var clip = n1.clip();
+            clip.should.have.property('name','clip');
+            var bridges = BridgeConfigNode.bridges();
+            bridges['n1'].should.have.property('id','n1');
+            done();
+        });
+    });
+
+    it('catch errors when executing on("close")', function (done) {
+        const fakeClip = sandbox.fake(() => { return {
+            name: "clip",
+            destructor: function() {}
+        } });
+        sandbox.replace(BridgeConfigNode.prototype,'_constructClip',fakeClip);
+        const fakeDestructor = sandbox.fake(() => { throw "Exception"; })
+        sandbox.replace(BridgeConfigNode.prototype,'destructor',fakeDestructor);
+
+        var flow = [{ 
+            id: "n1",
+            type: "BridgeConfigNode",
+            name: "bridge config node",
+        }];
+
+        helper.load(testnodes, flow, function () {
+            var n1 = helper.getNode("n1");
+            n1.close();
+            done();
+        });
+    });
+
+    it('should call clip.requestStartup when requestStartup() is called', function (done) {
+        const fakeClip = sandbox.fake(() => { return {
+            name: "clip",
+            destructor: function() {},
+            requestStartup: function() { done(); }
+        } });
+        sandbox.replace(BridgeConfigNode.prototype,'_constructClip',fakeClip);
+
+        var flow = [{ 
+            id: "n1",
+            type: "BridgeConfigNode",
+            name: "bridge config node",
+        }];
+
+        helper.load(testnodes, flow, function () {
+            var n1 = helper.getNode("n1");
+            n1.requestStartup("resource");
+        });
+    });
+
+    it('should not attempt to call clip.requestStartup when clip is null', function (done) {
+        const fakeClip = sandbox.fake(() => { return null; } );
+        sandbox.replace(BridgeConfigNode.prototype,'_constructClip',fakeClip);
+
+        var flow = [{ 
+            id: "n1",
+            type: "BridgeConfigNode",
+            name: "bridge config node",
+        }];
+
+        helper.load(testnodes, flow, function () {
+            var n1 = helper.getNode("n1");
+            n1.requestStartup("resource");
+            done();
+        });
+    });
+
+    it('should construct Clip instance', function (done) {
+        sandbox.stub(ClipApi.prototype,'_initRestApi').callsFake(() => null);
+        sandbox.stub(ClipApi.prototype,'_initEventStream').callsFake(() => null);
+        sandbox.stub(ClipApi.prototype,'_requestResources').callsFake(done);
+
+        var flow = [{ 
+            id: "n1",
+            type: "BridgeConfigNode",
+            name: "bridge config node",
+        }];
+
+        helper.load(testnodes, flow, function () {
+            var n1 = helper.getNode("n1");
+        });
+    });
+});
+
+describe('Bridge Config Node (static)', function () {
+    beforeEach(()=>{
+        sandbox = sinon.createSandbox();
+    });
+
+    afterEach(function () {
+        sandbox.restore();
+    });
+
+    it('should discover bridges', function (done) {
+        var count = 0;
+        sandbox.stub(BridgeConfigNode,'_axios').callsFake(function() {
+            if (count > 0) {
+                count++;
+                //console.log("fake bridge query");
+                return Promise.resolve({ data: {}});
+            } else {
+                //console.log("fake meethue query");
+                return Promise.resolve({ data: [{ "internalipaddress": "ip" }]});
+            }
+        });
+
+        BridgeConfigNode.DiscoverBridges();
+        done();
+    });
+
+    it('should acquire application key', function (done) {
+        sandbox.stub(BridgeConfigNode,'_axios').callsFake(function() {
+            return Promise.resolve({ data : [
+                { success: "username" }
+            ]});
+        });
+
+        BridgeConfigNode.AcquireApplicationKey("ip");
+        done();
+    });
+
+    it('should acquire application key, but returns error', function (done) {
+        sandbox.stub(BridgeConfigNode,'_axios').callsFake(function() {
+            return Promise.resolve({ data : [
+                { error: "some error" }
+            ]});
+        });
+
+        BridgeConfigNode.AcquireApplicationKey("ip");
+        done();
+    });
+
+    it('should acquire application key, but throws exception', function (done) {
+        sandbox.stub(BridgeConfigNode,'_axios').callsFake(function() {
+            return Promise.reject("trigger exception");
+        });
+
+        BridgeConfigNode.AcquireApplicationKey("ip");
+        done();
+    });
+});

package/test/ButtonNode_spec.js

@@ -0,0 +1,178 @@
+const helper = require("node-red-node-test-helper");
+const assert = require('assert');
+const sinon = require('sinon');
+
+const testnodes = function(RED) {
+    "use strict";
+
+    const BaseNode = require('../src/nodes/BaseNode');
+    BaseNode.nodeAPI = RED;
+
+    RED.nodes.registerType("ButtonNode",ButtonNode);
+}
+const ButtonNode = require('../src/nodes/ButtonNode')
+
+describe('ButtonNode', function () {
+    beforeEach(()=>{
+        sandbox = sinon.createSandbox();
+    });
+
+    afterEach(function () {
+        sandbox.restore();
+        helper.unload();
+      });
+  
+    it('should load', function (done) {
+
+        var flow = [{
+            id: "n1",
+            type: "ButtonNode",
+            name: "button node",
+        }];
+
+        helper.load(testnodes, flow, function () {
+            var n1 = helper.getNode("n1");
+            n1.should.have.property('config');
+
+            var config = n1.config;
+            config.should.have.property('name', 'button node');
+            done();
+        });
+    });
+
+    it('should call updateStatus() twice with 3s delay when onUpdate(event) is called', function (done) {
+        var statuscount = 0;
+        const fakeStatus = sandbox.fake(() => {
+            if (statuscount++ > 0) {
+                done()
+            }
+        });
+        sandbox.replace(ButtonNode.prototype,'updateStatus',fakeStatus);
+
+        var flow = [{
+            id: "n1",
+            type: "ButtonNode",
+            name: "button node",
+        }];
+
+        helper.load(testnodes, flow, function () {
+            var n1 = helper.getNode("n1");
+            n1.onUpdate({
+                name: "event"
+            });
+        });
+    });
+
+    it('should call status() with "blue/dot/last_event" and "grey/dot/last_event"', function (done) {
+        var statuscount = 0;
+        const fakeStatus = sandbox.fake(() => {
+            var args = fakeStatus.firstArg;
+            if (statuscount++ == 0) {
+                assert.equal(args.fill,"blue");
+                assert.equal(args.shape,"dot");
+                assert.equal(args.text,"last_event");
+            } else {
+                assert.equal(args.fill,"grey");
+                assert.equal(args.shape,"dot");
+                assert.equal(args.text,"last_event");
+                done()
+            }
+        });
+        sandbox.replace(ButtonNode.prototype,'status',fakeStatus);
+        const fakeResource = sandbox.fake(() => { 
+            return {
+                data: function() {
+                    return { button: { last_event: "last_event" } }
+                }
+            }
+        });
+        sandbox.replace(ButtonNode.prototype,'resource',fakeResource);
+
+        var flow = [{
+            id: "n1",
+            type: "ButtonNode",
+            name: "button node",
+        }];
+
+        helper.load(testnodes, flow, function () {
+            var n1 = helper.getNode("n1");
+            n1.onUpdate({
+                button: { last_event: "last_event" }
+            });
+        });
+    });
+
+    it('should call status() with "blue/dot/" and "grey/dot/" when resource==null', function (done) {
+        var statuscount = 0;
+        const fakeStatus = sandbox.fake(() => {
+            var args = fakeStatus.firstArg;
+            if (statuscount++ == 0) {
+                assert.equal(args.fill,"blue");
+                assert.equal(args.shape,"dot");
+                assert.equal(args.text,"");
+            } else {
+                assert.equal(args.fill,"grey");
+                assert.equal(args.shape,"dot");
+                assert.equal(args.text,"");
+                done()
+            }
+        });
+        sandbox.replace(ButtonNode.prototype,'status',fakeStatus);
+        const fakeResource = sandbox.fake(() => { 
+            return null
+        });
+        sandbox.replace(ButtonNode.prototype,'resource',fakeResource);
+
+        var flow = [{
+            id: "n1",
+            type: "ButtonNode",
+            name: "button node",
+        }];
+
+        helper.load(testnodes, flow, function () {
+            var n1 = helper.getNode("n1");
+            n1.onUpdate({
+                button: { last_event: "last_event" }
+            });
+        });
+    });
+
+    it('should call status() with "blue/dot/" and "grey/dot/" when last_event==null', function (done) {
+        var statuscount = 0;
+        const fakeStatus = sandbox.fake(() => {
+            var args = fakeStatus.firstArg;
+            if (statuscount++ == 0) {
+                assert.equal(args.fill,"blue");
+                assert.equal(args.shape,"dot");
+                assert.equal(args.text,"");
+            } else {
+                assert.equal(args.fill,"grey");
+                assert.equal(args.shape,"dot");
+                assert.equal(args.text,"");
+                done()
+            }
+        });
+        sandbox.replace(ButtonNode.prototype,'status',fakeStatus);
+        const fakeResource = sandbox.fake(() => { 
+            return {
+                data: function() {
+                    return { button: { last_event: null } }
+                }
+            }
+        });
+        sandbox.replace(ButtonNode.prototype,'resource',fakeResource);
+
+        var flow = [{
+            id: "n1",
+            type: "ButtonNode",
+            name: "button node",
+        }];
+
+        helper.load(testnodes, flow, function () {
+            var n1 = helper.getNode("n1");
+            n1.onUpdate({
+                button: { last_event: "last_event" }
+            });
+        });
+    });
+});