@oneuptime/common 11.3.26 → 11.4.0

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

@@ -0,0 +1,260 @@
+import CalendarEvent from "../../../Types/Calendar/CalendarEvent";
+import OneUptimeDate from "../../../Types/Date";
+import ScheduleShiftUtil, {
+  CoverageGap,
+  CurrentAndNextShift,
+  OnCallShift,
+} from "../../../Types/OnCallDutyPolicy/ScheduleShiftUtil";
+
+/*
+ * These tests pin the pure event -> shift transformation the on-call schedule
+ * summaries depend on. They deliberately do NOT re-test LayerUtil (covered by
+ * its own exhaustive suites) — they only cover the grouping / gap / current-next
+ * logic layered on top of its output.
+ */
+
+// Build a CalendarEvent the way LayerUtil emits one: user id in `title`.
+const event: (userId: string, start: Date, end: Date) => CalendarEvent = (
+  userId: string,
+  start: Date,
+  end: Date,
+): CalendarEvent => {
+  return {
+    id: 0,
+    title: userId,
+    allDay: false,
+    start,
+    end,
+  };
+};
+
+const at: (iso: string) => Date = (iso: string): Date => {
+  return OneUptimeDate.fromString(iso);
+};
+
+/*
+ * Build an OnCallShift literal for the resolver/gap tests (coverageSeconds is
+ * irrelevant to those, so default it to the wall-clock span).
+ */
+const mkShift: (userId: string, start: Date, end: Date) => OnCallShift = (
+  userId: string,
+  start: Date,
+  end: Date,
+): OnCallShift => {
+  return {
+    userId,
+    start,
+    end,
+    coverageSeconds: OneUptimeDate.getDifferenceInSeconds(end, start),
+  };
+};
+
+describe("ScheduleShiftUtil", () => {
+  describe("groupEventsIntoShifts", () => {
+    test("returns empty array for no events", () => {
+      expect(ScheduleShiftUtil.groupEventsIntoShifts([])).toEqual([]);
+    });
+
+    test("keeps distinct users as separate shifts (24/7 rotation)", () => {
+      const events: Array<CalendarEvent> = [
+        event("A", at("2024-01-01T09:00:00Z"), at("2024-01-02T09:00:00Z")),
+        event("B", at("2024-01-02T09:00:01Z"), at("2024-01-03T09:00:00Z")),
+        event("A", at("2024-01-03T09:00:01Z"), at("2024-01-04T09:00:00Z")),
+      ];
+
+      const shifts: Array<OnCallShift> =
+        ScheduleShiftUtil.groupEventsIntoShifts(events);
+
+      expect(shifts).toHaveLength(3);
+      expect(
+        shifts.map((s: OnCallShift) => {
+          return s.userId;
+        }),
+      ).toEqual(["A", "B", "A"]);
+      expect(shifts[0]!.end).toEqual(at("2024-01-02T09:00:00Z"));
+    });
+
+    test("merges touching same-user segments into one contiguous shift", () => {
+      // Two segments one second apart -> a single shift.
+      const events: Array<CalendarEvent> = [
+        event("A", at("2024-01-01T09:00:00Z"), at("2024-01-01T17:00:00Z")),
+        event("A", at("2024-01-01T17:00:01Z"), at("2024-01-02T09:00:00Z")),
+      ];
+
+      const shifts: Array<OnCallShift> =
+        ScheduleShiftUtil.groupEventsIntoShifts(events);
+
+      expect(shifts).toHaveLength(1);
+      expect(shifts[0]!.start).toEqual(at("2024-01-01T09:00:00Z"));
+      expect(shifts[0]!.end).toEqual(at("2024-01-02T09:00:00Z"));
+    });
+
+    test("does NOT merge same-user segments across a real gap by default", () => {
+      // Daily 9-5 restriction: same user, but a 16h nightly gap between days.
+      const events: Array<CalendarEvent> = [
+        event("A", at("2024-01-01T09:00:00Z"), at("2024-01-01T17:00:00Z")),
+        event("A", at("2024-01-02T09:00:00Z"), at("2024-01-02T17:00:00Z")),
+      ];
+
+      const shifts: Array<OnCallShift> =
+        ScheduleShiftUtil.groupEventsIntoShifts(events);
+
+      expect(shifts).toHaveLength(2);
+    });
+
+    test("merges same-user segments across gaps when mergeAcrossGaps=true", () => {
+      const events: Array<CalendarEvent> = [
+        event("A", at("2024-01-01T09:00:00Z"), at("2024-01-01T17:00:00Z")),
+        event("A", at("2024-01-02T09:00:00Z"), at("2024-01-02T17:00:00Z")),
+        event("B", at("2024-01-03T09:00:00Z"), at("2024-01-03T17:00:00Z")),
+      ];
+
+      const shifts: Array<OnCallShift> =
+        ScheduleShiftUtil.groupEventsIntoShifts(events, {
+          mergeAcrossGaps: true,
+        });
+
+      expect(shifts).toHaveLength(2);
+      expect(shifts[0]!.userId).toBe("A");
+      expect(shifts[0]!.start).toEqual(at("2024-01-01T09:00:00Z"));
+      // Turn end is the last covered instant of that user's run.
+      expect(shifts[0]!.end).toEqual(at("2024-01-02T17:00:00Z"));
+      /*
+       * coverageSeconds is the REAL active time (two 8h days = 16h), not the
+       * ~32h wall-clock span across the overnight gap.
+       */
+      expect(shifts[0]!.coverageSeconds).toBe(16 * 3600);
+      expect(shifts[1]!.userId).toBe("B");
+    });
+
+    test("sorts unsorted input by start time and never mutates the caller array", () => {
+      const events: Array<CalendarEvent> = [
+        event("B", at("2024-01-02T09:00:00Z"), at("2024-01-03T09:00:00Z")),
+        event("A", at("2024-01-01T09:00:00Z"), at("2024-01-02T09:00:00Z")),
+      ];
+      const snapshot: Array<string> = events.map((e: CalendarEvent) => {
+        return e.title;
+      });
+
+      const shifts: Array<OnCallShift> =
+        ScheduleShiftUtil.groupEventsIntoShifts(events);
+
+      expect(
+        shifts.map((s: OnCallShift) => {
+          return s.userId;
+        }),
+      ).toEqual(["A", "B"]);
+      // input order preserved (we copy before sorting)
+      expect(
+        events.map((e: CalendarEvent) => {
+          return e.title;
+        }),
+      ).toEqual(snapshot);
+    });
+  });
+
+  describe("getCurrentAndNextShift", () => {
+    const shifts: Array<OnCallShift> = [
+      mkShift("A", at("2024-01-01T09:00:00Z"), at("2024-01-02T09:00:00Z")),
+      mkShift("B", at("2024-01-02T09:00:00Z"), at("2024-01-03T09:00:00Z")),
+    ];
+
+    test("resolves the current and next shift when now is inside a shift", () => {
+      const result: CurrentAndNextShift =
+        ScheduleShiftUtil.getCurrentAndNextShift(
+          shifts,
+          at("2024-01-01T12:00:00Z"),
+        );
+
+      expect(result.current?.userId).toBe("A");
+      expect(result.next?.userId).toBe("B");
+    });
+
+    test("current is null inside a coverage gap but next is still found", () => {
+      const gapped: Array<OnCallShift> = [
+        mkShift("A", at("2024-01-01T09:00:00Z"), at("2024-01-01T17:00:00Z")),
+        mkShift("A", at("2024-01-02T09:00:00Z"), at("2024-01-02T17:00:00Z")),
+      ];
+
+      const result: CurrentAndNextShift =
+        ScheduleShiftUtil.getCurrentAndNextShift(
+          gapped,
+          at("2024-01-01T20:00:00Z"),
+        );
+
+      expect(result.current).toBeNull();
+      expect(result.next?.start).toEqual(at("2024-01-02T09:00:00Z"));
+    });
+
+    test("next is null when now is past the last shift", () => {
+      const result: CurrentAndNextShift =
+        ScheduleShiftUtil.getCurrentAndNextShift(
+          shifts,
+          at("2024-01-05T00:00:00Z"),
+        );
+
+      expect(result.current).toBeNull();
+      expect(result.next).toBeNull();
+    });
+  });
+
+  describe("getCoverageGaps", () => {
+    test("reports a leading gap before the first shift", () => {
+      const shifts: Array<OnCallShift> = [
+        mkShift("A", at("2024-01-01T12:00:00Z"), at("2024-01-01T18:00:00Z")),
+      ];
+
+      const gaps: Array<CoverageGap> = ScheduleShiftUtil.getCoverageGaps(
+        shifts,
+        at("2024-01-01T09:00:00Z"),
+        at("2024-01-01T20:00:00Z"),
+      );
+
+      expect(gaps).toHaveLength(1);
+      expect(gaps[0]!.start).toEqual(at("2024-01-01T09:00:00Z"));
+      expect(gaps[0]!.end).toEqual(at("2024-01-01T12:00:00Z"));
+    });
+
+    test("reports gaps between shifts but not trailing time after the last", () => {
+      const shifts: Array<OnCallShift> = [
+        mkShift("A", at("2024-01-01T09:00:00Z"), at("2024-01-01T17:00:00Z")),
+        mkShift("A", at("2024-01-02T09:00:00Z"), at("2024-01-02T17:00:00Z")),
+      ];
+
+      const gaps: Array<CoverageGap> = ScheduleShiftUtil.getCoverageGaps(
+        shifts,
+        at("2024-01-01T09:00:00Z"),
+        at("2024-01-03T00:00:00Z"),
+      );
+
+      expect(gaps).toHaveLength(1);
+      expect(gaps[0]!.start).toEqual(at("2024-01-01T17:00:00Z"));
+      expect(gaps[0]!.end).toEqual(at("2024-01-02T09:00:00Z"));
+    });
+
+    test("treats the whole window as a gap when there are no shifts", () => {
+      const gaps: Array<CoverageGap> = ScheduleShiftUtil.getCoverageGaps(
+        [],
+        at("2024-01-01T09:00:00Z"),
+        at("2024-01-02T09:00:00Z"),
+      );
+
+      expect(gaps).toHaveLength(1);
+    });
+
+    test("ignores the one-second boundaries between touching segments", () => {
+      const shifts: Array<OnCallShift> = [
+        mkShift("A", at("2024-01-01T09:00:00Z"), at("2024-01-01T17:00:00Z")),
+        mkShift("B", at("2024-01-01T17:00:01Z"), at("2024-01-02T09:00:00Z")),
+      ];
+
+      const gaps: Array<CoverageGap> = ScheduleShiftUtil.getCoverageGaps(
+        shifts,
+        at("2024-01-01T09:00:00Z"),
+        at("2024-01-02T09:00:00Z"),
+      );
+
+      expect(gaps).toHaveLength(0);
+    });
+  });
+});

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

@@ -0,0 +1,255 @@
+import CalendarEvent from "../../../Types/Calendar/CalendarEvent";
+import UserOverrideUtil, {
+  UserOverrideRecord,
+} from "../../../Types/OnCallDutyPolicy/UserOverrideUtil";
+
+function at(
+  hours: number,
+  minutes: number = 0,
+  seconds: number = 0,
+  ms: number = 0,
+): Date {
+  return new Date(2026, 0, 1, hours, minutes, seconds, ms);
+}
+
+function event(
+  title: string,
+  startHour: number,
+  endHour: number,
+): CalendarEvent {
+  return {
+    id: 1,
+    title: title,
+    allDay: false,
+    start: at(startHour),
+    end: at(endHour),
+  };
+}
+
+function resolvedAt(events: Array<CalendarEvent>, t: Date): string | null {
+  for (const e of events) {
+    if (t.getTime() >= e.start.getTime() && t.getTime() < e.end.getTime()) {
+      return e.title;
+    }
+  }
+  return null;
+}
+
+describe("UserOverrideUtil M-4: overrides are non-transitive", () => {
+  const base: CalendarEvent = event("A", 8, 14);
+
+  const g1: UserOverrideRecord = {
+    overrideUserId: "A",
+    routeAlertsToUserId: "B",
+    startsAt: at(9),
+    endsAt: at(13),
+    onCallDutyPolicyId: null,
+  };
+  const g2: UserOverrideRecord = {
+    overrideUserId: "B",
+    routeAlertsToUserId: "C",
+    startsAt: at(10),
+    endsAt: at(12),
+    onCallDutyPolicyId: null,
+  };
+
+  test("chain A->B then B->C does NOT double-substitute (stays B)", () => {
+    const result: Array<CalendarEvent> =
+      UserOverrideUtil.applyOverridesToEvents({
+        events: [base],
+        overrides: [g1, g2],
+      });
+    // At 11:00 the override result of A->B must remain B, not become C.
+    expect(resolvedAt(result, at(11))).toBe("B");
+    // Segments outside the override window remain A.
+    expect(resolvedAt(result, at(8, 30))).toBe("A");
+    expect(resolvedAt(result, at(13, 30))).toBe("A");
+  });
+
+  test("result is independent of override ordering", () => {
+    const forward: Array<CalendarEvent> =
+      UserOverrideUtil.applyOverridesToEvents({
+        events: [event("A", 8, 14)],
+        overrides: [g1, g2],
+      });
+    const reverse: Array<CalendarEvent> =
+      UserOverrideUtil.applyOverridesToEvents({
+        events: [event("A", 8, 14)],
+        overrides: [g2, g1],
+      });
+    expect(resolvedAt(forward, at(11))).toBe(resolvedAt(reverse, at(11)));
+    expect(resolvedAt(reverse, at(11))).toBe("B");
+  });
+});
+
+describe("UserOverrideUtil INFO-1: consistent second-precision boundary handling", () => {
+  test("override starting exactly at event end does not substitute", () => {
+    const base: CalendarEvent = event("A", 8, 12); // ends 12:00:00.000
+    const override: UserOverrideRecord = {
+      overrideUserId: "A",
+      routeAlertsToUserId: "B",
+      startsAt: at(12), // exactly event end
+      endsAt: at(13),
+      onCallDutyPolicyId: null,
+    };
+    const result: Array<CalendarEvent> =
+      UserOverrideUtil.applyOverridesToEvents({
+        events: [base],
+        overrides: [override],
+      });
+    expect(result.length).toBe(1);
+    expect(result[0]!.title).toBe("A");
+  });
+
+  test("sub-second offset at the boundary does not create an inverted segment", () => {
+    const base: CalendarEvent = event("A", 8, 12); // ends 12:00:00.000
+    const override: UserOverrideRecord = {
+      overrideUserId: "A",
+      routeAlertsToUserId: "B",
+      startsAt: at(12, 0, 0, 500), // 12:00:00.500 — same second as event end
+      endsAt: at(13),
+      onCallDutyPolicyId: null,
+    };
+    const result: Array<CalendarEvent> =
+      UserOverrideUtil.applyOverridesToEvents({
+        events: [base],
+        overrides: [override],
+      });
+    // No inverted/negative-length segment; event returned unchanged.
+    expect(result.length).toBe(1);
+    expect(result[0]!.title).toBe("A");
+    for (const e of result) {
+      expect(e.end.getTime()).toBeGreaterThan(e.start.getTime());
+    }
+  });
+});
+
+describe("UserOverrideUtil: baseline substitution still works", () => {
+  test("A->B within the event window splits into A | B | A", () => {
+    const base: CalendarEvent = event("A", 8, 14);
+    const override: UserOverrideRecord = {
+      overrideUserId: "A",
+      routeAlertsToUserId: "B",
+      startsAt: at(10),
+      endsAt: at(12),
+      onCallDutyPolicyId: null,
+    };
+    const result: Array<CalendarEvent> =
+      UserOverrideUtil.applyOverridesToEvents({
+        events: [base],
+        overrides: [override],
+      });
+    expect(resolvedAt(result, at(9))).toBe("A");
+    expect(resolvedAt(result, at(11))).toBe("B");
+    expect(resolvedAt(result, at(13))).toBe("A");
+  });
+
+  test("policy-scoped override wins over global for the same user/window", () => {
+    const base: CalendarEvent = event("A", 8, 14);
+    const globalOverride: UserOverrideRecord = {
+      overrideUserId: "A",
+      routeAlertsToUserId: "B",
+      startsAt: at(9),
+      endsAt: at(13),
+      onCallDutyPolicyId: null,
+    };
+    const policyOverride: UserOverrideRecord = {
+      overrideUserId: "A",
+      routeAlertsToUserId: "C",
+      startsAt: at(9),
+      endsAt: at(13),
+      onCallDutyPolicyId: "policy-1",
+    };
+    const result: Array<CalendarEvent> =
+      UserOverrideUtil.applyOverridesToEvents({
+        events: [base],
+        overrides: [globalOverride, policyOverride],
+        currentOnCallDutyPolicyId: "policy-1",
+      });
+    // Policy-scoped C wins over global B.
+    expect(resolvedAt(result, at(11))).toBe("C");
+  });
+});
+
+describe("UserOverrideUtil edge cases", () => {
+  test("override fully covering the event replaces the whole event", () => {
+    const base: CalendarEvent = event("A", 10, 12);
+    const override: UserOverrideRecord = {
+      overrideUserId: "A",
+      routeAlertsToUserId: "B",
+      startsAt: at(8), // starts before
+      endsAt: at(14), // ends after
+      onCallDutyPolicyId: null,
+    };
+    const result: Array<CalendarEvent> =
+      UserOverrideUtil.applyOverridesToEvents({
+        events: [base],
+        overrides: [override],
+      });
+    expect(result.length).toBe(1);
+    expect(result[0]!.title).toBe("B");
+    // Segment is clamped to the event window, not the override window.
+    expect(result[0]!.start.getTime()).toBe(at(10).getTime());
+    expect(result[0]!.end.getTime()).toBe(at(12).getTime());
+  });
+
+  test("one override spans two separate events for the same user", () => {
+    const e1: CalendarEvent = event("A", 8, 10);
+    const e2: CalendarEvent = { ...event("A", 12, 14), id: 2 };
+    const override: UserOverrideRecord = {
+      overrideUserId: "A",
+      routeAlertsToUserId: "B",
+      startsAt: at(9),
+      endsAt: at(13),
+      onCallDutyPolicyId: null,
+    };
+    const result: Array<CalendarEvent> =
+      UserOverrideUtil.applyOverridesToEvents({
+        events: [e1, e2],
+        overrides: [override],
+      });
+    // Both events are partially substituted.
+    expect(resolvedAt(result, at(8, 30))).toBe("A"); // before override in e1
+    expect(resolvedAt(result, at(9, 30))).toBe("B"); // override in e1
+    expect(resolvedAt(result, at(12, 30))).toBe("B"); // override in e2
+    expect(resolvedAt(result, at(13, 30))).toBe("A"); // after override in e2
+  });
+
+  test("two overrides on different original users both apply", () => {
+    const e1: CalendarEvent = event("A", 8, 12);
+    const e2: CalendarEvent = { ...event("B", 12, 16), id: 2 };
+    const overrideA: UserOverrideRecord = {
+      overrideUserId: "A",
+      routeAlertsToUserId: "X",
+      startsAt: at(9),
+      endsAt: at(11),
+      onCallDutyPolicyId: null,
+    };
+    const overrideB: UserOverrideRecord = {
+      overrideUserId: "B",
+      routeAlertsToUserId: "Y",
+      startsAt: at(13),
+      endsAt: at(15),
+      onCallDutyPolicyId: null,
+    };
+    const result: Array<CalendarEvent> =
+      UserOverrideUtil.applyOverridesToEvents({
+        events: [e1, e2],
+        overrides: [overrideA, overrideB],
+      });
+    expect(resolvedAt(result, at(10))).toBe("X"); // A -> X
+    expect(resolvedAt(result, at(14))).toBe("Y"); // B -> Y
+    expect(resolvedAt(result, at(8, 30))).toBe("A"); // untouched
+    expect(resolvedAt(result, at(12, 30))).toBe("B"); // untouched
+  });
+
+  test("no overrides returns the events unchanged", () => {
+    const base: CalendarEvent = event("A", 8, 14);
+    const result: Array<CalendarEvent> =
+      UserOverrideUtil.applyOverridesToEvents({
+        events: [base],
+        overrides: [],
+      });
+    expect(result).toEqual([base]);
+  });
+});