@oneuptime/common 12.0.29 → 12.0.31

package/Tests/Types/OnCallDutyPolicy/CalendarFeedTestFixtures.ts

@@ -0,0 +1,310 @@
+import moment from "moment-timezone";
+import User from "../../../Models/DatabaseModels/User";
+import OneUptimeDate from "../../../Types/Date";
+import EventInterval from "../../../Types/Events/EventInterval";
+import Recurring from "../../../Types/Events/Recurring";
+import MaterializedShiftUtil, {
+  MaterializedShift,
+  MaterializedShiftPolicy,
+} from "../../../Types/OnCallDutyPolicy/MaterializedShift";
+import RestrictionTimes, {
+  RestrictionType,
+  WeeklyResctriction,
+} from "../../../Types/OnCallDutyPolicy/RestrictionTimes";
+import { OnCallShift } from "../../../Types/OnCallDutyPolicy/ScheduleShiftUtil";
+
+/*
+ * Shared fixtures for the on-call calendar feed suites. Everything is built
+ * from explicit IANA zones and fixed ISO instants (the tzInstant / hhmm idiom
+ * from LayerUtilTimezone.test.ts) so the results do not depend on the zone
+ * the test process happens to run in.
+ */
+
+export function user(id: string): User {
+  return {
+    id: {
+      toString: (): string => {
+        return id;
+      },
+    } as any,
+  } as User;
+}
+
+export function rotation(
+  intervalType: EventInterval,
+  intervalCount: number,
+): Recurring {
+  return Recurring.fromJSON({
+    _type: "Recurring",
+    value: {
+      intervalType: intervalType,
+      intervalCount: { _type: "PositiveNumber", value: intervalCount },
+    },
+  } as any);
+}
+
+export function noRestriction(): RestrictionTimes {
+  const restrictionTimes: RestrictionTimes = new RestrictionTimes();
+  restrictionTimes.restictionType = RestrictionType.None;
+  restrictionTimes.dayRestrictionTimes = null;
+  return restrictionTimes;
+}
+
+// An absolute instant that is `iso` ("YYYY-MM-DD HH:mm") wall-clock in `tz`.
+export function tzInstant(iso: string, tz: string): Date {
+  return moment.tz(iso, tz).toDate();
+}
+
+// Wall-clock "HH:mm" of an instant AS SEEN IN `tz`.
+export function hhmm(date: Date, tz: string): string {
+  return moment.tz(date, tz).format("HH:mm");
+}
+
+export function at(iso: string): Date {
+  return OneUptimeDate.fromString(iso);
+}
+
+/*
+ * Daily HH:mm-HH:mm restriction authored in `tz`. LayerUtil only reads the
+ * wall-clock time of the two instants (keepTimeButMoveDay), so the date part
+ * is irrelevant.
+ */
+export function dailyRestriction(
+  startHHmm: string,
+  endHHmm: string,
+  tz: string,
+): RestrictionTimes {
+  const restrictionTimes: RestrictionTimes = new RestrictionTimes();
+  restrictionTimes.restictionType = RestrictionType.Daily;
+  restrictionTimes.dayRestrictionTimes = {
+    startTime: tzInstant(`2026-01-05 ${startHHmm}`, tz),
+    endTime: tzInstant(`2026-01-05 ${endHHmm}`, tz),
+  };
+  return restrictionTimes;
+}
+
+/*
+ * Office hours, Mon-Fri 09:00-17:00 in `tz`, authored as five weekday windows
+ * on the week of Monday 2026-01-05. The engine derives the enforced weekday
+ * from each instant's weekday in `tz`.
+ */
+export function businessHoursRestriction(tz: string): RestrictionTimes {
+  const restrictionTimes: RestrictionTimes = new RestrictionTimes();
+  restrictionTimes.restictionType = RestrictionType.Weekly;
+  restrictionTimes.weeklyRestrictionTimes = [
+    "2026-01-05",
+    "2026-01-06",
+    "2026-01-07",
+    "2026-01-08",
+    "2026-01-09",
+  ].map((day: string): WeeklyResctriction => {
+    const startTime: Date = tzInstant(`${day} 09:00`, tz);
+    const endTime: Date = tzInstant(`${day} 17:00`, tz);
+    return {
+      startDay: OneUptimeDate.getDayOfWeek(startTime, tz),
+      endDay: OneUptimeDate.getDayOfWeek(endTime, tz),
+      startTime,
+      endTime,
+    };
+  });
+  return restrictionTimes;
+}
+
+export const DEFAULT_POLICY: MaterializedShiftPolicy = {
+  policyId: "pol-1",
+  policyName: "Payments Policy",
+  ruleId: "rule-1",
+  ruleName: "Primary",
+  ruleOrder: 1,
+};
+
+export const DEFAULT_LAST_MODIFIED: Date = at("2026-08-01T10:00:00Z");
+
+export const DASHBOARD_URL: string = "https://oneuptime.example.com/dashboard";
+
+export type ShiftOverrides = Omit<
+  Partial<MaterializedShift>,
+  "scheduleTimezone"
+> & {
+  start: Date;
+  end: Date;
+  // Pass an explicit undefined to build a legacy shift with no timezone.
+  scheduleTimezone?: string | undefined;
+};
+
+/*
+ * A MaterializedShift with sensible defaults: Alice on the "Payments"
+ * schedule (Europe/Stockholm) attached to one policy. Optional fields are only
+ * added when the caller supplies them, so key presence matches what the
+ * materializer would produce.
+ */
+export function shift(overrides: ShiftOverrides): MaterializedShift {
+  const scheduleId: string = overrides.scheduleId ?? "sched-1";
+  const policyVariantOf: MaterializedShift["policyVariantOf"] =
+    overrides.policyVariantOf;
+
+  const base: MaterializedShift = {
+    shiftKey:
+      overrides.shiftKey ??
+      MaterializedShiftUtil.buildShiftKey({
+        scheduleId,
+        start: overrides.start,
+        policyId: policyVariantOf?.policyId,
+      }),
+    contentHash: overrides.contentHash ?? "hash",
+    projectId: overrides.projectId ?? "proj-1",
+    scheduleId,
+    scheduleName: overrides.scheduleName ?? "Payments",
+    userId: overrides.userId ?? "user-a",
+    userName: overrides.userName ?? "Alice Andersson",
+    start: overrides.start,
+    end: overrides.end,
+    coverageSeconds:
+      overrides.coverageSeconds ??
+      Math.round((overrides.end.getTime() - overrides.start.getTime()) / 1000),
+    policies: overrides.policies ?? [{ ...DEFAULT_POLICY }],
+    isPast: overrides.isPast ?? false,
+    lastModifiedAt: overrides.lastModifiedAt ?? DEFAULT_LAST_MODIFIED,
+    shiftConfigVersion: overrides.shiftConfigVersion ?? 3,
+  };
+
+  if ("scheduleTimezone" in overrides) {
+    if (overrides.scheduleTimezone !== undefined) {
+      base.scheduleTimezone = overrides.scheduleTimezone;
+    }
+  } else {
+    base.scheduleTimezone = "Europe/Stockholm";
+  }
+
+  if (overrides.projectName !== undefined) {
+    base.projectName = overrides.projectName;
+  }
+
+  if (overrides.layerId !== undefined) {
+    base.layerId = overrides.layerId;
+  }
+
+  if (overrides.layerName !== undefined) {
+    base.layerName = overrides.layerName;
+  }
+
+  if (overrides.override !== undefined) {
+    base.override = overrides.override;
+  }
+
+  if (policyVariantOf !== undefined) {
+    base.policyVariantOf = policyVariantOf;
+  }
+
+  return base;
+}
+
+// Turn engine-derived OnCallShifts into MaterializedShifts on one schedule.
+export function materialize(
+  shifts: Array<OnCallShift>,
+  overrides?: Partial<MaterializedShift> | undefined,
+): Array<MaterializedShift> {
+  return shifts.map((onCallShift: OnCallShift) => {
+    const extra: Partial<MaterializedShift> = { ...(overrides ?? {}) };
+
+    if (onCallShift.override) {
+      extra.override = {
+        originalUserId: onCallShift.override.originalUserId,
+        originalUserName: `Name of ${onCallShift.override.originalUserId}`,
+        overrideStartsAt: onCallShift.override.overrideStartsAt,
+        overrideEndsAt: onCallShift.override.overrideEndsAt,
+      };
+    }
+
+    if (onCallShift.layerId !== undefined) {
+      extra.layerId = onCallShift.layerId;
+    }
+
+    if (onCallShift.layerName !== undefined) {
+      extra.layerName = onCallShift.layerName;
+    }
+
+    return shift({
+      ...extra,
+      start: onCallShift.start,
+      end: onCallShift.end,
+      userId: onCallShift.userId,
+      userName: `Name of ${onCallShift.userId}`,
+      coverageSeconds: onCallShift.coverageSeconds,
+    });
+  });
+}
+
+// Physical lines of a serialized calendar (CRLF separated, no folding undone).
+export function physicalLines(body: string): Array<string> {
+  const lines: Array<string> = body.split("\r\n");
+  // A well-formed body ends with CRLF, leaving one empty trailing element.
+  if (lines[lines.length - 1] === "") {
+    lines.pop();
+  }
+  return lines;
+}
+
+// Logical (unfolded) lines of a serialized calendar.
+export function logicalLines(body: string): Array<string> {
+  return physicalLines(body.replace(/\r\n[ \t]/g, ""));
+}
+
+// The value of the first logical line starting with `NAME:` / `NAME;`.
+export function property(body: string, name: string): string | undefined {
+  const line: string | undefined = logicalLines(body).find((entry: string) => {
+    return entry.startsWith(`${name}:`) || entry.startsWith(`${name};`);
+  });
+
+  if (line === undefined) {
+    return undefined;
+  }
+
+  return line.slice(line.indexOf(":") + 1);
+}
+
+// Every value of a repeated property (e.g. every UID in the body).
+export function properties(body: string, name: string): Array<string> {
+  return logicalLines(body)
+    .filter((entry: string) => {
+      return entry.startsWith(`${name}:`) || entry.startsWith(`${name};`);
+    })
+    .map((entry: string) => {
+      return entry.slice(entry.indexOf(":") + 1);
+    });
+}
+
+// The logical lines of each VEVENT block, in document order.
+export function eventBlocks(body: string): Array<Array<string>> {
+  const blocks: Array<Array<string>> = [];
+  let current: Array<string> | null = null;
+
+  for (const line of logicalLines(body)) {
+    if (line === "BEGIN:VEVENT") {
+      current = [];
+      continue;
+    }
+    if (line === "END:VEVENT") {
+      if (current) {
+        blocks.push(current);
+      }
+      current = null;
+      continue;
+    }
+    if (current) {
+      current.push(line);
+    }
+  }
+
+  return blocks;
+}
+
+export function blockProperty(
+  block: Array<string>,
+  name: string,
+): string | undefined {
+  const line: string | undefined = block.find((entry: string) => {
+    return entry.startsWith(`${name}:`) || entry.startsWith(`${name};`);
+  });
+  return line === undefined ? undefined : line.slice(line.indexOf(":") + 1);
+}

package/Tests/Types/OnCallDutyPolicy/CalendarFeedWindow.test.ts

@@ -0,0 +1,205 @@
+import CalendarFeedWindow, {
+  BODY_CACHE_TTL_SECONDS,
+  DEFAULT_FUTURE_DAYS,
+  DEFAULT_PAST_DAYS,
+  FEED_SIMULATION_ITERATION_CAP,
+  FeedWindow,
+  MAX_EVENTS,
+  MAX_FUTURE_DAYS,
+  MAX_GAP_EVENTS,
+  MAX_PAST_DAYS,
+  MIN_FUTURE_DAYS,
+  PREVIOUS_TOKEN_GRACE_DAYS,
+  RENDER_CONCURRENCY,
+  SCHEDULE_CACHE_TTL_SECONDS,
+} from "../../../Types/OnCallDutyPolicy/CalendarFeedWindow";
+import { at } from "./CalendarFeedTestFixtures";
+
+describe("CalendarFeedWindow constants", () => {
+  test("hold the values the design fixes", () => {
+    expect(MAX_FUTURE_DAYS).toBe(180);
+    expect(MIN_FUTURE_DAYS).toBe(7);
+    expect(DEFAULT_FUTURE_DAYS).toBe(90);
+    expect(MAX_PAST_DAYS).toBe(60);
+    expect(DEFAULT_PAST_DAYS).toBe(2);
+    expect(MAX_EVENTS).toBe(5000);
+    expect(MAX_GAP_EVENTS).toBe(100);
+    expect(PREVIOUS_TOKEN_GRACE_DAYS).toBe(30);
+    expect(BODY_CACHE_TTL_SECONDS).toBe(300);
+    expect(SCHEDULE_CACHE_TTL_SECONDS).toBe(3600);
+    expect(RENDER_CONCURRENCY).toBe(4);
+    expect(FEED_SIMULATION_ITERATION_CAP).toBe(200000);
+  });
+
+  test("are internally consistent", () => {
+    expect(MIN_FUTURE_DAYS).toBeLessThanOrEqual(DEFAULT_FUTURE_DAYS);
+    expect(DEFAULT_FUTURE_DAYS).toBeLessThanOrEqual(MAX_FUTURE_DAYS);
+    expect(DEFAULT_PAST_DAYS).toBeLessThanOrEqual(MAX_PAST_DAYS);
+    expect(MAX_GAP_EVENTS).toBeLessThan(MAX_EVENTS);
+  });
+});
+
+describe("CalendarFeedWindow.clampPastDays", () => {
+  test("keeps values inside 0..MAX_PAST_DAYS and clamps the rest", () => {
+    expect(CalendarFeedWindow.clampPastDays(0)).toBe(0);
+    expect(CalendarFeedWindow.clampPastDays(2)).toBe(2);
+    expect(CalendarFeedWindow.clampPastDays(60)).toBe(60);
+    expect(CalendarFeedWindow.clampPastDays(61)).toBe(60);
+    expect(CalendarFeedWindow.clampPastDays(999)).toBe(60);
+    expect(CalendarFeedWindow.clampPastDays(-5)).toBe(0);
+  });
+
+  test("floors fractions and parses numeric strings (as stored Number columns arrive)", () => {
+    expect(CalendarFeedWindow.clampPastDays(2.9)).toBe(2);
+    expect(CalendarFeedWindow.clampPastDays("7")).toBe(7);
+    expect(CalendarFeedWindow.clampPastDays(" 90 ")).toBe(60);
+  });
+
+  test("falls back to the default for anything that is not a number", () => {
+    expect(CalendarFeedWindow.clampPastDays(undefined)).toBe(DEFAULT_PAST_DAYS);
+    expect(CalendarFeedWindow.clampPastDays(null)).toBe(DEFAULT_PAST_DAYS);
+    expect(CalendarFeedWindow.clampPastDays(Number.NaN)).toBe(
+      DEFAULT_PAST_DAYS,
+    );
+    expect(CalendarFeedWindow.clampPastDays("abc")).toBe(DEFAULT_PAST_DAYS);
+    expect(CalendarFeedWindow.clampPastDays("")).toBe(DEFAULT_PAST_DAYS);
+    expect(CalendarFeedWindow.clampPastDays(Number.POSITIVE_INFINITY)).toBe(
+      DEFAULT_PAST_DAYS,
+    );
+    expect(CalendarFeedWindow.clampPastDays({})).toBe(DEFAULT_PAST_DAYS);
+  });
+});
+
+describe("CalendarFeedWindow.clampFutureDays", () => {
+  test("keeps values inside MIN..MAX and clamps the rest", () => {
+    expect(CalendarFeedWindow.clampFutureDays(7)).toBe(7);
+    expect(CalendarFeedWindow.clampFutureDays(90)).toBe(90);
+    expect(CalendarFeedWindow.clampFutureDays(180)).toBe(180);
+    expect(CalendarFeedWindow.clampFutureDays(181)).toBe(180);
+    expect(CalendarFeedWindow.clampFutureDays(6)).toBe(7);
+    expect(CalendarFeedWindow.clampFutureDays(0)).toBe(7);
+    expect(CalendarFeedWindow.clampFutureDays(-1)).toBe(7);
+  });
+
+  test("falls back to the default for anything that is not a number", () => {
+    expect(CalendarFeedWindow.clampFutureDays(undefined)).toBe(
+      DEFAULT_FUTURE_DAYS,
+    );
+    expect(CalendarFeedWindow.clampFutureDays(null)).toBe(DEFAULT_FUTURE_DAYS);
+    expect(CalendarFeedWindow.clampFutureDays("x")).toBe(DEFAULT_FUTURE_DAYS);
+    expect(CalendarFeedWindow.clampFutureDays("30")).toBe(30);
+  });
+});
+
+describe("CalendarFeedWindow.computeFeedWindow", () => {
+  test("puts both edges on UTC midnights around a mid-day instant", () => {
+    const window: FeedWindow = CalendarFeedWindow.computeFeedWindow({
+      now: at("2026-08-31T14:37:12Z"),
+      pastDays: 2,
+      futureDays: 90,
+    });
+
+    expect(window.feedStart.toISOString()).toBe("2026-08-29T00:00:00.000Z");
+    // 90 days ahead is 2026-11-29; the exclusive end is the following midnight.
+    expect(window.feedEnd.toISOString()).toBe("2026-11-30T00:00:00.000Z");
+  });
+
+  test("is identical for every instant inside the same UTC day", () => {
+    const first: FeedWindow = CalendarFeedWindow.computeFeedWindow({
+      now: at("2026-08-31T00:00:00Z"),
+      pastDays: 2,
+      futureDays: 30,
+    });
+    const last: FeedWindow = CalendarFeedWindow.computeFeedWindow({
+      now: at("2026-08-31T23:59:59.999Z"),
+      pastDays: 2,
+      futureDays: 30,
+    });
+
+    expect(first.feedStart.getTime()).toBe(last.feedStart.getTime());
+    expect(first.feedEnd.getTime()).toBe(last.feedEnd.getTime());
+  });
+
+  test("changes at the UTC day boundary, not the local one", () => {
+    const before: FeedWindow = CalendarFeedWindow.computeFeedWindow({
+      now: at("2026-08-31T23:59:59Z"),
+      pastDays: 0,
+      futureDays: 7,
+    });
+    const after: FeedWindow = CalendarFeedWindow.computeFeedWindow({
+      now: at("2026-09-01T00:00:00Z"),
+      pastDays: 0,
+      futureDays: 7,
+    });
+
+    expect(before.feedStart.toISOString()).toBe("2026-08-31T00:00:00.000Z");
+    expect(after.feedStart.toISOString()).toBe("2026-09-01T00:00:00.000Z");
+    expect(after.feedEnd.getTime() - before.feedEnd.getTime()).toBe(
+      24 * 3600 * 1000,
+    );
+  });
+
+  test("clamps the day counts before applying them", () => {
+    const window: FeedWindow = CalendarFeedWindow.computeFeedWindow({
+      now: at("2026-08-31T12:00:00Z"),
+      pastDays: 500,
+      futureDays: 1,
+    });
+
+    expect(window.feedStart.toISOString()).toBe("2026-07-02T00:00:00.000Z"); // 60 days back
+    expect(window.feedEnd.toISOString()).toBe("2026-09-08T00:00:00.000Z"); // MIN 7 days + 1
+  });
+
+  test("pastDays 0 starts today; the window always spans at least MIN_FUTURE_DAYS + 1 days", () => {
+    const window: FeedWindow = CalendarFeedWindow.computeFeedWindow({
+      now: at("2026-02-28T09:00:00Z"),
+      pastDays: 0,
+      futureDays: 7,
+    });
+
+    expect(window.feedStart.toISOString()).toBe("2026-02-28T00:00:00.000Z");
+    expect(window.feedEnd.toISOString()).toBe("2026-03-08T00:00:00.000Z");
+    expect(
+      (window.feedEnd.getTime() - window.feedStart.getTime()) / 86400000,
+    ).toBe(8);
+  });
+
+  test("survives leap days and year boundaries", () => {
+    const window: FeedWindow = CalendarFeedWindow.computeFeedWindow({
+      now: at("2028-02-29T12:00:00Z"),
+      pastDays: 1,
+      futureDays: 7,
+    });
+
+    expect(window.feedStart.toISOString()).toBe("2028-02-28T00:00:00.000Z");
+    expect(window.feedEnd.toISOString()).toBe("2028-03-08T00:00:00.000Z");
+
+    const newYear: FeedWindow = CalendarFeedWindow.computeFeedWindow({
+      now: at("2026-12-31T23:00:00Z"),
+      pastDays: 2,
+      futureDays: 7,
+    });
+
+    expect(newYear.feedStart.toISOString()).toBe("2026-12-29T00:00:00.000Z");
+    expect(newYear.feedEnd.toISOString()).toBe("2027-01-08T00:00:00.000Z");
+  });
+});
+
+describe("CalendarFeedWindow.startOfUtcDay / getUtcDayBucket", () => {
+  test("startOfUtcDay truncates to 00:00:00.000 UTC", () => {
+    expect(
+      new Date(
+        CalendarFeedWindow.startOfUtcDay(at("2026-08-31T23:59:59.999Z")),
+      ).toISOString(),
+    ).toBe("2026-08-31T00:00:00.000Z");
+  });
+
+  test("getUtcDayBucket is the UTC calendar date", () => {
+    expect(CalendarFeedWindow.getUtcDayBucket(at("2026-08-31T23:59:59Z"))).toBe(
+      "2026-08-31",
+    );
+    expect(CalendarFeedWindow.getUtcDayBucket(at("2026-09-01T00:00:00Z"))).toBe(
+      "2026-09-01",
+    );
+  });
+});