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

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()

package/tests/components/automationslice/AutomationRescheduleFixtures.res.mjs

@@ -0,0 +1,259 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Sury from "sury";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Clock$Reventless from "@reventlessdev/reventless-spec/src/components/Clock.res.mjs";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as Message$Reventless from "@reventlessdev/reventless-spec/src/types/Message.res.mjs";
+import * as Schedule$Reventless from "@reventlessdev/reventless-spec/src/types/Schedule.res.mjs";
+import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
+import * as Adapter$ReventlessInfra from "@reventlessdev/reventless-infra/src/adapter/Adapter.res.mjs";
+import * as LocalBus$ReventlessLocal from "../../../src/adapter/LocalBus.res.mjs";
+import * as AutomationSlice$Reventless from "@reventlessdev/reventless-spec/src/components/AutomationSlice.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../../src/test/TestRunner.res.mjs";
+import * as TestFixtures$ReventlessLocal from "../../TestFixtures.res.mjs";
+import * as AutomationSlice_Builder$ReventlessLocal from "../../../src/components/AutomationSlice_Builder.res.mjs";
+import * as AutomationSlice_Schedules$ReventlessCore from "@reventlessdev/reventless-core/src/components/AutomationSlice/AutomationSlice_Schedules.res.mjs";
+import * as LocalAutomationSchedules$ReventlessLocal from "../../../src/components/LocalAutomationSchedules.res.mjs";
+
+let name = "DigestPreferencesEventTopic";
+
+let eventSchema = Sury.union([
+  Sury.$schema(s => ({
+    TAG: "DigestTimeChosen",
+    recipientId: s.m(Sury.string),
+    time: s.m(Schedule$Reventless.timeSchema)
+  })),
+  Sury.$schema(s => ({
+    TAG: "Unsubscribed",
+    recipientId: s.m(Sury.string)
+  }))
+]);
+
+let PreferencesSource = {
+  Id: undefined,
+  name: name,
+  eventSchema: eventSchema
+};
+
+let name$1 = "LocalDigest";
+
+let moduleUrl = import.meta.url;
+
+let todoItemSchema = Sury.$schema(s => ({
+  recipientId: s.m(Sury.string)
+}));
+
+let commandSchema = Sury.$schema(s => ({
+  TAG: "SendDigest",
+  recipientId: s.m(DcbTag$Reventless.string)
+}));
+
+function authorizationOf(param) {
+  return "AllowAuthenticated";
+}
+
+function commandTransition(param) {
+  return "Undeclared";
+}
+
+let traits = [];
+
+let DigestSpec = {
+  name: name$1,
+  moduleUrl: moduleUrl,
+  todoItemSchema: todoItemSchema,
+  commandSchema: commandSchema,
+  maxRetries: 2,
+  heartbeatInterval: 60,
+  targetName: "SendDigest",
+  schedule: undefined,
+  authorizationOf: authorizationOf,
+  commandTransition: commandTransition,
+  traits: traits
+};
+
+function collect(param, param$1, _ctx) {
+  let key = param.key;
+  return [[
+      Clock$Reventless.itemId(key, param.at),
+      {
+        recipientId: key
+      }
+    ]];
+}
+
+function resolve(param) {
+  
+}
+
+function reschedule(param) {
+  return [];
+}
+
+let FromClock = AutomationSlice$Reventless.Mapping.Make({
+  Id: Id$Reventless.$$String,
+  name: Clock$Reventless.name,
+  eventSchema: Clock$Reventless.eventSchema
+})(DigestSpec)({
+  collect: collect,
+  resolve: resolve,
+  reschedule: reschedule
+});
+
+function collect$1(param, param$1, _ctx) {
+  return [];
+}
+
+function resolve$1(param) {
+  
+}
+
+function reschedule$1(event) {
+  if (event.TAG === "DigestTimeChosen") {
+    return [{
+        TAG: "Set",
+        key: event.recipientId,
+        time: event.time
+      }];
+  } else {
+    return [{
+        TAG: "Clear",
+        key: event.recipientId
+      }];
+  }
+}
+
+let FromPreferences = AutomationSlice$Reventless.Mapping.Make({
+  Id: Id$Reventless.$$String,
+  name: name,
+  eventSchema: eventSchema
+})(DigestSpec)({
+  collect: collect$1,
+  resolve: resolve$1,
+  reschedule: reschedule$1
+});
+
+function process(_id, item, param) {
+  return [
+    item.recipientId,
+    {
+      TAG: "SendDigest",
+      recipientId: item.recipientId
+    }
+  ];
+}
+
+function onExhausted(_id, _item) {
+  
+}
+
+let moduleUrl$1 = import.meta.url;
+
+AutomationSlice$Reventless.Mappings.Make(DigestSpec);
+
+let mappings = [
+  FromClock,
+  FromPreferences
+];
+
+let DigestAutomation = {
+  process: process,
+  onExhausted: onExhausted,
+  moduleUrl: moduleUrl$1,
+  mappings: mappings
+};
+
+let preferencesResource = Adapter$ReventlessInfra.make(Pulumi.output(name), Pulumi.output(name), Pulumi.output(name), Pulumi.output("memory:InMemory"), undefined, undefined, undefined, undefined, undefined, undefined);
+
+let Bus = LocalBus$ReventlessLocal.Make({});
+
+TestRunner$ReventlessLocal.setup();
+
+let AutomationSliceMaker = AutomationSlice_Builder$ReventlessLocal.Make(Bus);
+
+let Digest = AutomationSliceMaker.Make(DigestSpec)(DigestAutomation);
+
+let publishedCommands = {
+  contents: []
+};
+
+async function publishJsons(cmds) {
+  publishedCommands.contents = publishedCommands.contents.concat(cmds);
+}
+
+function makeSlice() {
+  return Digest.make(Object.fromEntries([[
+      name,
+      {
+        resources: [preferencesResource]
+      }
+    ]]), Pulumi.output(publishJsons), {
+    environment: "local",
+    platformName: "local",
+    pluginName: "TestPlugin",
+    sliceName: name$1
+  }, undefined, undefined);
+}
+
+function eventJson(event, recipientId) {
+  let newrecord = {...TestFixtures$ReventlessLocal.makeTestMeta(name)};
+  newrecord.time = new Date(Date.now()).toISOString();
+  return [
+    newrecord,
+    Object.fromEntries([
+      [
+        "id",
+        recipientId
+      ],
+      [
+        "meta",
+        Util_Sury$Reventless.toJson(newrecord, Message$Reventless.metaSchema)
+      ],
+      [
+        "event",
+        Util_Sury$Reventless.toJson(event, eventSchema)
+      ]
+    ])
+  ];
+}
+
+async function publish(event, recipientId) {
+  let match = eventJson(event, recipientId);
+  return await Bus.publishEvent(name, "test", match[0], match[1]);
+}
+
+function storedSchedules() {
+  return Stdlib_Array.filterMap(Stdlib_Option.getOr(Stdlib_Option.map(Bus.getQueryDbScan(Stdlib_Option.getOr(Digest.schedulesDbName, "")), scan => scan()), []).map(row => Util_Sury$Reventless.fromJson(row, AutomationSlice_Schedules$ReventlessCore.rowSchema)), row => Stdlib_Option.map(AutomationSlice_Schedules$ReventlessCore.timeOf(row), t => [
+    row.key,
+    t
+  ])).toSorted((param, param$1) => Primitive_string.compare(param[0], param$1[0]));
+}
+
+function timers() {
+  return LocalAutomationSchedules$ReventlessLocal.platformFor(name$1).names();
+}
+
+export {
+  PreferencesSource,
+  DigestSpec,
+  FromClock,
+  FromPreferences,
+  DigestAutomation,
+  preferencesResource,
+  Bus,
+  AutomationSliceMaker,
+  Digest,
+  publishedCommands,
+  publishJsons,
+  makeSlice,
+  eventJson,
+  publish,
+  storedSchedules,
+  timers,
+}
+/* eventSchema Not a pure module */

package/tests/components/automationslice/AutomationRescheduleTest.res

@@ -0,0 +1,96 @@
+// Schedules set by events, on the local platform: a recipient's choice is stored and
+// starts their timer, the timer's tick sends their digest, unsubscribing removes
+// both, and a rebuild from the events reproduces the rows and removes a stray timer.
+
+open JestGlobals
+open AutomationRescheduleFixtures
+
+type jestObj
+@module("@jest/globals") external jest: jestObj = "jest"
+@send external useFakeTimers: jestObj => unit = "useFakeTimers"
+@send external useRealTimers: jestObj => unit = "useRealTimers"
+@send external setSystemTime: (jestObj, float) => unit = "setSystemTime"
+@send
+external advanceTimersByTimeAsync: (jestObj, float) => promise<unit> = "advanceTimersByTimeAsync"
+
+let time = iso => Date.fromString(iso)->Date.getTime
+let at18 = Reventless.Schedule.Calendar({calendar: Daily({hour: 18, minute: 0})})
+let at19Berlin = Reventless.Schedule.Calendar({
+  calendar: Daily({hour: 19, minute: 0}),
+  zone: "Europe/Berlin",
+})
+
+let settle = async () =>
+  for _ in 1 to 20 {
+    await jest->advanceTimersByTimeAsync(0.)
+  }
+
+let sorted = keys => keys->Array.toSorted(String.compare)
+
+describe("schedules set by events, locally", () => {
+  let slice = ref(None)
+  let ops = async () =>
+    await slice.contents->Option.getOrThrow->ReventlessCore.Component.operations->TestRunner.resolve
+
+  let _ = beforeAllAsync(async () => {
+    jest->useFakeTimers
+    jest->setSystemTime(time("2026-10-16T12:00:00Z"))
+    slice := Some(makeSlice())
+    let _ = await ops()
+    await settle()
+  })
+  let _ = afterAll(() => {
+    LocalAutomationSchedules.reset()
+    jest->useRealTimers
+  })
+
+  testPromise("a choice is stored and starts the recipient's timer", async () => {
+    await publish(DigestTimeChosen({recipientId: "r1", time: at18}), ~recipientId="r1")
+    await publish(DigestTimeChosen({recipientId: "r2", time: at19Berlin}), ~recipientId="r2")
+    await settle()
+    expect((storedSchedules(), (await timers())->sorted))->toEqual((
+      [("r1", at18), ("r2", at19Berlin)],
+      ["r1", "r2"],
+    ))
+  })
+
+  testPromise("each recipient's tick comes at their own time and sends their digest", async () => {
+    // 18:00 UTC is r1's; 19:00 in Berlin is 17:00 UTC, r2's.
+    await jest->advanceTimersByTimeAsync(5. *. 3_600_000. +. 1_000.)
+    await settle()
+    expect(publishedCommands.contents->Array.map(c => c.id))->toEqual(["r2"])
+    await jest->advanceTimersByTimeAsync(3_600_000.)
+    await settle()
+    // Nothing answers r2's command here, so 18:00's pass, an hour on, sends it again.
+    expect(publishedCommands.contents->Array.map(c => c.id))->toEqual(["r2", "r2", "r1"])
+  })
+
+  testPromise("unsubscribing removes the recipient's row and timer, and only theirs", async () => {
+    await publish(Unsubscribed({recipientId: "r1"}), ~recipientId="r1")
+    await settle()
+    expect((storedSchedules(), await timers()))->toEqual(([("r2", at19Berlin)], ["r2"]))
+  })
+
+  testPromise("a later reconcile keeps the times events set", async () => {
+    let ops = await ops()
+    await ops.reconcileSchedules()
+    expect((storedSchedules(), await timers()))->toEqual(([("r2", at19Berlin)], ["r2"]))
+  })
+
+  testPromise(
+    "a rebuild reproduces the rows from the events and removes a stray timer",
+    async () => {
+      let platform = LocalAutomationSchedules.platformFor(~slice=DigestSpec.name)
+      await platform.put(~key="stray", at18)
+      let events =
+        [
+          eventJson(DigestTimeChosen({recipientId: "r1", time: at18}), ~recipientId="r1"),
+          eventJson(DigestTimeChosen({recipientId: "r3", time: at19Berlin}), ~recipientId="r3"),
+          eventJson(Unsubscribed({recipientId: "r1"}), ~recipientId="r1"),
+        ]->Array.map(((_, json)) => json)
+      let ops = await ops()
+      await ops.rebuildSchedules(events)
+      expect((storedSchedules(), (await timers())->sorted))->toEqual(([("r3", at19Berlin)], ["r3"]))
+    },
+  )
+})

package/tests/components/automationslice/AutomationRescheduleTest.res.mjs

@@ -0,0 +1,177 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Globals from "@jest/globals";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../../src/test/TestRunner.res.mjs";
+import * as LocalAutomationSchedules$ReventlessLocal from "../../../src/components/LocalAutomationSchedules.res.mjs";
+import * as AutomationRescheduleFixtures$ReventlessLocal from "./AutomationRescheduleFixtures.res.mjs";
+
+function time(iso) {
+  return new Date(iso).getTime();
+}
+
+let at18 = {
+  TAG: "Calendar",
+  calendar: {
+    TAG: "Daily",
+    hour: 18,
+    minute: 0
+  }
+};
+
+let at19Berlin = {
+  TAG: "Calendar",
+  calendar: {
+    TAG: "Daily",
+    hour: 19,
+    minute: 0
+  },
+  zone: "Europe/Berlin"
+};
+
+async function settle() {
+  for (let _for = 1; _for <= 20; ++_for) {
+    await Globals.jest.advanceTimersByTimeAsync(0);
+  }
+}
+
+function sorted(keys) {
+  return keys.toSorted(Primitive_string.compare);
+}
+
+globalThis.describe("schedules set by events, locally", () => {
+  let slice = {
+    contents: undefined
+  };
+  let ops = async () => await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(Stdlib_Option.getOrThrow(slice.contents, undefined)));
+  globalThis.beforeAll(async () => {
+    Globals.jest.useFakeTimers();
+    Globals.jest.setSystemTime(new Date("2026-10-16T12:00:00Z").getTime());
+    slice.contents = Primitive_option.some(AutomationRescheduleFixtures$ReventlessLocal.makeSlice());
+    await ops();
+    return await settle();
+  });
+  globalThis.afterAll(() => {
+    LocalAutomationSchedules$ReventlessLocal.reset();
+    Globals.jest.useRealTimers();
+  });
+  globalThis.test("a choice is stored and starts the recipient's timer", async () => {
+    await AutomationRescheduleFixtures$ReventlessLocal.publish({
+      TAG: "DigestTimeChosen",
+      recipientId: "r1",
+      time: at18
+    }, "r1");
+    await AutomationRescheduleFixtures$ReventlessLocal.publish({
+      TAG: "DigestTimeChosen",
+      recipientId: "r2",
+      time: at19Berlin
+    }, "r2");
+    await settle();
+    globalThis.expect([
+      AutomationRescheduleFixtures$ReventlessLocal.storedSchedules(),
+      sorted(await AutomationRescheduleFixtures$ReventlessLocal.timers())
+    ]).toEqual([
+      [
+        [
+          "r1",
+          at18
+        ],
+        [
+          "r2",
+          at19Berlin
+        ]
+      ],
+      [
+        "r1",
+        "r2"
+      ]
+    ]);
+  });
+  globalThis.test("each recipient's tick comes at their own time and sends their digest", async () => {
+    await Globals.jest.advanceTimersByTimeAsync(5 * 3600000 + 1000);
+    await settle();
+    globalThis.expect(AutomationRescheduleFixtures$ReventlessLocal.publishedCommands.contents.map(c => c.id)).toEqual(["r2"]);
+    await Globals.jest.advanceTimersByTimeAsync(3600000);
+    await settle();
+    globalThis.expect(AutomationRescheduleFixtures$ReventlessLocal.publishedCommands.contents.map(c => c.id)).toEqual([
+      "r2",
+      "r2",
+      "r1"
+    ]);
+  });
+  globalThis.test("unsubscribing removes the recipient's row and timer, and only theirs", async () => {
+    await AutomationRescheduleFixtures$ReventlessLocal.publish({
+      TAG: "Unsubscribed",
+      recipientId: "r1"
+    }, "r1");
+    await settle();
+    globalThis.expect([
+      AutomationRescheduleFixtures$ReventlessLocal.storedSchedules(),
+      await AutomationRescheduleFixtures$ReventlessLocal.timers()
+    ]).toEqual([
+      [[
+          "r2",
+          at19Berlin
+        ]],
+      ["r2"]
+    ]);
+  });
+  globalThis.test("a later reconcile keeps the times events set", async () => {
+    let ops$1 = await ops();
+    await ops$1.reconcileSchedules();
+    globalThis.expect([
+      AutomationRescheduleFixtures$ReventlessLocal.storedSchedules(),
+      await AutomationRescheduleFixtures$ReventlessLocal.timers()
+    ]).toEqual([
+      [[
+          "r2",
+          at19Berlin
+        ]],
+      ["r2"]
+    ]);
+  });
+  globalThis.test("a rebuild reproduces the rows from the events and removes a stray timer", async () => {
+    let platform = LocalAutomationSchedules$ReventlessLocal.platformFor(AutomationRescheduleFixtures$ReventlessLocal.DigestSpec.name);
+    await platform.put("stray", at18);
+    let events = [
+      AutomationRescheduleFixtures$ReventlessLocal.eventJson({
+        TAG: "DigestTimeChosen",
+        recipientId: "r1",
+        time: at18
+      }, "r1"),
+      AutomationRescheduleFixtures$ReventlessLocal.eventJson({
+        TAG: "DigestTimeChosen",
+        recipientId: "r3",
+        time: at19Berlin
+      }, "r3"),
+      AutomationRescheduleFixtures$ReventlessLocal.eventJson({
+        TAG: "Unsubscribed",
+        recipientId: "r1"
+      }, "r1")
+    ].map(param => param[1]);
+    let ops$1 = await ops();
+    await ops$1.rebuildSchedules(events);
+    globalThis.expect([
+      AutomationRescheduleFixtures$ReventlessLocal.storedSchedules(),
+      sorted(await AutomationRescheduleFixtures$ReventlessLocal.timers())
+    ]).toEqual([
+      [[
+          "r3",
+          at19Berlin
+        ]],
+      ["r3"]
+    ]);
+  });
+});
+
+export {
+  time,
+  at18,
+  at19Berlin,
+  settle,
+  sorted,
+}
+/*  Not a pure module */