@oneuptime/common 13.0.7 → 14.0.0

package/Tests/UI/Utils/ModelAPIRequestClient.test.ts

@@ -0,0 +1,278 @@
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+import Log from "../../../Models/AnalyticsModels/Log";
+import Incident from "../../../Models/DatabaseModels/Incident";
+import Project from "../../../Models/DatabaseModels/Project";
+import HTTPResponse from "../../../Types/API/HTTPResponse";
+import URL from "../../../Types/API/URL";
+import Dictionary from "../../../Types/Dictionary";
+import { JSONArray, JSONObject } from "../../../Types/JSON";
+import ObjectID from "../../../Types/ObjectID";
+import AnalyticsModelAPI from "../../../UI/Utils/AnalyticsModelAPI/AnalyticsModelAPI";
+import DashboardAPI from "../../../UI/Utils/API/API";
+import ModelAPI from "../../../UI/Utils/ModelAPI/ModelAPI";
+import ProjectUtil from "../../../UI/Utils/Project";
+
+/*
+ * RequestOptions.apiClient picks the client for ONE model request. A public
+ * dashboard widget uses it to send its /public-dashboard-api read through the
+ * public dashboard's client, so that endpoint's 401 never reaches the
+ * dashboard client's refresh-token + User.logout + /accounts/login.
+ *
+ * Each client's `fetch` is spied independently, and the dashboard spy rejects
+ * whenever it must not be used, so a model API that ignores the routed client
+ * (or hard-codes the dashboard client again) fails here.
+ */
+
+interface StaticSpy {
+  mockResolvedValue: (value: unknown) => StaticSpy;
+  mockRejectedValue: (value: unknown) => StaticSpy;
+  mock: { calls: Array<Array<unknown>> };
+}
+
+class RoutedAPI extends DashboardAPI {}
+
+class SubclassDefaultAPI extends DashboardAPI {}
+
+class SubclassModelAPI extends ModelAPI {
+  protected static override getApiClient(): typeof DashboardAPI {
+    return SubclassDefaultAPI;
+  }
+}
+
+const VIEWER_PROJECT_ID: string = "019acd20-1111-4111-8111-111111111111";
+
+const OVERRIDE_URL: string =
+  "https://dashboards.example.com/public-dashboard-api/resource-list/dashboard-id/incident";
+
+let routedFetchSpy: StaticSpy;
+let subclassDefaultFetchSpy: StaticSpy;
+let dashboardFetchSpy: StaticSpy;
+
+const listResponse: () => HTTPResponse<JSONArray> =
+  (): HTTPResponse<JSONArray> => {
+    return new HTTPResponse<JSONArray>(
+      200,
+      { data: [], count: 0, skip: 0, limit: 10 },
+      {},
+    );
+  };
+
+const countResponse: () => HTTPResponse<JSONObject> =
+  (): HTTPResponse<JSONObject> => {
+    return new HTTPResponse<JSONObject>(200, { count: 0 }, {});
+  };
+
+const requestedUrl: (spy: StaticSpy) => string = (spy: StaticSpy): string => {
+  return String((spy.mock.calls[0]![0] as { url: URL }).url);
+};
+
+beforeEach(() => {
+  /*
+   * Spy on the inherited statics of the subclasses first: jest then installs
+   * own spies on them, and the later DashboardAPI spy stays independent.
+   */
+  routedFetchSpy = jest.spyOn(RoutedAPI, "fetch") as unknown as StaticSpy;
+  subclassDefaultFetchSpy = jest.spyOn(
+    SubclassDefaultAPI,
+    "fetch",
+  ) as unknown as StaticSpy;
+  dashboardFetchSpy = jest.spyOn(DashboardAPI, "fetch") as unknown as StaticSpy;
+
+  routedFetchSpy.mockResolvedValue(listResponse());
+  subclassDefaultFetchSpy.mockResolvedValue(listResponse());
+  dashboardFetchSpy.mockRejectedValue(
+    new Error("the dashboard client must not receive this request"),
+  );
+});
+
+afterEach(() => {
+  jest.restoreAllMocks();
+});
+
+describe("RequestOptions.apiClient routes a single model request", () => {
+  test("ModelAPI.getList sends a routed read through the routed client", async () => {
+    await ModelAPI.getList<Incident>({
+      modelType: Incident,
+      query: {},
+      limit: 10,
+      skip: 0,
+      select: { title: true },
+      sort: {},
+      requestOptions: {
+        overrideRequestUrl: URL.fromString(OVERRIDE_URL),
+        apiClient: RoutedAPI,
+      },
+    });
+
+    expect(routedFetchSpy.mock.calls).toHaveLength(1);
+    expect(requestedUrl(routedFetchSpy)).toContain(OVERRIDE_URL);
+    expect(dashboardFetchSpy.mock.calls).toHaveLength(0);
+  });
+
+  test("ModelAPI.count sends a routed read through the routed client", async () => {
+    routedFetchSpy.mockResolvedValue(countResponse());
+
+    await ModelAPI.count<Incident>({
+      modelType: Incident,
+      query: {},
+      requestOptions: {
+        overrideRequestUrl: URL.fromString(OVERRIDE_URL),
+        apiClient: RoutedAPI,
+      },
+    });
+
+    expect(routedFetchSpy.mock.calls).toHaveLength(1);
+    expect(dashboardFetchSpy.mock.calls).toHaveLength(0);
+  });
+
+  test("AnalyticsModelAPI.getList sends a routed read through the routed client", async () => {
+    await AnalyticsModelAPI.getList<Log>({
+      modelType: Log,
+      query: {},
+      limit: 10,
+      skip: 0,
+      select: { body: true },
+      sort: {},
+      requestOptions: {
+        overrideRequestUrl: URL.fromString(OVERRIDE_URL),
+        apiClient: RoutedAPI,
+      },
+    });
+
+    expect(routedFetchSpy.mock.calls).toHaveLength(1);
+    expect(requestedUrl(routedFetchSpy)).toContain(OVERRIDE_URL);
+    expect(dashboardFetchSpy.mock.calls).toHaveLength(0);
+  });
+
+  test("AnalyticsModelAPI.count sends a routed read through the routed client", async () => {
+    routedFetchSpy.mockResolvedValue(countResponse());
+
+    await AnalyticsModelAPI.count<Log>(
+      Log,
+      {},
+      {
+        overrideRequestUrl: URL.fromString(OVERRIDE_URL),
+        apiClient: RoutedAPI,
+      },
+    );
+
+    expect(routedFetchSpy.mock.calls).toHaveLength(1);
+    expect(dashboardFetchSpy.mock.calls).toHaveLength(0);
+  });
+
+  test("without a routed client, both model APIs keep the dashboard client", async () => {
+    dashboardFetchSpy.mockResolvedValue(listResponse());
+
+    await ModelAPI.getList<Incident>({
+      modelType: Incident,
+      query: {},
+      limit: 10,
+      skip: 0,
+      select: { title: true },
+      sort: {},
+    });
+
+    await AnalyticsModelAPI.getList<Log>({
+      modelType: Log,
+      query: {},
+      limit: 10,
+      skip: 0,
+      select: { body: true },
+      sort: {},
+      requestOptions: { overrideRequestUrl: URL.fromString(OVERRIDE_URL) },
+    });
+
+    expect(dashboardFetchSpy.mock.calls).toHaveLength(2);
+    expect(routedFetchSpy.mock.calls).toHaveLength(0);
+  });
+
+  /*
+   * A ModelAPI subclass (StatusPageModelAPI) changes the DEFAULT client; a
+   * request that names its own client still wins, and one that does not keeps
+   * the subclass's default rather than falling back to the dashboard client.
+   */
+  test("a routed client wins over a subclass's default, which still applies otherwise", async () => {
+    await SubclassModelAPI.getList<Incident>({
+      modelType: Incident,
+      query: {},
+      limit: 10,
+      skip: 0,
+      select: { title: true },
+      sort: {},
+      requestOptions: {
+        overrideRequestUrl: URL.fromString(OVERRIDE_URL),
+        apiClient: RoutedAPI,
+      },
+    });
+
+    expect(routedFetchSpy.mock.calls).toHaveLength(1);
+    expect(subclassDefaultFetchSpy.mock.calls).toHaveLength(0);
+
+    await SubclassModelAPI.getList<Incident>({
+      modelType: Incident,
+      query: {},
+      limit: 10,
+      skip: 0,
+      select: { title: true },
+      sort: {},
+      requestOptions: { overrideRequestUrl: URL.fromString(OVERRIDE_URL) },
+    });
+
+    expect(subclassDefaultFetchSpy.mock.calls).toHaveLength(1);
+    expect(dashboardFetchSpy.mock.calls).toHaveLength(0);
+  });
+});
+
+/*
+ * A routed request is scoped by its own client, not by the viewer's dashboard
+ * project: the public dashboard's client sends an empty tenant, and a
+ * remembered (possibly stale or foreign) project would override it and turn
+ * the public read into a 405 (tenant not found).
+ */
+describe("RequestOptions.apiClient and the viewer's dashboard project", () => {
+  beforeEach(() => {
+    const project: Project = new Project();
+    project.id = new ObjectID(VIEWER_PROJECT_ID);
+
+    // ModelAPI reads the id; AnalyticsModelAPI reads the stored project.
+    jest
+      .spyOn(ProjectUtil, "getCurrentProjectId")
+      .mockReturnValue(new ObjectID(VIEWER_PROJECT_ID));
+    jest.spyOn(ProjectUtil, "getCurrentProject").mockReturnValue(project);
+  });
+
+  test("a routed request does not carry the viewer's tenant", () => {
+    const modelHeaders: Dictionary<string> = ModelAPI.getCommonHeaders({
+      overrideRequestUrl: URL.fromString(OVERRIDE_URL),
+      apiClient: RoutedAPI,
+    });
+
+    const analyticsHeaders: Dictionary<string> =
+      AnalyticsModelAPI.getCommonHeaders({
+        overrideRequestUrl: URL.fromString(OVERRIDE_URL),
+        apiClient: RoutedAPI,
+      });
+
+    expect(modelHeaders["tenantid"]).toBeUndefined();
+    expect(analyticsHeaders["tenantid"]).toBeUndefined();
+  });
+
+  test("every other request still carries it", () => {
+    expect(ModelAPI.getCommonHeaders()["tenantid"]).toBe(VIEWER_PROJECT_ID);
+    expect(
+      ModelAPI.getCommonHeaders({
+        overrideRequestUrl: URL.fromString(OVERRIDE_URL),
+      })["tenantid"],
+    ).toBe(VIEWER_PROJECT_ID);
+    expect(AnalyticsModelAPI.getCommonHeaders()["tenantid"]).toBe(
+      VIEWER_PROJECT_ID,
+    );
+  });
+});

package/Tests/UI/Utils/Navigation.test.ts

@@ -317,3 +317,36 @@ describe("Navigation internal route safety", () => {
     expect(window.location.hash).toBe("#forced");
   });
 });
+
+describe("Navigation current route", () => {
+  const clearRouterLocation: () => void = (): void => {
+    (Navigation as unknown as { location: unknown }).location = undefined;
+  };
+
+  afterEach(() => {
+    clearRouterLocation();
+    window.history.replaceState(null, "", "/");
+  });
+
+  test("reads the address bar before the router has provided a location", () => {
+    clearRouterLocation();
+    window.history.replaceState(null, "", "/status-page/abc/login?x=1");
+
+    expect(Navigation.getCurrentRoute().toString()).toBe(
+      "/status-page/abc/login",
+    );
+  });
+
+  test("prefers the router's location once it has been set", () => {
+    window.history.replaceState(null, "", "/from-the-address-bar");
+    Navigation.setLocation({
+      pathname: "/from-the-router",
+      search: "",
+      hash: "",
+      state: null,
+      key: "navigation-current-route",
+    });
+
+    expect(Navigation.getCurrentRoute().toString()).toBe("/from-the-router");
+  });
+});

package/Tests/UI/Utils/PricingPlan.test.ts

@@ -0,0 +1,295 @@
+import { afterEach, beforeEach, describe, expect, it } from "@jest/globals";
+import PricingPlan from "../../../UI/Utils/PricingPlan";
+import PricingPlanType from "../../../Types/PricingPlan";
+import BadDataException from "../../../Types/Exception/BadDataException";
+
+/*
+ * PricingPlan picks between two hard-coded Stripe catalogues based on whether
+ * the public Stripe key is a test key. `env()` reads process.env on every call,
+ * so each test can switch environment by setting STRIPE_PUBLIC_KEY.
+ */
+
+const TEST_PLAN_IDS: Array<string> = [
+  "plan_GoWIYiX2L8hwzx",
+  "plan_GoWIqpBpStiqQp",
+  "plan_GoWKgxRnPPBJWy",
+  "plan_GoWKiTdQ6NiQFw",
+  "plan_H9Iox3l2YqLTDR",
+  "plan_H9IlBKhsFz4hV2",
+];
+
+const LIVE_PLAN_IDS: Array<string> = [
+  "plan_GoVgVbvNdbWwlm",
+  "plan_GoVgJu5PKMLRJU",
+  "plan_GoVi9EIa6MU0fG",
+  "plan_GoViZshjqzZ0vv",
+  "plan_H9Ii6Qj3HLdtty",
+  "plan_H9IjvX2Flsvlcg",
+];
+
+const getPlanIds: () => Array<string> = (): Array<string> => {
+  return PricingPlan.getPlans().map((plan: PricingPlanType) => {
+    return plan.planId;
+  });
+};
+
+const firstDollarAmount: (details: string) => number = (
+  details: string,
+): number => {
+  const match: RegExpMatchArray | null = details.match(/\$(\d+)/);
+  expect(match).not.toBeNull();
+  return Number((match as RegExpMatchArray)[1]);
+};
+
+describe("UI PricingPlan util", () => {
+  let originalStripeKey: string | undefined;
+
+  beforeEach(() => {
+    originalStripeKey = process.env["STRIPE_PUBLIC_KEY"];
+    delete process.env["STRIPE_PUBLIC_KEY"];
+  });
+
+  afterEach(() => {
+    if (originalStripeKey === undefined) {
+      delete process.env["STRIPE_PUBLIC_KEY"];
+    } else {
+      process.env["STRIPE_PUBLIC_KEY"] = originalStripeKey;
+    }
+  });
+
+  describe("getPlans environment selection", () => {
+    it("returns the live catalogue when no Stripe key is configured", () => {
+      expect(getPlanIds()).toEqual(LIVE_PLAN_IDS);
+    });
+
+    it("returns the live catalogue for an empty Stripe key", () => {
+      process.env["STRIPE_PUBLIC_KEY"] = "";
+      expect(getPlanIds()).toEqual(LIVE_PLAN_IDS);
+    });
+
+    it("returns the live catalogue for a live Stripe key", () => {
+      process.env["STRIPE_PUBLIC_KEY"] = "pk_live_abc123";
+      expect(getPlanIds()).toEqual(LIVE_PLAN_IDS);
+    });
+
+    it("returns the test catalogue for a pk_test key", () => {
+      process.env["STRIPE_PUBLIC_KEY"] = "pk_test_abc123";
+      expect(getPlanIds()).toEqual(TEST_PLAN_IDS);
+    });
+
+    it("only treats a pk_test PREFIX as a test key", () => {
+      process.env["STRIPE_PUBLIC_KEY"] = "xpk_test_abc";
+      expect(getPlanIds()).toEqual(LIVE_PLAN_IDS);
+
+      process.env["STRIPE_PUBLIC_KEY"] = "PK_TEST_abc";
+      expect(getPlanIds()).toEqual(LIVE_PLAN_IDS);
+    });
+
+    it("re-evaluates the environment on every call", () => {
+      process.env["STRIPE_PUBLIC_KEY"] = "pk_test_1";
+      expect(getPlanIds()).toEqual(TEST_PLAN_IDS);
+
+      process.env["STRIPE_PUBLIC_KEY"] = "pk_live_1";
+      expect(getPlanIds()).toEqual(LIVE_PLAN_IDS);
+    });
+
+    it("returns a fresh array each call so callers cannot corrupt the catalogue", () => {
+      const first: Array<PricingPlanType> = PricingPlan.getPlans();
+      first.pop();
+      (first[0] as PricingPlanType).amount = 1;
+
+      const second: Array<PricingPlanType> = PricingPlan.getPlans();
+      expect(second).toHaveLength(6);
+      expect((second[0] as PricingPlanType).amount).toBe(25);
+    });
+  });
+
+  describe.each([
+    ["live", "pk_live_x"],
+    ["test", "pk_test_x"],
+  ])("%s catalogue shape", (_label: string, key: string) => {
+    beforeEach(() => {
+      process.env["STRIPE_PUBLIC_KEY"] = key;
+    });
+
+    it("has unique plan ids", () => {
+      const ids: Array<string> = getPlanIds();
+      expect(new Set(ids).size).toBe(ids.length);
+    });
+
+    it("offers exactly a monthly and an annual plan for each category", () => {
+      const plans: Array<PricingPlanType> = PricingPlan.getPlans();
+      const categories: Array<string> = ["Startup", "Growth", "Scale"];
+
+      expect(
+        Array.from(
+          new Set(
+            plans.map((plan: PricingPlanType) => {
+              return plan.category;
+            }),
+          ),
+        ),
+      ).toEqual(categories);
+
+      for (const category of categories) {
+        const types: Array<string> = plans
+          .filter((plan: PricingPlanType) => {
+            return plan.category === category;
+          })
+          .map((plan: PricingPlanType) => {
+            return plan.type;
+          })
+          .sort();
+
+        expect(types).toEqual(["annual", "month"]);
+      }
+    });
+
+    it("prices tiers in ascending order and makes annual cheaper per month", () => {
+      const plans: Array<PricingPlanType> = PricingPlan.getPlans();
+      const monthly: Array<number> = plans
+        .filter((plan: PricingPlanType) => {
+          return plan.type === "month";
+        })
+        .map((plan: PricingPlanType) => {
+          return plan.amount;
+        });
+
+      expect(monthly).toEqual([25, 59, 99]);
+
+      for (const plan of plans.filter((p: PricingPlanType) => {
+        return p.type === "annual";
+      })) {
+        const monthlyPlan: PricingPlanType = plans.find(
+          (p: PricingPlanType) => {
+            return p.category === plan.category && p.type === "month";
+          },
+        ) as PricingPlanType;
+
+        /*
+         * Compared with the ADVERTISED monthly price: because the monthly
+         * Scale plan charges 99 (not the advertised 120), Scale annual is
+         * exactly equal to the charged monthly amount (1188 / 12 === 99).
+         */
+        expect(plan.amount / 12).toBeLessThan(
+          firstDollarAmount(monthlyPlan.details),
+        );
+        expect(plan.amount / 12).toBeLessThanOrEqual(monthlyPlan.amount);
+      }
+    });
+
+    it("annual amount equals 12x the advertised per-month price", () => {
+      const annualPlans: Array<PricingPlanType> = PricingPlan.getPlans().filter(
+        (plan: PricingPlanType) => {
+          return plan.type === "annual";
+        },
+      );
+
+      for (const plan of annualPlans) {
+        expect(plan.amount).toBe(firstDollarAmount(plan.details) * 12);
+        expect(plan.details).toContain("paid annually");
+      }
+    });
+
+    it("monthly Startup and Growth amounts match their advertised price", () => {
+      const plans: Array<PricingPlanType> = PricingPlan.getPlans();
+
+      for (const category of ["Startup", "Growth"]) {
+        const plan: PricingPlanType = plans.find((p: PricingPlanType) => {
+          return p.category === category && p.type === "month";
+        }) as PricingPlanType;
+
+        expect(plan.amount).toBe(firstDollarAmount(plan.details));
+      }
+    });
+
+    /*
+     * The monthly Scale plan charges 99 but advertises "$120 / Month / User".
+     * Pinned here so the discrepancy is visible; see the report.
+     */
+    it("monthly Scale plan amount (99) differs from its advertised price ($120)", () => {
+      const plan: PricingPlanType = PricingPlan.getPlans().find(
+        (p: PricingPlanType) => {
+          return p.category === "Scale" && p.type === "month";
+        },
+      ) as PricingPlanType;
+
+      expect(plan.amount).toBe(99);
+      expect(firstDollarAmount(plan.details)).toBe(120);
+    });
+  });
+
+  describe("getPlanById", () => {
+    it("returns the matching live plan", () => {
+      process.env["STRIPE_PUBLIC_KEY"] = "pk_live_x";
+
+      expect(PricingPlan.getPlanById("plan_GoVi9EIa6MU0fG")).toEqual({
+        category: "Growth",
+        planId: "plan_GoVi9EIa6MU0fG",
+        type: "month",
+        amount: 59,
+        details: "$59 / Month / User",
+      });
+    });
+
+    it("returns the matching test plan", () => {
+      process.env["STRIPE_PUBLIC_KEY"] = "pk_test_x";
+
+      expect(PricingPlan.getPlanById("plan_H9IlBKhsFz4hV2")).toEqual({
+        category: "Scale",
+        planId: "plan_H9IlBKhsFz4hV2",
+        type: "annual",
+        amount: 1188,
+        details: "$99/mo per user paid annually. ",
+      });
+    });
+
+    it("resolves every plan id in the active catalogue", () => {
+      process.env["STRIPE_PUBLIC_KEY"] = "pk_test_x";
+      for (const id of TEST_PLAN_IDS) {
+        expect(PricingPlan.getPlanById(id).planId).toBe(id);
+      }
+
+      process.env["STRIPE_PUBLIC_KEY"] = "pk_live_x";
+      for (const id of LIVE_PLAN_IDS) {
+        expect(PricingPlan.getPlanById(id).planId).toBe(id);
+      }
+    });
+
+    it("does not resolve a test plan id when running against live Stripe", () => {
+      process.env["STRIPE_PUBLIC_KEY"] = "pk_live_x";
+
+      expect(() => {
+        PricingPlan.getPlanById("plan_GoWIYiX2L8hwzx");
+      }).toThrow(BadDataException);
+    });
+
+    it("does not resolve a live plan id when running against test Stripe", () => {
+      process.env["STRIPE_PUBLIC_KEY"] = "pk_test_x";
+
+      expect(() => {
+        PricingPlan.getPlanById("plan_GoVgVbvNdbWwlm");
+      }).toThrow(BadDataException);
+    });
+
+    it("throws a BadDataException naming the unknown id", () => {
+      expect(() => {
+        PricingPlan.getPlanById("plan_does_not_exist");
+      }).toThrow("Plan with id plan_does_not_exist not found");
+    });
+
+    it("does not match on empty or partial ids", () => {
+      expect(() => {
+        PricingPlan.getPlanById("");
+      }).toThrow(BadDataException);
+
+      expect(() => {
+        PricingPlan.getPlanById("plan_GoVgVbvNdbWwl");
+      }).toThrow(BadDataException);
+
+      expect(() => {
+        PricingPlan.getPlanById("PLAN_GOVGVBVNDBWWLM");
+      }).toThrow(BadDataException);
+    });
+  });
+});