@oneuptime/common 11.3.25 → 11.3.28

package/Tests/Types/DateTimezoneWallClock.test.ts

@@ -0,0 +1,99 @@
+/**
+ * Tests for the timezone wall-clock helpers backing the on-call restriction
+ * time-picker fix (audit F1) and the summary formatting fix (audit F10):
+ *   - getInstantFromLocalWallClockInTimezone
+ *   - getLocalDateFromWallClockInTimezone (inverse)
+ *   - getHourAndMinuteInTimezoneString
+ *
+ * Assertions are expressed in wall-clock via moment-timezone so they hold
+ * regardless of the process TZ the suite runs under.
+ */
+import OneUptimeDate from "../../Types/Date";
+import moment from "moment-timezone";
+
+const NY: string = "America/New_York";
+const KOLKATA: string = "Asia/Kolkata";
+
+describe("OneUptimeDate timezone wall-clock helpers", () => {
+  describe("getInstantFromLocalWallClockInTimezone", () => {
+    it("plants the local wall-clock components as the same wall-clock in the target zone", () => {
+      // A local Date reading 09:00 on 2025-01-06 in the process zone.
+      const local: Date = new Date(2025, 0, 6, 9, 0, 0);
+      const instant: Date =
+        OneUptimeDate.getInstantFromLocalWallClockInTimezone(local, NY);
+      // The resulting instant must read 09:00 in New York.
+      expect(moment.tz(instant, NY).format("HH:mm")).toBe("09:00");
+    });
+
+    it("produces different absolute instants for the same wall-clock in different zones", () => {
+      const local: Date = new Date(2025, 5, 15, 9, 0, 0);
+      const inNY: Date = OneUptimeDate.getInstantFromLocalWallClockInTimezone(
+        local,
+        NY,
+      );
+      const inKolkata: Date =
+        OneUptimeDate.getInstantFromLocalWallClockInTimezone(local, KOLKATA);
+      // 09:00 NY and 09:00 Kolkata are different moments.
+      expect(inNY.getTime()).not.toBe(inKolkata.getTime());
+      expect(moment.tz(inNY, NY).format("HH:mm")).toBe("09:00");
+      expect(moment.tz(inKolkata, KOLKATA).format("HH:mm")).toBe("09:00");
+    });
+  });
+
+  describe("getLocalDateFromWallClockInTimezone", () => {
+    it("returns a local Date whose local wall-clock equals the target-zone wall-clock", () => {
+      // An instant that is 09:00 in New York.
+      const instant: Date = moment.tz("2025-01-06 09:00", NY).toDate();
+      const local: Date = OneUptimeDate.getLocalDateFromWallClockInTimezone(
+        instant,
+        NY,
+      );
+      // Its LOCAL hour/minute should read 09:00.
+      expect(local.getHours()).toBe(9);
+      expect(local.getMinutes()).toBe(0);
+    });
+  });
+
+  describe("round-trip", () => {
+    it("local -> tz-instant -> local preserves the wall-clock (incl. across a DST week)", () => {
+      for (const wall of [
+        new Date(2025, 0, 6, 9, 0, 0), // winter
+        new Date(2025, 6, 6, 14, 30, 0), // summer
+        new Date(2026, 2, 8, 1, 30, 0), // US spring-forward day
+      ]) {
+        const instant: Date =
+          OneUptimeDate.getInstantFromLocalWallClockInTimezone(wall, NY);
+        const back: Date = OneUptimeDate.getLocalDateFromWallClockInTimezone(
+          instant,
+          NY,
+        );
+        expect(back.getHours()).toBe(wall.getHours());
+        expect(back.getMinutes()).toBe(wall.getMinutes());
+      }
+    });
+  });
+
+  describe("getHourAndMinuteInTimezoneString", () => {
+    it("formats an instant in the given timezone (NY noon reads 09:00 in LA, differs from NY)", () => {
+      const nyNoon: Date = moment.tz("2025-01-06 12:00", NY).toDate();
+      const inNY: string = OneUptimeDate.getHourAndMinuteInTimezoneString(
+        nyNoon,
+        NY,
+      );
+      const inKolkata: string = OneUptimeDate.getHourAndMinuteInTimezoneString(
+        nyNoon,
+        KOLKATA,
+      );
+      expect(inNY).not.toBe(inKolkata);
+      // Kolkata is +5:30, so the minute component is :30.
+      expect(inKolkata).toContain("30");
+    });
+
+    it("falls back to local wall-clock when no timezone is given", () => {
+      const d: Date = new Date(2025, 0, 6, 8, 15, 0);
+      expect(OneUptimeDate.getHourAndMinuteInTimezoneString(d, undefined)).toBe(
+        OneUptimeDate.getLocalHourAndMinuteFromDate(d),
+      );
+    });
+  });
+});

package/Tests/Types/Events/Recurring.test.ts

@@ -273,15 +273,28 @@ describe("Recurring", () => {
     });
 
     test("leaves a start date equal to now unchanged (zero intervals to add)", () => {
-      const now: Date = OneUptimeDate.getCurrentDate();
-
-      const next: Date = Recurring.getNextDate(
-        now,
-        makeRecurring(EventInterval.Day, 1),
-      );
-
-      // The <= branch is entered, diff is 0, so Math.ceil(0) === 0 intervals are added.
-      expect(next.getTime()).toBe(now.getTime());
+      /*
+       * getNextDate() reads the clock internally via getCurrentDate(). Pin it so
+       * the start date and the internal "now" resolve to the exact same instant;
+       * otherwise a sub-millisecond gap between the two clock reads makes diff a
+       * tiny positive number and Math.ceil() rounds it up to a full extra day.
+       */
+      const now: Date = OneUptimeDate.fromString("2023-01-01T00:00:00.000Z");
+      const getCurrentDateSpy: jest.SpyInstance = jest
+        .spyOn(OneUptimeDate, "getCurrentDate")
+        .mockReturnValue(now);
+
+      try {
+        const next: Date = Recurring.getNextDate(
+          now,
+          makeRecurring(EventInterval.Day, 1),
+        );
+
+        // The <= branch is entered, diff is 0, so Math.ceil(0) === 0 intervals are added.
+        expect(next.getTime()).toBe(now.getTime());
+      } finally {
+        getCurrentDateSpy.mockRestore();
+      }
     });
 
     test("throws BadDataException for an unknown interval type when the start date is in the past", () => {

package/Tests/Types/Metrics/RecordingRuleDefinition.test.ts

@@ -0,0 +1,213 @@
+import AggregationType from "../../../Types/BaseDatabase/AggregationType";
+import RecordingRuleDefinition, {
+  RecordingRuleDefinitionUtil,
+  RecordingRuleSource,
+  RECORDING_RULE_MAX_SOURCES,
+  RECORDING_RULE_MAX_EXPRESSION_LENGTH,
+} from "../../../Types/Metrics/RecordingRuleDefinition";
+
+describe("RecordingRuleDefinitionUtil", () => {
+  const makeSource: (
+    overrides?: Partial<RecordingRuleSource>,
+  ) => RecordingRuleSource = (
+    overrides: Partial<RecordingRuleSource> = {},
+  ): RecordingRuleSource => {
+    return {
+      alias: "A",
+      metricName: "http.requests",
+      aggregationType: AggregationType.Sum,
+      ...overrides,
+    };
+  };
+
+  describe("getAggregationOptions", () => {
+    test("returns a value/label option for each supported aggregation", () => {
+      const options: Array<{ value: AggregationType; label: string }> =
+        RecordingRuleDefinitionUtil.getAggregationOptions();
+
+      expect(options.length).toBeGreaterThan(0);
+      for (const option of options) {
+        expect(typeof option.label).toBe("string");
+        expect(option.label.length).toBeGreaterThan(0);
+        expect(Object.values(AggregationType)).toContain(option.value);
+      }
+    });
+  });
+
+  describe("getNextAlias", () => {
+    test("returns A when there are no sources", () => {
+      expect(RecordingRuleDefinitionUtil.getNextAlias(undefined)).toBe("A");
+      expect(RecordingRuleDefinitionUtil.getNextAlias([])).toBe("A");
+    });
+
+    test("returns the first unused letter", () => {
+      expect(
+        RecordingRuleDefinitionUtil.getNextAlias([makeSource({ alias: "A" })]),
+      ).toBe("B");
+      expect(
+        RecordingRuleDefinitionUtil.getNextAlias([
+          makeSource({ alias: "A" }),
+          makeSource({ alias: "B" }),
+        ]),
+      ).toBe("C");
+    });
+
+    test("skips gaps and returns the lowest free letter", () => {
+      expect(
+        RecordingRuleDefinitionUtil.getNextAlias([
+          makeSource({ alias: "A" }),
+          makeSource({ alias: "C" }),
+        ]),
+      ).toBe("B");
+    });
+  });
+
+  describe("getEmptyDefinition", () => {
+    test("returns a single source aliased A with expression A", () => {
+      const def: RecordingRuleDefinition =
+        RecordingRuleDefinitionUtil.getEmptyDefinition();
+
+      expect(def.sources.length).toBe(1);
+      expect(def.sources[0]!.alias).toBe("A");
+      expect(def.expression).toBe("A");
+    });
+
+    test("is itself a valid definition once a metric name is provided", () => {
+      const def: RecordingRuleDefinition =
+        RecordingRuleDefinitionUtil.getEmptyDefinition();
+      def.sources[0]!.metricName = "http.requests";
+
+      expect(RecordingRuleDefinitionUtil.getValidationError(def)).toBeNull();
+    });
+  });
+
+  describe("getValidationError", () => {
+    const validDefinition: () => RecordingRuleDefinition =
+      (): RecordingRuleDefinition => {
+        return {
+          sources: [makeSource({ alias: "A" }), makeSource({ alias: "B" })],
+          expression: "A / B * 100",
+        };
+      };
+
+    test("accepts a valid definition", () => {
+      expect(
+        RecordingRuleDefinitionUtil.getValidationError(validDefinition()),
+      ).toBeNull();
+    });
+
+    test("requires a definition", () => {
+      expect(RecordingRuleDefinitionUtil.getValidationError(undefined)).toBe(
+        "Definition is required.",
+      );
+    });
+
+    test("requires at least one source", () => {
+      expect(
+        RecordingRuleDefinitionUtil.getValidationError({
+          sources: [],
+          expression: "A",
+        }),
+      ).toBe("Add at least one source metric.");
+    });
+
+    test("rejects more than the maximum number of sources", () => {
+      const sources: Array<RecordingRuleSource> = Array.from(
+        { length: RECORDING_RULE_MAX_SOURCES + 1 },
+        (_unused: unknown, i: number) => {
+          return makeSource({ alias: "ABCDE"[i] as string });
+        },
+      );
+
+      expect(
+        RecordingRuleDefinitionUtil.getValidationError({
+          sources,
+          expression: "A",
+        }),
+      ).toContain(`at most ${RECORDING_RULE_MAX_SOURCES}`);
+    });
+
+    test("rejects an invalid alias", () => {
+      expect(
+        RecordingRuleDefinitionUtil.getValidationError({
+          sources: [makeSource({ alias: "a" })],
+          expression: "A",
+        }),
+      ).toContain("single uppercase letter");
+    });
+
+    test("rejects duplicate aliases", () => {
+      expect(
+        RecordingRuleDefinitionUtil.getValidationError({
+          sources: [makeSource({ alias: "A" }), makeSource({ alias: "A" })],
+          expression: "A",
+        }),
+      ).toContain("Duplicate alias");
+    });
+
+    test("requires a metric name", () => {
+      expect(
+        RecordingRuleDefinitionUtil.getValidationError({
+          sources: [makeSource({ alias: "A", metricName: "  " })],
+          expression: "A",
+        }),
+      ).toContain("Metric name is required");
+    });
+
+    test("requires both a filter key and value, or neither", () => {
+      expect(
+        RecordingRuleDefinitionUtil.getValidationError({
+          sources: [makeSource({ alias: "A", filterAttributeKey: "env" })],
+          expression: "A",
+        }),
+      ).toContain("needs both a key and a value");
+    });
+
+    test("requires an expression", () => {
+      expect(
+        RecordingRuleDefinitionUtil.getValidationError({
+          sources: [makeSource({ alias: "A" })],
+          expression: "   ",
+        }),
+      ).toBe("Expression is required.");
+    });
+
+    test("rejects an over-length expression", () => {
+      expect(
+        RecordingRuleDefinitionUtil.getValidationError({
+          sources: [makeSource({ alias: "A" })],
+          expression: "A".repeat(RECORDING_RULE_MAX_EXPRESSION_LENGTH + 1),
+        }),
+      ).toContain(
+        `${RECORDING_RULE_MAX_EXPRESSION_LENGTH} characters or fewer`,
+      );
+    });
+
+    test("rejects an expression referencing an undefined alias", () => {
+      expect(
+        RecordingRuleDefinitionUtil.getValidationError({
+          sources: [makeSource({ alias: "A" })],
+          expression: "A + B",
+        }),
+      ).toContain("references alias 'B'");
+    });
+
+    test("rejects an expression that references no alias", () => {
+      expect(
+        RecordingRuleDefinitionUtil.getValidationError({
+          sources: [makeSource({ alias: "A" })],
+          expression: "5 + 10",
+        }),
+      ).toContain("must reference at least one source alias");
+    });
+
+    test("rejects an expression with characters outside the DSL grammar", () => {
+      expect(
+        RecordingRuleDefinitionUtil.getValidationError({
+          sources: [makeSource({ alias: "A" }), makeSource({ alias: "B" })],
+          expression: "A & B",
+        }),
+      ).toContain("may only contain");
+    });
+  });
+});

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

@@ -0,0 +1,291 @@
+import LayerUtil, { LayerProps } from "../../../Types/OnCallDutyPolicy/Layer";
+import CalendarEvent from "../../../Types/Calendar/CalendarEvent";
+import RestrictionTimes, {
+  RestrictionType,
+  WeeklyResctriction,
+} from "../../../Types/OnCallDutyPolicy/RestrictionTimes";
+import Recurring from "../../../Types/Events/Recurring";
+import OneUptimeDate from "../../../Types/Date";
+import User from "../../../Models/DatabaseModels/User";
+import EventInterval from "../../../Types/Events/EventInterval";
+import DayOfWeek from "../../../Types/Day/DayOfWeek";
+
+/*
+ * Regression tests for the on-call audit fixes:
+ *   1. Daily/weekly restriction dropped coverage for every day after the first
+ *      in a multi-day rotation period (getEventsByDailyRestriction case 2 used
+ *      to terminate instead of advancing).
+ *   2. Weekly wrap-around restriction emitted phantom all-day windows when the
+ *      resolution window did not start on the ISO-week boundary.
+ *   3. Multi-layer merge silently deleted a lower-priority (fallback) layer's
+ *      coverage after two adjacent higher-priority windows.
+ *
+ * These assert observable on-call coverage (who is on call at a given instant),
+ * which is what actually matters operationally.
+ */
+
+function user(id: string): User {
+  return {
+    id: {
+      toString: () => {
+        return id;
+      },
+    } as any,
+  } as User;
+}
+
+function rotation(t: EventInterval, c: number): Recurring {
+  return Recurring.fromJSON({
+    _type: "Recurring",
+    value: {
+      intervalType: t,
+      intervalCount: { _type: "PositiveNumber", value: c },
+    },
+  } as any);
+}
+
+function noRestriction(): RestrictionTimes {
+  const r: RestrictionTimes = new RestrictionTimes();
+  r.restictionType = RestrictionType.None;
+  r.dayRestrictionTimes = null;
+  return r;
+}
+
+function dailyRestriction(
+  startHour: number,
+  endHour: number,
+): RestrictionTimes {
+  const r: RestrictionTimes = new RestrictionTimes();
+  r.restictionType = RestrictionType.Daily;
+  r.dayRestrictionTimes = {
+    startTime: OneUptimeDate.getDateWithCustomTime({
+      hours: startHour,
+      minutes: 0,
+      seconds: 0,
+    }),
+    endTime: OneUptimeDate.getDateWithCustomTime({
+      hours: endHour,
+      minutes: 0,
+      seconds: 0,
+    }),
+  };
+  return r;
+}
+
+// Which user (event title) covers instant t? (start <= t < end). null if none.
+function coveringUser(events: Array<CalendarEvent>, t: Date): string | null {
+  for (const e of events) {
+    if (e.start.getTime() <= t.getTime() && e.end.getTime() > t.getTime()) {
+      return e.title;
+    }
+  }
+  return null;
+}
+
+// Seconds in [rangeStart, rangeEnd] not covered by any event (tolerating 1s seams).
+function uncoveredSeconds(
+  events: Array<CalendarEvent>,
+  rangeStart: Date,
+  rangeEnd: Date,
+): number {
+  const sorted: Array<CalendarEvent> = [...events].sort(
+    (a: CalendarEvent, b: CalendarEvent) => {
+      return a.start.getTime() - b.start.getTime();
+    },
+  );
+  let uncovered: number = 0;
+  let cursor: number = rangeStart.getTime();
+  for (const e of sorted) {
+    if (e.start.getTime() > cursor + 1000) {
+      uncovered += e.start.getTime() - cursor;
+    }
+    cursor = Math.max(cursor, e.end.getTime());
+  }
+  if (rangeEnd.getTime() > cursor + 1000) {
+    uncovered += rangeEnd.getTime() - cursor;
+  }
+  return Math.round(uncovered / 1000);
+}
+
+describe("LayerUtil audit fixes", () => {
+  describe("Fix 1: daily restriction keeps coverage every day of a multi-day rotation", () => {
+    test("weekly rotation + daily 09:00-17:00 + handoff at/after 09:00", () => {
+      const layerUtil: LayerUtil = new LayerUtil();
+      const layerStart: Date = new Date(2026, 0, 5, 0, 0, 0); // Mon Jan 5 2026
+      const events: Array<CalendarEvent> = layerUtil.getEvents({
+        users: [user("A"), user("B")],
+        startDateTimeOfLayer: layerStart,
+        restrictionTimes: dailyRestriction(9, 17),
+        handOffTime: new Date(2026, 0, 5, 10, 0, 0), // 10:00 (after restriction start)
+        rotation: rotation(EventInterval.Week, 1),
+        calendarStartDate: layerStart,
+        calendarEndDate: new Date(2026, 0, 19, 0, 0, 0),
+      });
+
+      /*
+       * Week 1 (B is on call after the 10:00 handoff on Jan 5): every day Jan 6-11
+       * must be covered by B during the 09-17 window (the bug left these empty).
+       */
+      for (let day: number = 6; day <= 11; day++) {
+        expect(coveringUser(events, new Date(2026, 0, day, 11, 0, 0))).toBe(
+          "B",
+        );
+      }
+      // Week 2 (A): every day Jan 13-18 covered by A during the window.
+      for (let day: number = 13; day <= 18; day++) {
+        expect(coveringUser(events, new Date(2026, 0, day, 11, 0, 0))).toBe(
+          "A",
+        );
+      }
+      // Outside the restriction window: nobody on call.
+      expect(coveringUser(events, new Date(2026, 0, 7, 3, 0, 0))).toBeNull();
+      expect(coveringUser(events, new Date(2026, 0, 7, 20, 0, 0))).toBeNull();
+    });
+
+    test("Day x2 rotation + daily 09:00-17:00 + noon handoff covers in-between days", () => {
+      const layerUtil: LayerUtil = new LayerUtil();
+      const layerStart: Date = new Date(2026, 0, 5, 0, 0, 0);
+      const events: Array<CalendarEvent> = layerUtil.getEvents({
+        users: [user("A"), user("B")],
+        startDateTimeOfLayer: layerStart,
+        restrictionTimes: dailyRestriction(9, 17),
+        handOffTime: new Date(2026, 0, 5, 12, 0, 0),
+        rotation: rotation(EventInterval.Day, 2),
+        calendarStartDate: layerStart,
+        calendarEndDate: new Date(2026, 0, 13, 0, 0, 0),
+      });
+      // Jan 6 is the "second day" of B's 2-day period and used to be uncovered.
+      expect(coveringUser(events, new Date(2026, 0, 6, 11, 0, 0))).toBe("B");
+      // Jan 8 is the second day of A's next 2-day period.
+      expect(coveringUser(events, new Date(2026, 0, 8, 11, 0, 0))).toBe("A");
+    });
+  });
+
+  describe("Fix 2: weekly wrap-around restriction has no phantom coverage", () => {
+    const weekend: WeeklyResctriction = {
+      startDay: DayOfWeek.Friday,
+      endDay: DayOfWeek.Monday,
+      startTime: new Date(2026, 0, 2, 20, 0, 0), // Fri 20:00
+      endTime: new Date(2026, 0, 5, 8, 0, 0), // Mon 08:00
+    };
+
+    function weekendRestriction(): RestrictionTimes {
+      const r: RestrictionTimes = new RestrictionTimes();
+      r.restictionType = RestrictionType.Weekly;
+      r.weeklyRestrictionTimes = [weekend];
+      return r;
+    }
+
+    test("resolved mid-week (Wed): excluded weekdays have NO coverage", () => {
+      const layerUtil: LayerUtil = new LayerUtil();
+      const events: Array<CalendarEvent> = layerUtil.getEvents({
+        users: [user("A")],
+        startDateTimeOfLayer: new Date(2026, 0, 1, 0, 0, 0),
+        restrictionTimes: weekendRestriction(),
+        handOffTime: new Date(2026, 0, 1, 0, 0, 0),
+        rotation: rotation(EventInterval.Week, 1),
+        calendarStartDate: new Date(2026, 0, 7, 0, 0, 0), // Wed Jan 7 (NOT week-aligned)
+        calendarEndDate: new Date(2026, 0, 13, 0, 0, 0),
+      });
+      // Weekday daytime is OUTSIDE the Fri20:00->Mon08:00 window: nobody on call.
+      expect(coveringUser(events, new Date(2026, 0, 7, 14, 30, 0))).toBeNull(); // Wed
+      expect(coveringUser(events, new Date(2026, 0, 8, 10, 0, 0))).toBeNull(); // Thu
+      expect(coveringUser(events, new Date(2026, 0, 9, 12, 0, 0))).toBeNull(); // Fri noon
+      // Inside the weekend window: A is on call.
+      expect(coveringUser(events, new Date(2026, 0, 9, 22, 0, 0))).toBe("A"); // Fri 22:00
+      expect(coveringUser(events, new Date(2026, 0, 10, 12, 0, 0))).toBe("A"); // Sat
+      expect(coveringUser(events, new Date(2026, 0, 11, 12, 0, 0))).toBe("A"); // Sun
+      expect(coveringUser(events, new Date(2026, 0, 12, 7, 0, 0))).toBe("A"); // Mon 07:00
+      expect(coveringUser(events, new Date(2026, 0, 12, 9, 0, 0))).toBeNull(); // Mon 09:00 (after handoff)
+    });
+
+    test("live 1-second window mid-week returns nobody during excluded hours", () => {
+      const layerUtil: LayerUtil = new LayerUtil();
+      const resolveAt: (now: Date) => string | null = (
+        now: Date,
+      ): string | null => {
+        const events: Array<CalendarEvent> = layerUtil.getMultiLayerEvents(
+          {
+            layers: [
+              {
+                users: [user("A")],
+                startDateTimeOfLayer: new Date(2026, 0, 1, 0, 0, 0),
+                restrictionTimes: weekendRestriction(),
+                handOffTime: new Date(2026, 0, 1, 0, 0, 0),
+                rotation: rotation(EventInterval.Week, 1),
+              },
+            ],
+            calendarStartDate: now,
+            calendarEndDate: OneUptimeDate.addRemoveSeconds(now, 1),
+          },
+          { getNumberOfEvents: 1 },
+        );
+        return events[0]?.title ?? null;
+      };
+      expect(resolveAt(new Date(2026, 0, 7, 14, 30, 0))).toBeNull(); // Wed excluded
+      expect(resolveAt(new Date(2026, 0, 8, 10, 0, 0))).toBeNull(); // Thu excluded
+      expect(resolveAt(new Date(2026, 0, 10, 22, 0, 0))).toBe("A"); // Sat included
+    });
+
+    test("resolved on the week boundary (Mon) still correct (no regression)", () => {
+      const layerUtil: LayerUtil = new LayerUtil();
+      const events: Array<CalendarEvent> = layerUtil.getEvents({
+        users: [user("A")],
+        startDateTimeOfLayer: new Date(2026, 0, 1, 0, 0, 0),
+        restrictionTimes: weekendRestriction(),
+        handOffTime: new Date(2026, 0, 1, 0, 0, 0),
+        rotation: rotation(EventInterval.Week, 1),
+        calendarStartDate: new Date(2026, 0, 5, 0, 0, 0), // Mon Jan 5
+        calendarEndDate: new Date(2026, 0, 13, 0, 0, 0),
+      });
+      expect(coveringUser(events, new Date(2026, 0, 5, 7, 0, 0))).toBe("A"); // Mon 07:00 (tail of prior weekend)
+      expect(coveringUser(events, new Date(2026, 0, 7, 12, 0, 0))).toBeNull(); // Wed excluded
+      expect(coveringUser(events, new Date(2026, 0, 10, 12, 0, 0))).toBe("A"); // Sat included
+    });
+  });
+
+  describe("Fix 3: multi-layer fallback coverage survives adjacent higher-priority windows", () => {
+    test("24/7 fallback under a primary that emits two back-to-back windows", () => {
+      const layerUtil: LayerUtil = new LayerUtil();
+      const calStart: Date = new Date(2026, 2, 2, 0, 0, 0);
+      const calEnd: Date = new Date(2026, 2, 4, 0, 0, 0);
+
+      /*
+       * Primary: A/B hourly rotation restricted to 10:00-12:00, handoff at 11:00
+       * -> emits two adjacent windows per day: A[10:00-11:00], B[11:00:01-12:00].
+       */
+      const primary: LayerProps = {
+        users: [user("A"), user("B")],
+        startDateTimeOfLayer: calStart,
+        restrictionTimes: dailyRestriction(10, 12),
+        handOffTime: new Date(2026, 2, 2, 11, 0, 0),
+        rotation: rotation(EventInterval.Hour, 1),
+      };
+      // Fallback: C on call 24/7.
+      const fallback: LayerProps = {
+        users: [user("C")],
+        startDateTimeOfLayer: calStart,
+        restrictionTimes: noRestriction(),
+        handOffTime: new Date(2026, 2, 2, 0, 0, 0),
+        rotation: rotation(EventInterval.Week, 1),
+      };
+
+      const events: Array<CalendarEvent> = layerUtil.getMultiLayerEvents({
+        layers: [primary, fallback],
+        calendarStartDate: calStart,
+        calendarEndDate: calEnd,
+      });
+
+      // No uncovered time anywhere in the window (fallback fills every gap).
+      expect(uncoveredSeconds(events, calStart, calEnd)).toBe(0);
+
+      // Primary owns 10:00-12:00; fallback C owns everything else.
+      expect(coveringUser(events, new Date(2026, 2, 2, 10, 30, 0))).toBe("A");
+      expect(coveringUser(events, new Date(2026, 2, 2, 11, 30, 0))).toBe("B");
+      expect(coveringUser(events, new Date(2026, 2, 2, 15, 0, 0))).toBe("C"); // afternoon
+      expect(coveringUser(events, new Date(2026, 2, 3, 3, 0, 0))).toBe("C"); // overnight
+      expect(coveringUser(events, new Date(2026, 2, 3, 8, 0, 0))).toBe("C"); // next morning
+      expect(coveringUser(events, new Date(2026, 2, 3, 10, 30, 0))).toBe("A"); // next day primary
+    });
+  });
+});