node-red-contrib-power-saver 2.0.5 → 3.0.2

package/test/mostSavedStrategy.test.js

@@ -1,74 +1,44 @@
 const expect = require("expect");
-const mostSavedStrategy = require("../mostSavedStrategy");
+const { calculate, isOnOffSequencesOk } = require("../src/strategy-best-save-functions");
 
 const prices = require("./data/prices");
 
 describe("mostSavedStrategy", () => {
+  it("evaluates onOff sequences correct", () => {
+    expect(isOnOffSequencesOk([], 0, 0)).toBeTruthy();
+    expect(isOnOffSequencesOk([true], 0, 0)).toBeTruthy();
+    expect(isOnOffSequencesOk([false], 0, 0)).toBeFalsy();
+    expect(isOnOffSequencesOk([true, false], 0, 0)).toBeFalsy();
+    expect(isOnOffSequencesOk([true, false], 1, 0)).toBeTruthy();
+    const onOff = [true, true, false, false, false, true, true, false];
+    expect(isOnOffSequencesOk(onOff, 3, 2)).toBeTruthy();
+    expect(isOnOffSequencesOk(onOff, 4, 2)).toBeTruthy();
+    expect(isOnOffSequencesOk(onOff, 2, 2)).toBeFalsy();
+    expect(isOnOffSequencesOk(onOff, 3, 3)).toBeFalsy();
+  });
+
   it("saves correct hours", () => {
     const values = prices.today.map((p) => p.value);
-    expect(mostSavedStrategy.calculate(values, 3, 1, 0.001)).toEqual([
-      true,
-      true,
-      false,
-      false,
-      true,
-      false,
-      false,
-      false,
-      true,
-      true,
-    ]);
-    expect(mostSavedStrategy.calculate(values, 3, 1, 0.001)).toEqual([
-      true,
-      true,
-      false,
-      false,
-      true,
-      false,
-      false,
-      false,
-      true,
-      true,
-    ]);
-    expect(mostSavedStrategy.calculate(values, 2, 1, 0.001)).toEqual([
-      true,
-      true,
-      true,
+    expect(calculate(values, 3, 1, 0.001)).toEqual([true, true, false, false, true, false, false, false, true, true]);
+    expect(calculate(values, 3, 1, 0.001)).toEqual([true, true, false, false, true, false, false, false, true, true]);
+    expect(calculate(values, 2, 1, 0.001)).toEqual([true, true, true, false, false, true, false, false, true, true]);
+    expect(calculate(values, 2, 3, 0.001)).toEqual([true, true, true, false, true, true, false, false, true, true]);
+    expect(calculate(values, 2, 0, 0.001)).toEqual([true, true, true, false, false, true, false, false, true, true]);
+    const values2 = prices.tomorrow.map((p) => p.value);
+    expect(calculate(values2, 2, 1, 0.001, true, 1)).toEqual([
       false,
       false,
       true,
       false,
       false,
       true,
-      true,
-    ]);
-    expect(mostSavedStrategy.calculate(values, 2, 3, 0.001)).toEqual([
-      true,
-      true,
-      true,
-      false,
-      true,
-      true,
       false,
       false,
       true,
       true,
     ]);
-    expect(mostSavedStrategy.calculate(values, 2, 0, 0.001)).toEqual([
+    expect(calculate(values2, 2, 1, 0.001, false, 1)).toEqual([
       true,
-      true,
-      true,
-      false,
-      false,
-      true,
-      false,
-      false,
-      true,
-      true,
-    ]);
-    const values2 = prices.tomorrow.map((p) => p.value);
-    expect(mostSavedStrategy.calculate(values2, 2, 1, 0.001, true, 1)).toEqual([
-      false,
       false,
       true,
       false,
@@ -79,8 +49,5 @@ describe("mostSavedStrategy", () => {
       true,
       true,
     ]);
-    expect(mostSavedStrategy.calculate(values2, 2, 1, 0.001, false, 1)).toEqual(
-      [true, false, true, false, false, true, false, false, true, true]
-    );
   });
 });

package/test/power-saver.test.js

@@ -1,28 +1,11 @@
 const cloneDeep = require("lodash.clonedeep");
 const expect = require("expect");
 const helper = require("node-red-node-test-helper");
-const powerSaver = require("../power-saver.js");
-const { DateTime } = require("luxon");
+const powerSaver = require("../src/power-saver.js");
 
 const prices = require("./data/prices");
 const result = require("./data/result");
-
-const plan = {
-  schedule: [
-    { time: "2021-06-20T01:50:00.000+02:00", value: true },
-    { time: "2021-06-20T01:50:00.020+02:00", value: false },
-    { time: "2021-06-20T01:50:00.040+02:00", value: true },
-    { time: "2021-06-20T01:50:00.050+02:00", value: false },
-    { time: "2021-06-20T01:50:00.080+02:00", value: true },
-    { time: "2021-06-20T01:50:00.100+02:00", value: false },
-    { time: "2021-06-20T01:50:00.120+02:00", value: true },
-    { time: "2021-06-20T01:50:00.130+02:00", value: false },
-    { time: "2021-06-20T01:50:00.140+02:00", value: true },
-    { time: "2021-06-20T01:50:00.150+02:00", value: false },
-    { time: "2021-06-20T01:50:00.180+02:00", value: true },
-  ],
-  time: "2021-06-20T01:50:00+02:00",
-};
+const { testPlan: plan, makePayload } = require("./test-utils");
 
 helper.init(require.resolve("node-red"));
 
@@ -167,8 +150,8 @@ describe("power-saver Node", function () {
     });
   });
   it("works for Tibber data", function (done) {
-    const tibberData = require("./data/tibber_prices.json");
-    const tibberResult = require("./data/tibber_result.json");
+    const tibberData = require("./data/tibber-prices.json");
+    const tibberResult = require("./data/tibber-result.json");
     const flow = makeFlow(4, 2);
     helper.load(powerSaver, flow, function () {
       const n1 = helper.getNode("n1");
@@ -198,20 +181,3 @@ function makeFlow(maxHoursToSaveInSequence, minHoursOnAfterMaxSequenceSaved) {
     { id: "n4", type: "helper" },
   ];
 }
-
-function makePayload(prices, time) {
-  const payload = cloneDeep(prices);
-  payload.time = time;
-  let entryTime = DateTime.fromISO(payload.time);
-  payload.today.forEach((e) => {
-    e.start = entryTime.toISO();
-    entryTime = entryTime.plus({ milliseconds: 10 });
-    e.end = entryTime.toISO();
-  });
-  payload.tomorrow?.forEach((e) => {
-    e.start = entryTime.toISO();
-    entryTime = entryTime.plus({ milliseconds: 10 });
-    e.end = entryTime.toISO();
-  });
-  return payload;
-}

package/test/receive-price-functions.test.js

@@ -0,0 +1,153 @@
+const expect = require("expect");
+const { convertMsg } = require("../src/receive-price-functions");
+
+describe("receive-price-functions", () => {
+  it("can convert input msg", () => {
+    const msgStd = {
+      payload: {
+        today: [
+          { value: 1, start: "2021-06-21T00:00:00+02:00" },
+          { value: 2, start: "2021-06-21T01:00:00+02:00" },
+        ],
+        tomorrow: [
+          { value: 3, start: "2021-06-22T00:00:00+02:00" },
+          { value: 4, start: "2021-06-22T01:00:00+02:00" },
+        ],
+      },
+    };
+    const msgStdTodayOnly = {
+      payload: {
+        today: [
+          { value: 1, start: "2021-06-21T00:00:00+02:00" },
+          { value: 2, start: "2021-06-21T01:00:00+02:00" },
+        ],
+        tomorrow: [],
+      },
+    };
+    const msgNordpool = {
+      data: {
+        new_state: {
+          attributes: {
+            raw_today: [
+              { value: 1, start: "2021-06-21T00:00:00+02:00" },
+              { value: 2, start: "2021-06-21T01:00:00+02:00" },
+            ],
+            raw_tomorrow: [
+              { value: 3, start: "2021-06-22T00:00:00+02:00" },
+              { value: 4, start: "2021-06-22T01:00:00+02:00" },
+            ],
+          },
+        },
+      },
+    };
+    const msgTibber = {
+      payload: {
+        viewer: {
+          homes: [
+            {
+              currentSubscription: {
+                priceInfo: {
+                  current: {
+                    total: 0.6411,
+                    energy: 0.505,
+                    tax: 0.1361,
+                    startsAt: "2021-06-21T00:00:00+02:00",
+                  },
+                  today: [
+                    {
+                      total: 1,
+                      energy: 0.5051,
+                      tax: 0.1361,
+                      startsAt: "2021-06-21T00:00:00+02:00",
+                    },
+                    {
+                      total: 2,
+                      energy: 0.5016,
+                      tax: 0.1353,
+                      startsAt: "2021-06-21T01:00:00+02:00",
+                    },
+                  ],
+                  tomorrow: [
+                    {
+                      total: 3,
+                      energy: 0.4521,
+                      tax: 0.1229,
+                      startsAt: "2021-06-22T00:00:00+02:00",
+                    },
+                    {
+                      total: 4,
+                      energy: 0.4488,
+                      tax: 0.1221,
+                      startsAt: "2021-06-22T01:00:00+02:00",
+                    },
+                  ],
+                },
+              },
+            },
+          ],
+        },
+      },
+    };
+
+    const msgTibberSingle = {
+      payload: {
+        viewer: {
+          home: {
+            currentSubscription: {
+              priceInfo: {
+                today: [
+                  {
+                    total: 1,
+                    startsAt: "2021-06-21T00:00:00+02:00",
+                  },
+                  {
+                    total: 2,
+                    startsAt: "2021-06-21T01:00:00+02:00",
+                  },
+                ],
+                tomorrow: [
+                  {
+                    total: 3,
+                    startsAt: "2021-06-22T00:00:00+02:00",
+                  },
+                  {
+                    total: 4,
+                    startsAt: "2021-06-22T01:00:00+02:00",
+                  },
+                ],
+              },
+            },
+          },
+        },
+      },
+    };
+
+    expect(convertMsg(msgStd)).toEqual({ source: "Other", ...msgStd.payload });
+    expect(convertMsg(msgTibber)).toEqual({
+      source: "Tibber",
+      ...msgStd.payload,
+    });
+    expect(convertMsg(msgTibberSingle)).toEqual({
+      source: "Tibber",
+      ...msgStd.payload,
+    });
+    expect(convertMsg(msgNordpool)).toEqual({
+      source: "Nordpool",
+      ...msgStd.payload,
+    });
+    msgTibber.payload.viewer.homes[0].currentSubscription.priceInfo.tomorrow = [];
+    expect(convertMsg(msgTibber)).toEqual({
+      source: "Tibber",
+      ...msgStdTodayOnly.payload,
+    });
+    msgNordpool.data.new_state.attributes.raw_tomorrow = [];
+    expect(convertMsg(msgNordpool)).toEqual({
+      source: "Nordpool",
+      ...msgStdTodayOnly.payload,
+    });
+    expect(convertMsg(msgStdTodayOnly)).toEqual({
+      source: "Other",
+      ...msgStdTodayOnly.payload,
+    });
+  });
+});

package/test/receive-price.test.js

@@ -0,0 +1,122 @@
+const helper = require("node-red-node-test-helper");
+const receivePrices = require("../src/receive-price.js");
+const expect = require("expect");
+
+helper.init(require.resolve("node-red"));
+
+describe("receive-price node", function () {
+  beforeEach(function (done) {
+    helper.startServer(done);
+  });
+
+  afterEach(function (done) {
+    helper.unload().then(function () {
+      helper.stopServer(done);
+    });
+  });
+
+  it("should be loaded", function (done) {
+    const flow = [{ id: "n1", type: "ps-receive-price", name: "test name" }];
+    helper.load(receivePrices, flow, function () {
+      const n1 = helper.getNode("n1");
+      expect(n1).toHaveProperty("name", "test name");
+      done();
+    });
+  });
+
+  it("should convert tibber prices", function (done) {
+    const tibberPrices = require("./data/tibber-prices.json");
+    const convertedPrices = require("./data/converted-prices.json");
+    convertedPrices.priceData.source = "Tibber";
+    const flow = [
+      {
+        id: "n1",
+        type: "ps-receive-price",
+        name: "Receive prices",
+        wires: [["n2"]],
+      },
+      { id: "n2", type: "helper" },
+    ];
+    helper.load(receivePrices, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      n2.on("input", function (msg) {
+        expect(msg).toHaveProperty("payload", convertedPrices);
+        done();
+      });
+      n1.receive(tibberPrices);
+    });
+  });
+
+  it("should convert tibber single home prices", function (done) {
+    const tibberPrices = require("./data/tibber-prices-single-home.json");
+    const convertedPrices = require("./data/converted-prices.json");
+    convertedPrices.priceData.source = "Tibber";
+    const flow = [
+      {
+        id: "n1",
+        type: "ps-receive-price",
+        name: "Receive prices",
+        wires: [["n2"]],
+      },
+      { id: "n2", type: "helper" },
+    ];
+    helper.load(receivePrices, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      n2.on("input", function (msg) {
+        expect(msg).toHaveProperty("payload", convertedPrices);
+        done();
+      });
+      n1.receive(tibberPrices);
+    });
+  });
+
+  it("should convert nordpool event prices", function (done) {
+    const nordpoolPrices = require("./data/nordpool-event-prices.json");
+    const convertedPrices = require("./data/converted-prices.json");
+    convertedPrices.priceData.source = "Nordpool";
+    const flow = [
+      {
+        id: "n1",
+        type: "ps-receive-price",
+        name: "Receive prices",
+        wires: [["n2"]],
+      },
+      { id: "n2", type: "helper" },
+    ];
+    helper.load(receivePrices, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      n2.on("input", function (msg) {
+        expect(msg).toHaveProperty("payload", convertedPrices);
+        done();
+      });
+      n1.receive(nordpoolPrices);
+    });
+  });
+
+  it("should convert nordpool current state prices", function (done) {
+    const nordpoolPrices = require("./data/nordpool-current-state-prices.json");
+    const convertedPrices = require("./data/converted-prices.json");
+    convertedPrices.priceData.source = "Nordpool";
+    const flow = [
+      {
+        id: "n1",
+        type: "ps-receive-price",
+        name: "Receive prices",
+        wires: [["n2"]],
+      },
+      { id: "n2", type: "helper" },
+    ];
+    helper.load(receivePrices, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      n2.on("input", function (msg) {
+        expect(msg).toHaveProperty("payload", convertedPrices);
+        done();
+      });
+      n1.receive({ payload: nordpoolPrices });
+    });
+  });
+});

package/test/send-config-input.test.js

@@ -0,0 +1,121 @@
+const expect = require("expect");
+const helper = require("node-red-node-test-helper");
+const bestSave = require("../src/strategy-best-save.js");
+const { DateTime } = require("luxon");
+const prices = require("./data/converted-prices.json");
+const result = require("./data/best-save-result.json");
+const reconfigResult = require("./data/reconfigResult");
+const adjustedResult = require("./data/adjustedResult");
+const { testPlan, equalPlan } = require("./test-utils");
+const { makeFlow, makePayload } = require("./strategy-best-save-test-utils");
+
+helper.init(require.resolve("node-red"));
+
+describe("send config as input", () => {
+  beforeEach(function (done) {
+    helper.startServer(done);
+  });
+
+  afterEach(function (done) {
+    helper.unload().then(function () {
+      helper.stopServer(done);
+    });
+  });
+
+  it("should send new schedule on output 3", function (done) {
+    const flow = makeFlow(3, 2);
+    let pass = 1;
+    helper.load(bestSave, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      n2.on("input", function (msg) {
+        switch (pass) {
+          case 1:
+            pass++;
+            expect(equalPlan(result, msg.payload)).toBeTruthy();
+            n1.receive({ payload: { config: { minSaving: 1.0 } } });
+            break;
+          case 2:
+            pass++;
+            expect(msg.payload.schedule.length).toEqual(1);
+            n1.receive({ payload: makePayload(prices, testPlan.time) });
+            break;
+          case 3:
+            pass++;
+            expect(msg.payload.schedule.length).toEqual(1);
+            done();
+        }
+      });
+      n1.receive({ payload: makePayload(prices, testPlan.time) });
+    });
+  });
+  it("should schedule only from selected time", function (done) {
+    const flow = makeFlow(3, 2);
+    flow[0].scheduleOnlyFromCurrentTime = false;
+    const changeTime = DateTime.fromISO("2021-06-20T01:50:00.045+02:00");
+    let pass = 1;
+    helper.load(bestSave, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      n2.on("input", function (msg) {
+        switch (pass) {
+          case 1:
+            pass++;
+            expect(equalPlan(result, msg.payload)).toBeTruthy();
+            n1.receive({
+              payload: {
+                config: { scheduleOnlyFromCurrentTime: true },
+                time: changeTime,
+              },
+            });
+            break;
+          case 2:
+            pass++;
+            reconfigResult.config.scheduleOnlyFromCurrentTime = true;
+            expect(equalPlan(reconfigResult, msg.payload)).toBeTruthy();
+            const payload = makePayload(prices, testPlan.time);
+            payload.time = changeTime;
+            n1.receive({ payload });
+            break;
+          case 3:
+            pass++;
+            expect(equalPlan(reconfigResult, msg.payload)).toBeTruthy();
+            done();
+        }
+      });
+      n1.receive({ payload: makePayload(prices, testPlan.time) });
+    });
+  });
+  it("should correct savings for passed hours", function (done) {
+    const flow = makeFlow(3, 2);
+    const changeTime = DateTime.fromISO("2021-06-20T01:50:00.045+02:00");
+    let pass = 1;
+    helper.load(bestSave, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      n2.on("input", function (msg) {
+        switch (pass) {
+          case 1:
+            pass++;
+            expect(equalPlan(result, msg.payload)).toBeTruthy();
+            n1.receive({
+              payload: {
+                config: {
+                  maxHoursToSaveInSequence: 5,
+                  minSaving: 0.25,
+                  scheduleOnlyFromCurrentTime: true,
+                },
+                time: changeTime,
+              },
+            });
+            break;
+          case 2:
+            pass++;
+            expect(equalPlan(adjustedResult, msg.payload)).toBeTruthy();
+            done();
+        }
+      });
+      n1.receive({ payload: makePayload(prices, testPlan.time) });
+    });
+  });
+});

package/test/strategy-best-save-test-utils.js

@@ -0,0 +1,32 @@
+const cloneDeep = require("lodash.clonedeep");
+const { DateTime } = require("luxon");
+
+function makeFlow(maxHoursToSaveInSequence, minHoursOnAfterMaxSequenceSaved) {
+  return [
+    {
+      id: "n1",
+      type: "ps-strategy-best-save",
+      name: "test name",
+      maxHoursToSaveInSequence,
+      minHoursOnAfterMaxSequenceSaved,
+      minSaving: 0.001,
+      wires: [["n3"], ["n4"], ["n2"]],
+    },
+    { id: "n2", type: "helper" },
+    { id: "n3", type: "helper" },
+    { id: "n4", type: "helper" },
+  ];
+}
+
+function makePayload(prices, time) {
+  const payload = cloneDeep(prices);
+  payload.time = time;
+  let entryTime = DateTime.fromISO(payload.time);
+  payload.priceData.forEach((e) => {
+    e.start = entryTime.toISO();
+    entryTime = entryTime.plus({ milliseconds: 10 });
+  });
+  return payload;
+}
+
+module.exports = { makeFlow, makePayload };

package/test/strategy-best-save.test.js

@@ -0,0 +1,103 @@
+const cloneDeep = require("lodash.clonedeep");
+const { DateTime } = require("luxon");
+const expect = require("expect");
+const helper = require("node-red-node-test-helper");
+const bestSave = require("../src/strategy-best-save.js");
+const prices = require("./data/converted-prices.json");
+const result = require("./data/best-save-result.json");
+const { testPlan: plan } = require("./test-utils");
+const { makeFlow } = require("./strategy-best-save-test-utils");
+
+helper.init(require.resolve("node-red"));
+
+describe("ps-strategy-best-save node", function () {
+  beforeEach(function (done) {
+    helper.startServer(done);
+  });
+
+  afterEach(function (done) {
+    helper.unload().then(function () {
+      helper.stopServer(done);
+    });
+  });
+
+  it("should be loaded", function (done) {
+    const flow = [{ id: "n1", type: "ps-strategy-best-save", name: "test name" }];
+    helper.load(bestSave, flow, function () {
+      const n1 = helper.getNode("n1");
+      expect(n1).toHaveProperty("name", "test name");
+      done();
+    });
+  });
+
+  it("should log error when illegal data is received", function (done) {
+    const flow = [{ id: "n1", type: "ps-strategy-best-save", name: "test name" }];
+    helper.load(bestSave, flow, function () {
+      const n1 = helper.getNode("n1");
+      n1.receive({});
+      n1.warn.should.be.calledWithExactly("No payload");
+      n1.receive({ payload: "Error" });
+      n1.warn.should.be.calledWithExactly("Payload is not an object");
+      n1.receive({ payload: [] });
+      n1.warn.should.be.calledWithExactly("Payload is missing priceData");
+      n1.receive({ payload: { priceData: [] } });
+      n1.warn.should.be.calledWithExactly("priceData is empty");
+      n1.receive({ payload: { priceData: { today: [], tomorrow: [] } } });
+      n1.warn.should.be.calledWithExactly("Illegal priceData in payload. Did you use the receive-price node?");
+
+      ["start", "value"].forEach((attr) => {
+        const testData1 = cloneDeep(prices);
+        delete testData1.priceData[3][attr];
+        n1.receive({ payload: testData1 });
+        n1.warn.should.be.calledWithExactly(
+          "Malformed entries in priceData. All entries must contain start and value."
+        );
+      });
+
+      n1.receive({ payload: cloneDeep(prices) });
+      n1.warn.should.not.be.called;
+      done();
+    });
+  });
+  it("should send new schedule on output 3", function (done) {
+    const flow = makeFlow(3, 2);
+    helper.load(bestSave, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      const n3 = helper.getNode("n3");
+      const n4 = helper.getNode("n4");
+      let countOn = 0;
+      let countOff = 0;
+      n2.on("input", function (msg) {
+        expect(msg).toHaveProperty("payload", result);
+        n1.warn.should.not.be.called;
+      });
+      n3.on("input", function (msg) {
+        countOn++;
+        expect(msg).toHaveProperty("payload", true);
+        if (countOn === 7 && countOff === 7) {
+          done();
+        }
+      });
+      n4.on("input", function (msg) {
+        countOff++;
+        expect(msg).toHaveProperty("payload", false);
+        if (countOn === 7 && countOff === 7) {
+          done();
+        }
+      });
+      n1.receive({ payload: makePayload(prices, plan.time) });
+    });
+  });
+});
+
+function makePayload(prices, time) {
+  const payload = cloneDeep(prices);
+  payload.time = time;
+  let entryTime = DateTime.fromISO(payload.time);
+  payload.priceData.forEach((e) => {
+    e.start = entryTime.toISO();
+    entryTime = entryTime.plus({ milliseconds: 10 });
+  });
+  return payload;
+}