@reventlessdev/reventless-core 3.0.0-alpha.295 → 3.0.0-alpha.297

package/tests/automationslice/AutomationSliceSchedulesTest.res

@@ -0,0 +1,143 @@
+// A slice's schedule rows, and how the platform is brought in line with them: the
+// declared time is written unless an event set or cleared the slice-wide key, the
+// platform gets what it is missing and loses what the rows do not hold, and a
+// once-only time already past is not put again.
+
+open JestGlobals
+
+module Schedules = AutomationSlice_Schedules
+
+let at = iso => Date.fromString(iso)->Date.getTime
+let daily6 = Reventless.Schedule.Calendar({calendar: Daily({hour: 6, minute: 0})})
+let daily18 = Reventless.Schedule.Calendar({calendar: Daily({hour: 18, minute: 0})})
+let now = at("2026-10-16T12:00:00Z")
+
+// A platform that holds its schedules in a dict and records what it was told.
+let fakePlatform = (~held: array<string>=[]) => {
+  let schedules = Dict.fromArray(held->Array.map(name => (name, daily6)))
+  let calls = []
+  let platform: ReventlessInfra.AutomationSlice.platformSchedules = {
+    put: async (~key, time) => {
+      calls->Array.push(`put ${key}`)
+      schedules->Dict.set(key, time)
+    },
+    removeName: async name => {
+      calls->Array.push(`remove ${name}`)
+      schedules->Dict.delete(name)
+    },
+    names: async () => schedules->Dict.keysToArray,
+    nameOf: key => key,
+  }
+  (platform, schedules, calls)
+}
+
+let liveKeys = rows =>
+  rows
+  ->Dict.valuesToArray
+  ->Array.filter(row => row.Schedules.time->Option.isSome)
+  ->Array.map(row => row.key)
+  ->Array.toSorted(String.compare)
+
+let set = (rows, key, time, ~recordedAt=now) =>
+  rows->Schedules.apply(Set({key, time}), ~setBy="event", ~recordedAt)
+let clear = (rows, key) => rows->Schedules.apply(Clear({key: key}), ~setBy="event", ~recordedAt=now)
+
+describe("the declared time", () => {
+  testSync("is written when no event has touched the slice-wide key", () => {
+    let rows = Dict.make()
+    rows->Schedules.declare(Some(daily6), ~now)
+    expect(rows->Dict.get("default")->Option.flatMap(Schedules.timeOf))->toEqual(Some(daily6))
+  })
+
+  testSync("does not replace a time an event set", () => {
+    let rows = Dict.make()
+    let _ = rows->set("default", daily18)
+    rows->Schedules.declare(Some(daily6), ~now)
+    expect(rows->Dict.get("default")->Option.flatMap(Schedules.timeOf))->toEqual(Some(daily18))
+  })
+
+  testSync("does not come back after an event cleared it", () => {
+    let rows = Dict.make()
+    rows->Schedules.declare(Some(daily6), ~now)
+    let _ = rows->clear("default")
+    rows->Schedules.declare(Some(daily6), ~now)
+    expect(rows->liveKeys)->toEqual([])
+  })
+
+  testSync("follows a changed declaration, and goes with it", () => {
+    let rows = Dict.make()
+    rows->Schedules.declare(Some(daily6), ~now)
+    rows->Schedules.declare(Some(daily18), ~now)
+    let changed = rows->Dict.get("default")->Option.flatMap(Schedules.timeOf)
+    rows->Schedules.declare(None, ~now)
+    expect((changed, rows->liveKeys))->toEqual((Some(daily18), []))
+  })
+})
+
+describe("a change an event makes", () => {
+  testSync("counts an After from when the event was recorded", () => {
+    let rows = Dict.make()
+    let _ =
+      rows->set("o1", Once({moment: After(Minutes(10))}), ~recordedAt=at("2026-10-16T09:00:00Z"))
+    expect(rows->Dict.get("o1")->Option.flatMap(Schedules.timeOf))->toEqual(
+      Some(
+        Reventless.Schedule.Once({
+          moment: At({year: 2026, month: 10, day: 16, hour: 9, minute: 10}),
+        }),
+      ),
+    )
+  })
+
+  testSync("refuses a time that cannot fire, and changes nothing", () => {
+    let rows = Dict.make()
+    let refused = rows->set("r1", Calendar({calendar: Daily({hour: 25, minute: 0})}))
+    expect((refused->Result.isError, rows->liveKeys))->toEqual((true, []))
+  })
+
+  testSync("removes a once-only schedule when it fires, not a recurring one", () => {
+    let rows = Dict.make()
+    let _ = rows->set("o1", Once({moment: After(Minutes(10))}))
+    let _ = rows->set("r1", daily18)
+    rows->Schedules.fired(~key="o1")
+    rows->Schedules.fired(~key="r1")
+    expect(rows->liveKeys)->toEqual(["r1"])
+  })
+})
+
+describe("the reconcile", () => {
+  testPromise(
+    "puts what the platform is missing and removes what the rows do not hold",
+    async () => {
+      let rows = Dict.make()
+      let _ = rows->set("r1", daily18)
+      let _ = rows->set("r2", daily18)
+      let (platform, held, _) = fakePlatform(~held=["r2", "stray"])
+      await rows->Schedules.reconcile(platform, ~declaredTime=None, ~now)
+      expect(held->Dict.keysToArray->Array.toSorted(String.compare))->toEqual(["r1", "r2"])
+    },
+  )
+
+  testPromise("does not put again a schedule an event set and the platform holds", async () => {
+    let rows = Dict.make()
+    let _ = rows->set("r1", daily18)
+    let (platform, _, calls) = fakePlatform(~held=["r1"])
+    await rows->Schedules.reconcile(platform, ~declaredTime=None, ~now)
+    expect(calls)->toEqual([])
+  })
+
+  testPromise("puts the declared time again, in case it changed", async () => {
+    let rows = Dict.make()
+    let (platform, _, calls) = fakePlatform(~held=["default"])
+    await rows->Schedules.reconcile(platform, ~declaredTime=Some(daily6), ~now)
+    expect(calls)->toEqual(["put default"])
+  })
+
+  testPromise("drops a once-only time already past, from the rows and the platform", async () => {
+    let rows = Dict.make()
+    let _ =
+      rows->set("o1", Once({moment: After(Minutes(10))}), ~recordedAt=at("2026-10-16T09:00:00Z"))
+    let (platform, held, _) = fakePlatform(~held=["o1"])
+    await rows->Schedules.reconcile(platform, ~declaredTime=None, ~now)
+    expect((rows->liveKeys, held->Dict.keysToArray))->toEqual(([], []))
+  })
+})

package/tests/automationslice/AutomationSliceSchedulesTest.res.mjs

@@ -0,0 +1,247 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as AutomationSlice_Schedules$ReventlessCore from "../../src/components/AutomationSlice/AutomationSlice_Schedules.res.mjs";
+
+function at(iso) {
+  return new Date(iso).getTime();
+}
+
+let daily6 = {
+  TAG: "Calendar",
+  calendar: {
+    TAG: "Daily",
+    hour: 6,
+    minute: 0
+  }
+};
+
+let daily18 = {
+  TAG: "Calendar",
+  calendar: {
+    TAG: "Daily",
+    hour: 18,
+    minute: 0
+  }
+};
+
+let now = new Date("2026-10-16T12:00:00Z").getTime();
+
+function fakePlatform(heldOpt) {
+  let held = heldOpt !== undefined ? heldOpt : [];
+  let schedules = Object.fromEntries(held.map(name => [
+    name,
+    daily6
+  ]));
+  let calls = [];
+  let platform_put = async (key, time) => {
+    calls.push(`put ` + key);
+    schedules[key] = time;
+  };
+  let platform_removeName = async name => {
+    calls.push(`remove ` + name);
+    return Stdlib_Dict.$$delete(schedules, name);
+  };
+  let platform_names = async () => Object.keys(schedules);
+  let platform_nameOf = key => key;
+  let platform = {
+    put: platform_put,
+    removeName: platform_removeName,
+    names: platform_names,
+    nameOf: platform_nameOf
+  };
+  return [
+    platform,
+    schedules,
+    calls
+  ];
+}
+
+function liveKeys(rows) {
+  return Object.values(rows).filter(row => Stdlib_Option.isSome(row.time)).map(row => row.key).toSorted(Primitive_string.compare);
+}
+
+function set(rows, key, time, recordedAtOpt) {
+  let recordedAt = recordedAtOpt !== undefined ? recordedAtOpt : now;
+  return AutomationSlice_Schedules$ReventlessCore.apply(rows, {
+    TAG: "Set",
+    key: key,
+    time: time
+  }, "event", recordedAt);
+}
+
+function clear(rows, key) {
+  return AutomationSlice_Schedules$ReventlessCore.apply(rows, {
+    TAG: "Clear",
+    key: key
+  }, "event", now);
+}
+
+globalThis.describe("the declared time", () => {
+  globalThis.test("is written when no event has touched the slice-wide key", () => {
+    let rows = {};
+    AutomationSlice_Schedules$ReventlessCore.declare(rows, daily6, now);
+    globalThis.expect(Stdlib_Option.flatMap(rows["default"], AutomationSlice_Schedules$ReventlessCore.timeOf)).toEqual(daily6);
+  });
+  globalThis.test("does not replace a time an event set", () => {
+    let rows = {};
+    set(rows, "default", daily18, undefined);
+    AutomationSlice_Schedules$ReventlessCore.declare(rows, daily6, now);
+    globalThis.expect(Stdlib_Option.flatMap(rows["default"], AutomationSlice_Schedules$ReventlessCore.timeOf)).toEqual(daily18);
+  });
+  globalThis.test("does not come back after an event cleared it", () => {
+    let rows = {};
+    AutomationSlice_Schedules$ReventlessCore.declare(rows, daily6, now);
+    clear(rows, "default");
+    AutomationSlice_Schedules$ReventlessCore.declare(rows, daily6, now);
+    globalThis.expect(liveKeys(rows)).toEqual([]);
+  });
+  globalThis.test("follows a changed declaration, and goes with it", () => {
+    let rows = {};
+    AutomationSlice_Schedules$ReventlessCore.declare(rows, daily6, now);
+    AutomationSlice_Schedules$ReventlessCore.declare(rows, daily18, now);
+    let changed = Stdlib_Option.flatMap(rows["default"], AutomationSlice_Schedules$ReventlessCore.timeOf);
+    AutomationSlice_Schedules$ReventlessCore.declare(rows, undefined, now);
+    globalThis.expect([
+      changed,
+      liveKeys(rows)
+    ]).toEqual([
+      daily18,
+      []
+    ]);
+  });
+});
+
+globalThis.describe("a change an event makes", () => {
+  globalThis.test("counts an After from when the event was recorded", () => {
+    let rows = {};
+    set(rows, "o1", {
+      TAG: "Once",
+      moment: {
+        TAG: "After",
+        _0: {
+          TAG: "Minutes",
+          _0: 10
+        }
+      }
+    }, new Date("2026-10-16T09:00:00Z").getTime());
+    globalThis.expect(Stdlib_Option.flatMap(rows["o1"], AutomationSlice_Schedules$ReventlessCore.timeOf)).toEqual({
+      TAG: "Once",
+      moment: {
+        TAG: "At",
+        _0: {
+          year: 2026,
+          month: 10,
+          day: 16,
+          hour: 9,
+          minute: 10
+        }
+      }
+    });
+  });
+  globalThis.test("refuses a time that cannot fire, and changes nothing", () => {
+    let rows = {};
+    let refused = set(rows, "r1", {
+      TAG: "Calendar",
+      calendar: {
+        TAG: "Daily",
+        hour: 25,
+        minute: 0
+      }
+    }, undefined);
+    globalThis.expect([
+      Stdlib_Result.isError(refused),
+      liveKeys(rows)
+    ]).toEqual([
+      true,
+      []
+    ]);
+  });
+  globalThis.test("removes a once-only schedule when it fires, not a recurring one", () => {
+    let rows = {};
+    set(rows, "o1", {
+      TAG: "Once",
+      moment: {
+        TAG: "After",
+        _0: {
+          TAG: "Minutes",
+          _0: 10
+        }
+      }
+    }, undefined);
+    set(rows, "r1", daily18, undefined);
+    AutomationSlice_Schedules$ReventlessCore.fired(rows, "o1");
+    AutomationSlice_Schedules$ReventlessCore.fired(rows, "r1");
+    globalThis.expect(liveKeys(rows)).toEqual(["r1"]);
+  });
+});
+
+globalThis.describe("the reconcile", () => {
+  globalThis.test("puts what the platform is missing and removes what the rows do not hold", async () => {
+    let rows = {};
+    set(rows, "r1", daily18, undefined);
+    set(rows, "r2", daily18, undefined);
+    let match = fakePlatform([
+      "r2",
+      "stray"
+    ]);
+    await AutomationSlice_Schedules$ReventlessCore.reconcile(rows, match[0], undefined, now);
+    globalThis.expect(Object.keys(match[1]).toSorted(Primitive_string.compare)).toEqual([
+      "r1",
+      "r2"
+    ]);
+  });
+  globalThis.test("does not put again a schedule an event set and the platform holds", async () => {
+    let rows = {};
+    set(rows, "r1", daily18, undefined);
+    let match = fakePlatform(["r1"]);
+    await AutomationSlice_Schedules$ReventlessCore.reconcile(rows, match[0], undefined, now);
+    globalThis.expect(match[2]).toEqual([]);
+  });
+  globalThis.test("puts the declared time again, in case it changed", async () => {
+    let rows = {};
+    let match = fakePlatform(["default"]);
+    await AutomationSlice_Schedules$ReventlessCore.reconcile(rows, match[0], daily6, now);
+    globalThis.expect(match[2]).toEqual(["put default"]);
+  });
+  globalThis.test("drops a once-only time already past, from the rows and the platform", async () => {
+    let rows = {};
+    set(rows, "o1", {
+      TAG: "Once",
+      moment: {
+        TAG: "After",
+        _0: {
+          TAG: "Minutes",
+          _0: 10
+        }
+      }
+    }, new Date("2026-10-16T09:00:00Z").getTime());
+    let match = fakePlatform(["o1"]);
+    await AutomationSlice_Schedules$ReventlessCore.reconcile(rows, match[0], undefined, now);
+    globalThis.expect([
+      liveKeys(rows),
+      Object.keys(match[1])
+    ]).toEqual([
+      [],
+      []
+    ]);
+  });
+});
+
+let Schedules;
+
+export {
+  Schedules,
+  at,
+  daily6,
+  daily18,
+  now,
+  fakePlatform,
+  liveKeys,
+  set,
+  clear,
+}
+/* now Not a pure module */