node-red-contrib-power-saver 5.0.0-beta.2 → 5.0.0-beta.3

package/test/mostSavedStrategy.test.js

@@ -19,6 +19,32 @@ describe("mostSavedStrategy", () => {
     expect(isOnOffSequencesOk(onOff, 3, 3, 100)).to.equal(false);
     expect(isOnOffSequencesOk(onOff, 3, 3, 50)).to.equal(true);
     expect(isOnOffSequencesOk(onOff, 3, 3, 50, 3)).to.equal(true);
+    expect(isOnOffSequencesOk(onOff, 3, 3, 100)).to.equal(false);
+    expect(isOnOffSequencesOk(onOff, 3, 3, 90)).to.equal(false);
+  });
+
+  it("evaluates a long onOff sequence correct", () => {
+    const minutesSetting = [
+      { count: 465, value: true },
+      { count: 75, value: false },
+      { count: 541, value: true },
+      { count: 74, value: false },
+      { count: 15, value: true },
+      { count: 75, value: false },
+      { count: 1335, value: true },
+      { count: 75, value: false },
+      { count: 315, value: true },
+    ];
+
+    const minutes = [];
+    minutesSetting.forEach((ms) => {
+      for (let i = 0; i < ms.count; i++) {
+        minutes.push(ms.value);
+      }
+    });
+
+    expect(isOnOffSequencesOk(minutes, 75, 15, 85)).to.equal(false);
+
   });
 
   it("saves correct hours", () => {

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

@@ -0,0 +1,53 @@
+const cloneDeep = require("lodash.clonedeep");
+const { DateTime } = require("luxon");
+const expect = require("chai").expect;
+const helper = require("node-red-node-test-helper");
+const bestSave = require("../src/strategy-best-save.js");
+const input = require("./data/bug-232-input.json");
+const output = require("./data/bug-232-output.json");
+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"));
+
+describe("ps-strategy-best-save bug-232", function () {
+  beforeEach(function (done) {
+    helper.startServer(done);
+  });
+
+  afterEach(function (done) {
+    helper.unload().then(function () {
+      helper.stopServer(done);
+    });
+  });
+
+  it.skip("find bug", function (done) {
+    const flow = makeFlow(output.config.maxMinutesOff, output.config.minMinutesOff, output.config.recoveryPercentage  , output.config.recoveryMaxMinutes);
+    flow[0].minSaving = output.config.minSaving;
+    flow[0].outputIfNoSchedule = output.config.outputIfNoSchedule;
+    const expected = cloneDeep(output);
+    expected.version = output.version;
+    expected.time = output.time;
+    expected.source = output.source;
+    expected.current = false;
+    helper.load(bestSave, flow, function () {
+      const n1 = helper.getNode("n1");
+      const n2 = helper.getNode("n2");
+      n2.on("input", function (msg) {
+        expect(equalPlan(expected, msg.payload)).to.equal(true);
+        n1.warn.should.not.be.called;
+        setTimeout(() => {
+          done();
+        }, 900);
+      });
+      n1.receive({ payload: makePayload()})
+    });
+  });
+});
+
+function makePayload() {
+  const payload = cloneDeep(input);
+  payload.time = output.time;
+  return payload;
+}

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

@@ -151,7 +151,10 @@ describe("ps-strategy-heat-capacitor node", function () {
       const n1 = helper.getNode("n1");
       n1.receive({ payload: multiTrade });
       n1.receive({ payload: prices });
-      expect(n1.priceData.length).to.equal(72);
+      const latestStart = DateTime.fromISO(n1.priceData[n1.priceData.length - 1].start);
+      const cutoff = latestStart.minus({ hours: 72 });
+      const allWithinRange = n1.priceData.every((entry) => DateTime.fromISO(entry.start) >= cutoff);
+      expect(allWithinRange).to.equal(true);
       done();
     });
   });

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

@@ -11,6 +11,51 @@ const {
 const converted_prices = require("./data/converted-prices.json");
 const decreasing_end_prices = require("./data/tibber-decreasing2-24h.json");
 
+function buildMinutePriceVectorForTests(priceData) {
+  if (!Array.isArray(priceData) || priceData.length === 0) {
+    return { minutePrices: [], startDate: null };
+  }
+
+  const sorted = priceData
+    .slice()
+    .sort((a, b) => DateTime.fromISO(a.start).toMillis() - DateTime.fromISO(b.start).toMillis());
+
+  const minutePrices = [];
+  let previousIntervalMinutes = 60;
+
+  for (let i = 0; i < sorted.length; i++) {
+    const currentStart = DateTime.fromISO(sorted[i].start);
+    let intervalMinutes = previousIntervalMinutes;
+
+    if (sorted[i + 1]) {
+      intervalMinutes = DateTime.fromISO(sorted[i + 1].start).diff(currentStart, "minutes").minutes;
+    } else if (sorted[i].end) {
+      intervalMinutes = DateTime.fromISO(sorted[i].end).diff(currentStart, "minutes").minutes;
+    }
+
+    intervalMinutes = Math.max(1, Math.round(intervalMinutes));
+    previousIntervalMinutes = intervalMinutes;
+
+    for (let m = 0; m < intervalMinutes; m++) {
+      minutePrices.push(sorted[i].value);
+    }
+  }
+
+  return { minutePrices, startDate: DateTime.fromISO(sorted[0].start) };
+}
+
+function buildMinutePricesFromValues(values, startIso) {
+  if (!Array.isArray(values) || values.length === 0) {
+    return [];
+  }
+  const baseDate = startIso ? DateTime.fromISO(startIso) : DateTime.fromISO(converted_prices.priceData[0].start);
+  const priceData = values.map((value, idx) => ({
+    value,
+    start: baseDate.plus({ hours: idx }).toISO(),
+  }));
+  return buildMinutePriceVectorForTests(priceData).minutePrices;
+}
+
 describe("ps-strategy-heat-capacitor-functions", () => {
   let prices, decreasing_24h_prices, start_date, buy_pattern, sell_pattern;
 
@@ -24,15 +69,16 @@ describe("ps-strategy-heat-capacitor-functions", () => {
   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);
+    const convertedSingleHour = buildMinutePriceVectorForTests(converted_prices.priceData.slice(0, 1));
+    prices = convertedSingleHour.minutePrices;
+    decreasing_24h_prices = buildMinutePriceVectorForTests(decreasing_end_prices.priceData).minutePrices;
+    start_date = convertedSingleHour.startDate;
     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_prices = prices.slice();
     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);
@@ -43,7 +89,7 @@ describe("ps-strategy-heat-capacitor-functions", () => {
 
   it("Can find procurement pattern", () => {
     //Use a simple price list
-    const my_prices = [1, 2, 2, 1, 8, 1];
+    const my_prices = buildMinutePricesFromValues([1, 2, 2, 1, 8, 1], start_date.toISO());
 
     const buy_prices = calculateOpportunities(my_prices, buy_pattern, 1);
     const sell_prices = calculateOpportunities(my_prices, sell_pattern, 1);
@@ -57,7 +103,7 @@ describe("ps-strategy-heat-capacitor-functions", () => {
   });
 
   it("DictList test", () => {
-    const my_prices = [1, 2, 2, 1, 8, 1];
+    const my_prices = buildMinutePricesFromValues([1, 2, 2, 1, 8, 1], start_date.toISO());
     const my_buy_sell_indexes = [
       [0, 173],
       [131, 251],
@@ -70,7 +116,7 @@ describe("ps-strategy-heat-capacitor-functions", () => {
   });
 
   it("DictList test at decreasing end", () => {
-    const my_prices = decreasing_end_prices.priceData.map((p) => p.value);
+    const my_prices = decreasing_24h_prices;
     const buy_prices = calculateOpportunities(my_prices, buy_pattern, 1);
     const sell_prices = calculateOpportunities(my_prices, sell_pattern, 1);
 
@@ -91,7 +137,7 @@ describe("ps-strategy-heat-capacitor-functions", () => {
   });
 
   it("Check removal of low benefit buy-sell pairs", () => {
-    const my_prices = [1, 2, 1, 1.05, 1, 2];
+    const my_prices = buildMinutePricesFromValues([1, 2, 1, 1.05, 1, 2], start_date.toISO());
     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);