node-red-contrib-power-saver 2.1.0 → 3.0.0

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;
+}

package/test/strategy-lowest-price-functions.test.js

@@ -0,0 +1,40 @@
+const { DateTime } = require("luxon");
+const expect = require("expect");
+const { getBestContinuous, getBestX } = require("../src/strategy-lowest-price-functions");
+const convertedPrices = require("./data/converted-prices.json");
+const { cloneDeep } = require("lodash");
+
+describe("strategy-utils", () => {
+  it("can find best x", () => {
+    const values = convertedPrices.priceData.slice(0, 48).map((p) => p.value);
+    const result = cloneDeep(values).fill(false);
+    result.fill(true, 0, 6);
+    result.fill(true, 24, 31);
+    expect(getBestX(values, 13)).toEqual(result);
+    const values1 = convertedPrices.priceData.slice(0, 12).map((p) => p.value);
+    const result1 = cloneDeep(values1).fill(false);
+    expect(getBestX(values1, 1)).toEqual(cloneDeep(result1).fill(true, 2, 3));
+    expect(getBestX(values1, 3)).toEqual(cloneDeep(result1).fill(true, 1, 4));
+    const values2 = convertedPrices.priceData.slice(24, 28).map((p) => p.value);
+    const result2 = cloneDeep(values2).fill(false);
+    expect(getBestX(values2, 1)).toEqual(cloneDeep(result2).fill(true, 3, 4));
+    expect(getBestX(values2, 3)).toEqual(cloneDeep(result2).fill(true, 1, 4));
+  });
+
+  it("can find best x continuous", () => {
+    const values = convertedPrices.priceData.slice(0, 12).map((p) => p.value);
+    const result = cloneDeep(values).fill(false);
+    expect(getBestContinuous(values, 1)).toEqual(cloneDeep(result).fill(true, 2, 3));
+    expect(getBestContinuous(values, 3)).toEqual(cloneDeep(result).fill(true, 1, 4));
+    const values2 = convertedPrices.priceData.slice(24, 28).map((p) => p.value);
+    const result2 = cloneDeep(values2).fill(false);
+    expect(getBestContinuous(values2, 1)).toEqual(cloneDeep(result2).fill(true, 3, 4));
+    expect(getBestContinuous(values2, 3)).toEqual(cloneDeep(result2).fill(true, 1, 4));
+  });
+});
+
+function validatePeriod(period, start, end, count) {
+  expect(period.length).toEqual(count);
+  expect(period[0]).toEqual(start);
+  expect(period[count - 1]).toEqual(end);
+}

package/test/strategy-lowest-price.test.js

@@ -0,0 +1,338 @@
+const cloneDeep = require("lodash.clonedeep");
+const { DateTime } = require("luxon");
+const expect = require("expect");
+const helper = require("node-red-node-test-helper");
+const lowestPrice = require("../src/strategy-lowest-price.js");
+const prices = require("./data/converted-prices.json");
+
+helper.init(require.resolve("node-red"));
+
+describe("ps-strategy-lowest-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-strategy-lowest-price", name: "test name" }];
+    helper.load(lowestPrice, 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-lowest-price", name: "test name" }];
+    helper.load(lowestPrice, 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 plan correct continuous schedule", function (done) {
+    const resultContinuous = require("./data/lowest-price-result-cont.json");
+    const flow = makeFlow(4);
+    helper.load(lowestPrice, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      n2.on("input", function (msg) {
+        expect(msg.payload).toHaveProperty("schedule", resultContinuous.schedule);
+        expect(msg.payload).toHaveProperty("config", resultContinuous.config);
+        n1.warn.should.not.be.called;
+        done();
+      });
+      const time = DateTime.fromISO(prices.priceData[10].start);
+      n1.receive({ payload: makePayload(prices, time) });
+    });
+  });
+  it("should plan correct splitted schedule", function (done) {
+    const resultSplitted = require("./data/lowest-price-result-split.json");
+    const flow = makeFlow(6);
+    flow[0].doNotSplit = false;
+    helper.load(lowestPrice, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      n2.on("input", function (msg) {
+        expect(msg.payload).toHaveProperty("schedule", resultSplitted.schedule);
+        expect(msg.payload).toHaveProperty("config", resultSplitted.config);
+        n1.warn.should.not.be.called;
+        done();
+      });
+      const time = DateTime.fromISO(prices.priceData[10].start);
+      n1.receive({ payload: makePayload(prices, time) });
+    });
+  });
+  it("should plan correct for all day period - 00-00", function (done) {
+    const resultAllDay = require("./data/lowest-price-result-split-allday.json");
+    const flow = makeFlow(8);
+    flow[0].doNotSplit = false;
+    flow[0].fromTime = "00";
+    flow[0].toTime = "00";
+    helper.load(lowestPrice, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      n2.on("input", function (msg) {
+        expect(msg.payload).toHaveProperty("schedule", resultAllDay.schedule);
+        expect(msg.payload).toHaveProperty("config", resultAllDay.config);
+        n1.warn.should.not.be.called;
+        done();
+      });
+      const time = DateTime.fromISO(prices.priceData[10].start);
+      n1.receive({ payload: makePayload(prices, time) });
+    });
+  });
+  it("should plan correct for all day period - 10-10", function (done) {
+    const resultAllDay10 = require("./data/lowest-price-result-split-allday10.json");
+    const flow = makeFlow(10);
+    flow[0].doNotSplit = false;
+    flow[0].fromTime = "10";
+    flow[0].toTime = "10";
+    helper.load(lowestPrice, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      n2.on("input", function (msg) {
+        const config = cloneDeep(resultAllDay10.config);
+        expect(msg.payload).toHaveProperty("schedule", resultAllDay10.schedule);
+        expect(msg.payload).toHaveProperty("config", config);
+        n1.warn.should.not.be.called;
+        done();
+      });
+      const time = DateTime.fromISO(prices.priceData[10].start);
+      n1.receive({ payload: makePayload(prices, time) });
+    });
+  });
+  it("should plan correct for all day period - 10-10 outside on", function (done) {
+    const resultAllDay10 = require("./data/lowest-price-result-split-allday10.json");
+    const flow = makeFlow(10);
+    flow[0].doNotSplit = false;
+    flow[0].fromTime = "10";
+    flow[0].toTime = "10";
+    flow[0].outputOutsidePeriod = true;
+    helper.load(lowestPrice, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      n2.on("input", function (msg) {
+        const config = cloneDeep(resultAllDay10.config);
+        config.outputOutsidePeriod = true;
+        expect(msg.payload).toHaveProperty("schedule", resultAllDay10.schedule);
+        expect(msg.payload).toHaveProperty("config", config);
+        n1.warn.should.not.be.called;
+        done();
+      });
+      const time = DateTime.fromISO(prices.priceData[10].start);
+      n1.receive({ payload: makePayload(prices, time) });
+    });
+  });
+  it("should plan correct for all day period - 10-10 nosched on", function (done) {
+    const resultAllDay10 = require("./data/lowest-price-result-split-allday10.json");
+    const flow = makeFlow(10);
+    flow[0].doNotSplit = false;
+    flow[0].fromTime = "10";
+    flow[0].toTime = "10";
+    flow[0].outputIfNoSchedule = "true";
+    helper.load(lowestPrice, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      n2.on("input", function (msg) {
+        const config = cloneDeep(resultAllDay10.config);
+        config.outputIfNoSchedule = true;
+        expect(msg.payload).toHaveProperty("schedule", resultAllDay10.schedule);
+        expect(msg.payload).toHaveProperty("config", config);
+        n1.warn.should.not.be.called;
+        done();
+      });
+      const time = DateTime.fromISO(prices.priceData[10].start);
+      n1.receive({ payload: makePayload(prices, time) });
+    });
+  });
+  it("should plan correct outside selected period - split", function (done) {
+    const resultSplitted = require("./data/lowest-price-result-split.json");
+    const flow = makeFlow(6);
+    flow[0].doNotSplit = false;
+    flow[0].outputOutsidePeriod = true;
+    helper.load(lowestPrice, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      n2.on("input", function (msg) {
+        const schedule = cloneDeep(resultSplitted.schedule);
+        const config = cloneDeep(resultSplitted.config);
+        schedule[0].value = true;
+        schedule.splice(1, 0, { time: "2021-10-11T10:00:00.000+02:00", value: false });
+        schedule.splice(4, 0, { time: "2021-10-11T20:00:00.000+02:00", value: true });
+        schedule.splice(5, 0, { time: "2021-10-12T10:00:00.000+02:00", value: false });
+        schedule.splice(schedule.length - 1, 1);
+        config.outputOutsidePeriod = true;
+        expect(msg.payload).toHaveProperty("schedule", schedule);
+        expect(msg.payload).toHaveProperty("config", config);
+        n1.warn.should.not.be.called;
+        done();
+      });
+      const time = DateTime.fromISO(prices.priceData[10].start);
+      n1.receive({ payload: makePayload(prices, time) });
+    });
+  });
+  it("should plan correct outside selected period - cont", function (done) {
+    const resultContinuous = require("./data/lowest-price-result-cont.json");
+    const flow = makeFlow(4);
+    flow[0].doNotSplit = true;
+    flow[0].outputOutsidePeriod = true;
+    helper.load(lowestPrice, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      n2.on("input", function (msg) {
+        const schedule = cloneDeep(resultContinuous.schedule);
+        const config = cloneDeep(resultContinuous.config);
+        schedule[0].value = true;
+        schedule.splice(1, 0, { time: "2021-10-11T10:00:00.000+02:00", value: false });
+        schedule.splice(4, 0, { time: "2021-10-11T20:00:00.000+02:00", value: true });
+        schedule.splice(5, 0, { time: "2021-10-12T10:00:00.000+02:00", value: false });
+        schedule.splice(schedule.length, 0, { time: "2021-10-12T20:00:00.000+02:00", value: true });
+        // schedule.splice(schedule.length - 1, 1);
+        config.outputOutsidePeriod = true;
+        expect(msg.payload).toHaveProperty("schedule", schedule);
+        expect(msg.payload).toHaveProperty("config", config);
+        n1.warn.should.not.be.called;
+        done();
+      });
+      const time = DateTime.fromISO(prices.priceData[10].start);
+      n1.receive({ payload: makePayload(prices, time) });
+    });
+  });
+  it("should work with 0 hours on", function (done) {
+    const result = [{ time: "2021-10-11T00:00:00.000+02:00", value: false }];
+    const flow = makeFlow(0);
+    helper.load(lowestPrice, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      n2.on("input", function (msg) {
+        expect(msg.payload).toHaveProperty("schedule", result);
+        n1.warn.should.not.be.called;
+        done();
+      });
+      const time = DateTime.fromISO(prices.priceData[10].start);
+      n1.receive({ payload: makePayload(prices, time) });
+    });
+  });
+  it("should work with 0 hours on outside on", function (done) {
+    const result = [
+      { time: "2021-10-11T00:00:00.000+02:00", value: true },
+      { time: "2021-10-11T10:00:00.000+02:00", value: false },
+      { time: "2021-10-11T20:00:00.000+02:00", value: true },
+      { time: "2021-10-12T10:00:00.000+02:00", value: false },
+      { time: "2021-10-12T20:00:00.000+02:00", value: true },
+    ];
+    const flow = makeFlow(0);
+    flow[0].outputOutsidePeriod = true;
+    helper.load(lowestPrice, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      n2.on("input", function (msg) {
+        expect(msg.payload).toHaveProperty("schedule", result);
+        n1.warn.should.not.be.called;
+        done();
+      });
+      const time = DateTime.fromISO(prices.priceData[10].start);
+      n1.receive({ payload: makePayload(prices, time) });
+    });
+  });
+  it("should work with 1 hours on", function (done) {
+    const result = [
+      { time: "2021-10-11T00:00:00.000+02:00", value: false },
+      { time: "2021-10-11T12:00:00.000+02:00", value: true },
+      { time: "2021-10-11T13:00:00.000+02:00", value: false },
+      { time: "2021-10-12T14:00:00.000+02:00", value: true },
+      { time: "2021-10-12T15:00:00.000+02:00", value: false },
+    ];
+    const flow = makeFlow(1);
+    helper.load(lowestPrice, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      n2.on("input", function (msg) {
+        expect(msg.payload).toHaveProperty("schedule", result);
+        n1.warn.should.not.be.called;
+        done();
+      });
+      const time = DateTime.fromISO(prices.priceData[10].start);
+      n1.receive({ payload: makePayload(prices, time) });
+    });
+  });
+  it("should work with 24 hours on", function (done) {
+    const result = [
+      { time: "2021-10-11T00:00:00.000+02:00", value: false },
+      { time: "2021-10-11T10:00:00.000+02:00", value: true },
+      { time: "2021-10-11T20:00:00.000+02:00", value: false },
+      { time: "2021-10-12T10:00:00.000+02:00", value: true },
+      { time: "2021-10-12T20:00:00.000+02:00", value: false },
+    ];
+    const flow = makeFlow(24);
+    helper.load(lowestPrice, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      n2.on("input", function (msg) {
+        expect(msg.payload).toHaveProperty("schedule", result);
+        n1.warn.should.not.be.called;
+        done();
+      });
+      const time = DateTime.fromISO(prices.priceData[10].start);
+      n1.receive({ payload: makePayload(prices, time) });
+    });
+  });
+});
+
+function makeFlow(hoursOn) {
+  return [
+    {
+      id: "n1",
+      type: "ps-strategy-lowest-price",
+      name: "test name",
+      fromTime: "10",
+      toTime: "20",
+      hoursOn: hoursOn,
+      doNotSplit: true,
+      sendCurrentValueWhenRescheduling: true,
+      outputIfNoSchedule: true,
+      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;
+}

package/test/test-utils.js

@@ -18,23 +18,6 @@ const testPlan = {
   time: "2021-06-20T01:50:00+02:00",
 };
 
-function makeFlow(maxHoursToSaveInSequence, minHoursOnAfterMaxSequenceSaved) {
-  return [
-    {
-      id: "n1",
-      type: "power-saver",
-      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;
@@ -118,7 +101,6 @@ function equalPlan(expected, actual) {
 
 module.exports = {
   testPlan,
-  makeFlow,
   makePayload,
   equalPlan,
 };