@reventlessdev/reventless-local 3.0.0-alpha.284 → 3.0.0-alpha.286

package/tests/adapter/ScheduledPublisherTest.res

@@ -1,41 +1,27 @@
 // Unit tests for LocalScheduledPublisher.
-// Uses fake timers to verify createSchedule, deleteSchedule, and reset.
+// Uses fake timers, which also fix Date.now, to check each shape of a time fires when
+// ScheduleTime says it does.
 
 open JestGlobals
 
-// ─────────────────────────────────────────────────────────────
-// Fake timer bindings
-// ─────────────────────────────────────────────────────────────
-
 type jestObj
 @module("@jest/globals") external jest: jestObj = "jest"
 @send external useFakeTimers: jestObj => unit = "useFakeTimers"
 @send external useRealTimers: jestObj => unit = "useRealTimers"
-@send external runAllTimers: jestObj => unit = "runAllTimers"
-@send external advanceTimersByTime: (jestObj, int) => unit = "advanceTimersByTime"
+@send external advanceTimersByTime: (jestObj, float) => unit = "advanceTimersByTime"
+@send external setSystemTime: (jestObj, float) => unit = "setSystemTime"
 
 let _ = beforeAll(() => {
   jest->useFakeTimers
 })
 
-// ─────────────────────────────────────────────────────────────
 // Pulumi mock (needed for Pulumi.Output.make in ScheduledPublisher)
-// ─────────────────────────────────────────────────────────────
-
 let _ = TestRunner.setup()
 
-// ─────────────────────────────────────────────────────────────
-// Restore real timers after all tests in this file
-// ─────────────────────────────────────────────────────────────
-
 let _ = afterAll(() => {
   jest->useRealTimers
 })
 
-// ─────────────────────────────────────────────────────────────
-// Helper: create a topic resource with a known name
-// ─────────────────────────────────────────────────────────────
-
 let makeTopicResource = (topicName: string): ReventlessInfra.Adapter.resolvedResource => {
   name: topicName,
   id: topicName,
@@ -49,186 +35,201 @@ let makeTopicResource = (topicName: string): ReventlessInfra.Adapter.resolvedRes
   tags: Dict.make(),
 }
 
+let minute = 60_000.
+let hour = 60. *. minute
+let day = 24. *. hour
+let at = iso => Date.fromString(iso)->Date.getTime
+
+// Two microtask ticks: publishEvent uses Effect.all(concurrency=unbounded) which forks
+// child fibers — one tick for the child fiber to offer to the Queue, a second for the
+// drain fiber to run the callback.
+let flush = async () => {
+  let _ = await Promise.resolve()
+  let _ = await Promise.resolve()
+}
+
+let advance = async ms => {
+  jest->advanceTimersByTime(ms)
+  await flush()
+}
+
+module TestBus = LocalBus.Make()
+module SP = LocalScheduledPublisher.Make(TestBus)
+
+let topicCount = ref(0)
+let fired = topic => {
+  let count = ref(0)
+  TestBus.subscribeToEvents(topic, async (_, _, _) => {
+    count := count.contents + 1
+  })
+  count
+}
+
+// A fresh topic per test, so a subscriber never sees another test's firings.
+let schedule = async (~now, time) => {
+  jest->setSystemTime(now->at)
+  topicCount := topicCount.contents + 1
+  let topic = `sched-topic-${topicCount.contents->Int.toString}`
+  let count = fired(topic)
+  let ops = await SP.make(~name="scheduler", ~opts={}).operations->TestRunner.resolve
+  await ops.createSchedule([makeTopicResource(topic)], {name: topic, time, payload: "{}"})
+  (ops, topic, count)
+}
+
 describe("LocalScheduledPublisher", () => {
-  describe("createSchedule", () => {
+  let _ = afterEach(() => SP.reset())
+
+  describe("Every", () => {
     testPromise(
-      "single-shot schedule fires event after runAllTimers",
+      "fires one interval after it is set, and again each interval",
       async () => {
-        module TestBus = LocalBus.Make()
-        module SP = LocalScheduledPublisher.Make(TestBus)
-        let count: ref<int> = ref(0)
-        TestBus.subscribeToEvents(
-          "sched-topic",
-          async (_, _, _) => {
-            count := count.contents + 1
-          },
+        let (_, _, count) = await schedule(~now="2026-10-16T10:00:00Z", Every(Minutes(3)))
+        await advance(3. *. minute -. 1.)
+        expect(count.contents)->toBe(0)
+        await advance(1.)
+        expect(count.contents)->toBe(1)
+        await advance(3. *. minute)
+        expect(count.contents)->toBe(2)
+      },
+    )
+
+    testPromise(
+      "Hours(n) fires after n hours",
+      async () => {
+        let (_, _, count) = await schedule(~now="2026-10-16T10:00:00Z", Every(Hours(2)))
+        await advance(2. *. hour)
+        expect(count.contents)->toBe(1)
+      },
+    )
+  })
+
+  describe("Calendar", () => {
+    testPromise(
+      "fires at the wall-clock time each day, not 24 hours after it is set",
+      async () => {
+        let (_, _, count) = await schedule(
+          ~now="2026-10-16T05:58:00Z",
+          Calendar({calendar: Daily({hour: 6, minute: 0})}),
         )
-        let pub = SP.make(~name="scheduler", ~opts={})
-        let ops = await pub.operations->TestRunner.resolve
-        let schedule: Reventless.Schedule.schedule = {
-          name: "one-shot",
-          rate: Reventless.Schedule.Single(2024, 1, 1, 0, 0),
-          payload: "{}",
-        }
-        await ops.createSchedule([makeTopicResource("sched-topic")], schedule)
-        jest->runAllTimers
-        // Two microtask ticks: publishEvent uses Effect.all(concurrency=unbounded) which forks
-        // child fibers via startFork — one tick for the child fiber to offer to the Queue,
-        // a second tick for the drain fiber to run the callback.
-        let _ = await Promise.resolve()
-        let _ = await Promise.resolve()
+        await advance(2. *. minute)
         expect(count.contents)->toBe(1)
-        SP.reset()
+        await advance(day)
+        expect(count.contents)->toBe(2)
       },
     )
 
     testPromise(
-      "recurring schedule fires on each interval advance",
+      "skips a day whose time falls in the hour daylight saving skips",
       async () => {
-        module TestBus = LocalBus.Make()
-        module SP = LocalScheduledPublisher.Make(TestBus)
-        let count: ref<int> = ref(0)
-        TestBus.subscribeToEvents(
-          "repeat-topic",
-          async (_, _, _) => {
-            count := count.contents + 1
-          },
+        let (_, _, count) = await schedule(
+          ~now="2027-03-27T12:00:00Z",
+          Calendar({calendar: Daily({hour: 2, minute: 30}), zone: "Europe/Berlin"}),
         )
-        let pub = SP.make(~name="scheduler2", ~opts={})
-        let ops = await pub.operations->TestRunner.resolve
-        let schedule: Reventless.Schedule.schedule = {
-          name: "every-minute",
-          rate: Reventless.Schedule.Minutes(1),
-          payload: "{}",
-        }
-        await ops.createSchedule([makeTopicResource("repeat-topic")], schedule)
-        jest->advanceTimersByTime(60 * 1000)
-        let _ = await Promise.resolve()
-        let _ = await Promise.resolve()
-        jest->advanceTimersByTime(60 * 1000)
-        let _ = await Promise.resolve()
-        let _ = await Promise.resolve()
+        // 28 March fires; 29 March has no 02:30 in Berlin; 30 March fires
+        await advance(at("2027-03-29T12:00:00Z") -. at("2027-03-27T12:00:00Z"))
+        expect(count.contents)->toBe(1)
+        await advance(at("2027-03-30T12:00:00Z") -. at("2027-03-29T12:00:00Z"))
         expect(count.contents)->toBe(2)
-        SP.reset()
       },
     )
-  })
 
-  describe("deleteSchedule", () => {
     testPromise(
-      "clears a named schedule; advancing timers does not fire it",
+      "reaches a firing further away than a timer can wait",
       async () => {
-        module TestBus = LocalBus.Make()
-        module SP = LocalScheduledPublisher.Make(TestBus)
-        let count: ref<int> = ref(0)
-        TestBus.subscribeToEvents(
-          "del-topic",
-          async (_, _, _) => {
-            count := count.contents + 1
-          },
+        let (_, _, count) = await schedule(
+          ~now="2026-10-16T10:00:00Z",
+          Calendar({calendar: Yearly({month: 1, day: 1, hour: 6, minute: 0})}),
         )
-        let pub = SP.make(~name="scheduler3", ~opts={})
-        let ops = await pub.operations->TestRunner.resolve
-        let schedule: Reventless.Schedule.schedule = {
-          name: "to-delete",
-          rate: Reventless.Schedule.Minutes(1),
-          payload: "{}",
-        }
-        await ops.createSchedule([makeTopicResource("del-topic")], schedule)
-        await ops.deleteSchedule([], "to-delete")
-        jest->advanceTimersByTime(60 * 1000)
+        await advance(at("2027-01-01T05:59:00Z") -. at("2026-10-16T10:00:00Z"))
         expect(count.contents)->toBe(0)
-        SP.reset()
+        await advance(minute)
+        expect(count.contents)->toBe(1)
       },
     )
   })
 
-  describe("reset", () => {
+  describe("Once", () => {
     testPromise(
-      "clears all active timers; subsequent advance does not fire",
+      "fires once, a period after it is set",
       async () => {
-        module TestBus = LocalBus.Make()
-        module SP = LocalScheduledPublisher.Make(TestBus)
-        let count: ref<int> = ref(0)
-        TestBus.subscribeToEvents(
-          "reset-topic",
-          async (_, _, _) => {
-            count := count.contents + 1
-          },
+        let (_, _, count) = await schedule(
+          ~now="2026-10-16T10:00:00Z",
+          Once({moment: After(Minutes(10))}),
         )
-        let pub = SP.make(~name="scheduler4", ~opts={})
-        let ops = await pub.operations->TestRunner.resolve
-        let schedule: Reventless.Schedule.schedule = {
-          name: "reset-sched",
-          rate: Reventless.Schedule.Minutes(5),
-          payload: "{}",
-        }
-        await ops.createSchedule([makeTopicResource("reset-topic")], schedule)
-        SP.reset()
-        jest->advanceTimersByTime(5 * 60 * 1000)
+        await advance(10. *. minute)
+        expect(count.contents)->toBe(1)
+        await advance(day)
+        expect(count.contents)->toBe(1)
+      },
+    )
+
+    testPromise(
+      "never fires at a moment already past",
+      async () => {
+        let (_, _, count) = await schedule(
+          ~now="2026-10-16T10:00:00Z",
+          Once({moment: At({year: 2024, month: 1, day: 1, hour: 0, minute: 0})}),
+        )
+        await advance(day)
         expect(count.contents)->toBe(0)
       },
     )
   })
 
-  describe("rateToMs", () => {
+  describe("createSchedule", () => {
     testPromise(
-      "Minutes(n) fires after n minutes",
+      "replaces a schedule of the same name",
       async () => {
-        module TestBus = LocalBus.Make()
-        module SP = LocalScheduledPublisher.Make(TestBus)
-        let count: ref<int> = ref(0)
-        TestBus.subscribeToEvents(
-          "rate-topic",
-          async (_, _, _) => {
-            count := count.contents + 1
-          },
+        let (ops, topic, count) = await schedule(~now="2026-10-16T10:00:00Z", Every(Minutes(1)))
+        await ops.createSchedule(
+          [makeTopicResource(topic)],
+          {name: topic, time: Every(Minutes(5)), payload: "{}"},
         )
-        let pub = SP.make(~name="rate-scheduler", ~opts={})
-        let ops = await pub.operations->TestRunner.resolve
-        let schedule: Reventless.Schedule.schedule = {
-          name: "rate-sched",
-          rate: Reventless.Schedule.Minutes(3),
-          payload: "{}",
-        }
-        await ops.createSchedule([makeTopicResource("rate-topic")], schedule)
-        // Advance by slightly less than 3 minutes — should not fire
-        jest->advanceTimersByTime(3 * 60 * 1000 - 1)
-        expect(count.contents)->toBe(0)
-        // Advance the remaining millisecond — now fires; two ticks for Effect.all drain
-        jest->advanceTimersByTime(1)
-        let _ = await Promise.resolve()
-        let _ = await Promise.resolve()
+        await advance(5. *. minute)
         expect(count.contents)->toBe(1)
-        SP.reset()
       },
     )
 
     testPromise(
-      "Hours(n) fires after n hours",
+      "refuses a time that cannot fire",
       async () => {
-        module TestBus = LocalBus.Make()
-        module SP = LocalScheduledPublisher.Make(TestBus)
-        let count: ref<int> = ref(0)
-        TestBus.subscribeToEvents(
-          "hours-topic",
-          async (_, _, _) => {
-            count := count.contents + 1
+        let ops = await SP.make(~name="scheduler", ~opts={}).operations->TestRunner.resolve
+        let refused = switch await ops.createSchedule(
+          [makeTopicResource("refused")],
+          {
+            name: "refused",
+            time: Calendar({calendar: Daily({hour: 25, minute: 0}), zone: "Mars/Base"}),
+            payload: "{}",
           },
-        )
-        let pub = SP.make(~name="hours-scheduler", ~opts={})
-        let ops = await pub.operations->TestRunner.resolve
-        let schedule: Reventless.Schedule.schedule = {
-          name: "hours-sched",
-          rate: Reventless.Schedule.Hours(2),
-          payload: "{}",
+        ) {
+        | _ => false
+        | exception ReventlessCore.ScheduleTime.InvalidTime(_) => true
         }
-        await ops.createSchedule([makeTopicResource("hours-topic")], schedule)
-        jest->advanceTimersByTime(2 * 60 * 60 * 1000)
-        let _ = await Promise.resolve()
-        let _ = await Promise.resolve()
-        expect(count.contents)->toBe(1)
+        expect(refused)->toBe(true)
+      },
+    )
+  })
+
+  describe("deleteSchedule", () => {
+    testPromise(
+      "stops a schedule; advancing timers does not fire it",
+      async () => {
+        let (ops, topic, count) = await schedule(~now="2026-10-16T10:00:00Z", Every(Minutes(1)))
+        await ops.deleteSchedule([], topic)
+        await advance(minute)
+        expect(count.contents)->toBe(0)
+      },
+    )
+  })
+
+  describe("reset", () => {
+    testPromise(
+      "clears all active timers; subsequent advance does not fire",
+      async () => {
+        let (_, _, count) = await schedule(~now="2026-10-16T10:00:00Z", Every(Minutes(5)))
         SP.reset()
+        await advance(5. *. minute)
+        expect(count.contents)->toBe(0)
       },
     )
   })