node-red-contrib-power-saver 3.3.0 → 3.4.1

package/test/data/multiple-trades.json

@@ -0,0 +1,53 @@
+{
+  "source": "Tibber",
+  "priceData": [
+    { "value": 1.4157, "start": "2022-02-06T00:00:00.000+01:00" },
+    { "value": 1.3705, "start": "2022-02-06T01:00:00.000+01:00" },
+    { "value": 1.2487, "start": "2022-02-06T02:00:00.000+01:00" },
+    { "value": 1.1812, "start": "2022-02-06T03:00:00.000+01:00" },
+    { "value": 0.9632, "start": "2022-02-06T04:00:00.000+01:00" },
+    { "value": 1.0862, "start": "2022-02-06T05:00:00.000+01:00" },
+    { "value": 1.2638, "start": "2022-02-06T06:00:00.000+01:00" },
+    { "value": 1.3266, "start": "2022-02-06T07:00:00.000+01:00" },
+    { "value": 1.3734, "start": "2022-02-06T08:00:00.000+01:00" },
+    { "value": 1.4653, "start": "2022-02-06T09:00:00.000+01:00" },
+    { "value": 1.513, "start": "2022-02-06T10:00:00.000+01:00" },
+    { "value": 1.518, "start": "2022-02-06T11:00:00.000+01:00" },
+    { "value": 1.505, "start": "2022-02-06T12:00:00.000+01:00" },
+    { "value": 1.5038, "start": "2022-02-06T13:00:00.000+01:00" },
+    { "value": 1.5239, "start": "2022-02-06T14:00:00.000+01:00" },
+    { "value": 1.5269, "start": "2022-02-06T15:00:00.000+01:00" },
+    { "value": 1.5464, "start": "2022-02-06T16:00:00.000+01:00" },
+    { "value": 1.5553, "start": "2022-02-06T17:00:00.000+01:00" },
+    { "value": 1.6066, "start": "2022-02-06T18:00:00.000+01:00" },
+    { "value": 1.5541, "start": "2022-02-06T19:00:00.000+01:00" },
+    { "value": 1.5437, "start": "2022-02-06T20:00:00.000+01:00" },
+    { "value": 1.4912, "start": "2022-02-06T21:00:00.000+01:00" },
+    { "value": 1.473, "start": "2022-02-06T22:00:00.000+01:00" },
+    { "value": 1.4281, "start": "2022-02-06T23:00:00.000+01:00" },
+    { "value": 1.4179, "start": "2022-02-07T00:00:00.000+01:00" },
+    { "value": 1.3966, "start": "2022-02-07T01:00:00.000+01:00" },
+    { "value": 1.3953, "start": "2022-02-07T02:00:00.000+01:00" },
+    { "value": 1.3939, "start": "2022-02-07T03:00:00.000+01:00" },
+    { "value": 1.3962, "start": "2022-02-07T04:00:00.000+01:00" },
+    { "value": 1.4335, "start": "2022-02-07T05:00:00.000+01:00" },
+    { "value": 1.5191, "start": "2022-02-07T06:00:00.000+01:00" },
+    { "value": 1.6244, "start": "2022-02-07T07:00:00.000+01:00" },
+    { "value": 1.6508, "start": "2022-02-07T08:00:00.000+01:00" },
+    { "value": 1.6142, "start": "2022-02-07T09:00:00.000+01:00" },
+    { "value": 1.5632, "start": "2022-02-07T10:00:00.000+01:00" },
+    { "value": 1.5516, "start": "2022-02-07T11:00:00.000+01:00" },
+    { "value": 1.4922, "start": "2022-02-07T12:00:00.000+01:00" },
+    { "value": 1.5288, "start": "2022-02-07T13:00:00.000+01:00" },
+    { "value": 1.5522, "start": "2022-02-07T14:00:00.000+01:00" },
+    { "value": 1.5526, "start": "2022-02-07T15:00:00.000+01:00" },
+    { "value": 1.5799, "start": "2022-02-07T16:00:00.000+01:00" },
+    { "value": 1.6909, "start": "2022-02-07T17:00:00.000+01:00" },
+    { "value": 1.7136, "start": "2022-02-07T18:00:00.000+01:00" },
+    { "value": 1.703, "start": "2022-02-07T19:00:00.000+01:00" },
+    { "value": 1.675, "start": "2022-02-07T20:00:00.000+01:00" },
+    { "value": 1.6173, "start": "2022-02-07T21:00:00.000+01:00" },
+    { "value": 1.5638, "start": "2022-02-07T22:00:00.000+01:00" },
+    { "value": 1.4645, "start": "2022-02-07T23:00:00.000+01:00" }
+  ]
+}

package/test/data/tibber-decreasing-24h.json

@@ -0,0 +1,101 @@
+{
+    "source": "Tibber",
+    "priceData": [
+        {
+            "value": 1.8019,
+            "start": "2022-01-12T00:00:00.000+01:00"
+        },
+        {
+            "value": 1.7711,
+            "start": "2022-01-12T01:00:00.000+01:00"
+        },
+        {
+            "value": 1.7539,
+            "start": "2022-01-12T02:00:00.000+01:00"
+        },
+        {
+            "value": 1.7508,
+            "start": "2022-01-12T03:00:00.000+01:00"
+        },
+        {
+            "value": 1.7616,
+            "start": "2022-01-12T04:00:00.000+01:00"
+        },
+        {
+            "value": 1.7825,
+            "start": "2022-01-12T05:00:00.000+01:00"
+        },
+        {
+            "value": 1.7829,
+            "start": "2022-01-12T06:00:00.000+01:00"
+        },
+        {
+            "value": 1.8422,
+            "start": "2022-01-12T07:00:00.000+01:00"
+        },
+        {
+            "value": 1.8725,
+            "start": "2022-01-12T08:00:00.000+01:00"
+        },
+        {
+            "value": 1.8356,
+            "start": "2022-01-12T09:00:00.000+01:00"
+        },
+        {
+            "value": 1.8053,
+            "start": "2022-01-12T10:00:00.000+01:00"
+        },
+        {
+            "value": 1.7625,
+            "start": "2022-01-12T11:00:00.000+01:00"
+        },
+        {
+            "value": 1.7601,
+            "start": "2022-01-12T12:00:00.000+01:00"
+        },
+        {
+            "value": 1.7481,
+            "start": "2022-01-12T13:00:00.000+01:00"
+        },
+        {
+            "value": 1.7269,
+            "start": "2022-01-12T14:00:00.000+01:00"
+        },
+        {
+            "value": 1.717,
+            "start": "2022-01-12T15:00:00.000+01:00"
+        },
+        {
+            "value": 1.7181,
+            "start": "2022-01-12T16:00:00.000+01:00"
+        },
+        {
+            "value": 1.7169,
+            "start": "2022-01-12T17:00:00.000+01:00"
+        },
+        {
+            "value": 1.7015,
+            "start": "2022-01-12T18:00:00.000+01:00"
+        },
+        {
+            "value": 1.6708,
+            "start": "2022-01-12T19:00:00.000+01:00"
+        },
+        {
+            "value": 1.6499,
+            "start": "2022-01-12T20:00:00.000+01:00"
+        },
+        {
+            "value": 1.644,
+            "start": "2022-01-12T21:00:00.000+01:00"
+        },
+        {
+            "value": 1.624,
+            "start": "2022-01-12T22:00:00.000+01:00"
+        },
+        {
+            "value": 1.6078,
+            "start": "2022-01-12T23:00:00.000+01:00"
+        }
+    ]
+}

package/test/data/tibber-decreasing2-24h.json

@@ -0,0 +1,101 @@
+{
+    "priceData": [
+        {
+            "value": 1.7261,
+            "start": "2022-01-16T00:00:00.000+01:00"
+        },
+        {
+            "value": 1.7153,
+            "start": "2022-01-16T01:00:00.000+01:00"
+        },
+        {
+            "value": 1.6872,
+            "start": "2022-01-16T02:00:00.000+01:00"
+        },
+        {
+            "value": 1.6842,
+            "start": "2022-01-16T03:00:00.000+01:00"
+        },
+        {
+            "value": 1.6831,
+            "start": "2022-01-16T04:00:00.000+01:00"
+        },
+        {
+            "value": 1.6811,
+            "start": "2022-01-16T05:00:00.000+01:00"
+        },
+        {
+            "value": 1.6117,
+            "start": "2022-01-16T06:00:00.000+01:00"
+        },
+        {
+            "value": 1.5729,
+            "start": "2022-01-16T07:00:00.000+01:00"
+        },
+        {
+            "value": 1.5969,
+            "start": "2022-01-16T08:00:00.000+01:00"
+        },
+        {
+            "value": 1.6049,
+            "start": "2022-01-16T09:00:00.000+01:00"
+        },
+        {
+            "value": 1.6117,
+            "start": "2022-01-16T10:00:00.000+01:00"
+        },
+        {
+            "value": 1.6103,
+            "start": "2022-01-16T11:00:00.000+01:00"
+        },
+        {
+            "value": 1.6004,
+            "start": "2022-01-16T12:00:00.000+01:00"
+        },
+        {
+            "value": 1.5937,
+            "start": "2022-01-16T13:00:00.000+01:00"
+        },
+        {
+            "value": 1.5476,
+            "start": "2022-01-16T14:00:00.000+01:00"
+        },
+        {
+            "value": 1.5866,
+            "start": "2022-01-16T15:00:00.000+01:00"
+        },
+        {
+            "value": 1.5959,
+            "start": "2022-01-16T16:00:00.000+01:00"
+        },
+        {
+            "value": 1.6316,
+            "start": "2022-01-16T17:00:00.000+01:00"
+        },
+        {
+            "value": 1.5908,
+            "start": "2022-01-16T18:00:00.000+01:00"
+        },
+        {
+            "value": 1.5805,
+            "start": "2022-01-16T19:00:00.000+01:00"
+        },
+        {
+            "value": 1.5808,
+            "start": "2022-01-16T20:00:00.000+01:00"
+        },
+        {
+            "value": 1.5681,
+            "start": "2022-01-16T21:00:00.000+01:00"
+        },
+        {
+            "value": 1.5218,
+            "start": "2022-01-16T22:00:00.000+01:00"
+        },
+        {
+            "value": 1.46,
+            "start": "2022-01-16T23:00:00.000+01:00"
+        }
+    ],
+    "source": "Tibber"
+}

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

@@ -5,8 +5,9 @@ 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 { testPlan: plan, equalPlan } = require("./test-utils");
 const { makeFlow } = require("./strategy-best-save-test-utils");
+const { version } = require("../package.json");
 
 helper.init(require.resolve("node-red"));
 
@@ -61,6 +62,11 @@ describe("ps-strategy-best-save node", function () {
   });
   it("should send new schedule on output 3", function (done) {
     const flow = makeFlow(3, 2);
+    const expected = cloneDeep(result);
+    expected.version = version;
+    expected.time = plan.time;
+    expected.source = "Tibber";
+    expected.current = false;
     helper.load(bestSave, flow, function () {
       const n1 = helper.getNode("n1");
       const n2 = helper.getNode("n2");
@@ -69,22 +75,22 @@ describe("ps-strategy-best-save node", function () {
       let countOn = 0;
       let countOff = 0;
       n2.on("input", function (msg) {
-        expect(msg).toHaveProperty("payload", result);
+        expect(equalPlan(expected, msg.payload)).toBeTruthy();
         n1.warn.should.not.be.called;
+        setTimeout(() => {
+          console.log("countOn = " + countOn + ", countOff = " + countOff);
+          expect(countOn).toEqual(7);
+          expect(countOff).toEqual(7);
+          done();
+        }, 900);
       });
       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) });
     });

package/test/strategy-heat-capacitor-node.test.js

@@ -0,0 +1,183 @@
+"use strict";
+const cloneDeep = require("lodash.clonedeep");
+const { DateTime } = require("luxon");
+const expect = require("expect");
+const helper = require("node-red-node-test-helper");
+const node = require("../src/strategy-heat-capacitor.js");
+const prices = require("./data/converted-prices.json");
+const multiTrade = require("./data/multiple-trades.json");
+
+helper.init(require.resolve("node-red"));
+
+describe("ps-strategy-heat-capacitor 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-heat-capacitor", name: "Temp. Adj." }];
+    helper.load(node, flow, function () {
+      const n1 = helper.getNode("n1");
+      expect(n1).toHaveProperty("name", "Temp. Adj.");
+      done();
+    });
+  });
+
+  it("should log error when illegal data is received", function (done) {
+    const flow = [{ id: "n1", type: "ps-strategy-heat-capacitor", name: "Temp. Adj." }];
+    helper.load(node, 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 be configurable", function (done) {
+    const flow = [{ id: "n1", type: "ps-strategy-heat-capacitor", name: "Heat Capacitor" }];
+    helper.load(node, flow, function () {
+      const n1 = helper.getNode("n1");
+      n1.receive({
+        payload: {
+          config: {
+            timeHeat1C: 1,
+            timeCool1C: 2,
+            setpoint: 3,
+            maxTempAdjustment: 4,
+            minSavings: 5,
+            boostTempHeat: 6,
+            boostTempCool: 7,
+          },
+        },
+      });
+      expect(n1).toHaveProperty("timeHeat1C", 1);
+      expect(n1).toHaveProperty("timeCool1C", 2);
+      expect(n1).toHaveProperty("boostTempHeat", 6);
+      expect(n1).toHaveProperty("boostTempCool", 7);
+      expect(n1).toHaveProperty("setpoint", 3);
+      expect(n1).toHaveProperty("maxTempAdjustment", 4);
+      expect(n1).toHaveProperty("minSavings", 5);
+      n1.receive({ payload: { config: { setpoint: 24 } } });
+      expect(n1).toHaveProperty("setpoint", 24);
+      done();
+    });
+  });
+
+  it("should plan correctly", function (done) {
+    const result = 0.5;
+    const flow = makeFlow();
+    helper.load(node, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      const n3 = helper.getNode("n3");
+      let bothReceived = false;
+      n2.on("input", function (msg) {
+        expect(msg).toHaveProperty("payload", 22.5);
+        n1.warn.should.not.be.called;
+        bothReceived ? done() : (bothReceived = true);
+      });
+      n3.on("input", function (msg) {
+        expect(msg).toHaveProperty("payload", -0.5);
+        n1.warn.should.not.be.called;
+        bothReceived ? done() : (bothReceived = true);
+      });
+      const time = DateTime.fromISO(prices.priceData[10].start);
+      const p = cloneDeep(prices);
+      p.time = time;
+      n1.receive({ payload: p });
+    });
+  });
+
+  it("should plan correctly, multiTrade", function (done) {
+    const result = 0.5;
+    const flow = makeFlow();
+    helper.load(node, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      const n3 = helper.getNode("n3");
+      let bothReceived = false;
+      n2.on("input", function (msg) {
+        expect(msg).toHaveProperty("payload", 24.5);
+        n1.warn.should.not.be.called;
+        bothReceived ? done() : (bothReceived = true);
+      });
+      n3.on("input", function (msg) {
+        expect(msg).toHaveProperty("payload", 1.5);
+        n1.warn.should.not.be.called;
+        bothReceived ? done() : (bothReceived = true);
+      });
+      const time = DateTime.fromISO(multiTrade.priceData[4].start).plus({ minutes: 10 });
+      multiTrade.time = time;
+      n1.receive({ payload: multiTrade });
+    });
+  });
+
+  it("should merge and trim priceData", function (done) {
+    const flow = makeFlow();
+    helper.load(node, flow, function () {
+      const n1 = helper.getNode("n1");
+      n1.receive({ payload: multiTrade });
+      n1.receive({ payload: prices });
+      expect(n1.priceData.length).toEqual(72);
+      done();
+    });
+  });
+});
+
+function makeFlow() {
+  return [
+    {
+      id: "n1",
+      type: "ps-strategy-heat-capacitor",
+      name: "Temp. Adj.",
+      timeHeat1C: 60,
+      timeCool1C: 50,
+      boostTempHeat: 1,
+      boostTempCool: 1,
+      setpoint: 23,
+      maxTempAdjustment: 0.5,
+      minSavings: 0.08,
+      wires: [["n2"], ["n3"], ["n4"]],
+    },
+    { 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/strategy-heat-capacitor.test.js

@@ -0,0 +1,103 @@
+"use strict";
+const { DateTime } = require("luxon");
+const expect = require("expect");
+const {
+  calculateSchedule,
+  calculateOpportunities,
+  findBestBuySellPattern,
+  calculateValueDictList,
+  removeLowBuySellPairs,
+} = require("../src/strategy-heat-capacitor-functions");
+const converted_prices = require("./data/converted-prices.json");
+const decreasing_end_prices = require("./data/tibber-decreasing2-24h.json");
+
+describe("Test heat capacitor strategy functions", () => {
+  let prices, decreasing_24h_prices, start_date, buy_pattern, sell_pattern;
+
+  //User input
+  const timeHeat1C = 60;
+  const timeCool1C = 40;
+  const maxTempAdjustment = 1;
+  const boostTempHeat = 1;
+  const boostTempCool = 1;
+  const minSavings = 0.1;
+
+  before(function () {
+    prices = converted_prices.priceData.slice(0, 1).map((p) => p.value);
+    decreasing_24h_prices = decreasing_end_prices.priceData.slice(0, 1).map((p) => p.value);
+    start_date = DateTime.fromISO(converted_prices.priceData[0].start);
+    buy_pattern = Array(Math.round(timeHeat1C * maxTempAdjustment * 2)).fill(1);
+    sell_pattern = Array(Math.round(timeCool1C * maxTempAdjustment * 2)).fill(1);
+  });
+
+  it("Can calculate procurement opportunities", () => {
+    const my_prices = prices.slice(0, 1);
+    const my_buy_pattern = Array(5).fill(1);
+    //Calculate what it will cost to procure/sell 1 kWh as a function of time
+    let result = calculateOpportunities(my_prices, my_buy_pattern, 1);
+    //Remove float precisions errors by rounding
+    result = result.map((x) => Math.round(x * 1000000) / 1000000);
+    expect(result).toEqual(Array(56).fill(my_prices[0]));
+  });
+
+  it("Can find procurement pattern", () => {
+    //Use a simple price list
+    const my_prices = [1, 2, 2, 1, 8, 1];
+
+    const buy_prices = calculateOpportunities(my_prices, buy_pattern, 1);
+    const sell_prices = calculateOpportunities(my_prices, sell_pattern, 1);
+
+    const my_buy_sell = findBestBuySellPattern(buy_prices, buy_pattern.length, sell_prices, sell_pattern.length);
+
+    expect(my_buy_sell).toEqual([
+      [0, 141],
+      [100, 240],
+    ]);
+  });
+
+  it("DictList test", () => {
+    const my_prices = [1, 2, 2, 1, 8, 1];
+    const my_buy_sell_indexes = [
+      [0, 173],
+      [131, 251],
+    ];
+    const buy_prices = calculateOpportunities(my_prices, buy_pattern, 1);
+    const sell_prices = calculateOpportunities(my_prices, sell_pattern, 1);
+    const result = calculateValueDictList(my_buy_sell_indexes, buy_prices, sell_prices, start_date);
+
+    expect(result[0].sellDate).toEqual(start_date.plus({ minutes: 131 }));
+  });
+
+  it("DictList test at decreasing end", () => {
+    const my_prices = decreasing_end_prices.priceData.map((p) => p.value);
+    const buy_prices = calculateOpportunities(my_prices, buy_pattern, 1);
+    const sell_prices = calculateOpportunities(my_prices, sell_pattern, 1);
+
+    const my_buy_sell = findBestBuySellPattern(buy_prices, buy_pattern.length, sell_prices, sell_pattern.length);
+    const my_schedule = calculateSchedule(
+      start_date,
+      my_buy_sell,
+      buy_prices,
+      sell_prices,
+      maxTempAdjustment,
+      boostTempHeat,
+      boostTempCool,
+      buy_pattern.length,
+      sell_pattern.length
+    );
+    expect(my_schedule.temperatures[my_schedule.temperatures.length - 1]).toEqual(-maxTempAdjustment);
+  });
+
+  it("Check removal of low benefit buy-sell pairs", () => {
+    const my_prices = [1, 2, 1, 1.05, 1, 2];
+    const buy_prices = calculateOpportunities(my_prices, buy_pattern, 1);
+    const sell_prices = calculateOpportunities(my_prices, sell_pattern, 1);
+    const my_buy_sell = findBestBuySellPattern(buy_prices, buy_pattern.length, sell_prices, sell_pattern.length);
+
+    const result = removeLowBuySellPairs(my_buy_sell, buy_prices, sell_prices, minSavings, start_date);
+    //Should remove the sell at 1.05 and the re-buy at 1 (only 0.05 difference)
+    const compare = [my_buy_sell[0].slice(0, 2), [my_buy_sell[1][0], my_buy_sell[1][2]]];
+
+    expect(result).toEqual(compare);
+  });
+});

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

@@ -2,7 +2,7 @@ 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");
+const cloneDeep = require("lodash.clonedeep");
 
 describe("strategy-utils", () => {
   it("can find best x", () => {

package/test/utils.test.js

@@ -5,14 +5,12 @@ const {
   sortedIndex,
   firstOn,
   getDiffToNextOn,
-  isOnOffSequencesOk,
   getSavings,
   countAtEnd,
   makeSchedule,
   fillArray,
   extractPlanForDate,
   isSameDate,
-  getStartAtIndex,
 } = require("../src/utils");
 
 describe("utils", () => {