@reventlessdev/reventless-core 3.0.0-alpha.294 → 3.0.0-alpha.296

package/tests/util/ScheduleTimeTest.res.mjs

@@ -0,0 +1,532 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Cron from "effect/Cron";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as ScheduleTime$ReventlessCore from "../../src/util/ScheduleTime.res.mjs";
+
+function at(iso) {
+  return new Date(iso).getTime();
+}
+
+function iso(millis) {
+  return new Date(millis).toISOString();
+}
+
+function firings(time, from, n) {
+  let out = [];
+  let loop = _after => {
+    while (true) {
+      let after = _after;
+      let next = out.length < n ? ScheduleTime$ReventlessCore.nextFiring(time, after) : undefined;
+      if (next === undefined) {
+        return;
+      }
+      out.push(new Date(next).toISOString());
+      _after = next;
+      continue;
+    };
+  };
+  loop(new Date(from).getTime());
+  return out;
+}
+
+globalThis.describe("ScheduleTime.nextFiring", () => {
+  globalThis.test("Every counts from the previous firing, with no zone", () => {
+    globalThis.expect(firings({
+      TAG: "Every",
+      _0: {
+        TAG: "Hours",
+        _0: 2
+      }
+    }, "2026-03-29T00:30:00Z", 2)).toEqual([
+      "2026-03-29T02:30:00.000Z",
+      "2026-03-29T04:30:00.000Z"
+    ]);
+  });
+  globalThis.test("Daily is a wall-clock time in its zone, across both daylight-saving changes", () => {
+    let daily = {
+      TAG: "Calendar",
+      calendar: {
+        TAG: "Daily",
+        hour: 6,
+        minute: 0
+      },
+      zone: "Europe/Berlin"
+    };
+    globalThis.expect(firings(daily, "2026-03-28T12:00:00Z", 2)).toEqual([
+      "2026-03-29T04:00:00.000Z",
+      "2026-03-30T04:00:00.000Z"
+    ]);
+    globalThis.expect(firings(daily, "2026-10-24T12:00:00Z", 2)).toEqual([
+      "2026-10-25T05:00:00.000Z",
+      "2026-10-26T05:00:00.000Z"
+    ]);
+  });
+  globalThis.test("a time in the skipped hour does not fire that day; in the repeated hour, once", () => {
+    let night = {
+      TAG: "Calendar",
+      calendar: {
+        TAG: "Daily",
+        hour: 2,
+        minute: 30
+      },
+      zone: "Europe/Berlin"
+    };
+    globalThis.expect(firings(night, "2026-03-27T12:00:00Z", 2)).toEqual([
+      "2026-03-28T01:30:00.000Z",
+      "2026-03-30T00:30:00.000Z"
+    ]);
+    globalThis.expect(firings(night, "2026-10-24T12:00:00Z", 2)).toEqual([
+      "2026-10-25T00:30:00.000Z",
+      "2026-10-26T01:30:00.000Z"
+    ]);
+  });
+  globalThis.test("Weekly fires on its days only", () => {
+    let weekdays_0 = {
+      TAG: "Weekly",
+      days: [
+        "Mon",
+        "Fri"
+      ],
+      hour: 7,
+      minute: 30
+    };
+    let weekdays = {
+      TAG: "Calendar",
+      calendar: weekdays_0
+    };
+    globalThis.expect(firings(weekdays, "2026-10-16T08:00:00Z", 3)).toEqual([
+      "2026-10-19T07:30:00.000Z",
+      "2026-10-23T07:30:00.000Z",
+      "2026-10-26T07:30:00.000Z"
+    ]);
+  });
+  globalThis.test("Monthly on the 29th to 31st skips the months without that day", () => {
+    globalThis.expect(firings({
+      TAG: "Calendar",
+      calendar: {
+        TAG: "Monthly",
+        day: 29,
+        hour: 6,
+        minute: 0
+      }
+    }, "2027-01-30T00:00:00Z", 1)).toEqual(["2027-03-29T06:00:00.000Z"]);
+    globalThis.expect(firings({
+      TAG: "Calendar",
+      calendar: {
+        TAG: "Monthly",
+        day: 30,
+        hour: 6,
+        minute: 0
+      }
+    }, "2027-01-31T00:00:00Z", 1)).toEqual(["2027-03-30T06:00:00.000Z"]);
+    globalThis.expect(firings({
+      TAG: "Calendar",
+      calendar: {
+        TAG: "Monthly",
+        day: 31,
+        hour: 6,
+        minute: 0
+      }
+    }, "2026-04-01T00:00:00Z", 2)).toEqual([
+      "2026-05-31T06:00:00.000Z",
+      "2026-07-31T06:00:00.000Z"
+    ]);
+  });
+  globalThis.test("Monthly with every fires every so many months, from January", () => {
+    globalThis.expect(firings({
+      TAG: "Calendar",
+      calendar: {
+        TAG: "Monthly",
+        day: 1,
+        hour: 6,
+        minute: 0,
+        every: 3
+      }
+    }, "2026-02-15T00:00:00Z", 4)).toEqual([
+      "2026-04-01T06:00:00.000Z",
+      "2026-07-01T06:00:00.000Z",
+      "2026-10-01T06:00:00.000Z",
+      "2027-01-01T06:00:00.000Z"
+    ]);
+  });
+  globalThis.test("Yearly on 29 February fires in leap years", () => {
+    globalThis.expect(firings({
+      TAG: "Calendar",
+      calendar: {
+        TAG: "Yearly",
+        month: 2,
+        day: 29,
+        hour: 6,
+        minute: 0
+      }
+    }, "2026-01-01T00:00:00Z", 2)).toEqual([
+      "2028-02-29T06:00:00.000Z",
+      "2032-02-29T06:00:00.000Z"
+    ]);
+  });
+  globalThis.test("Once at a local time fires once, read in its zone; once past, never", () => {
+    let newYear = {
+      TAG: "Once",
+      moment: {
+        TAG: "At",
+        _0: {
+          year: 2026,
+          month: 12,
+          day: 31,
+          hour: 23,
+          minute: 59
+        }
+      },
+      zone: "Europe/Berlin"
+    };
+    globalThis.expect(firings(newYear, "2026-10-16T00:00:00Z", 3)).toEqual(["2026-12-31T22:59:00.000Z"]);
+    globalThis.expect(firings(newYear, "2027-01-01T00:00:00Z", 1)).toEqual([]);
+  });
+});
+
+globalThis.describe("ScheduleTime.resolveOnce", () => {
+  let resolved = (period, from, zoneOpt) => {
+    let zone = zoneOpt !== undefined ? zoneOpt : "UTC";
+    let match = ScheduleTime$ReventlessCore.resolveOnce({
+      TAG: "Once",
+      moment: {
+        TAG: "After",
+        _0: period
+      },
+      zone: zone
+    }, new Date(from).getTime());
+    switch (match.TAG) {
+      case "Every" :
+      case "Calendar" :
+        return;
+      case "Once" :
+        let localTime = match.moment;
+        if (localTime.TAG === "At") {
+          return localTime._0;
+        } else {
+          return;
+        }
+    }
+  };
+  globalThis.test("a month from 31 January is the last day of February", () => {
+    globalThis.expect(resolved({
+      TAG: "Months",
+      _0: 1
+    }, "2026-01-31T09:00:00Z", undefined)).toEqual({
+      year: 2026,
+      month: 2,
+      day: 28,
+      hour: 9,
+      minute: 0
+    });
+  });
+  globalThis.test("a day keeps the wall-clock time across a daylight-saving change", () => {
+    globalThis.expect(resolved({
+      TAG: "Days",
+      _0: 1
+    }, "2026-03-28T05:00:00Z", "Europe/Berlin")).toEqual({
+      year: 2026,
+      month: 3,
+      day: 29,
+      hour: 6,
+      minute: 0
+    });
+  });
+  globalThis.test("24 hours are elapsed time across the same change", () => {
+    globalThis.expect(resolved({
+      TAG: "Hours",
+      _0: 24
+    }, "2026-03-28T05:00:00Z", "Europe/Berlin")).toEqual({
+      year: 2026,
+      month: 3,
+      day: 29,
+      hour: 7,
+      minute: 0
+    });
+  });
+  globalThis.test("minutes are counted from the moment it is set, to the minute", () => {
+    globalThis.expect(resolved({
+      TAG: "Minutes",
+      _0: 10
+    }, "2026-10-15T14:02:37Z", undefined)).toEqual({
+      year: 2026,
+      month: 10,
+      day: 15,
+      hour: 14,
+      minute: 12
+    });
+  });
+});
+
+globalThis.describe("ScheduleTime.toAws", () => {
+  let setAt = new Date("2026-10-15T14:02:00Z").getTime();
+  globalThis.test("an interval is a rate, starting one interval later", () => {
+    let aws = ScheduleTime$ReventlessCore.toAws({
+      TAG: "Every",
+      _0: {
+        TAG: "Weeks",
+        _0: 2
+      }
+    }, setAt);
+    globalThis.expect(aws.expression).toBe("rate(14 days)");
+    globalThis.expect(aws.startDate).toEqual(setAt + 14 * 24 * 60 * 60000);
+    globalThis.expect(aws.timezone).toEqual(undefined);
+    globalThis.expect(ScheduleTime$ReventlessCore.toAws({
+      TAG: "Every",
+      _0: {
+        TAG: "Minutes",
+        _0: 1
+      }
+    }, setAt).expression).toBe("rate(1 minute)");
+  });
+  globalThis.test("a calendar time is a cron with its zone, UTC when it has none", () => {
+    let daily = ScheduleTime$ReventlessCore.toAws({
+      TAG: "Calendar",
+      calendar: {
+        TAG: "Daily",
+        hour: 6,
+        minute: 0
+      }
+    }, setAt);
+    globalThis.expect(daily.expression).toBe("cron(0 6 * * ? *)");
+    globalThis.expect(daily.timezone).toEqual("UTC");
+    let weekly = ScheduleTime$ReventlessCore.toAws({
+      TAG: "Calendar",
+      calendar: {
+        TAG: "Weekly",
+        days: [
+          "Mon",
+          "Tue",
+          "Wed",
+          "Thu",
+          "Fri"
+        ],
+        hour: 7,
+        minute: 30
+      },
+      zone: "Europe/Berlin"
+    }, setAt);
+    globalThis.expect(weekly.expression).toBe("cron(30 7 ? * MON,TUE,WED,THU,FRI *)");
+    globalThis.expect(weekly.timezone).toEqual("Europe/Berlin");
+    globalThis.expect(ScheduleTime$ReventlessCore.toAws({
+      TAG: "Calendar",
+      calendar: {
+        TAG: "Monthly",
+        day: 1,
+        hour: 6,
+        minute: 0,
+        every: 3
+      }
+    }, setAt).expression).toBe("cron(0 6 1 1/3 ? *)");
+    globalThis.expect(ScheduleTime$ReventlessCore.toAws({
+      TAG: "Calendar",
+      calendar: {
+        TAG: "Yearly",
+        month: 12,
+        day: 24,
+        hour: 18,
+        minute: 0
+      }
+    }, setAt).expression).toBe("cron(0 18 24 12 ? *)");
+  });
+  globalThis.test("a once-only time is an at in its zone, deleted after it fires", () => {
+    let aws = ScheduleTime$ReventlessCore.toAws({
+      TAG: "Once",
+      moment: {
+        TAG: "After",
+        _0: {
+          TAG: "Days",
+          _0: 3
+        }
+      },
+      zone: "Europe/Berlin"
+    }, setAt);
+    globalThis.expect(aws.expression).toBe("at(2026-10-18T16:02:00)");
+    globalThis.expect(aws.timezone).toEqual("Europe/Berlin");
+    globalThis.expect(aws.deleteAfterCompletion).toBe(true);
+  });
+});
+
+globalThis.describe("the two platforms agree", () => {
+  let fromAws = (calendar, zone) => {
+    let fields = ScheduleTime$ReventlessCore.cronExpressionOf(calendar).slice(5, -1).split(" ").map(f => {
+      if (f === "?") {
+        return "*";
+      } else {
+        return f;
+      }
+    });
+    let expression = fields.slice(0, 5).join(" ");
+    let tz = ScheduleTime$ReventlessCore.zoneOrThrow(zone);
+    let match = ScheduleTime$ReventlessCore.wallClockOf(calendar);
+    let minute = match[1];
+    let hour = match[0];
+    let cron = Cron.unsafeParse(expression, tz);
+    let out = [];
+    let loop = _after => {
+      while (true) {
+        let after = _after;
+        if (out.length >= 10) {
+          return;
+        }
+        let next = ScheduleTime$ReventlessCore.nextOnWallClock(cron, after, hour, minute, tz);
+        out.push(new Date(next).toISOString());
+        _after = next;
+        continue;
+      };
+    };
+    loop(new Date("2026-01-01T00:00:00Z").getTime());
+    return out;
+  };
+  let cases = [
+    [
+      "daily",
+      {
+        TAG: "Daily",
+        hour: 6,
+        minute: 0
+      },
+      "UTC"
+    ],
+    [
+      "daily in the skipped hour",
+      {
+        TAG: "Daily",
+        hour: 2,
+        minute: 30
+      },
+      "Europe/Berlin"
+    ],
+    [
+      "weekdays",
+      {
+        TAG: "Weekly",
+        days: [
+          "Mon",
+          "Tue",
+          "Wed",
+          "Thu",
+          "Fri"
+        ],
+        hour: 7,
+        minute: 30
+      },
+      "America/New_York"
+    ],
+    [
+      "weekends",
+      {
+        TAG: "Weekly",
+        days: [
+          "Sat",
+          "Sun"
+        ],
+        hour: 23,
+        minute: 59
+      },
+      "Australia/Sydney"
+    ],
+    [
+      "monthly on the 31st",
+      {
+        TAG: "Monthly",
+        day: 31,
+        hour: 6,
+        minute: 0
+      },
+      "Europe/Berlin"
+    ],
+    [
+      "quarterly",
+      {
+        TAG: "Monthly",
+        day: 15,
+        hour: 9,
+        minute: 15,
+        every: 3
+      },
+      "Asia/Kolkata"
+    ],
+    [
+      "every five months",
+      {
+        TAG: "Monthly",
+        day: 1,
+        hour: 0,
+        minute: 0,
+        every: 5
+      },
+      "UTC"
+    ],
+    [
+      "yearly",
+      {
+        TAG: "Yearly",
+        month: 3,
+        day: 29,
+        hour: 2,
+        minute: 30
+      },
+      "Europe/London"
+    ]
+  ];
+  cases.forEach(param => {
+    let zone = param[2];
+    let calendar = param[1];
+    globalThis.test(param[0], () => {
+      globalThis.expect(fromAws(calendar, zone)).toEqual(firings({
+        TAG: "Calendar",
+        calendar: calendar,
+        zone: zone
+      }, "2026-01-01T00:00:00Z", 10));
+    });
+  });
+});
+
+globalThis.describe("ScheduleTime.validate", () => {
+  globalThis.test("names every problem of a time", () => {
+    let message;
+    try {
+      ScheduleTime$ReventlessCore.validate({
+        TAG: "Calendar",
+        calendar: {
+          TAG: "Weekly",
+          days: [],
+          hour: 24,
+          minute: 0
+        },
+        zone: "Mars/Base"
+      });
+      message = "";
+    } catch (raw_message) {
+      let message$1 = Primitive_exceptions.internalToException(raw_message);
+      if (message$1.RE_EXN_ID === ScheduleTime$ReventlessCore.InvalidTime) {
+        message = message$1._1;
+      } else {
+        throw message$1;
+      }
+    }
+    globalThis.expect(message).toBe(`unknown time zone "Mars/Base"; a weekly time needs at least one day; hour must be 0 to 23, got 24`);
+  });
+  globalThis.test("accepts a time that can fire", () => {
+    globalThis.expect(ScheduleTime$ReventlessCore.errors({
+      TAG: "Once",
+      moment: {
+        TAG: "After",
+        _0: {
+          TAG: "Years",
+          _0: 1
+        }
+      },
+      zone: "Pacific/Auckland"
+    })).toEqual([]);
+  });
+});
+
+export {
+  at,
+  iso,
+  firings,
+}
+/*  Not a pure module */