@reventlessdev/reventless-local 3.0.0-alpha.285 → 3.0.0-alpha.287

package/tests/adapter/ScheduledPublisherTest.res.mjs

@@ -1,8 +1,10 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Globals from "@jest/globals";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as LocalBus$ReventlessLocal from "../../src/adapter/LocalBus.res.mjs";
 import * as TestRunner$ReventlessLocal from "../../src/test/TestRunner.res.mjs";
+import * as ScheduleTime$ReventlessCore from "@reventlessdev/reventless-core/src/util/ScheduleTime.res.mjs";
 import * as LocalScheduledPublisher$ReventlessLocal from "../../src/adapter/Scheduler/LocalScheduledPublisher.res.mjs";
 
 globalThis.beforeAll(() => {
@@ -30,174 +32,274 @@ function makeTopicResource(topicName) {
   };
 }
 
+let hour = 60 * 60000;
+
+let day = 24 * hour;
+
+function at(iso) {
+  return new Date(iso).getTime();
+}
+
+async function flush() {
+  await Promise.resolve();
+  await Promise.resolve();
+}
+
+async function advance(ms) {
+  Globals.jest.advanceTimersByTime(ms);
+  return await flush();
+}
+
+let TestBus = LocalBus$ReventlessLocal.Make({});
+
+let SP = LocalScheduledPublisher$ReventlessLocal.Make(TestBus);
+
+let topicCount = {
+  contents: 0
+};
+
+function fired(topic) {
+  let count = {
+    contents: 0
+  };
+  TestBus.subscribeToEvents(topic, async (param, param$1, param$2) => {
+    count.contents = count.contents + 1 | 0;
+  });
+  return count;
+}
+
+async function schedule(now, time) {
+  Globals.jest.setSystemTime(new Date(now).getTime());
+  topicCount.contents = topicCount.contents + 1 | 0;
+  let topic = `sched-topic-` + topicCount.contents.toString();
+  let count = fired(topic);
+  let ops = await TestRunner$ReventlessLocal.resolve(SP.make("scheduler", {}).operations);
+  await ops.createSchedule([makeTopicResource(topic)], {
+    name: topic,
+    time: time,
+    payload: "{}"
+  });
+  return [
+    ops,
+    topic,
+    count
+  ];
+}
+
 globalThis.describe("LocalScheduledPublisher", () => {
-  globalThis.describe("createSchedule", () => {
-    globalThis.test("single-shot schedule fires event after runAllTimers", async () => {
-      let TestBus = LocalBus$ReventlessLocal.Make({});
-      let SP = LocalScheduledPublisher$ReventlessLocal.Make(TestBus);
-      let count = {
-        contents: 0
-      };
-      TestBus.subscribeToEvents("sched-topic", async (param, param$1, param$2) => {
-        count.contents = count.contents + 1 | 0;
+  globalThis.afterEach(() => SP.reset());
+  globalThis.describe("Every", () => {
+    globalThis.test("fires one interval after it is set, and again each interval", async () => {
+      let match = await schedule("2026-10-16T10:00:00Z", {
+        TAG: "Every",
+        _0: {
+          TAG: "Minutes",
+          _0: 3
+        }
+      });
+      let count = match[2];
+      await advance(3 * 60000 - 1);
+      globalThis.expect(count.contents).toBe(0);
+      await advance(1);
+      globalThis.expect(count.contents).toBe(1);
+      await advance(3 * 60000);
+      globalThis.expect(count.contents).toBe(2);
+    });
+    globalThis.test("Hours(n) fires after n hours", async () => {
+      let match = await schedule("2026-10-16T10:00:00Z", {
+        TAG: "Every",
+        _0: {
+          TAG: "Hours",
+          _0: 2
+        }
+      });
+      await advance(2 * hour);
+      globalThis.expect(match[2].contents).toBe(1);
+    });
+  });
+  globalThis.describe("Calendar", () => {
+    globalThis.test("fires at the wall-clock time each day, not 24 hours after it is set", async () => {
+      let match = await schedule("2026-10-16T05:58:00Z", {
+        TAG: "Calendar",
+        calendar: {
+          TAG: "Daily",
+          hour: 6,
+          minute: 0
+        }
       });
-      let pub = SP.make("scheduler", {});
-      let ops = await TestRunner$ReventlessLocal.resolve(pub.operations);
-      await ops.createSchedule([makeTopicResource("sched-topic")], {
-        name: "one-shot",
-        rate: {
-          TAG: "Single",
-          _0: 2024,
-          _1: 1,
-          _2: 1,
-          _3: 0,
-          _4: 0
+      let count = match[2];
+      await advance(2 * 60000);
+      globalThis.expect(count.contents).toBe(1);
+      await advance(day);
+      globalThis.expect(count.contents).toBe(2);
+    });
+    globalThis.test("skips a day whose time falls in the hour daylight saving skips", async () => {
+      let match = await schedule("2027-03-27T12:00:00Z", {
+        TAG: "Calendar",
+        calendar: {
+          TAG: "Daily",
+          hour: 2,
+          minute: 30
         },
-        payload: "{}"
+        zone: "Europe/Berlin"
+      });
+      let count = match[2];
+      await advance(new Date("2027-03-29T12:00:00Z").getTime() - new Date("2027-03-27T12:00:00Z").getTime());
+      globalThis.expect(count.contents).toBe(1);
+      await advance(new Date("2027-03-30T12:00:00Z").getTime() - new Date("2027-03-29T12:00:00Z").getTime());
+      globalThis.expect(count.contents).toBe(2);
+    });
+    globalThis.test("reaches a firing further away than a timer can wait", async () => {
+      let match = await schedule("2026-10-16T10:00:00Z", {
+        TAG: "Calendar",
+        calendar: {
+          TAG: "Yearly",
+          month: 1,
+          day: 1,
+          hour: 6,
+          minute: 0
+        }
       });
-      Globals.jest.runAllTimers();
-      await Promise.resolve();
-      await Promise.resolve();
+      let count = match[2];
+      await advance(new Date("2027-01-01T05:59:00Z").getTime() - new Date("2026-10-16T10:00:00Z").getTime());
+      globalThis.expect(count.contents).toBe(0);
+      await advance(60000);
+      globalThis.expect(count.contents).toBe(1);
+    });
+  });
+  globalThis.describe("Once", () => {
+    globalThis.test("fires once, a period after it is set", async () => {
+      let match = await schedule("2026-10-16T10:00:00Z", {
+        TAG: "Once",
+        moment: {
+          TAG: "After",
+          _0: {
+            TAG: "Minutes",
+            _0: 10
+          }
+        }
+      });
+      let count = match[2];
+      await advance(10 * 60000);
+      globalThis.expect(count.contents).toBe(1);
+      await advance(day);
       globalThis.expect(count.contents).toBe(1);
-      return SP.reset();
     });
-    globalThis.test("recurring schedule fires on each interval advance", async () => {
-      let TestBus = LocalBus$ReventlessLocal.Make({});
-      let SP = LocalScheduledPublisher$ReventlessLocal.Make(TestBus);
-      let count = {
-        contents: 0
-      };
-      TestBus.subscribeToEvents("repeat-topic", async (param, param$1, param$2) => {
-        count.contents = count.contents + 1 | 0;
+    globalThis.test("never fires at a moment already past", async () => {
+      let match = await schedule("2026-10-16T10:00:00Z", {
+        TAG: "Once",
+        moment: {
+          TAG: "At",
+          _0: {
+            year: 2024,
+            month: 1,
+            day: 1,
+            hour: 0,
+            minute: 0
+          }
+        }
       });
-      let pub = SP.make("scheduler2", {});
-      let ops = await TestRunner$ReventlessLocal.resolve(pub.operations);
-      await ops.createSchedule([makeTopicResource("repeat-topic")], {
-        name: "every-minute",
-        rate: {
+      await advance(day);
+      globalThis.expect(match[2].contents).toBe(0);
+    });
+  });
+  globalThis.describe("createSchedule", () => {
+    globalThis.test("replaces a schedule of the same name", async () => {
+      let match = await schedule("2026-10-16T10:00:00Z", {
+        TAG: "Every",
+        _0: {
           TAG: "Minutes",
           _0: 1
+        }
+      });
+      let topic = match[1];
+      await match[0].createSchedule([makeTopicResource(topic)], {
+        name: topic,
+        time: {
+          TAG: "Every",
+          _0: {
+            TAG: "Minutes",
+            _0: 5
+          }
         },
         payload: "{}"
       });
-      Globals.jest.advanceTimersByTime(60000);
-      await Promise.resolve();
-      await Promise.resolve();
-      Globals.jest.advanceTimersByTime(60000);
-      await Promise.resolve();
-      await Promise.resolve();
-      globalThis.expect(count.contents).toBe(2);
-      return SP.reset();
+      await advance(5 * 60000);
+      globalThis.expect(match[2].contents).toBe(1);
+    });
+    globalThis.test("refuses a time that cannot fire", async () => {
+      let ops = await TestRunner$ReventlessLocal.resolve(SP.make("scheduler", {}).operations);
+      let refused;
+      try {
+        await ops.createSchedule([makeTopicResource("refused")], {
+          name: "refused",
+          time: {
+            TAG: "Calendar",
+            calendar: {
+              TAG: "Daily",
+              hour: 25,
+              minute: 0
+            },
+            zone: "Mars/Base"
+          },
+          payload: "{}"
+        });
+        refused = false;
+      } catch (raw_exn) {
+        let exn = Primitive_exceptions.internalToException(raw_exn);
+        if (exn.RE_EXN_ID === ScheduleTime$ReventlessCore.InvalidTime) {
+          refused = true;
+        } else {
+          throw exn;
+        }
+      }
+      globalThis.expect(refused).toBe(true);
     });
   });
   globalThis.describe("deleteSchedule", () => {
-    globalThis.test("clears a named schedule; advancing timers does not fire it", async () => {
-      let TestBus = LocalBus$ReventlessLocal.Make({});
-      let SP = LocalScheduledPublisher$ReventlessLocal.Make(TestBus);
-      let count = {
-        contents: 0
-      };
-      TestBus.subscribeToEvents("del-topic", async (param, param$1, param$2) => {
-        count.contents = count.contents + 1 | 0;
-      });
-      let pub = SP.make("scheduler3", {});
-      let ops = await TestRunner$ReventlessLocal.resolve(pub.operations);
-      await ops.createSchedule([makeTopicResource("del-topic")], {
-        name: "to-delete",
-        rate: {
+    globalThis.test("stops a schedule; advancing timers does not fire it", async () => {
+      let match = await schedule("2026-10-16T10:00:00Z", {
+        TAG: "Every",
+        _0: {
           TAG: "Minutes",
           _0: 1
-        },
-        payload: "{}"
+        }
       });
-      await ops.deleteSchedule([], "to-delete");
-      Globals.jest.advanceTimersByTime(60000);
-      globalThis.expect(count.contents).toBe(0);
-      return SP.reset();
+      await match[0].deleteSchedule([], match[1]);
+      await advance(60000);
+      globalThis.expect(match[2].contents).toBe(0);
     });
   });
   globalThis.describe("reset", () => {
     globalThis.test("clears all active timers; subsequent advance does not fire", async () => {
-      let TestBus = LocalBus$ReventlessLocal.Make({});
-      let SP = LocalScheduledPublisher$ReventlessLocal.Make(TestBus);
-      let count = {
-        contents: 0
-      };
-      TestBus.subscribeToEvents("reset-topic", async (param, param$1, param$2) => {
-        count.contents = count.contents + 1 | 0;
-      });
-      let pub = SP.make("scheduler4", {});
-      let ops = await TestRunner$ReventlessLocal.resolve(pub.operations);
-      await ops.createSchedule([makeTopicResource("reset-topic")], {
-        name: "reset-sched",
-        rate: {
+      let match = await schedule("2026-10-16T10:00:00Z", {
+        TAG: "Every",
+        _0: {
           TAG: "Minutes",
           _0: 5
-        },
-        payload: "{}"
+        }
       });
       SP.reset();
-      Globals.jest.advanceTimersByTime(300000);
-      globalThis.expect(count.contents).toBe(0);
-    });
-  });
-  globalThis.describe("rateToMs", () => {
-    globalThis.test("Minutes(n) fires after n minutes", async () => {
-      let TestBus = LocalBus$ReventlessLocal.Make({});
-      let SP = LocalScheduledPublisher$ReventlessLocal.Make(TestBus);
-      let count = {
-        contents: 0
-      };
-      TestBus.subscribeToEvents("rate-topic", async (param, param$1, param$2) => {
-        count.contents = count.contents + 1 | 0;
-      });
-      let pub = SP.make("rate-scheduler", {});
-      let ops = await TestRunner$ReventlessLocal.resolve(pub.operations);
-      await ops.createSchedule([makeTopicResource("rate-topic")], {
-        name: "rate-sched",
-        rate: {
-          TAG: "Minutes",
-          _0: 3
-        },
-        payload: "{}"
-      });
-      Globals.jest.advanceTimersByTime(179999);
-      globalThis.expect(count.contents).toBe(0);
-      Globals.jest.advanceTimersByTime(1);
-      await Promise.resolve();
-      await Promise.resolve();
-      globalThis.expect(count.contents).toBe(1);
-      return SP.reset();
-    });
-    globalThis.test("Hours(n) fires after n hours", async () => {
-      let TestBus = LocalBus$ReventlessLocal.Make({});
-      let SP = LocalScheduledPublisher$ReventlessLocal.Make(TestBus);
-      let count = {
-        contents: 0
-      };
-      TestBus.subscribeToEvents("hours-topic", async (param, param$1, param$2) => {
-        count.contents = count.contents + 1 | 0;
-      });
-      let pub = SP.make("hours-scheduler", {});
-      let ops = await TestRunner$ReventlessLocal.resolve(pub.operations);
-      await ops.createSchedule([makeTopicResource("hours-topic")], {
-        name: "hours-sched",
-        rate: {
-          TAG: "Hours",
-          _0: 2
-        },
-        payload: "{}"
-      });
-      Globals.jest.advanceTimersByTime(7200000);
-      await Promise.resolve();
-      await Promise.resolve();
-      globalThis.expect(count.contents).toBe(1);
-      return SP.reset();
+      await advance(5 * 60000);
+      globalThis.expect(match[2].contents).toBe(0);
     });
   });
 });
 
+let minute = 60000;
+
 export {
   makeTopicResource,
+  minute,
+  hour,
+  day,
+  at,
+  flush,
+  advance,
+  TestBus,
+  SP,
+  topicCount,
+  fired,
+  schedule,
 }
 /*  Not a pure module */

package/tests/components/automationslice/AutomationRescheduleFixtures.res

@@ -0,0 +1,142 @@
+// A digest per recipient on the local platform: the slice declares no time; a
+// recipient's choice sets their schedule, unsubscribing clears it, and each tick
+// sends that recipient's digest. The slice is made by `makeSlice`, so a test can fix
+// the time first.
+
+open TestFixtures
+open Reventless
+
+module PreferencesSource = {
+  module Id = Id.String
+  let name = "DigestPreferencesEventTopic"
+  @schema
+  type event =
+    | DigestTimeChosen({recipientId: string, time: Schedule.time})
+    | Unsubscribed({recipientId: string})
+}
+
+module DigestSpec = {
+  let name = "LocalDigest"
+  let moduleUrl: string = %raw(`import.meta.url`)
+
+  @schema
+  type todoItem = {recipientId: string}
+
+  @schema
+  type command = SendDigest({recipientId: @s.matches(DcbTag.string) string})
+
+  let maxRetries = 2
+  let heartbeatInterval = 60
+  let targetName = "SendDigest"
+  let schedule = None
+}
+
+module FromClock = AutomationSlice.Mapping.Make(
+  Clock,
+  DigestSpec,
+  {
+    let collect = (Clock.Tick({key, at}), ~sourceId as _, _ctx) => [
+      (Clock.itemId(key, at), ({recipientId: key}: DigestSpec.todoItem)),
+    ]
+    let resolve = _ => None
+    let reschedule = _ => []
+  },
+)
+
+module FromPreferences = AutomationSlice.Mapping.Make(
+  PreferencesSource,
+  DigestSpec,
+  {
+    let collect = (_, ~sourceId as _, _ctx) => []
+    let resolve = _ => None
+    let reschedule = event =>
+      switch event {
+      | PreferencesSource.DigestTimeChosen({recipientId, time}) => [
+          AutomationSlice.Set({key: recipientId, time}),
+        ]
+      | Unsubscribed({recipientId}) => [Clear({key: recipientId})]
+      }
+  },
+)
+
+module DigestAutomation: AutomationSlice.Automation with module Spec := DigestSpec = {
+  let process = (_id, item: DigestSpec.todoItem, ~now as _) => Some((
+    item.recipientId,
+    DigestSpec.SendDigest({recipientId: item.recipientId}),
+  ))
+  let onExhausted = (_id, _item: DigestSpec.todoItem) => None
+  let moduleUrl: string = %raw(`import.meta.url`)
+  module M = AutomationSlice.Mappings.Make(DigestSpec)
+  module type Mapping = M.Mapping
+  let mappings: array<module(Mapping)> = [module(FromClock), module(FromPreferences)]
+}
+
+let preferencesResource: ReventlessInfra.Adapter.resource = ReventlessInfra.Adapter.make(
+  ~name=PreferencesSource.name->Pulumi.Output.make,
+  ~id=PreferencesSource.name->Pulumi.Output.make,
+  ~urn=PreferencesSource.name->Pulumi.Output.make,
+  ~service="memory:InMemory"->Pulumi.Output.make,
+)
+
+module Bus = LocalBus.Make()
+let _ = TestRunner.setup()
+
+module AutomationSliceMaker = AutomationSlice_Builder.Make(Bus)
+module Digest = AutomationSliceMaker.Make(DigestSpec, DigestAutomation)
+
+let publishedCommands: ref<array<Reventless.Message.commandJson>> = ref([])
+let publishJsons: ReventlessInfra.CommandTopic.publishJsons = async cmds =>
+  publishedCommands := publishedCommands.contents->Array.concat(cmds)
+
+let makeSlice = () =>
+  Digest.make(
+    ~allEventTopics=Dict.fromArray([
+      (PreferencesSource.name, {ReventlessInfra.EventTopic.resources: [preferencesResource]}),
+    ]),
+    ~publishJsons=publishJsons->Pulumi.Output.make,
+    ~context={
+      environment: "local",
+      platformName: "local",
+      pluginName: "TestPlugin",
+      sliceName: DigestSpec.name,
+    },
+  )
+
+/** An event as the log would hold it, recorded now as the fake Date has it. */
+let eventJson = (event: PreferencesSource.event, ~recipientId) => {
+  let meta = {
+    ...makeTestMeta(~service=PreferencesSource.name),
+    time: Date.now()->Date.fromTime->Date.toISOString,
+  }
+  (
+    meta,
+    JSON.Encode.object(
+      Dict.fromArray([
+        ("id", recipientId->JSON.Encode.string),
+        ("meta", meta->Reventless.Util_Sury.toJson(Message.metaSchema)),
+        ("event", event->Reventless.Util_Sury.toJson(PreferencesSource.eventSchema)),
+      ]),
+    ),
+  )
+}
+
+let publish = async (event, ~recipientId) => {
+  let (meta, json) = eventJson(event, ~recipientId)
+  await Bus.publishEvent(PreferencesSource.name, "test", meta, json)
+}
+
+/** The keys and times the schedules store holds. */
+let storedSchedules = () =>
+  Bus.getQueryDbScan(Digest.schedulesDbName->Option.getOr(""))
+  ->Option.map(scan => scan())
+  ->Option.getOr([])
+  ->Array.map(row =>
+    row->Reventless.Util_Sury.fromJson(ReventlessCore.AutomationSlice_Schedules.rowSchema)
+  )
+  ->Array.filterMap(row =>
+    row->ReventlessCore.AutomationSlice_Schedules.timeOf->Option.map(t => (row.key, t))
+  )
+  ->Array.toSorted(((a, _), (b, _)) => String.compare(a, b))
+
+/** The keys whose timers the local platform holds for the slice. */
+let timers = () => LocalAutomationSchedules.platformFor(~slice=DigestSpec.name).names()