@oneuptime/common 11.3.28 → 11.4.1

package/Tests/Types/BaseDatabase/AggregationIntervalUtil.test.ts

@@ -0,0 +1,127 @@
+import AggregationInterval from "../../../Types/BaseDatabase/AggregationInterval";
+import AggregationIntervalUtil from "../../../Types/BaseDatabase/AggregationIntervalUtil";
+
+describe("AggregationIntervalUtil", () => {
+  const SECOND: number = 1000;
+  const HOUR: number = SECOND * 60 * 60;
+  const DAY: number = HOUR * 24;
+
+  const windowOf: (durationMs: number) => { startDate: Date; endDate: Date } = (
+    durationMs: number,
+  ): { startDate: Date; endDate: Date } => {
+    const startDate: Date = new Date(Date.UTC(2020, 0, 1, 0, 0, 0));
+    const endDate: Date = new Date(startDate.getTime() + durationMs);
+    return { startDate, endDate };
+  };
+
+  describe("getAggregationIntervalForWindow", () => {
+    const cases: Array<[string, number, AggregationInterval]> = [
+      ["2 hours -> Minute", 2 * HOUR, AggregationInterval.Minute],
+      [
+        "exactly 3 hours -> Minute (inclusive bound)",
+        3 * HOUR,
+        AggregationInterval.Minute,
+      ],
+      ["3 hours + 1ms -> Hour", 3 * HOUR + 1, AggregationInterval.Hour],
+      ["1 day -> Hour", DAY, AggregationInterval.Hour],
+      [
+        "exactly 7 days -> Hour (inclusive bound)",
+        7 * DAY,
+        AggregationInterval.Hour,
+      ],
+      ["7 days + 1ms -> Day", 7 * DAY + 1, AggregationInterval.Day],
+      ["14 days -> Day", 14 * DAY, AggregationInterval.Day],
+      [
+        "exactly 6 weeks -> Day (inclusive bound)",
+        42 * DAY,
+        AggregationInterval.Day,
+      ],
+      ["6 weeks + 1ms -> Week", 42 * DAY + 1, AggregationInterval.Week],
+      ["60 days -> Week", 60 * DAY, AggregationInterval.Week],
+      ["200 days -> Month", 200 * DAY, AggregationInterval.Month],
+      ["8 years -> Year", 8 * 365 * DAY, AggregationInterval.Year],
+    ];
+
+    test.each(cases)(
+      "%s",
+      (_label: string, durationMs: number, expected: AggregationInterval) => {
+        expect(
+          AggregationIntervalUtil.getAggregationIntervalForWindow(
+            windowOf(durationMs),
+          ),
+        ).toBe(expected);
+      },
+    );
+
+    test("returns the widest interval as the window grows", () => {
+      const order: Array<AggregationInterval> = [
+        AggregationInterval.Minute,
+        AggregationInterval.Hour,
+        AggregationInterval.Day,
+        AggregationInterval.Week,
+        AggregationInterval.Month,
+        AggregationInterval.Year,
+      ];
+      const durations: Array<number> = [
+        HOUR,
+        2 * DAY,
+        30 * DAY,
+        90 * DAY,
+        365 * DAY,
+        10 * 365 * DAY,
+      ];
+
+      const results: Array<AggregationInterval> = durations.map(
+        (d: number): AggregationInterval => {
+          return AggregationIntervalUtil.getAggregationIntervalForWindow(
+            windowOf(d),
+          );
+        },
+      );
+
+      // Each larger window is at least as wide an interval as the previous.
+      for (let i: number = 1; i < results.length; i++) {
+        expect(order.indexOf(results[i]!)).toBeGreaterThanOrEqual(
+          order.indexOf(results[i - 1]!),
+        );
+      }
+    });
+  });
+
+  describe("getAggregationIntervalMs", () => {
+    test.each([
+      [AggregationInterval.Minute, 1000 * 60],
+      [AggregationInterval.Hour, 1000 * 60 * 60],
+      [AggregationInterval.Day, 1000 * 60 * 60 * 24],
+      [AggregationInterval.Week, 1000 * 60 * 60 * 24 * 7],
+      [AggregationInterval.Month, 1000 * 60 * 60 * 24 * 30],
+      [AggregationInterval.Year, 1000 * 60 * 60 * 24 * 365],
+    ])(
+      "maps %s to its nominal width",
+      (interval: AggregationInterval, expectedMs: number) => {
+        expect(AggregationIntervalUtil.getAggregationIntervalMs(interval)).toBe(
+          expectedMs,
+        );
+      },
+    );
+
+    test("intervals are strictly increasing in width", () => {
+      const ordered: Array<AggregationInterval> = [
+        AggregationInterval.Minute,
+        AggregationInterval.Hour,
+        AggregationInterval.Day,
+        AggregationInterval.Week,
+        AggregationInterval.Month,
+        AggregationInterval.Year,
+      ];
+
+      for (let i: number = 1; i < ordered.length; i++) {
+        expect(
+          AggregationIntervalUtil.getAggregationIntervalMs(ordered[i]!),
+        ).toBeGreaterThan(
+          AggregationIntervalUtil.getAggregationIntervalMs(ordered[i - 1]!),
+        );
+      }
+    });
+  });
+});

package/Tests/Types/BaseDatabase/DatabaseCommonInteractionPropsUtil.test.ts

@@ -0,0 +1,152 @@
+import DatabaseCommonInteractionProps from "../../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import DatabaseCommonInteractionPropsUtil, {
+  PermissionType,
+} from "../../../Types/BaseDatabase/DatabaseCommonInteractionPropsUtil";
+import ObjectID from "../../../Types/ObjectID";
+import Permission, {
+  UserPermission,
+  UserTenantAccessPermission,
+} from "../../../Types/Permission";
+
+describe("DatabaseCommonInteractionPropsUtil.getUserPermissions", () => {
+  const makePerm: (
+    permission: Permission,
+    isBlockPermission: boolean,
+  ) => UserPermission = (
+    permission: Permission,
+    isBlockPermission: boolean,
+  ): UserPermission => {
+    return {
+      _type: "UserPermission",
+      permission,
+      labelIds: [],
+      isBlockPermission,
+    };
+  };
+
+  const permissionsOf: (result: Array<UserPermission>) => Array<Permission> = (
+    result: Array<UserPermission>,
+  ): Array<Permission> => {
+    return result.map((p: UserPermission): Permission => {
+      return p.permission;
+    });
+  };
+
+  describe("global permissions", () => {
+    test("always grants Public for an anonymous Allow request", () => {
+      const props: DatabaseCommonInteractionProps = {};
+
+      const perms: Array<Permission> = permissionsOf(
+        DatabaseCommonInteractionPropsUtil.getUserPermissions(
+          props,
+          PermissionType.Allow,
+        ),
+      );
+
+      expect(perms).toContain(Permission.Public);
+    });
+
+    test("adds CurrentUser when a user is logged in", () => {
+      const props: DatabaseCommonInteractionProps = {
+        userId: ObjectID.generate(),
+      };
+
+      const perms: Array<Permission> = permissionsOf(
+        DatabaseCommonInteractionPropsUtil.getUserPermissions(
+          props,
+          PermissionType.Allow,
+        ),
+      );
+
+      expect(perms).toContain(Permission.Public);
+      expect(perms).toContain(Permission.CurrentUser);
+    });
+
+    test("preserves existing global permissions and appends Public", () => {
+      const props: DatabaseCommonInteractionProps = {
+        userGlobalAccessPermission: {
+          _type: "UserGlobalAccessPermission",
+          projectIds: [],
+          globalPermissions: [Permission.ProjectOwner],
+        },
+      };
+
+      const perms: Array<Permission> = permissionsOf(
+        DatabaseCommonInteractionPropsUtil.getUserPermissions(
+          props,
+          PermissionType.Allow,
+        ),
+      );
+
+      expect(perms).toContain(Permission.ProjectOwner);
+      expect(perms).toContain(Permission.Public);
+    });
+
+    test("does not include global permissions for a Block request", () => {
+      const props: DatabaseCommonInteractionProps = {};
+
+      expect(
+        DatabaseCommonInteractionPropsUtil.getUserPermissions(
+          props,
+          PermissionType.Block,
+        ),
+      ).toEqual([]);
+    });
+  });
+
+  describe("tenant permissions", () => {
+    const buildTenantProps: () => {
+      props: DatabaseCommonInteractionProps;
+      tenantId: ObjectID;
+    } = (): {
+      props: DatabaseCommonInteractionProps;
+      tenantId: ObjectID;
+    } => {
+      const tenantId: ObjectID = ObjectID.generate();
+      const tenantPermission: UserTenantAccessPermission = {
+        _type: "UserTenantAccessPermission",
+        projectId: tenantId,
+        permissions: [
+          makePerm(Permission.ProjectMember, false), // allow row
+          makePerm(Permission.ProjectOwner, true), // block row
+        ],
+      };
+
+      return {
+        tenantId,
+        props: {
+          tenantId,
+          userTenantAccessPermission: {
+            [tenantId.toString()]: tenantPermission,
+          },
+        },
+      };
+    };
+
+    test("Allow includes the tenant's non-block permissions (plus global)", () => {
+      const perms: Array<Permission> = permissionsOf(
+        DatabaseCommonInteractionPropsUtil.getUserPermissions(
+          buildTenantProps().props,
+          PermissionType.Allow,
+        ),
+      );
+
+      expect(perms).toContain(Permission.ProjectMember); // allow tenant row
+      expect(perms).toContain(Permission.Public); // global
+      expect(perms).not.toContain(Permission.ProjectOwner); // block row excluded
+    });
+
+    test("Block includes only the tenant's block permissions", () => {
+      const perms: Array<Permission> = permissionsOf(
+        DatabaseCommonInteractionPropsUtil.getUserPermissions(
+          buildTenantProps().props,
+          PermissionType.Block,
+        ),
+      );
+
+      expect(perms).toContain(Permission.ProjectOwner); // block tenant row
+      expect(perms).not.toContain(Permission.ProjectMember); // allow row excluded
+      expect(perms).not.toContain(Permission.Public); // no global for Block
+    });
+  });
+});

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);
+    });
+  });
+});