smart-nodes 0.5.2 → 0.6.0

package/CHANGELOG.md

@@ -218,3 +218,9 @@
 ## Version 0.5.2:
 
 -   Added alarm mode to mixing-valve.
+
+## Version 0.6.0:
+
+-   Reduced amount of messages sent by light node when it is in alarm mode.
+-   Fixed forwarder node causing an error when no topic was sent.
+-   Added Jest example for all nodes to be able to debug nodes in vscode.

package/SmartNodesContext.json

@@ -0,0 +1 @@
+{"idn1":{"temperature_outside":10,"last_flow_temperature":null}}

package/__tests__/compare.test.js

@@ -0,0 +1,57 @@
+const th = require("./test-helper");
+const helper = th.helper;
+const nodeModule = require("../compare/compare.js");
+
+const nodeType = "smart_compare";
+
+th.init();
+
+test("compare", (done) =>
+{
+    const flow = [
+        {
+            id: "n1",
+            type: nodeType,
+            name: "test-compare",
+            comparator: "SMALLER",
+            value1: 5,
+            value2: 9,
+            wires: [["n2"]]
+        },
+        { id: "n2", type: "helper" }
+    ];
+
+    helper.load(nodeModule, flow, () =>
+    {
+        try
+        {
+            const n1 = helper.getNode("n1");
+            const n2 = helper.getNode("n2");
+
+            if (!n1) return done(new Error("Node n1 wurde nicht erstellt"));
+            if (!n2) return done(new Error("Helper-Node n2 fehlt"));
+
+            n2.on("input", (msg) =>
+            {
+                try
+                {
+                    console.log("Received:", msg);
+                    expect(msg).toBeDefined();
+                }
+                catch (err)
+                {
+                    done(err);
+                }
+            });
+
+            n1.receive({ topic: "1", payload: 7 });
+            n1.receive({ topic: "1", payload: 17 });
+
+            setImmediate(() => { done(); });
+        }
+        catch (err)
+        {
+            done(err);
+        }
+    });
+});

package/__tests__/counter.test.js

@@ -0,0 +1,54 @@
+const th = require("./test-helper");
+const helper = th.helper;
+const nodeModule = require("../counter/counter.js");
+
+const nodeType = "smart_counter";
+
+th.init();
+
+test("counter", (done) =>
+{
+    const flow = [
+        {
+            id: "n1",
+            type: nodeType,
+            name: "test-counter",
+            wires: [["n2"]]
+        },
+        { id: "n2", type: "helper" }
+    ];
+
+    helper.load(nodeModule, flow, () =>
+    {
+        try
+        {
+            const n1 = helper.getNode("n1");
+            const n2 = helper.getNode("n2");
+
+            if (!n1) return done(new Error("Node n1 wurde nicht erstellt"));
+            if (!n2) return done(new Error("Helper-Node n2 fehlt"));
+
+            n2.on("input", (msg) =>
+            {
+                try
+                {
+                    console.log("Received:", msg);
+                    expect(msg).toBeDefined();
+                }
+                catch (err)
+                {
+                    done(err);
+                }
+            });
+
+            n1.receive({ topic: "1", payload: 7 });
+            n1.receive({ topic: "1", payload: 17 });
+
+            setImmediate(() => { done(); });
+        }
+        catch (err)
+        {
+            done(err);
+        }
+    });
+});

package/__tests__/forwarder.test.js

@@ -0,0 +1,54 @@
+const th = require("./test-helper");
+const helper = th.helper;
+const nodeModule = require("../forwarder/forwarder.js");
+
+const nodeType = "smart_forwarder";
+
+th.init();
+
+test("forwarder", (done) =>
+{
+    const flow = [
+        {
+            id: "n1",
+            type: nodeType,
+            name: "test-forwarder",
+            wires: [["n2"]]
+        },
+        { id: "n2", type: "helper" }
+    ];
+
+    helper.load(nodeModule, flow, () =>
+    {
+        try
+        {
+            const n1 = helper.getNode("n1");
+            const n2 = helper.getNode("n2");
+
+            if (!n1) return done(new Error("Node n1 wurde nicht erstellt"));
+            if (!n2) return done(new Error("Helper-Node n2 fehlt"));
+
+            n2.on("input", (msg) =>
+            {
+                try
+                {
+                    console.log("Received:", msg);
+                    expect(msg).toBeDefined();
+                }
+                catch (err)
+                {
+                    done(err);
+                }
+            });
+
+            n1.receive({ topic: "1", payload: 7 });
+            n1.receive({ topic: "1", payload: 17 });
+
+            setImmediate(() => { done(); });
+        }
+        catch (err)
+        {
+            done(err);
+        }
+    });
+});

package/__tests__/heating-curve.test.js

@@ -0,0 +1,54 @@
+const th = require("./test-helper");
+const helper = th.helper;
+const nodeModule = require("../heating-curve/heating-curve.js");
+
+const nodeType = "smart_heating-curve";
+
+th.init();
+
+test("heating-curve", (done) =>
+{
+    const flow = [
+        {
+            id: "n1",
+            type: nodeType,
+            name: "test-heating-curve",
+            wires: [["n2"]]
+        },
+        { id: "n2", type: "helper" }
+    ];
+
+    helper.load(nodeModule, flow, () =>
+    {
+        try
+        {
+            const n1 = helper.getNode("n1");
+            const n2 = helper.getNode("n2");
+
+            if (!n1) return done(new Error("Node n1 wurde nicht erstellt"));
+            if (!n2) return done(new Error("Helper-Node n2 fehlt"));
+
+            n2.on("input", (msg) =>
+            {
+                try
+                {
+                    console.log("Received:", msg);
+                    expect(msg).toBeDefined();
+                }
+                catch (err)
+                {
+                    done(err);
+                }
+            });
+
+            n1.receive({ topic: "1", payload: 7 });
+            n1.receive({ topic: "1", payload: 17 });
+
+            setImmediate(() => { done(); });
+        }
+        catch (err)
+        {
+            done(err);
+        }
+    });
+});

package/__tests__/hysteresis.test.js

@@ -0,0 +1,54 @@
+const th = require("./test-helper");
+const helper = th.helper;
+const nodeModule = require("../hysteresis/hysteresis.js");
+
+const nodeType = "smart_hysteresis";
+
+th.init();
+
+test("hysteresis", (done) =>
+{
+    const flow = [
+        {
+            id: "n1",
+            type: nodeType,
+            name: "test-hysteresis",
+            wires: [["n2"]]
+        },
+        { id: "n2", type: "helper" }
+    ];
+
+    helper.load(nodeModule, flow, () =>
+    {
+        try
+        {
+            const n1 = helper.getNode("n1");
+            const n2 = helper.getNode("n2");
+
+            if (!n1) return done(new Error("Node n1 wurde nicht erstellt"));
+            if (!n2) return done(new Error("Helper-Node n2 fehlt"));
+
+            n2.on("input", (msg) =>
+            {
+                try
+                {
+                    console.log("Received:", msg);
+                    expect(msg).toBeDefined();
+                }
+                catch (err)
+                {
+                    done(err);
+                }
+            });
+
+            n1.receive({ topic: "1", payload: 7 });
+            n1.receive({ topic: "1", payload: 17 });
+
+            setImmediate(() => { done(); });
+        }
+        catch (err)
+        {
+            done(err);
+        }
+    });
+});

package/__tests__/light.test.js

@@ -0,0 +1,49 @@
+const th = require("./test-helper");
+const helper = th.helper;
+const nodeModule = require("../light/light.js");
+
+const nodeType = "smart_light-control";
+
+th.init();
+
+test("light node", (done) =>
+{
+    const flow = [
+        { id: "n1", type: nodeType, name: "test-light", wires: [["n2"]] },
+        { id: "n2", type: "helper" }
+    ];
+
+    helper.load(nodeModule, flow, () =>
+    {
+        try
+        {
+            const n1 = helper.getNode("n1");
+            const n2 = helper.getNode("n2");
+
+            if (!n1) return done(new Error("Node n1 wurde nicht erstellt"));
+            if (!n2) return done(new Error("Helper-Node n2 fehlt"));
+
+            n2.on("input", (msg) =>
+            {
+                try
+                {
+                    console.log("Received:", msg);
+                    expect(msg).toBeDefined();
+                }
+                catch (err)
+                {
+                    done(err);
+                }
+            });
+
+            n1.receive({ topic: "toggle" });
+            n1.receive({ topic: "toggle" });
+
+            setImmediate(() => { done(); });
+        }
+        catch (err)
+        {
+            done(err);
+        }
+    });
+});

package/__tests__/logic.test.js

@@ -0,0 +1,61 @@
+const th = require("./test-helper");
+const helper = th.helper;
+const nodeModule = require("../logic/logic.js");
+
+const nodeType = "smart_logic";
+
+th.init();
+
+test("logic", (done) =>
+{
+    const flow = [
+        {
+            id: "n1",
+            type: nodeType,
+            name: "test-logic",
+            out_true: "{}",
+            out_true_type: "json",
+            out_false: "{}",
+            out_false_type: "json",
+            inverts: "",
+            send_only_change: true,
+            outputs: 1,
+            wires: [["n2"]]
+        },
+        { id: "n2", type: "helper" }
+    ];
+
+    helper.load(nodeModule, flow, () =>
+    {
+        try
+        {
+            const n1 = helper.getNode("n1");
+            const n2 = helper.getNode("n2");
+
+            if (!n1) return done(new Error("Node n1 wurde nicht erstellt"));
+            if (!n2) return done(new Error("Helper-Node n2 fehlt"));
+
+            n2.on("input", (msg) =>
+            {
+                try
+                {
+                    console.log("Received:", msg);
+                    expect(msg).toBeDefined();
+                }
+                catch (err)
+                {
+                    done(err);
+                }
+            });
+
+            n1.receive({ topic: "1", payload: 7 });
+            n1.receive({ topic: "1", payload: 17 });
+
+            setImmediate(() => { done(); });
+        }
+        catch (err)
+        {
+            done(err);
+        }
+    });
+});

package/__tests__/long-press.test.js

@@ -0,0 +1,54 @@
+const th = require("./test-helper");
+const helper = th.helper;
+const nodeModule = require("../long-press/long-press.js");
+
+const nodeType = "smart_long-press-control";
+
+th.init();
+
+test("long-press", (done) =>
+{
+    const flow = [
+        {
+            id: "n1",
+            type: nodeType,
+            name: "test-long-press",
+            wires: [["n2"]]
+        },
+        { id: "n2", type: "helper" }
+    ];
+
+    helper.load(nodeModule, flow, () =>
+    {
+        try
+        {
+            const n1 = helper.getNode("n1");
+            const n2 = helper.getNode("n2");
+
+            if (!n1) return done(new Error("Node n1 wurde nicht erstellt"));
+            if (!n2) return done(new Error("Helper-Node n2 fehlt"));
+
+            n2.on("input", (msg) =>
+            {
+                try
+                {
+                    console.log("Received:", msg);
+                    expect(msg).toBeDefined();
+                }
+                catch (err)
+                {
+                    done(err);
+                }
+            });
+
+            n1.receive({ topic: "1", payload: 7 });
+            n1.receive({ topic: "1", payload: 17 });
+
+            setImmediate(() => { done(); });
+        }
+        catch (err)
+        {
+            done(err);
+        }
+    });
+});

package/__tests__/mixing-valve.test.js

@@ -0,0 +1,54 @@
+const th = require("./test-helper");
+const helper = th.helper;
+const nodeModule = require("../mixing-valve/mixing-valve.js");
+
+const nodeType = "smart_mixing-valve";
+
+th.init();
+
+test("mixing-valve", (done) =>
+{
+    const flow = [
+        {
+            id: "n1",
+            type: nodeType,
+            name: "test-mixing-valve",
+            wires: [["n2"]]
+        },
+        { id: "n2", type: "helper" }
+    ];
+
+    helper.load(nodeModule, flow, () =>
+    {
+        try
+        {
+            const n1 = helper.getNode("n1");
+            const n2 = helper.getNode("n2");
+
+            if (!n1) return done(new Error("Node n1 wurde nicht erstellt"));
+            if (!n2) return done(new Error("Helper-Node n2 fehlt"));
+
+            n2.on("input", (msg) =>
+            {
+                try
+                {
+                    console.log("Received:", msg);
+                    expect(msg).toBeDefined();
+                }
+                catch (err)
+                {
+                    done(err);
+                }
+            });
+
+            n1.receive({ topic: "1", payload: 7 });
+            n1.receive({ topic: "1", payload: 17 });
+
+            setImmediate(() => { done(); });
+        }
+        catch (err)
+        {
+            done(err);
+        }
+    });
+});

package/__tests__/mode-selector.test.js

@@ -0,0 +1,54 @@
+const th = require("./test-helper");
+const helper = th.helper;
+const nodeModule = require("../mode-selector/mode-selector.js");
+
+const nodeType = "smart_mode-selector";
+
+th.init();
+
+test("mode-selector", (done) =>
+{
+    const flow = [
+        {
+            id: "n1",
+            type: nodeType,
+            name: "test-mode-selector",
+            wires: [["n2"]]
+        },
+        { id: "n2", type: "helper" }
+    ];
+
+    helper.load(nodeModule, flow, () =>
+    {
+        try
+        {
+            const n1 = helper.getNode("n1");
+            const n2 = helper.getNode("n2");
+
+            if (!n1) return done(new Error("Node n1 wurde nicht erstellt"));
+            if (!n2) return done(new Error("Helper-Node n2 fehlt"));
+
+            n2.on("input", (msg) =>
+            {
+                try
+                {
+                    console.log("Received:", msg);
+                    expect(msg).toBeDefined();
+                }
+                catch (err)
+                {
+                    done(err);
+                }
+            });
+
+            n1.receive({ topic: "1", payload: 7 });
+            n1.receive({ topic: "1", payload: 17 });
+
+            setImmediate(() => { done(); });
+        }
+        catch (err)
+        {
+            done(err);
+        }
+    });
+});

package/__tests__/multi-press.test.js

@@ -0,0 +1,54 @@
+const th = require("./test-helper");
+const helper = th.helper;
+const nodeModule = require("../multi-press/multi-press.js");
+
+const nodeType = "smart_multi-press";
+
+th.init();
+
+test("multi-press", (done) =>
+{
+    const flow = [
+        {
+            id: "n1",
+            type: nodeType,
+            name: "test-multi-press",
+            wires: [["n2"]]
+        },
+        { id: "n2", type: "helper" }
+    ];
+
+    helper.load(nodeModule, flow, () =>
+    {
+        try
+        {
+            const n1 = helper.getNode("n1");
+            const n2 = helper.getNode("n2");
+
+            if (!n1) return done(new Error("Node n1 wurde nicht erstellt"));
+            if (!n2) return done(new Error("Helper-Node n2 fehlt"));
+
+            n2.on("input", (msg) =>
+            {
+                try
+                {
+                    console.log("Received:", msg);
+                    expect(msg).toBeDefined();
+                }
+                catch (err)
+                {
+                    done(err);
+                }
+            });
+
+            n1.receive({ topic: "1", payload: 7 });
+            n1.receive({ topic: "1", payload: 17 });
+
+            setImmediate(() => { done(); });
+        }
+        catch (err)
+        {
+            done(err);
+        }
+    });
+});

package/__tests__/scene.test.js

@@ -0,0 +1,54 @@
+const th = require("./test-helper");
+const helper = th.helper;
+const nodeModule = require("../scene/scene.js");
+
+const nodeType = "smart_scene-control";
+
+th.init();
+
+test("scene", (done) =>
+{
+    const flow = [
+        {
+            id: "n1",
+            type: nodeType,
+            name: "test-scene",
+            wires: [["n2"]]
+        },
+        { id: "n2", type: "helper" }
+    ];
+
+    helper.load(nodeModule, flow, () =>
+    {
+        try
+        {
+            const n1 = helper.getNode("n1");
+            const n2 = helper.getNode("n2");
+
+            if (!n1) return done(new Error("Node n1 wurde nicht erstellt"));
+            if (!n2) return done(new Error("Helper-Node n2 fehlt"));
+
+            n2.on("input", (msg) =>
+            {
+                try
+                {
+                    console.log("Received:", msg);
+                    expect(msg).toBeDefined();
+                }
+                catch (err)
+                {
+                    done(err);
+                }
+            });
+
+            n1.receive({ topic: "1", payload: 7 });
+            n1.receive({ topic: "1", payload: 17 });
+
+            setImmediate(() => { done(); });
+        }
+        catch (err)
+        {
+            done(err);
+        }
+    });
+});

package/__tests__/scheduler.test.js

@@ -0,0 +1,54 @@
+const th = require("./test-helper");
+const helper = th.helper;
+const nodeModule = require("../scheduler/scheduler.js");
+
+const nodeType = "smart_scheduler";
+
+th.init();
+
+test("scheduler", (done) =>
+{
+    const flow = [
+        {
+            id: "n1",
+            type: nodeType,
+            name: "test-scheduler",
+            wires: [["n2"]]
+        },
+        { id: "n2", type: "helper" }
+    ];
+
+    helper.load(nodeModule, flow, () =>
+    {
+        try
+        {
+            const n1 = helper.getNode("n1");
+            const n2 = helper.getNode("n2");
+
+            if (!n1) return done(new Error("Node n1 wurde nicht erstellt"));
+            if (!n2) return done(new Error("Helper-Node n2 fehlt"));
+
+            n2.on("input", (msg) =>
+            {
+                try
+                {
+                    console.log("Received:", msg);
+                    expect(msg).toBeDefined();
+                }
+                catch (err)
+                {
+                    done(err);
+                }
+            });
+
+            n1.receive({ topic: "1", payload: 7 });
+            n1.receive({ topic: "1", payload: 17 });
+
+            setImmediate(() => { done(); });
+        }
+        catch (err)
+        {
+            done(err);
+        }
+    });
+});

package/__tests__/shutter-complex.test.js

@@ -0,0 +1,54 @@
+const th = require("./test-helper");
+const helper = th.helper;
+const nodeModule = require("../shutter-complex/shutter-complex.js");
+
+const nodeType = "smart_shutter-complex-control";
+
+th.init();
+
+test("shutter-complex", (done) =>
+{
+    const flow = [
+        {
+            id: "n1",
+            type: nodeType,
+            name: "test-shutter-complex",
+            wires: [["n2"]]
+        },
+        { id: "n2", type: "helper" }
+    ];
+
+    helper.load(nodeModule, flow, () =>
+    {
+        try
+        {
+            const n1 = helper.getNode("n1");
+            const n2 = helper.getNode("n2");
+
+            if (!n1) return done(new Error("Node n1 wurde nicht erstellt"));
+            if (!n2) return done(new Error("Helper-Node n2 fehlt"));
+
+            n2.on("input", (msg) =>
+            {
+                try
+                {
+                    console.log("Received:", msg);
+                    expect(msg).toBeDefined();
+                }
+                catch (err)
+                {
+                    done(err);
+                }
+            });
+
+            n1.receive({ topic: "1", payload: 7 });
+            n1.receive({ topic: "1", payload: 17 });
+
+            setImmediate(() => { done(); });
+        }
+        catch (err)
+        {
+            done(err);
+        }
+    });
+});

package/__tests__/shutter.test.js

@@ -0,0 +1,54 @@
+const th = require("./test-helper");
+const helper = th.helper;
+const nodeModule = require("../shutter/shutter.js");
+
+const nodeType = "smart_shutter-control";
+
+th.init();
+
+test("shutter", (done) =>
+{
+    const flow = [
+        {
+            id: "n1",
+            type: nodeType,
+            name: "test-shutter",
+            wires: [["n2"]]
+        },
+        { id: "n2", type: "helper" }
+    ];
+
+    helper.load(nodeModule, flow, () =>
+    {
+        try
+        {
+            const n1 = helper.getNode("n1");
+            const n2 = helper.getNode("n2");
+
+            if (!n1) return done(new Error("Node n1 wurde nicht erstellt"));
+            if (!n2) return done(new Error("Helper-Node n2 fehlt"));
+
+            n2.on("input", (msg) =>
+            {
+                try
+                {
+                    console.log("Received:", msg);
+                    expect(msg).toBeDefined();
+                }
+                catch (err)
+                {
+                    done(err);
+                }
+            });
+
+            n1.receive({ topic: "1", payload: 7 });
+            n1.receive({ topic: "1", payload: 17 });
+
+            setImmediate(() => { done(); });
+        }
+        catch (err)
+        {
+            done(err);
+        }
+    });
+});

package/__tests__/statistics.test.js

@@ -0,0 +1,54 @@
+const th = require("./test-helper");
+const helper = th.helper;
+const nodeModule = require("../statistics/statistics.js");
+
+const nodeType = "smart_statistics";
+
+th.init();
+
+test("statistics", (done) =>
+{
+    const flow = [
+        {
+            id: "n1",
+            type: nodeType,
+            name: "test-statistics",
+            wires: [["n2"]]
+        },
+        { id: "n2", type: "helper" }
+    ];
+
+    helper.load(nodeModule, flow, () =>
+    {
+        try
+        {
+            const n1 = helper.getNode("n1");
+            const n2 = helper.getNode("n2");
+
+            if (!n1) return done(new Error("Node n1 wurde nicht erstellt"));
+            if (!n2) return done(new Error("Helper-Node n2 fehlt"));
+
+            n2.on("input", (msg) =>
+            {
+                try
+                {
+                    console.log("Received:", msg);
+                    expect(msg).toBeDefined();
+                }
+                catch (err)
+                {
+                    done(err);
+                }
+            });
+
+            n1.receive({ topic: "1", payload: 7 });
+            n1.receive({ topic: "1", payload: 17 });
+
+            setImmediate(() => { done(); });
+        }
+        catch (err)
+        {
+            done(err);
+        }
+    });
+});

package/__tests__/test-helper.js

@@ -0,0 +1,40 @@
+const helper = require("node-red-node-test-helper");
+
+module.exports = {
+    helper,
+
+    init: function ()
+    {
+        // init must be called once per test file before startServer
+        helper.init(require.resolve("node-red"));
+
+        beforeAll(() => this.startServer());
+        afterAll(() => this.stopServer());
+        afterEach(() => this.unload().then(() =>
+        {
+            process.removeAllListeners("uncaughtException");
+            process.removeAllListeners("unhandledRejection");
+        }));
+    },
+
+    startServer: function ()
+    {
+        return new Promise((resolve, reject) =>
+        {
+            helper.startServer((err) => (err ? reject(err) : resolve()));
+        });
+    },
+
+    stopServer: function ()
+    {
+        return new Promise((resolve) =>
+        {
+            helper.stopServer(() => resolve());
+        });
+    },
+
+    unload: function ()
+    {
+        return helper.unload().catch(() => { });
+    }
+};

package/__tests__/text-exec.test.js

@@ -0,0 +1,54 @@
+const th = require("./test-helper");
+const helper = th.helper;
+const nodeModule = require("../text-exec/text-exec.js");
+
+const nodeType = "smart_text-exec";
+
+th.init();
+
+test("text-exec", (done) =>
+{
+    const flow = [
+        {
+            id: "n1",
+            type: nodeType,
+            name: "test-text-exec",
+            wires: [["n2"]]
+        },
+        { id: "n2", type: "helper" }
+    ];
+
+    helper.load(nodeModule, flow, () =>
+    {
+        try
+        {
+            const n1 = helper.getNode("n1");
+            const n2 = helper.getNode("n2");
+
+            if (!n1) return done(new Error("Node n1 wurde nicht erstellt"));
+            if (!n2) return done(new Error("Helper-Node n2 fehlt"));
+
+            n2.on("input", (msg) =>
+            {
+                try
+                {
+                    console.log("Received:", msg);
+                    expect(msg).toBeDefined();
+                }
+                catch (err)
+                {
+                    done(err);
+                }
+            });
+
+            n1.receive({ topic: "1", payload: 7 });
+            n1.receive({ topic: "1", payload: 17 });
+
+            setImmediate(() => { done(); });
+        }
+        catch (err)
+        {
+            done(err);
+        }
+    });
+});

package/forwarder/forwarder.js

@@ -80,28 +80,31 @@ module.exports = function (RED)
         let handleTopic = msg =>
         {
             let real_topic = helper.getTopicName(msg.topic);
+            let new_state = null;
 
-            if (real_topic.startsWith("set_state"))
-                real_topic = real_topic.replace("set_state", "set");
-
-            if (real_topic == "set_inverted")
+            if (real_topic != null)
             {
-                real_topic = "set";
-                msg.payload = !msg.payload;
+                if (real_topic.startsWith("set_state"))
+                    real_topic = real_topic.replace("set_state", "set");
+
+                if (real_topic == "set_inverted")
+                {
+                    real_topic = "set";
+                    msg.payload = !msg.payload;
+                }
+
+                if (real_topic == "enable" || (real_topic == "set" && msg.payload))
+                    new_state = true;
+                else if (real_topic == "disable" || (real_topic == "set" && !msg.payload))
+                    new_state = false;
             }
 
-            let new_state = null;
-            if (real_topic == "enable" || (real_topic == "set" && msg.payload))
-                new_state = true;
-            else if (real_topic == "disable" || (real_topic == "set" && !msg.payload))
-                new_state = false;
-
             switch (real_topic)
             {
                 case "debug":
                     helper.nodeDebug(node, {
                         node_settings,
-                        forward_true,                        
+                        forward_true,
                         forward_false,
                         forward_last_on_enable,
                     });

package/heating-curve/heating-curve.html

@@ -27,8 +27,8 @@
                 $("#node-input-room_setpoint")
                     .css("max-width", "4rem")
                     .spinner({
-                        min: 15,
-                        max: 25,
+                        min: 5,
+                        max: 100,
                         step: 0.5,
                         change: function (event, ui)
                         {
@@ -77,8 +77,8 @@
                 $("#node-input-flow_max")
                     .css("max-width", "4rem")
                     .spinner({
-                        min: 50,
-                        max: 85,
+                        min: 5,
+                        max: 100,
                         change: function (event, ui)
                         {
                             var value = parseFloat(this.value);
@@ -94,7 +94,7 @@
                     .css("max-width", "4rem")
                     .spinner({
                         min: 5,
-                        max: 30,
+                        max: 100,
                         change: function (event, ui)
                         {
                             var value = parseFloat(this.value);

package/jest.config.js

@@ -0,0 +1,5 @@
+module.exports = {
+  testEnvironment: 'node',
+  testMatch: ['**/__tests__/**/*.test.js'],
+  verbose: true,
+};

package/light/light.js

@@ -46,6 +46,7 @@ module.exports = function (RED)
         let alarm_action = config.alarm_action || "NOTHING";
         let alarm_off_action = config.alarm_off_action || "NOTHING";
         let mode = config.mode || "BOOL";
+        let current_output_state = null;
 
         // ##################
         // # Runtime values #
@@ -149,6 +150,7 @@ module.exports = function (RED)
                         doRestartTimer = false;
 
                     node_settings.last_value = msg.payload;
+                    current_output_state = node_settings.last_value;
                     break;
 
                 case "off":
@@ -360,8 +362,11 @@ module.exports = function (RED)
                 }
             }
 
-            if (node_settings.alarm_active || helper.getTopicName(msg.topic) != "status")
+            if (real_topic != "status" && current_output_state !== node_settings.last_value)
+            {
                 node.send({ payload: node_settings.last_value });
+                current_output_state = node_settings.last_value;
+            }
 
             // Output is on, now
             if (node_settings.last_value && doRestartTimer)
@@ -410,6 +415,7 @@ module.exports = function (RED)
                     node_settings.last_value = 0;
 
                 node.send({ payload: node_settings.last_value });
+                current_output_state = node_settings.last_value;
                 notifyCentral(false);
 
                 setStatus();

package/mixing-valve/mixing-valve.js

@@ -155,6 +155,9 @@ module.exports = function (RED)
 
             let real_topic = helper.getTopicName(msg.topic);
 
+            if (real_topic == null)
+                node.warn("No topic set");
+
             if (real_topic.startsWith("set_state"))
                 real_topic = real_topic.replace("set_state", "set");
 
@@ -354,16 +357,21 @@ module.exports = function (RED)
                                 node_settings.alarm_active = false;
                                 return;
                         }
+
+                        stopSampling();
+                        startSampling();
                     }
                     else
                     {
                         force_position = null;
-                        if (!node_settings.enabled)
+                        stopSampling();
+                        stopChanging();
+
+                        if (node_settings.enabled)
+                            startSampling();
+                        else
                             doOffMode();
                     }
-
-                    stopSampling();
-                    startSampling();
                     break;
 
                 default:

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "smart-nodes",
-    "version": "0.5.2",
+    "version": "0.6.0",
     "description": "Controls light, shutters and more. Includes common used logic and statistic nodes to control your home.",
     "keywords": [
         "node-red",
@@ -27,7 +27,9 @@
         "text execution"
     ],
     "scripts": {
-        "test": "echo \"Error: no test specified\" && exit 1"
+        "test": "jest",
+        "test:watch": "jest --watch",
+        "test:debug": "node --inspect-brk node_modules/jest/bin/jest.js --runInBand"
     },
     "author": "Samuel Bergen",
     "license": "MIT",
@@ -59,9 +61,11 @@
         "type": "git",
         "url": "https://github.com/BergenSoft/smart-nodes"
     },
-    "dependencies": {},
     "devDependencies": {
-        "font-awesome": "^4.7.0"
+        "font-awesome": "^4.7.0",
+        "jest": "^27.5.1",
+        "node-red": "^4.1.1",
+        "node-red-node-test-helper": "^0.3.5"
     },
     "engines": {
         "node": ">=10"

package/persistence.js

@@ -1,3 +1,5 @@
+const { log } = require('console');
+
 let instance = null;
 
 module.exports = function (_RED)
@@ -5,21 +7,31 @@ module.exports = function (_RED)
     if (instance != null)
         return instance;
 
-    let RED = _RED;
     let hasChanges = false;
+    let inTestMode = _RED.settings.userDir == null;
+
+    // used for local debugging
+    if (inTestMode)
+        console.log("####### Test Mode detected #######");
 
     const fs = require('fs');
-    const path = RED.settings.userDir + '/SmartNodesContext.json';
+    const pathLib = require('path');
+
+    // Fallback, falls RED.settings.userDir in Tests nicht gesetzt ist
+    const userDir = (_RED.settings && _RED.settings.userDir) ? _RED.settings.userDir : process.cwd();
+    const filePath = pathLib.join(userDir, 'SmartNodesContext.json');
 
     let globalData = {};
 
-    if (fs.existsSync(path))
+    if (fs.existsSync(filePath))
     {
         try
         {
-            let fileContent = fs.readFileSync(path, "utf8");
+            let fileContent = fs.readFileSync(filePath, "utf8");
             globalData = Object.assign({}, JSON.parse(fileContent));
-            // console.log("Loaded " + Object.keys(globalData).length + " smart_nodes config items");
+
+            if (inTestMode)
+                console.log("Loaded:", globalData);
         }
         catch (error)
         {
@@ -35,12 +47,18 @@ module.exports = function (_RED)
 
     }, 30 * 1000);
 
+    // Prevent the interval from keeping the process alive (important for Jest)
+    if (interval && typeof interval.unref === "function")
+        interval.unref();
+
     function save()
     {
         try
         {
-            // console.log("Auto save");
-            fs.writeFile(path, JSON.stringify(globalData), err =>
+            if (inTestMode)
+                console.log("Save SmartNodeContext", globalData);
+
+            fs.writeFile(filePath, JSON.stringify(globalData), err =>
             {
                 if (err)
                     console.error(err);
@@ -57,6 +75,9 @@ module.exports = function (_RED)
     {
         hasChanges = true;
         globalData["id" + id] = data;
+
+        if (inTestMode)
+            save();
     }
 
     function get(id)
@@ -70,6 +91,15 @@ module.exports = function (_RED)
         delete globalData["id" + id];
     }
 
-    instance = { set, get, del };
+    function close()
+    {
+        if (interval)
+        {
+            clearInterval(interval);
+            interval = null;
+        }
+    }
+
+    instance = { set, get, del, close };
     return instance;
 };

package/smart_helper.js

@@ -291,16 +291,16 @@ module.exports = {
      *  Target range = 100 to 200
      * 
      *  current number = 0
-     *  scale(5, 0, 10, 100, 200) => 100
+     *  scale(0, 0, 10, 100, 200) => 100
      * 
      *  current number = 5
      *  scale(5, 0, 10, 100, 200) => 150
      * 
      *  current number = 10
-     *  scale(5, 0, 10, 100, 200) => 200
+     *  scale(10, 0, 10, 100, 200) => 200
      * 
-     *  current number = 20 (out of input range!)
-     *  scale(5, 0, 10, 100, 200) => 300 (out of output range!)
+     *  current number = 20 (input out of range!)
+     *  scale(20, 0, 10, 100, 200) => 300 (output out of range!)
      */
     scale(number, inMin, inMax, outMin, outMax)
     {