node-red-contrib-power-saver 3.6.1 → 4.0.0

package/test/data/nordpool-zero-prices.json

@@ -0,0 +1,90 @@
+{
+  "_msgid": "ccc08b141f59afdb",
+  "payload": "0.5",
+  "data": {
+    "entity_id": "sensor.nordpool_kwh_krsand_nok_2_10_025",
+    "state": "0.5",
+    "attributes": {
+      "current_price": 0.5,
+      "average": 0.41041666666666665,
+      "off_peak_1": 0.37125,
+      "off_peak_2": 0.21000000000000002,
+      "peak": 0.5225,
+      "min": 0.1,
+      "max": 0.67,
+      "unit": "kWh",
+      "currency": "NOK",
+      "country": "Norway",
+      "region": "Kr.sand",
+      "low price": false,
+      "tomorrow_valid": true,
+      "today": [
+        0.36, 0.34, 0.33, 0.31, 0.29, 0.31, 0.47, 0.56, 0.67, 0.58, 0.56, 0.53, 0.53, 0.51, 0.5, 0.48, 0.49, 0.48, 0.39,
+        0.32, 0.31, 0.28, 0.15, 0.1
+      ],
+      "tomorrow": [
+        0.01, 0, 0, 0, 0, 0, 0.11, 0.13, 0.14, 0.14, 0.14, 0.14, 0.13, 0.13, 0.13, 0.14, 0.16, 0.18, 0.16, 0.13, 0.11,
+        0.11, 0.01, 0
+      ],
+      "raw_today": [
+        { "start": "2022-11-10T00:00:00+01:00", "end": "2022-11-10T01:00:00+01:00", "value": 0.36 },
+        { "start": "2022-11-10T01:00:00+01:00", "end": "2022-11-10T02:00:00+01:00", "value": 0.34 },
+        { "start": "2022-11-10T02:00:00+01:00", "end": "2022-11-10T03:00:00+01:00", "value": 0.33 },
+        { "start": "2022-11-10T03:00:00+01:00", "end": "2022-11-10T04:00:00+01:00", "value": 0.31 },
+        { "start": "2022-11-10T04:00:00+01:00", "end": "2022-11-10T05:00:00+01:00", "value": 0.29 },
+        { "start": "2022-11-10T05:00:00+01:00", "end": "2022-11-10T06:00:00+01:00", "value": 0.31 },
+        { "start": "2022-11-10T06:00:00+01:00", "end": "2022-11-10T07:00:00+01:00", "value": 0.47 },
+        { "start": "2022-11-10T07:00:00+01:00", "end": "2022-11-10T08:00:00+01:00", "value": 0.56 },
+        { "start": "2022-11-10T08:00:00+01:00", "end": "2022-11-10T09:00:00+01:00", "value": 0.67 },
+        { "start": "2022-11-10T09:00:00+01:00", "end": "2022-11-10T10:00:00+01:00", "value": 0.58 },
+        { "start": "2022-11-10T10:00:00+01:00", "end": "2022-11-10T11:00:00+01:00", "value": 0.56 },
+        { "start": "2022-11-10T11:00:00+01:00", "end": "2022-11-10T12:00:00+01:00", "value": 0.53 },
+        { "start": "2022-11-10T12:00:00+01:00", "end": "2022-11-10T13:00:00+01:00", "value": 0.53 },
+        { "start": "2022-11-10T13:00:00+01:00", "end": "2022-11-10T14:00:00+01:00", "value": 0.51 },
+        { "start": "2022-11-10T14:00:00+01:00", "end": "2022-11-10T15:00:00+01:00", "value": 0.5 },
+        { "start": "2022-11-10T15:00:00+01:00", "end": "2022-11-10T16:00:00+01:00", "value": 0.48 },
+        { "start": "2022-11-10T16:00:00+01:00", "end": "2022-11-10T17:00:00+01:00", "value": 0.49 },
+        { "start": "2022-11-10T17:00:00+01:00", "end": "2022-11-10T18:00:00+01:00", "value": 0.48 },
+        { "start": "2022-11-10T18:00:00+01:00", "end": "2022-11-10T19:00:00+01:00", "value": 0.39 },
+        { "start": "2022-11-10T19:00:00+01:00", "end": "2022-11-10T20:00:00+01:00", "value": 0.32 },
+        { "start": "2022-11-10T20:00:00+01:00", "end": "2022-11-10T21:00:00+01:00", "value": 0.31 },
+        { "start": "2022-11-10T21:00:00+01:00", "end": "2022-11-10T22:00:00+01:00", "value": 0.28 },
+        { "start": "2022-11-10T22:00:00+01:00", "end": "2022-11-10T23:00:00+01:00", "value": 0.15 },
+        { "start": "2022-11-10T23:00:00+01:00", "end": "2022-11-11T00:00:00+01:00", "value": 0.1 }
+      ],
+      "raw_tomorrow": [
+        { "start": "2022-11-11T00:00:00+01:00", "end": "2022-11-11T01:00:00+01:00", "value": 0.01 },
+        { "start": "2022-11-11T01:00:00+01:00", "end": "2022-11-11T02:00:00+01:00", "value": 0 },
+        { "start": "2022-11-11T02:00:00+01:00", "end": "2022-11-11T03:00:00+01:00", "value": 0 },
+        { "start": "2022-11-11T03:00:00+01:00", "end": "2022-11-11T04:00:00+01:00", "value": 0 },
+        { "start": "2022-11-11T04:00:00+01:00", "end": "2022-11-11T05:00:00+01:00", "value": 0 },
+        { "start": "2022-11-11T05:00:00+01:00", "end": "2022-11-11T06:00:00+01:00", "value": 0 },
+        { "start": "2022-11-11T06:00:00+01:00", "end": "2022-11-11T07:00:00+01:00", "value": 0.11 },
+        { "start": "2022-11-11T07:00:00+01:00", "end": "2022-11-11T08:00:00+01:00", "value": 0.13 },
+        { "start": "2022-11-11T08:00:00+01:00", "end": "2022-11-11T09:00:00+01:00", "value": 0.14 },
+        { "start": "2022-11-11T09:00:00+01:00", "end": "2022-11-11T10:00:00+01:00", "value": 0.14 },
+        { "start": "2022-11-11T10:00:00+01:00", "end": "2022-11-11T11:00:00+01:00", "value": 0.14 },
+        { "start": "2022-11-11T11:00:00+01:00", "end": "2022-11-11T12:00:00+01:00", "value": 0.14 },
+        { "start": "2022-11-11T12:00:00+01:00", "end": "2022-11-11T13:00:00+01:00", "value": 0.13 },
+        { "start": "2022-11-11T13:00:00+01:00", "end": "2022-11-11T14:00:00+01:00", "value": 0.13 },
+        { "start": "2022-11-11T14:00:00+01:00", "end": "2022-11-11T15:00:00+01:00", "value": 0.13 },
+        { "start": "2022-11-11T15:00:00+01:00", "end": "2022-11-11T16:00:00+01:00", "value": 0.14 },
+        { "start": "2022-11-11T16:00:00+01:00", "end": "2022-11-11T17:00:00+01:00", "value": 0.16 },
+        { "start": "2022-11-11T17:00:00+01:00", "end": "2022-11-11T18:00:00+01:00", "value": 0.18 },
+        { "start": "2022-11-11T18:00:00+01:00", "end": "2022-11-11T19:00:00+01:00", "value": 0.16 },
+        { "start": "2022-11-11T19:00:00+01:00", "end": "2022-11-11T20:00:00+01:00", "value": 0.13 },
+        { "start": "2022-11-11T20:00:00+01:00", "end": "2022-11-11T21:00:00+01:00", "value": 0.11 },
+        { "start": "2022-11-11T21:00:00+01:00", "end": "2022-11-11T22:00:00+01:00", "value": 0.11 },
+        { "start": "2022-11-11T22:00:00+01:00", "end": "2022-11-11T23:00:00+01:00", "value": 0.01 },
+        { "start": "2022-11-11T23:00:00+01:00", "end": "2022-11-12T00:00:00+01:00", "value": 0 }
+      ],
+      "unit_of_measurement": "NOK/kWh",
+      "icon": "mdi:flash",
+      "friendly_name": "nordpool_kwh_krsand_nok_2_10_025"
+    },
+    "context": { "id": "01GHGTS9D4YTFD3BETMHQ5QTMR", "parent_id": null, "user_id": null },
+    "last_changed": "2022-11-10T13:13:35.396Z",
+    "last_updated": "2022-11-10T13:13:35.396Z",
+    "timeSinceChangedMs": 1145332
+  }
+}

package/test/data/reconfigResult.js

@@ -12,6 +12,7 @@ module.exports = {
     { time: "2021-06-20T01:50:00.360+02:00", value: true },
     { time: "2021-06-20T01:50:00.410+02:00", value: false },
     { time: "2021-06-20T01:50:00.440+02:00", value: true },
+    { time: "2021-06-20T02:50:00.470+02:00", value: false },
   ],
   hours: [
     { price: 0.2494, onOff: false, start: "2021-06-20T01:50:00.000+02:00", saving: 0.0395 },

package/test/data/result.js

@@ -170,6 +170,7 @@ module.exports = {
   ],
   source: "Other",
   config: {
+    hasChanged: false,
     maxHoursToSaveInSequence: 3,
     minHoursOnAfterMaxSequenceSaved: 2,
     minSaving: 0.001,

package/test/data/tibber-result-end-0-24h.json

@@ -19,6 +19,11 @@
       "time": "2021-12-15T21:00:00.000+01:00",
       "value": true,
       "countHours": 3
+    },
+    {
+      "time": "2021-12-16T00:00:00.000+01:00",
+      "value": false,
+      "countHours": null
     }
   ],
   "hours": [
@@ -313,6 +318,7 @@
   ],
   "source": "Tibber",
   "config": {
+    "hasChanged": false,
     "contextStorage": "default",
     "fromTime": "16",
     "toTime": "00",
@@ -321,9 +327,13 @@
     "doNotSplit": false,
     "sendCurrentValueWhenRescheduling": true,
     "outputIfNoSchedule": false,
-    "outputOutsidePeriod": false
+    "outputValueForOff": false,
+    "outputValueForOfftype": "bool",
+    "outputValueForOn": true,
+    "outputValueForOntype": "bool",
+    "outputOutsidePeriod": false,
+    "override": "auto"
   },
-  "sentOnCommand": false,
   "time": "2021-10-11T10:00:00.000+02:00",
   "version": "1.2.3"
 }

package/test/data/tibber-result-end-0.json

@@ -9,6 +9,11 @@
       "time": "2021-12-14T21:00:00.000+01:00",
       "value": true,
       "countHours": 3
+    },
+    {
+      "time": "2021-12-15T00:00:00.000+01:00",
+      "value": false,
+      "countHours": null
     }
   ],
   "hours": [
@@ -159,6 +164,7 @@
   ],
   "source": "Tibber",
   "config": {
+    "hasChanged": false,
     "contextStorage": "default",
     "fromTime": "16",
     "toTime": "00",
@@ -167,9 +173,13 @@
     "doNotSplit": false,
     "sendCurrentValueWhenRescheduling": true,
     "outputIfNoSchedule": false,
-    "outputOutsidePeriod": false
+    "outputValueForOff": false,
+    "outputValueForOfftype": "bool",
+    "outputValueForOn": true,
+    "outputValueForOntype": "bool",
+    "outputOutsidePeriod": false,
+    "override": "auto"
   },
-  "sentOnCommand": false,
   "time": "2021-10-11T10:00:00.000+02:00",
   "version": "1.2.3"
 }

package/test/data/tibber-result.json

@@ -363,6 +363,7 @@
   ],
   "source": "Tibber",
   "config": {
+    "hasChanged": false,
     "maxHoursToSaveInSequence": 4,
     "minHoursOnAfterMaxSequenceSaved": 2,
     "minSaving": 0.001,

package/test/receive-price.test.js

@@ -142,4 +142,26 @@ describe("receive-price node", function () {
       n1.receive({ payload: nordpoolPrices.payload });
     });
   });
+  it("should convert nordpool zero prices", function (done) {
+    const nordpoolPrices = require("./data/nordpool-zero-prices.json");
+    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.payload.priceData.length).toEqual(48);
+        expect(msg.payload.source).toEqual("Nordpool");
+        done();
+      });
+      n1.receive(nordpoolPrices);
+    });
+  });
 });

package/test/schedule-merger-functions.test.js

@@ -0,0 +1,101 @@
+const { DateTime } = require("luxon");
+const expect = require("expect");
+const { validateSchedule, saveSchedule, mergeSchedules, runSchedule } = require("../src/schedule-merger-functions");
+const bestSaveResult = require("./data/best-save-result.json");
+const mergeData = require("./data/merge-schedule-data.js");
+const cloneDeep = require("lodash.clonedeep");
+
+describe("schedule-merger-functions", () => {
+  it("saveSchedule", () => {
+    const node = useNodeMock();
+    const msg = { payload: cloneDeep(bestSaveResult) };
+    msg.payload.strategyNodeId = "1";
+    msg.payload.hours[0].onOff = false;
+    saveSchedule(node, msg);
+    expect(node.context().get()["1"]).toEqual(msg.payload);
+
+    msg.payload.strategyNodeId = "2";
+    msg.payload.hours[0].onOff = true;
+    saveSchedule(node, msg);
+    expect(node.context().get()["1"]).toEqual(msg.payload);
+    expect(node.context().get()["2"]).toEqual(msg.payload);
+    expect(node.context().get()["1"].hours.onOff).toBeFalsy;
+    expect(node.context().get()["2"].hours.onOff).toBeTruthy;
+  });
+
+  it("mergeSchedule", () => {
+    const messages = {};
+    Object.keys(mergeData).forEach((ds) => {
+      messages[ds] = {
+        payload: {
+          strategyNodeId: ds,
+          hours: mergeData[ds],
+        },
+      };
+    });
+
+    let node = useNodeMock();
+    saveSchedule(node, messages.allOff);
+    expect(mergeSchedules(node, "OR").map((h) => h.onOff)).toEqual([false, false, false, false, false]);
+    saveSchedule(node, messages.allOn);
+    expect(mergeSchedules(node, "OR").map((h) => h.onOff)).toEqual([true, true, true, true, true]);
+    expect(mergeSchedules(node, "AND").map((h) => h.onOff)).toEqual([false, false, false, false, false]);
+
+    node = useNodeMock();
+    saveSchedule(node, messages.someOn);
+    saveSchedule(node, messages.allOn);
+    expect(mergeSchedules(node, "OR").map((h) => h.onOff)).toEqual([true, true, true, true, true]);
+    expect(mergeSchedules(node, "AND").map((h) => h.onOff)).toEqual([true, false, true, false, true]);
+
+    node = useNodeMock();
+    saveSchedule(node, messages.someOn);
+    saveSchedule(node, messages.allOff);
+    expect(mergeSchedules(node, "OR").map((h) => h.onOff)).toEqual([true, false, true, false, true]);
+    expect(mergeSchedules(node, "AND").map((h) => h.onOff)).toEqual([false, false, false, false, false]);
+    saveSchedule(node, messages.hourLater);
+    expect(mergeSchedules(node, "OR").map((h) => h.onOff)).toEqual([true, false, false, true, true]);
+    expect(mergeSchedules(node, "AND").map((h) => h.onOff)).toEqual([true, false, false, true, true]);
+
+    saveSchedule(node, messages.someOn);
+    saveSchedule(node, messages.allOff);
+    expect(mergeSchedules(node, "OR").map((h) => h.onOff)).toEqual([true, false, true, false, true]);
+    expect(mergeSchedules(node, "AND").map((h) => h.onOff)).toEqual([false, false, false, false, false]);
+
+    node = useNodeMock();
+    saveSchedule(node, messages.someOn);
+    saveSchedule(node, messages.lessHours);
+    expect(mergeSchedules(node, "OR").map((h) => h.onOff)).toEqual([false, true, false]);
+
+    node = useNodeMock();
+    saveSchedule(node, messages.someOn);
+    saveSchedule(node, messages.moreHours);
+    expect(mergeSchedules(node, "OR").map((h) => h.onOff)).toEqual([
+      true,
+      true,
+      false,
+      false,
+      false,
+      true,
+      true,
+      false,
+    ]);
+  });
+});
+
+// Node mock
+const useNodeMock = function () {
+  let savedSchedules = {};
+  const set = function (_, obj) {
+    savedSchedules = { ...obj };
+  };
+  const get = function () {
+    return savedSchedules;
+  };
+  const context = function () {
+    return { get, set };
+  };
+  const warn = function (msg) {
+    console.log(msg);
+  };
+  return { context, warn };
+};

package/test/schedule-merger-test-utils.js

@@ -0,0 +1,27 @@
+function makeFlow(logicFunction, outputIfNoSchedule = true) {
+  return [
+    {
+      id: "n1",
+      type: "ps-schedule-merger",
+      name: "test name",
+      logicFunction,
+      outputIfNoSchedule,
+      schedulingDelay: 10, // May need to increase on a slow computer
+      sendCurrentValueWhenRescheduling: true,
+      wires: [["n3"], ["n4"], ["n2"]],
+    },
+    { id: "n2", type: "helper" },
+    { id: "n3", type: "helper" },
+    { id: "n4", type: "helper" },
+  ];
+}
+
+function makePayload(strategyNodeId, hours) {
+  const payload = {
+    strategyNodeId,
+    hours,
+  };
+  return payload;
+}
+
+module.exports = { makeFlow, makePayload };

package/test/schedule-merger.test.js

@@ -0,0 +1,130 @@
+const expect = require("expect");
+const helper = require("node-red-node-test-helper");
+const scheduleMerger = require("../src/schedule-merger.js");
+const { equalHours } = require("./test-utils");
+const { allOff, allOn, someOn, theOtherOn } = require("./data/merge-schedule-data.js");
+const { makeFlow, makePayload } = require("./schedule-merger-test-utils.js");
+
+helper.init(require.resolve("node-red"));
+
+describe("schedule-merger 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-schedule-merger", name: "test name" }];
+    helper.load(scheduleMerger, flow, function () {
+      const n1 = helper.getNode("n1");
+      expect(n1).toHaveProperty("name", "test name");
+      done();
+    });
+  });
+
+  it("can merge two schedules with OR", function (done) {
+    const flow = makeFlow("OR");
+    helper.load(scheduleMerger, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      n2.on("input", function (msg) {
+        expect(equalHours(someOn, msg.payload.hours, ["price", "onOff", "start"])).toBeTruthy();
+        n1.warn.should.not.be.called;
+        done();
+      });
+      n1.receive({ payload: makePayload("s1", someOn) });
+      n1.receive({ payload: makePayload("s2", allOff) });
+    });
+  });
+
+  it("can merge two schedules with AND", function (done) {
+    const flow = makeFlow("AND", false);
+    helper.load(scheduleMerger, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      n2.on("input", function (msg) {
+        expect(equalHours(someOn, msg.payload.hours, ["price", "onOff", "start"])).toBeTruthy();
+        expect(msg.payload.schedule.length).toBe(6);
+        expect(msg.payload.schedule[5].value).toBeFalsy();
+        expect(msg.payload.schedule[5].countHours).toBeNull();
+        n1.warn.should.not.be.called;
+        done();
+      });
+      n1.receive({ payload: makePayload("s1", someOn) });
+      n1.receive({ payload: makePayload("s2", allOn) });
+    });
+  });
+
+  it("can merge two schedules with OR all on", function (done) {
+    const flow = makeFlow("OR");
+    helper.load(scheduleMerger, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      n2.on("input", function (msg) {
+        expect(equalHours(allOn, msg.payload.hours, ["price", "onOff", "start"])).toBeTruthy();
+        expect(msg.payload.schedule.length).toBe(1);
+        n1.warn.should.not.be.called;
+        done();
+      });
+      n1.receive({ payload: makePayload("s1", someOn) });
+      n1.receive({ payload: makePayload("s2", allOn) });
+    });
+  });
+
+  it("can merge two schedules with AND all off", function (done) {
+    const flow = makeFlow("AND");
+    helper.load(scheduleMerger, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      n2.on("input", function (msg) {
+        expect(equalHours(allOff, msg.payload.hours, ["price", "onOff", "start"])).toBeTruthy();
+        expect(msg.payload.schedule.length).toBe(2);
+        expect(msg.payload.schedule[1].value).toBeTruthy();
+        expect(msg.payload.schedule[1].countHours).toBeNull();
+        n1.warn.should.not.be.called;
+        done();
+      });
+      n1.receive({ payload: makePayload("s1", someOn) });
+      n1.receive({ payload: makePayload("s2", allOff) });
+    });
+  });
+
+  it("can merge three schedules with OR", function (done) {
+    const flow = makeFlow("OR");
+    helper.load(scheduleMerger, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      n2.on("input", function (msg) {
+        expect(equalHours(allOn, msg.payload.hours, ["price", "onOff", "start"])).toBeTruthy();
+        expect(msg.payload.schedule.length).toBe(1);
+        n1.warn.should.not.be.called;
+        done();
+      });
+      n1.receive({ payload: makePayload("s1", someOn) });
+      n1.receive({ payload: makePayload("s2", allOff) });
+      n1.receive({ payload: makePayload("s3", theOtherOn) });
+    });
+  });
+
+  it("can merge three schedules with AND", function (done) {
+    const flow = makeFlow("AND", false);
+    helper.load(scheduleMerger, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      n2.on("input", function (msg) {
+        expect(equalHours(allOff, msg.payload.hours, ["price", "onOff", "start"])).toBeTruthy();
+        expect(msg.payload.schedule.length).toBe(1);
+        n1.warn.should.not.be.called;
+        done();
+      });
+      n1.receive({ payload: makePayload("s1", someOn) });
+      n1.receive({ payload: makePayload("s2", allOn) });
+      n1.receive({ payload: makePayload("s3", theOtherOn) });
+    });
+  });
+});

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

@@ -37,12 +37,12 @@ describe("send config as input", () => {
             break;
           case 2:
             pass++;
-            expect(msg.payload.schedule.length).toEqual(1);
+            expect(msg.payload.schedule.length).toEqual(2);
             n1.receive({ payload: makePayload(prices, testPlan.time) });
             break;
           case 3:
             pass++;
-            expect(msg.payload.schedule.length).toEqual(1);
+            expect(msg.payload.schedule.length).toEqual(2);
             done();
         }
       });
@@ -113,6 +113,49 @@ describe("send config as input", () => {
       n1.receive({ payload: makePayload(prices, testPlan.time) });
     });
   });
+  it("can override", function (done) {
+    const flow = makeFlow(3, 2, false);
+    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;
+      let pass = 0;
+      n2.on("input", function (msg) {
+        pass++;
+        n1.warn.should.not.be.called;
+        if (pass === 1) {
+          setTimeout(() => {
+            console.log("countOn = " + countOn + ", countOff = " + countOff);
+            expect(countOn).toEqual(2);
+            expect(countOff).toEqual(2);
+            done();
+          }, 900);
+        }
+      });
+      n3.on("input", function (msg) {
+        countOn++;
+        expect(msg).toHaveProperty("payload", true);
+        if (countOn === 2) {
+          n1.receive({ payload: { config: { override: "on" } } });
+        }
+      });
+      n4.on("input", function (msg) {
+        countOff++;
+        expect(msg).toHaveProperty("payload", false);
+        if (countOff === 1) {
+          n1.receive({ payload: { config: { override: "on" }, name: "wrong name" } });
+        }
+        if (countOff === 2) {
+          n1.receive({ payload: { config: { override: "on" } } });
+        }
+      });
+      const time = prices.priceData[0].start;
+      n1.receive({ payload: makePayload(prices, time) });
+    });
+  });
 });
 
 function makePayloadWithConfigAndPrices(prices, time) {

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

@@ -1,7 +1,7 @@
 const cloneDeep = require("lodash.clonedeep");
 const { DateTime } = require("luxon");
 
-function makeFlow(maxHoursToSaveInSequence, minHoursOnAfterMaxSequenceSaved, sendCurrentValueWhenRescheduling = false) {
+function makeFlow(maxHoursToSaveInSequence, minHoursOnAfterMaxSequenceSaved, sendCurrentValueWhenRescheduling = true) {
   return [
     {
       id: "n1",

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

@@ -5,6 +5,7 @@ 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 convertedPrices = require("./data/converted-prices.json");
 const { testPlan: plan, equalPlan } = require("./test-utils");
 const { makeFlow } = require("./strategy-best-save-test-utils");
 const { version } = require("../package.json");
@@ -95,6 +96,50 @@ describe("ps-strategy-best-save node", function () {
       n1.receive({ payload: makePayload(prices, plan.time) });
     });
   });
+  it("should not send output when rescheduling", function (done) {
+    const flow = makeFlow(3, 2, false);
+    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;
+      let pass = 0;
+      n2.on("input", function (msg) {
+        pass++;
+        switch (pass) {
+          case 1:
+            const payload = {
+              ...convertedPrices,
+              time: "2021-10-11T01:11:00.000+02:00",
+            };
+            n1.receive({ payload });
+            break;
+          case 2:
+            setTimeout(() => {
+              console.log("countOn = " + countOn + ", countOff = " + countOff);
+              expect(countOn).toEqual(0);
+              expect(countOff).toEqual(1);
+              done();
+            }, 100);
+        }
+      });
+      n3.on("input", function (msg) {
+        countOn++;
+        expect(msg).toHaveProperty("payload", true);
+      });
+      n4.on("input", function (msg) {
+        countOff++;
+        expect(msg).toHaveProperty("payload", false);
+      });
+      const payload = {
+        ...convertedPrices,
+        time: "2021-10-11T01:10:00.000+02:00",
+      };
+      n1.receive({ payload });
+    });
+  });
 });
 
 function makePayload(prices, time) {