@oneuptime/common 12.0.1 → 12.0.3

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

@@ -0,0 +1,228 @@
+import Monitor from "../../../Models/DatabaseModels/Monitor";
+import MonitorLabelRuleEngineService from "../../../Server/Services/MonitorLabelRuleEngineService";
+import MonitorOwnerRuleEngineService from "../../../Server/Services/MonitorOwnerRuleEngineService";
+import MonitorService from "../../../Server/Services/MonitorService";
+import ServiceLevelObjectiveMonitorRuleEngineService from "../../../Server/Services/ServiceLevelObjectiveMonitorRuleEngineService";
+import StatusPageMonitorRuleEngineService from "../../../Server/Services/StatusPageMonitorRuleEngineService";
+import CreateBy from "../../../Server/Types/Database/CreateBy";
+import { OnCreate } from "../../../Server/Types/Database/Hooks";
+import MonitorType from "../../../Types/Monitor/MonitorType";
+import ObjectID from "../../../Types/ObjectID";
+import { describe, expect, it, beforeEach, afterEach } from "@jest/globals";
+
+/*
+ * Contract under test - the create-side half of the status page monitor rule
+ * trigger, which is how monitors normally arrive on a status page. A rule that
+ * only ever noticed EDITS would leave every newly created monitor off the page
+ * until somebody happened to touch it again.
+ *
+ * MonitorService.onCreateSuccess runs its slow work on a detached promise
+ * chain (the create response must not wait for it), so these tests call the
+ * hook and then wait for the effect rather than awaiting the hook alone.
+ *
+ * Ordering matters as much as the call itself: the sync has to run AFTER
+ * MonitorLabelRuleEngineService, because a monitor created with no labels of
+ * its own can still earn them from a label rule, and those labels are exactly
+ * what a status page rule is likely to match on.
+ */
+
+const PROJECT_ID: ObjectID = new ObjectID(
+  "22222222-2222-4222-8222-222222222222",
+);
+const MONITOR_ID: ObjectID = new ObjectID(
+  "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa",
+);
+const MONITOR_STATUS_ID: ObjectID = new ObjectID(
+  "55555555-5555-4555-8555-555555555555",
+);
+
+// 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 createdMonitor(): Monitor {
+  return {
+    id: MONITOR_ID,
+    _id: MONITOR_ID.toString(),
+    projectId: PROJECT_ID,
+    name: "Checkout API",
+    description: "tier-1",
+    // Manual monitors take no probes, which keeps the inline probe step out.
+    monitorType: MonitorType.Manual,
+    currentMonitorStatusId: MONITOR_STATUS_ID,
+  } as unknown as Monitor;
+}
+
+function onCreate(): OnCreate<Monitor> {
+  return {
+    createBy: {
+      data: createdMonitor(),
+      props: { isRoot: true, tenantId: PROJECT_ID },
+    } as unknown as CreateBy<Monitor>,
+    carryForward: null,
+  };
+}
+
+/**
+ * The chain is detached, so poll for the effect instead of awaiting the hook.
+ * Returns as soon as the predicate holds, or gives up after ~2s so a genuine
+ * regression fails loudly rather than hanging the suite.
+ */
+async function waitFor(predicate: () => boolean): Promise<void> {
+  for (let attempt: number = 0; attempt < 200; attempt++) {
+    if (predicate()) {
+      return;
+    }
+
+    await new Promise<void>((resolve: () => void) => {
+      setTimeout(resolve, 10);
+    });
+  }
+}
+
+describe("MonitorService.onCreateSuccess - putting a new monitor on the status pages that want it", () => {
+  let syncRulesForMonitorSpy: jest.SpyInstance;
+  let applyLabelRulesSpy: jest.SpyInstance;
+  const callOrder: Array<string> = [];
+
+  beforeEach(() => {
+    callOrder.length = 0;
+
+    applyLabelRulesSpy = jest
+      .spyOn(MonitorLabelRuleEngineService, "applyRulesToMonitor")
+      .mockImplementation(async () => {
+        callOrder.push("labelRules");
+      });
+
+    syncRulesForMonitorSpy = jest
+      .spyOn(StatusPageMonitorRuleEngineService, "syncRulesForMonitor")
+      .mockImplementation(async () => {
+        callOrder.push("statusPageRules");
+        return [];
+      });
+
+    jest
+      .spyOn(MonitorOwnerRuleEngineService, "applyRulesToMonitor")
+      .mockResolvedValue(undefined);
+    jest
+      .spyOn(
+        ServiceLevelObjectiveMonitorRuleEngineService,
+        "syncSlosForMonitor",
+      )
+      .mockResolvedValue([]);
+    jest
+      .spyOn(MonitorService, "findOneById")
+      .mockResolvedValue(createdMonitor());
+    /*
+     * Private/protected members of the service under test, spied so the hook
+     * never reaches the network or the database. Billing is not stubbed: the
+     * step is gated on IsBillingEnabled, which is off in tests.
+     */
+    const service: never = MonitorService as never;
+
+    jest
+      .spyOn(service, "handleWorkspaceOperationsAsync" as never)
+      .mockResolvedValue(undefined as never);
+    jest
+      .spyOn(service, "refreshMonitorProbeStatus" as never)
+      .mockResolvedValue(undefined as never);
+    jest
+      .spyOn(service, "changeMonitorStatus" as never)
+      .mockResolvedValue(undefined as never);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it("runs the status page monitor rules for a monitor that was just created", async () => {
+    await callHook(
+      MonitorService,
+      "onCreateSuccess",
+      onCreate(),
+      createdMonitor(),
+    );
+
+    await waitFor(() => {
+      return syncRulesForMonitorSpy.mock.calls.length > 0;
+    });
+
+    expect(syncRulesForMonitorSpy).toHaveBeenCalledWith({
+      monitorId: MONITOR_ID,
+      projectId: PROJECT_ID,
+    });
+  });
+
+  /*
+   * A monitor created with no labels can be given some by a MonitorLabelRule.
+   * Running the status page rules first would evaluate them against a monitor
+   * that has not earned its labels yet, and it would land on no page at all.
+   */
+  it("runs them after the label rules, so rule-added labels are visible", async () => {
+    await callHook(
+      MonitorService,
+      "onCreateSuccess",
+      onCreate(),
+      createdMonitor(),
+    );
+
+    await waitFor(() => {
+      return callOrder.includes("statusPageRules");
+    });
+
+    expect(callOrder.indexOf("labelRules")).toBeGreaterThanOrEqual(0);
+    expect(callOrder.indexOf("statusPageRules")).toBeGreaterThan(
+      callOrder.indexOf("labelRules"),
+    );
+  });
+
+  it("does not fail the monitor create when the sync throws", async () => {
+    syncRulesForMonitorSpy.mockRejectedValue(new Error("db down"));
+
+    await expect(
+      callHook(MonitorService, "onCreateSuccess", onCreate(), createdMonitor()),
+    ).resolves.toBeDefined();
+
+    await waitFor(() => {
+      return syncRulesForMonitorSpy.mock.calls.length > 0;
+    });
+
+    expect(syncRulesForMonitorSpy).toHaveBeenCalled();
+  });
+
+  /*
+   * The label rule step is wrapped in its own try/catch that returns early on
+   * failure. If that early return also skipped the status page sync, a project
+   * with a broken label rule would quietly stop putting new monitors on its
+   * status pages.
+   */
+  it("still runs them when the label rules step fails", async () => {
+    applyLabelRulesSpy.mockRejectedValue(new Error("label rules down"));
+
+    await callHook(
+      MonitorService,
+      "onCreateSuccess",
+      onCreate(),
+      createdMonitor(),
+    );
+
+    await waitFor(() => {
+      return syncRulesForMonitorSpy.mock.calls.length > 0;
+    });
+
+    expect(syncRulesForMonitorSpy).toHaveBeenCalled();
+  });
+});

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

package/Tests/Server/TestingUtils/Services/BillingServiceHelper.ts

@@ -61,32 +61,92 @@ const getStripeCustomer: GetStripeCustomerFunction = (
 type GetStripeSubscriptionFunction = (options?: {
   id?: string | undefined;
   status?: Stripe.Subscription.Status | undefined;
+
+  /*
+   * The trial Stripe itself reports on the subscription, as a unix timestamp -
+   * what a real subscription carries and what changePlan reads to make sure a
+   * plan change cannot cut a running trial short. Omitted means no trial.
+   */
+  trialEnd?: number | null | undefined;
+  customer?: string | undefined;
+
+  /*
+   * The id of the subscription's single item - the handle changePlan swaps the
+   * new plan's price onto. An empty array stands for a subscription with no
+   * items at all, which has no such handle.
+   */
+  itemId?: string | undefined;
+  items?: Array<{ id: string }> | undefined;
 }) => Stripe.Subscription;
 
 const getStripeSubscription: GetStripeSubscriptionFunction = (options?: {
   id?: string | undefined;
   status?: Stripe.Subscription.Status | undefined;
+  trialEnd?: number | null | undefined;
+  customer?: string | undefined;
+  itemId?: string | undefined;
+  items?: Array<{ id: string }> | undefined;
 }): Stripe.Subscription => {
+  const items: Array<{ id: string }> = options?.items || [
+    { id: options?.itemId || Faker.generateRandomObjectID().toString() },
+  ];
+
   return {
     id: options?.id || Faker.generateRandomObjectID().toString(),
     items: {
-      data: [
-        {
-          id: Faker.generateRandomObjectID().toString(),
-          // @ts-expect-error - Simplified mock price object for testing without all required Stripe Price properties
+      data: items.map((item: { id: string }) => {
+        // Simplified mock item: only the fields the service actually reads.
+        return {
+          id: item.id,
           price: {
             id: new BillingService().getMeteredPlanPriceId(
               ProductType.ActiveMonitoring,
             ),
           },
-        },
-      ],
+        } as Stripe.SubscriptionItem;
+      }),
     },
     status: options?.status || "active",
-    customer: getStripeCustomer(),
-  };
+    trial_end: options?.trialEnd ?? null,
+    customer: options?.customer || getStripeCustomer(),
+  } as Stripe.Subscription;
 };
 
+/*
+ * A plan with an exact trial period, for the cases where the trial length is
+ * the thing under test. getSubscriptionPlanData randomises it between 1 and
+ * 100, so it can never produce the 0-trial-day plans (Basic, Scale) that the
+ * mid-trial plan change has to keep trialing.
+ */
+type GetSubscriptionPlanWithTrialPeriodFunction = (
+  trialPeriodInDays: number,
+  options?: {
+    name?: string | undefined;
+    monthlyPlanId?: string | undefined;
+    yearlyPlanId?: string | undefined;
+  },
+) => SubscriptionPlan;
+
+const getSubscriptionPlanWithTrialPeriod: GetSubscriptionPlanWithTrialPeriodFunction =
+  (
+    trialPeriodInDays: number,
+    options?: {
+      name?: string | undefined;
+      monthlyPlanId?: string | undefined;
+      yearlyPlanId?: string | undefined;
+    },
+  ): SubscriptionPlan => {
+    return new SubscriptionPlan(
+      options?.monthlyPlanId || "price_monthly_test_plan",
+      options?.yearlyPlanId || "price_yearly_test_plan",
+      options?.name || "Scale",
+      99, // monthlySubscriptionAmountInUSD
+      84, // yearlySubscriptionAmountInUSD
+      3, // order
+      trialPeriodInDays,
+    );
+  };
+
 type GetSubscriptionPlanDataFunction = () => SubscriptionPlan;
 
 const getSubscriptionPlanData: GetSubscriptionPlanDataFunction =
@@ -200,6 +260,7 @@ export {
   getStripeCustomer,
   getStripeSubscription,
   getSubscriptionPlanData,
+  getSubscriptionPlanWithTrialPeriod,
   getCustomerData,
   getSubscriptionData,
   getMeteredSubscription,