@oneuptime/common 12.0.0 → 12.0.2

package/Tests/Server/Services/ServiceLevelObjectiveService.test.ts

@@ -13,6 +13,7 @@ import AlertStateTimelineService from "../../../Server/Services/AlertStateTimeli
 import MonitorStatusService from "../../../Server/Services/MonitorStatusService";
 import ServiceLevelObjectiveService from "../../../Server/Services/ServiceLevelObjectiveService";
 import ServiceLevelObjectiveBurnRateRuleService from "../../../Server/Services/ServiceLevelObjectiveBurnRateRuleService";
+import ServiceLevelObjectiveMonitorRuleEngineService from "../../../Server/Services/ServiceLevelObjectiveMonitorRuleEngineService";
 import ServiceLevelObjectiveOwnerTeamService from "../../../Server/Services/ServiceLevelObjectiveOwnerTeamService";
 import ServiceLevelObjectiveOwnerUserService from "../../../Server/Services/ServiceLevelObjectiveOwnerUserService";
 import TeamMemberService from "../../../Server/Services/TeamMemberService";
@@ -1986,3 +1987,132 @@ describe("ServiceLevelObjectiveService.getSloLinkInDashboard", () => {
     expect(path).toContain("/slos/");
   });
 });
+
+/*
+ * The label rule has to be applied by the service that owns the column, not
+ * only by the dashboard that sets it: an SLO created or edited over the API
+ * must come out carrying the monitors its rule implies. Both hooks are
+ * best-effort - a rule that cannot be applied is logged, never allowed to
+ * fail the write that triggered it.
+ */
+describe("ServiceLevelObjectiveService - applying the monitor label rule", () => {
+  let syncMonitorsForSloSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    syncMonitorsForSloSpy = jest
+      .spyOn(
+        ServiceLevelObjectiveMonitorRuleEngineService,
+        "syncMonitorsForSlo",
+      )
+      .mockResolvedValue({ monitorIdsAdded: [], monitorIdsRemoved: [] });
+
+    jest
+      .spyOn(ServiceLevelObjectiveService, "updateOneById")
+      .mockResolvedValue(1);
+    jest
+      .spyOn(ServiceLevelObjectiveService, "findOneById")
+      .mockResolvedValue(makeSlo({ projectId: PROJECT_ID }));
+    jest
+      .spyOn(ServiceLevelObjectiveService, "resolveOpenBurnRateAlertsForSlo")
+      .mockResolvedValue(undefined);
+    jest.spyOn(AlertSeverityService, "findOneBy").mockResolvedValue(null);
+    jest
+      .spyOn(ServiceLevelObjectiveBurnRateRuleService, "create")
+      .mockResolvedValue(makeBurnRateRule(RULE_ID));
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it("runs the rule for a newly created SLO so it is not born with an empty monitor list", async () => {
+    const createdItem: ServiceLevelObjective = makeSlo({
+      _id: SLO_ID.toString(),
+      id: SLO_ID,
+      projectId: PROJECT_ID,
+      targetPercentage: 99.9,
+    });
+
+    await callHook(
+      "onCreateSuccess",
+      {
+        createBy: makeCreateBy({
+          projectId: PROJECT_ID,
+          targetPercentage: 99.9,
+        }),
+        carryForward: null,
+      },
+      createdItem,
+    );
+
+    expect(syncMonitorsForSloSpy).toHaveBeenCalledTimes(1);
+    expect(syncMonitorsForSloSpy).toHaveBeenCalledWith({
+      serviceLevelObjectiveId: SLO_ID,
+    });
+  });
+
+  it("does not fail the create when the rule cannot be applied", async () => {
+    syncMonitorsForSloSpy.mockRejectedValue(new Error("db down"));
+
+    const createdItem: ServiceLevelObjective = makeSlo({
+      _id: SLO_ID.toString(),
+      id: SLO_ID,
+      projectId: PROJECT_ID,
+    });
+
+    await expect(
+      callHook(
+        "onCreateSuccess",
+        {
+          createBy: makeCreateBy({ projectId: PROJECT_ID }),
+          carryForward: null,
+        },
+        createdItem,
+      ),
+    ).resolves.toBe(createdItem);
+  });
+
+  it("re-runs the rule for every SLO whose rule was just edited", async () => {
+    await callHook(
+      "onUpdateSuccess",
+      makeOnUpdate({ monitorLabels: [{ _id: RULE_ID.toString() }] }),
+      [SLO_ID, OTHER_RULE_ID],
+    );
+
+    expect(syncMonitorsForSloSpy).toHaveBeenCalledTimes(2);
+    expect(syncMonitorsForSloSpy).toHaveBeenNthCalledWith(1, {
+      serviceLevelObjectiveId: SLO_ID,
+    });
+    expect(syncMonitorsForSloSpy).toHaveBeenNthCalledWith(2, {
+      serviceLevelObjectiveId: OTHER_RULE_ID,
+    });
+  });
+
+  it("re-runs the rule when it is cleared, which is what gives the monitors back", async () => {
+    await callHook("onUpdateSuccess", makeOnUpdate({ monitorLabels: [] }), [
+      SLO_ID,
+    ]);
+
+    expect(syncMonitorsForSloSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("leaves the rule alone for an edit that does not touch it", async () => {
+    await callHook(
+      "onUpdateSuccess",
+      makeOnUpdate({ targetPercentage: 99.5 }),
+      [SLO_ID],
+    );
+
+    expect(syncMonitorsForSloSpy).not.toHaveBeenCalled();
+  });
+
+  it("does not fail the update when the rule cannot be applied", async () => {
+    syncMonitorsForSloSpy.mockRejectedValue(new Error("db down"));
+
+    await expect(
+      callHook("onUpdateSuccess", makeOnUpdate({ monitorLabels: [] }), [
+        SLO_ID,
+      ]),
+    ).resolves.toBeDefined();
+  });
+});

package/Tests/Server/Services/SloMonitorLabelRuleHooks.test.ts

@@ -0,0 +1,352 @@
+import Label from "../../../Models/DatabaseModels/Label";
+import Monitor from "../../../Models/DatabaseModels/Monitor";
+import ServiceLevelObjective from "../../../Models/DatabaseModels/ServiceLevelObjective";
+import DatabaseConfig from "../../../Server/DatabaseConfig";
+import LabelService from "../../../Server/Services/LabelService";
+import MonitorFeedService from "../../../Server/Services/MonitorFeedService";
+import MonitorService from "../../../Server/Services/MonitorService";
+import ServiceLevelObjectiveMonitorRuleEngineService from "../../../Server/Services/ServiceLevelObjectiveMonitorRuleEngineService";
+import ServiceLevelObjectiveService from "../../../Server/Services/ServiceLevelObjectiveService";
+import DeleteBy from "../../../Server/Types/Database/DeleteBy";
+import { OnDelete, OnUpdate } from "../../../Server/Types/Database/Hooks";
+import UpdateBy from "../../../Server/Types/Database/UpdateBy";
+import URL from "../../../Types/API/URL";
+import ObjectID from "../../../Types/ObjectID";
+import { describe, expect, it, beforeEach, afterEach } from "@jest/globals";
+
+/*
+ * Contract under test - the three places that have to notice a label rule
+ * became stale. The engine itself is covered separately; what matters here is
+ * that something actually calls it.
+ *
+ *   - MonitorService, when a monitor's labels change. Keyed on the field
+ *     being present rather than non-empty, because clearing every label
+ *     arrives as `[]` and is exactly the edit that should detach the monitor
+ *     from its rule-driven SLOs.
+ *
+ *   - LabelService, when a label is deleted. Postgres cascades the rule's
+ *     join rows away without any service hook firing, so the SLOs that used
+ *     that label would otherwise keep monitors nothing explains.
+ *
+ * Every one of them is best-effort: the sync must never fail the write that
+ * triggered it.
+ */
+
+const PROJECT_ID: ObjectID = new ObjectID(
+  "22222222-2222-4222-8222-222222222222",
+);
+const MONITOR_ID: ObjectID = new ObjectID(
+  "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa",
+);
+const OTHER_MONITOR_ID: ObjectID = new ObjectID(
+  "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb",
+);
+const LABEL_ID: ObjectID = new ObjectID("dddddddd-dddd-4ddd-8ddd-dddddddddddd");
+const SLO_ID: ObjectID = new ObjectID("11111111-1111-4111-8111-111111111111");
+const OTHER_SLO_ID: ObjectID = new ObjectID(
+  "1a1a1a1a-1a1a-4a1a-8a1a-1a1a1a1a1a1a",
+);
+
+// Calls a protected hook without widening the service's public surface.
+function callHook(
+  service: unknown,
+  name: string,
+  ...args: Array<unknown>
+): Promise<unknown> {
+  const hooks: Record<
+    string,
+    (...hookArgs: Array<unknown>) => Promise<unknown>
+  > = service as Record<
+    string,
+    (...hookArgs: Array<unknown>) => Promise<unknown>
+  >;
+
+  return hooks[name]!.apply(service, args);
+}
+
+function monitorUpdate(data: Record<string, unknown>): OnUpdate<Monitor> {
+  return {
+    updateBy: {
+      query: { _id: MONITOR_ID.toString() },
+      data: data,
+      props: { isRoot: true, tenantId: PROJECT_ID },
+      limit: 1,
+      skip: 0,
+    } as unknown as UpdateBy<Monitor>,
+    carryForward: null,
+  };
+}
+
+function fakeMonitorRow(): Monitor {
+  return {
+    id: MONITOR_ID,
+    _id: MONITOR_ID.toString(),
+    projectId: PROJECT_ID,
+    name: "API",
+  } as unknown as Monitor;
+}
+
+function fakeLabelRow(id: ObjectID): Label {
+  return { id: id, _id: id.toString(), name: "Production" } as unknown as Label;
+}
+
+function fakeSloRow(id: ObjectID): ServiceLevelObjective {
+  return {
+    id: id,
+    _id: id.toString(),
+    projectId: PROJECT_ID,
+  } as unknown as ServiceLevelObjective;
+}
+
+describe("MonitorService.onUpdateSuccess - keeping SLO label rules honest", () => {
+  let syncSlosForMonitorSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    syncSlosForMonitorSpy = jest
+      .spyOn(
+        ServiceLevelObjectiveMonitorRuleEngineService,
+        "syncSlosForMonitor",
+      )
+      .mockResolvedValue([]);
+
+    jest
+      .spyOn(MonitorService, "findOneById")
+      .mockResolvedValue(fakeMonitorRow());
+    jest
+      .spyOn(DatabaseConfig, "getDashboardUrl")
+      .mockResolvedValue(URL.fromString("https://oneuptime.test/dashboard"));
+    jest.spyOn(LabelService, "findBy").mockResolvedValue([]);
+    jest
+      .spyOn(MonitorFeedService, "createMonitorFeedItem")
+      .mockResolvedValue(undefined as never);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it("re-runs the SLO label rules when a monitor gains a label", async () => {
+    await callHook(
+      MonitorService,
+      "onUpdateSuccess",
+      monitorUpdate({ labels: [{ _id: LABEL_ID.toString() }] }),
+      [MONITOR_ID],
+    );
+
+    expect(syncSlosForMonitorSpy).toHaveBeenCalledTimes(1);
+    expect(syncSlosForMonitorSpy).toHaveBeenCalledWith({
+      monitorId: MONITOR_ID,
+      projectId: PROJECT_ID,
+    });
+  });
+
+  it("re-runs them when the last label is removed - `[]` is an edit, not an absence", async () => {
+    await callHook(
+      MonitorService,
+      "onUpdateSuccess",
+      monitorUpdate({ labels: [] }),
+      [MONITOR_ID],
+    );
+
+    expect(syncSlosForMonitorSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("re-runs them for every monitor a bulk label edit touched", async () => {
+    await callHook(
+      MonitorService,
+      "onUpdateSuccess",
+      monitorUpdate({ labels: [{ _id: LABEL_ID.toString() }] }),
+      [MONITOR_ID, OTHER_MONITOR_ID],
+    );
+
+    expect(syncSlosForMonitorSpy).toHaveBeenCalledTimes(2);
+    expect(syncSlosForMonitorSpy).toHaveBeenNthCalledWith(2, {
+      monitorId: OTHER_MONITOR_ID,
+      projectId: PROJECT_ID,
+    });
+  });
+
+  it("does not run them for an edit that cannot change SLO membership", async () => {
+    await callHook(
+      MonitorService,
+      "onUpdateSuccess",
+      monitorUpdate({ description: "just a doc tweak" }),
+      [MONITOR_ID],
+    );
+
+    expect(syncSlosForMonitorSpy).not.toHaveBeenCalled();
+  });
+
+  it("does not fail the monitor update when the sync throws", async () => {
+    syncSlosForMonitorSpy.mockRejectedValue(new Error("db down"));
+
+    await expect(
+      callHook(
+        MonitorService,
+        "onUpdateSuccess",
+        monitorUpdate({ labels: [] }),
+        [MONITOR_ID],
+      ),
+    ).resolves.toBeDefined();
+  });
+
+  it("keeps syncing the remaining monitors after one of them fails", async () => {
+    syncSlosForMonitorSpy
+      .mockRejectedValueOnce(new Error("db down"))
+      .mockResolvedValueOnce([]);
+
+    await callHook(
+      MonitorService,
+      "onUpdateSuccess",
+      monitorUpdate({ labels: [] }),
+      [MONITOR_ID, OTHER_MONITOR_ID],
+    );
+
+    expect(syncSlosForMonitorSpy).toHaveBeenCalledTimes(2);
+  });
+});
+
+describe("LabelService - a deleted label takes its SLO rule with it", () => {
+  let syncMonitorsForSloSpy: jest.SpyInstance;
+  let sloFindBySpy: jest.SpyInstance;
+  let labelFindBySpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    syncMonitorsForSloSpy = jest
+      .spyOn(
+        ServiceLevelObjectiveMonitorRuleEngineService,
+        "syncMonitorsForSlo",
+      )
+      .mockResolvedValue({ monitorIdsAdded: [], monitorIdsRemoved: [] });
+    sloFindBySpy = jest.spyOn(ServiceLevelObjectiveService, "findBy");
+    labelFindBySpy = jest.spyOn(LabelService, "findBy");
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  function deleteBy(): DeleteBy<Label> {
+    return {
+      query: { _id: LABEL_ID.toString() },
+      props: { isRoot: true },
+      limit: 1,
+      skip: 0,
+    } as unknown as DeleteBy<Label>;
+  }
+
+  it("notes down the SLOs whose rule uses the label, while the label still exists", async () => {
+    labelFindBySpy.mockResolvedValue([fakeLabelRow(LABEL_ID)]);
+    sloFindBySpy.mockResolvedValue([
+      fakeSloRow(SLO_ID),
+      fakeSloRow(OTHER_SLO_ID),
+    ]);
+
+    const onDelete: OnDelete<Label> = (await callHook(
+      LabelService,
+      "onBeforeDelete",
+      deleteBy(),
+    )) as OnDelete<Label>;
+
+    const query: { monitorLabels: Array<ObjectID> } = sloFindBySpy.mock
+      .calls[0]![0]!.query as { monitorLabels: Array<ObjectID> };
+
+    expect(
+      query.monitorLabels.map((id: ObjectID) => {
+        return id.toString();
+      }),
+    ).toEqual([LABEL_ID.toString()]);
+
+    const carried: { serviceLevelObjectiveIds: Array<ObjectID> } =
+      onDelete.carryForward as { serviceLevelObjectiveIds: Array<ObjectID> };
+
+    expect(
+      carried.serviceLevelObjectiveIds.map((id: ObjectID) => {
+        return id.toString();
+      }),
+    ).toEqual([SLO_ID.toString(), OTHER_SLO_ID.toString()]);
+  });
+
+  it("does not go looking for SLOs when the delete matched no labels", async () => {
+    labelFindBySpy.mockResolvedValue([]);
+
+    await callHook(LabelService, "onBeforeDelete", deleteBy());
+
+    expect(sloFindBySpy).not.toHaveBeenCalled();
+  });
+
+  it("re-runs the now-smaller rule for each noted SLO once the label is gone", async () => {
+    await callHook(
+      LabelService,
+      "onDeleteSuccess",
+      {
+        deleteBy: deleteBy(),
+        carryForward: { serviceLevelObjectiveIds: [SLO_ID, OTHER_SLO_ID] },
+      },
+      [LABEL_ID],
+    );
+
+    expect(syncMonitorsForSloSpy).toHaveBeenCalledTimes(2);
+    expect(syncMonitorsForSloSpy).toHaveBeenNthCalledWith(1, {
+      serviceLevelObjectiveId: SLO_ID,
+    });
+    expect(syncMonitorsForSloSpy).toHaveBeenNthCalledWith(2, {
+      serviceLevelObjectiveId: OTHER_SLO_ID,
+    });
+  });
+
+  it("does nothing after deleting a label no SLO rule referenced", async () => {
+    await callHook(
+      LabelService,
+      "onDeleteSuccess",
+      { deleteBy: deleteBy(), carryForward: { serviceLevelObjectiveIds: [] } },
+      [LABEL_ID],
+    );
+
+    expect(syncMonitorsForSloSpy).not.toHaveBeenCalled();
+  });
+
+  it("tolerates a delete that carried nothing forward", async () => {
+    await expect(
+      callHook(
+        LabelService,
+        "onDeleteSuccess",
+        { deleteBy: deleteBy(), carryForward: null },
+        [LABEL_ID],
+      ),
+    ).resolves.toBeDefined();
+
+    expect(syncMonitorsForSloSpy).not.toHaveBeenCalled();
+  });
+
+  it("still deletes the label when the SLO lookup fails", async () => {
+    labelFindBySpy.mockRejectedValue(new Error("db down"));
+
+    const onDelete: OnDelete<Label> = (await callHook(
+      LabelService,
+      "onBeforeDelete",
+      deleteBy(),
+    )) as OnDelete<Label>;
+
+    expect(
+      (onDelete.carryForward as { serviceLevelObjectiveIds: Array<ObjectID> })
+        .serviceLevelObjectiveIds,
+    ).toEqual([]);
+  });
+
+  it("still reports the delete as done when re-running a rule fails", async () => {
+    syncMonitorsForSloSpy.mockRejectedValue(new Error("db down"));
+
+    await expect(
+      callHook(
+        LabelService,
+        "onDeleteSuccess",
+        {
+          deleteBy: deleteBy(),
+          carryForward: { serviceLevelObjectiveIds: [SLO_ID] },
+        },
+        [LABEL_ID],
+      ),
+    ).resolves.toBeDefined();
+  });
+});

package/Tests/Server/Services/StatusPageSubscriberReport.test.ts

@@ -28,6 +28,10 @@ import StatusPageResource from "../../../Models/DatabaseModels/StatusPageResourc
 import Dictionary from "../../../Types/Dictionary";
 import ObjectID from "../../../Types/ObjectID";
 import OneUptimeDate from "../../../Types/Date";
+import StatusPageReportPeriodType from "../../../Types/StatusPage/StatusPageReportPeriodType";
+import StatusPageReportPeriodUtil, {
+  StatusPageReportPeriod,
+} from "../../../Utils/StatusPage/ReportPeriod";
 import PositiveNumber from "../../../Types/PositiveNumber";
 import { Green, Red } from "../../../Types/BrandColors";
 import {
@@ -74,6 +78,18 @@ const WEBSITE_MONITOR: ObjectID = new ObjectID(
 
 const HISTORY_DAYS: number = 14;
 
+/*
+ * The window under test: the rolling fourteen days the timeline below is built
+ * around. Resolved through the same util the worker uses so these tests keep
+ * exercising the real string formatting as well as the boundaries.
+ */
+function reportPeriod(): StatusPageReportPeriod {
+  return StatusPageReportPeriodUtil.getReportPeriod({
+    periodType: StatusPageReportPeriodType.Rolling,
+    reportDataInDays: HISTORY_DAYS,
+  });
+}
+
 const OPERATIONAL: MonitorStatus = new MonitorStatus();
 OPERATIONAL.id = new ObjectID("bb000000-0000-4000-8000-000000000001");
 OPERATIONAL.name = "Operational";
@@ -284,7 +300,7 @@ describe("StatusPageService.getReportByStatusPage", () => {
       const report: StatusPageReport =
         await StatusPageService.getReportByStatusPage({
           statusPageId: STATUS_PAGE_ID,
-          historyDays: HISTORY_DAYS,
+          reportPeriod: reportPeriod(),
         });
 
       expect(report.hasGroups).toBe(true);
@@ -303,7 +319,7 @@ describe("StatusPageService.getReportByStatusPage", () => {
       const report: StatusPageReport =
         await StatusPageService.getReportByStatusPage({
           statusPageId: STATUS_PAGE_ID,
-          historyDays: HISTORY_DAYS,
+          reportPeriod: reportPeriod(),
         });
 
       expect(rowNames(report.rows)).toEqual([
@@ -321,7 +337,7 @@ describe("StatusPageService.getReportByStatusPage", () => {
       const report: StatusPageReport =
         await StatusPageService.getReportByStatusPage({
           statusPageId: STATUS_PAGE_ID,
-          historyDays: HISTORY_DAYS,
+          reportPeriod: reportPeriod(),
         });
 
       const unit: StatusPageReportGroup =
@@ -344,7 +360,7 @@ describe("StatusPageService.getReportByStatusPage", () => {
       const report: StatusPageReport =
         await StatusPageService.getReportByStatusPage({
           statusPageId: STATUS_PAGE_ID,
-          historyDays: HISTORY_DAYS,
+          reportPeriod: reportPeriod(),
         });
 
       const pathByName: Dictionary<string> = {};
@@ -368,7 +384,7 @@ describe("StatusPageService.getReportByStatusPage", () => {
       const report: StatusPageReport =
         await StatusPageService.getReportByStatusPage({
           statusPageId: STATUS_PAGE_ID,
-          historyDays: HISTORY_DAYS,
+          reportPeriod: reportPeriod(),
         });
 
       const uptimeByName: Dictionary<string> = {};
@@ -387,7 +403,7 @@ describe("StatusPageService.getReportByStatusPage", () => {
       const report: StatusPageReport =
         await StatusPageService.getReportByStatusPage({
           statusPageId: STATUS_PAGE_ID,
-          historyDays: HISTORY_DAYS,
+          reportPeriod: reportPeriod(),
         });
 
       const corporate: StatusPageReportGroup = report.groups[0]!;
@@ -405,7 +421,7 @@ describe("StatusPageService.getReportByStatusPage", () => {
       const report: StatusPageReport =
         await StatusPageService.getReportByStatusPage({
           statusPageId: STATUS_PAGE_ID,
-          historyDays: HISTORY_DAYS,
+          reportPeriod: reportPeriod(),
         });
 
       const corporate: StatusPageReportGroup = report.groups[0]!;
@@ -418,7 +434,7 @@ describe("StatusPageService.getReportByStatusPage", () => {
       const report: StatusPageReport =
         await StatusPageService.getReportByStatusPage({
           statusPageId: STATUS_PAGE_ID,
-          historyDays: HISTORY_DAYS,
+          reportPeriod: reportPeriod(),
         });
 
       const corporate: StatusPageReportGroup = report.groups[0]!;
@@ -441,7 +457,7 @@ describe("StatusPageService.getReportByStatusPage", () => {
 
       await StatusPageService.getReportByStatusPage({
         statusPageId: STATUS_PAGE_ID,
-        historyDays: HISTORY_DAYS,
+        reportPeriod: reportPeriod(),
       });
 
       /*
@@ -456,7 +472,7 @@ describe("StatusPageService.getReportByStatusPage", () => {
       const report: StatusPageReport =
         await StatusPageService.getReportByStatusPage({
           statusPageId: STATUS_PAGE_ID,
-          historyDays: HISTORY_DAYS,
+          reportPeriod: reportPeriod(),
         });
 
       expect(report.totalResources).toBe(3);
@@ -471,7 +487,7 @@ describe("StatusPageService.getReportByStatusPage", () => {
       const report: StatusPageReport =
         await StatusPageService.getReportByStatusPage({
           statusPageId: STATUS_PAGE_ID,
-          historyDays: HISTORY_DAYS,
+          reportPeriod: reportPeriod(),
         });
 
       expect(
@@ -513,7 +529,7 @@ describe("StatusPageService.getReportByStatusPage", () => {
       const report: StatusPageReport =
         await StatusPageService.getReportByStatusPage({
           statusPageId: STATUS_PAGE_ID,
-          historyDays: HISTORY_DAYS,
+          reportPeriod: reportPeriod(),
         });
 
       expect(report.hasGroups).toBe(false);
@@ -541,7 +557,7 @@ describe("StatusPageService.getReportByStatusPage", () => {
       const report: StatusPageReport =
         await StatusPageService.getReportByStatusPage({
           statusPageId: STATUS_PAGE_ID,
-          historyDays: HISTORY_DAYS,
+          reportPeriod: reportPeriod(),
         });
 
       expect(report.totalResources).toBe(0);