@oneuptime/common 12.0.34 → 13.0.1

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

@@ -0,0 +1,315 @@
+import MobilePasskeyLoginService, {
+  MobilePasskeyContext,
+} from "../../../Server/Services/MobilePasskeyLoginService";
+import Redis from "../../../Server/Infrastructure/Redis";
+import * as EnvironmentConfig from "../../../Server/EnvironmentConfig";
+import ObjectID from "../../../Types/ObjectID";
+import { createHash } from "crypto";
+import { URL } from "url";
+import { getJestSpyOn } from "../../Spy";
+
+jest.mock("../../../Server/EnvironmentConfig", () => {
+  return {
+    __esModule: true,
+    ...jest.requireActual("../../../Server/EnvironmentConfig"),
+    Host: "EXAMPLE.COM:443",
+    HttpProtocol: "https://",
+  };
+});
+jest.mock("../../../Server/Infrastructure/Redis", () => {
+  return {
+    __esModule: true,
+    default: { getClient: jest.fn(), isConnected: jest.fn() },
+  };
+});
+
+const verifier: string = "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk";
+const challenge: string = "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM";
+const state: string = "s".repeat(64);
+const userId: ObjectID = new ObjectID("11111111-1111-4111-8111-111111111111");
+const context: MobilePasskeyContext = {
+  codeChallenge: challenge,
+  codeChallengeMethod: "S256",
+  state,
+  serverOrigin: "https://example.com",
+};
+const code: string = "a".repeat(43);
+let client: { set: jest.Mock; eval: jest.Mock };
+
+beforeEach(() => {
+  jest.restoreAllMocks();
+  jest.clearAllMocks();
+  client = {
+    set: jest.fn().mockResolvedValue("OK"),
+    eval: jest.fn().mockResolvedValue(null),
+  };
+  getJestSpyOn(Redis, "getClient").mockReturnValue(client);
+  getJestSpyOn(Redis, "isConnected").mockReturnValue(true);
+});
+
+describe("mobile passkey request validation", () => {
+  it("normalizes the configured HTTPS origin and discards supplied destinations", () => {
+    expect(
+      MobilePasskeyLoginService.validateRequest({
+        ...context,
+        serverOrigin: "https://attacker.example",
+        callbackUrl: "attacker://callback",
+      }),
+    ).toEqual(context);
+  });
+
+  it.each([undefined, null, [], "invalid", 1, true])(
+    "rejects malformed mobile metadata %p",
+    (value: unknown) => {
+      expect(() => {
+        return MobilePasskeyLoginService.validateRequest(value);
+      }).toThrow();
+    },
+  );
+
+  it.each([
+    { codeChallenge: undefined },
+    { codeChallenge: "short" },
+    { codeChallenge: "a".repeat(44) },
+    { codeChallenge: "=".repeat(43) },
+    { codeChallengeMethod: "plain" },
+    { codeChallengeMethod: undefined },
+    { state: undefined },
+    { state: "s".repeat(42) },
+    { state: "s".repeat(129) },
+    { state: "s".repeat(42) + "&" },
+  ])(
+    "rejects invalid PKCE or state fields %p",
+    (override: Record<string, unknown>) => {
+      expect(() => {
+        return MobilePasskeyLoginService.validateRequest({
+          ...context,
+          ...override,
+        });
+      }).toThrow();
+    },
+  );
+
+  it.each(["\n", "\r", "\r\n"])(
+    "rejects a trailing line ending in mobile request fields: %p",
+    (ending: string) => {
+      for (const override of [
+        { codeChallenge: challenge + ending },
+        { state: state + ending },
+      ]) {
+        expect(() => {
+          return MobilePasskeyLoginService.validateRequest({
+            ...context,
+            ...override,
+          });
+        }).toThrow();
+      }
+    },
+  );
+
+  it("refuses mobile sign-in on an insecure server", () => {
+    const configuration: { HttpProtocol: string } =
+      EnvironmentConfig as unknown as { HttpProtocol: string };
+    const previous: string = configuration.HttpProtocol;
+    configuration.HttpProtocol = "http://";
+    try {
+      expect(() => {
+        return MobilePasskeyLoginService.validateRequest(context);
+      }).toThrow();
+    } finally {
+      configuration.HttpProtocol = previous;
+    }
+  });
+});
+
+describe("mobile passkey challenge binding", () => {
+  it("stores only validated handoff metadata with a five-minute TTL", async () => {
+    await MobilePasskeyLoginService.storeChallengeContext(code, context);
+    expect(client.set).toHaveBeenCalledWith(
+      `mobile-passkey-challenge-${createHash("sha256").update(code).digest("base64url")}`,
+      JSON.stringify(context),
+      "EX",
+      300,
+      "NX",
+    );
+  });
+
+  it("atomically consumes the exact browser challenge's context", async () => {
+    client.eval.mockResolvedValue(JSON.stringify(context));
+    await expect(
+      MobilePasskeyLoginService.consumeChallengeContext(code),
+    ).resolves.toEqual(context);
+    expect(client.eval).toHaveBeenCalledWith(
+      expect.stringContaining("redis.call('DEL', KEYS[1])"),
+      1,
+      `mobile-passkey-challenge-${createHash("sha256").update(code).digest("base64url")}`,
+    );
+  });
+
+  it("returns no context for an ordinary browser challenge", async () => {
+    await expect(
+      MobilePasskeyLoginService.consumeChallengeContext(code),
+    ).resolves.toBeNull();
+  });
+
+  it.each([
+    1,
+    "broken-json",
+    "null",
+    "{}",
+    JSON.stringify({ ...context, serverOrigin: "https://other.example" }),
+    JSON.stringify({ ...context, codeChallengeMethod: "plain" }),
+  ])(
+    "fails closed for malformed stored metadata %p",
+    async (value: unknown) => {
+      client.eval.mockResolvedValue(value);
+      await expect(
+        MobilePasskeyLoginService.consumeChallengeContext(code),
+      ).rejects.toThrow();
+    },
+  );
+});
+
+describe("mobile authorization codes", () => {
+  it("returns only a random code, state and server on the fixed app callback", async () => {
+    const callback: URL = new URL(
+      await MobilePasskeyLoginService.createAuthorizationCode({
+        userId,
+        context,
+      }),
+    );
+    expect(callback.protocol).toBe("oneuptime:");
+    expect(callback.hostname).toBe("passkey");
+    expect(callback.pathname).toBe("");
+    expect(callback.searchParams.get("code")).toMatch(/^[A-Za-z0-9_-]{43}$/);
+    expect(callback.searchParams.get("state")).toBe(state);
+    expect(callback.searchParams.get("serverOrigin")).toBe(
+      context.serverOrigin,
+    );
+    expect(Array.from(callback.searchParams.keys())).toEqual([
+      "code",
+      "state",
+      "serverOrigin",
+    ]);
+    expect(client.set).toHaveBeenCalledWith(
+      expect.stringMatching(/^mobile-passkey-code-[A-Za-z0-9_-]{43}$/),
+      JSON.stringify({ ...context, userId: userId.toString() }),
+      "EX",
+      120,
+      "NX",
+    );
+    expect(client.set.mock.calls[0]?.[0]).not.toContain(
+      callback.searchParams.get("code"),
+    );
+  });
+
+  it("refuses a context issued for another server", async () => {
+    await expect(
+      MobilePasskeyLoginService.createAuthorizationCode({
+        userId,
+        context: { ...context, serverOrigin: "https://other.example" },
+      }),
+    ).rejects.toThrow();
+    expect(client.set).not.toHaveBeenCalled();
+  });
+
+  it("uses the RFC 7636 S256 challenge, never sends the verifier to Redis", async () => {
+    client.eval.mockResolvedValue(userId.toString());
+    await expect(
+      MobilePasskeyLoginService.exchangeAuthorizationCode({
+        code,
+        codeVerifier: verifier,
+        state,
+      }),
+    ).resolves.toEqual(userId);
+    expect(client.eval).toHaveBeenCalledWith(
+      expect.stringContaining("data.codeChallenge ~= ARGV[1]"),
+      1,
+      expect.stringMatching(/^mobile-passkey-code-/),
+      challenge,
+      state,
+      context.serverOrigin,
+    );
+    expect(JSON.stringify(client.eval.mock.calls)).not.toContain(verifier);
+  });
+
+  it.each([
+    null,
+    undefined,
+    [],
+    { code, codeVerifier: verifier },
+    { code, codeVerifier: verifier, state: "short" },
+    { code: "short", codeVerifier: verifier, state },
+    { code: "a".repeat(44), codeVerifier: verifier, state },
+    { code, codeVerifier: "short", state },
+    { code, codeVerifier: "v".repeat(129), state },
+    { code, codeVerifier: "v".repeat(42) + "/", state },
+    { code, codeVerifier: {}, state },
+  ])(
+    "rejects malformed exchanges before touching Redis: %p",
+    async (value: unknown) => {
+      await expect(
+        MobilePasskeyLoginService.exchangeAuthorizationCode(value),
+      ).rejects.toThrow();
+      expect(client.eval).not.toHaveBeenCalled();
+    },
+  );
+
+  it.each(["\n", "\r", "\r\n"])(
+    "rejects a trailing line ending in code, verifier or state before Redis: %p",
+    async (ending: string) => {
+      for (const override of [
+        { code: code + ending },
+        { codeVerifier: verifier + ending },
+        { state: state + ending },
+      ]) {
+        await expect(
+          MobilePasskeyLoginService.exchangeAuthorizationCode({
+            code,
+            codeVerifier: verifier,
+            state,
+            ...override,
+          }),
+        ).rejects.toThrow();
+      }
+      expect(client.eval).not.toHaveBeenCalled();
+    },
+  );
+
+  it.each([null, 1, "", "not-a-user-id"])(
+    "rejects a missing, expired, mismatched or malformed code result %p",
+    async (value: unknown) => {
+      client.eval.mockResolvedValue(value);
+      await expect(
+        MobilePasskeyLoginService.exchangeAuthorizationCode({
+          code,
+          codeVerifier: verifier,
+          state,
+        }),
+      ).rejects.toThrow();
+    },
+  );
+
+  it("fails closed when the store is unavailable", async () => {
+    getJestSpyOn(Redis, "isConnected").mockReturnValue(false);
+    await expect(
+      MobilePasskeyLoginService.createAuthorizationCode({ userId, context }),
+    ).rejects.toThrow("temporarily unavailable");
+    await expect(
+      MobilePasskeyLoginService.exchangeAuthorizationCode({
+        code,
+        codeVerifier: verifier,
+        state,
+      }),
+    ).rejects.toThrow("temporarily unavailable");
+    expect(client.set).not.toHaveBeenCalled();
+    expect(client.eval).not.toHaveBeenCalled();
+  });
+
+  it("fails closed on a refused code write", async () => {
+    client.set.mockResolvedValue(null);
+    await expect(
+      MobilePasskeyLoginService.createAuthorizationCode({ userId, context }),
+    ).rejects.toThrow();
+  });
+});

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

@@ -0,0 +1,302 @@
+import MonitorService from "../../../Server/Services/MonitorService";
+import MonitorStatusService from "../../../Server/Services/MonitorStatusService";
+import ProjectService from "../../../Server/Services/ProjectService";
+import PayAsYouGoBillingService from "../../../Server/Services/PayAsYouGoBillingService";
+import MonitorStepsProjectValidator from "../../../Server/Utils/Monitor/MonitorStepsProjectValidator";
+import Monitor from "../../../Models/DatabaseModels/Monitor";
+import MonitorStatus from "../../../Models/DatabaseModels/MonitorStatus";
+import CreateBy from "../../../Server/Types/Database/CreateBy";
+import UpdateBy from "../../../Server/Types/Database/UpdateBy";
+import MonitorType from "../../../Types/Monitor/MonitorType";
+import ObjectID from "../../../Types/ObjectID";
+import PositiveNumber from "../../../Types/PositiveNumber";
+import { PlanType } from "../../../Types/Billing/SubscriptionPlan";
+import PaymentRequiredException from "../../../Types/Exception/PaymentRequiredException";
+import * as EnvironmentConfig from "../../../Server/EnvironmentConfig";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+
+jest.mock("../../../Server/EnvironmentConfig", () => {
+  return {
+    __esModule: true,
+    ...(jest.requireActual(
+      "../../../Server/EnvironmentConfig",
+    ) as typeof EnvironmentConfig),
+    IsBillingEnabled: true,
+  };
+});
+
+type MonitorHooks = {
+  onBeforeCreate: (input: CreateBy<Monitor>) => Promise<unknown>;
+  onBeforeUpdate: (input: UpdateBy<Monitor>) => Promise<unknown>;
+};
+const hooks: MonitorHooks = MonitorService as unknown as MonitorHooks;
+const projectId: ObjectID = ObjectID.generate();
+const otherProjectId: ObjectID = ObjectID.generate();
+
+function createInput(monitorType: MonitorType): CreateBy<Monitor> {
+  const monitor: Monitor = new Monitor();
+  monitor.monitorType = monitorType;
+  return { data: monitor, props: { isRoot: true, tenantId: projectId } };
+}
+
+function updateInput(data: UpdateBy<Monitor>["data"]): UpdateBy<Monitor> {
+  return {
+    data,
+    query: { _id: ObjectID.generate().toString() },
+    props: { isRoot: true },
+    limit: 10,
+    skip: 0,
+  };
+}
+
+function storedMonitor(project: ObjectID, monitorType: MonitorType): Monitor {
+  return Object.assign(new Monitor(), { projectId: project, monitorType });
+}
+
+type PaymentCheck = Parameters<
+  typeof PayAsYouGoBillingService.canUsePayAsYouGo
+>;
+
+/*
+ * requirePayAsYouGo forwards its own options argument straight through to
+ * canUsePayAsYouGo, so a recorded check carries a second argument as well as
+ * the project. Assert the two things that decide the outcome rather than the
+ * exact argument list: whose payment setup was read, and that monitoring stays
+ * a read-through check - it must not answer from the cached denial that only
+ * telemetry admission opts into, or adding a card would leave monitor writes
+ * refused for the rest of that denial's TTL.
+ */
+function expectPaymentCheckedFor(project: ObjectID): void {
+  const checks: Array<PaymentCheck> = jest.mocked(
+    PayAsYouGoBillingService.canUsePayAsYouGo,
+  ).mock.calls;
+
+  expect(
+    checks.map((check: PaymentCheck): string => {
+      return check[0].toString();
+    }),
+  ).toEqual([project.toString()]);
+
+  for (const check of checks) {
+    expect(check[1]?.allowStaleDenial).toBeFalsy();
+  }
+}
+
+beforeEach(() => {
+  jest.restoreAllMocks();
+  (EnvironmentConfig as { IsBillingEnabled: boolean }).IsBillingEnabled = true;
+  jest
+    .spyOn(PayAsYouGoBillingService, "canUsePayAsYouGo")
+    .mockResolvedValue(false);
+  jest.spyOn(ProjectService, "getCurrentPlan").mockResolvedValue({
+    plan: PlanType.Free,
+    isSubscriptionUnpaid: false,
+  });
+  jest
+    .spyOn(MonitorService, "countBy")
+    .mockResolvedValue(new PositiveNumber(0));
+  jest
+    .spyOn(MonitorStepsProjectValidator, "validateMonitorStepsBelongToProject")
+    .mockResolvedValue(undefined);
+  jest
+    .spyOn(MonitorService, "validateDependencyConfiguration")
+    .mockResolvedValue(undefined);
+  const status: MonitorStatus = new MonitorStatus();
+  status.id = ObjectID.generate();
+  jest.spyOn(MonitorStatusService, "findOneBy").mockResolvedValue(status);
+  jest.spyOn(MonitorService, "findBy").mockResolvedValue([]);
+});
+
+afterEach(() => {
+  jest.restoreAllMocks();
+});
+
+describe("monitor creation payment admission", () => {
+  test.each(
+    Object.values(MonitorType).filter((type: MonitorType) => {
+      return type !== MonitorType.Manual;
+    }),
+  )(
+    "requires payment setup before creating %s on a Free project",
+    async (monitorType: MonitorType) => {
+      await expect(
+        hooks.onBeforeCreate(createInput(monitorType)),
+      ).rejects.toBeInstanceOf(PaymentRequiredException);
+      expect(MonitorStatusService.findOneBy).not.toHaveBeenCalled();
+      expect(MonitorService.countBy).not.toHaveBeenCalled();
+    },
+  );
+
+  test("keeps Manual monitors available without payment setup", async () => {
+    await expect(
+      hooks.onBeforeCreate(createInput(MonitorType.Manual)),
+    ).resolves.toBeDefined();
+    expect(PayAsYouGoBillingService.canUsePayAsYouGo).not.toHaveBeenCalled();
+  });
+
+  test.each([PlanType.Free, PlanType.Growth])(
+    "keeps free Manual monitors available when the %s subscription is unpaid",
+    async (plan: PlanType) => {
+      jest.spyOn(ProjectService, "getCurrentPlan").mockResolvedValue({
+        plan,
+        isSubscriptionUnpaid: true,
+      });
+
+      await expect(
+        hooks.onBeforeCreate(createInput(MonitorType.Manual)),
+      ).resolves.toBeDefined();
+      expect(PayAsYouGoBillingService.canUsePayAsYouGo).not.toHaveBeenCalled();
+      expect(MonitorService.countBy).not.toHaveBeenCalled();
+    },
+  );
+
+  test("checks the creating tenant even when the payload names another project", async () => {
+    const input: CreateBy<Monitor> = createInput(MonitorType.Website);
+    input.data.projectId = otherProjectId;
+    await expect(hooks.onBeforeCreate(input)).rejects.toBeInstanceOf(
+      PaymentRequiredException,
+    );
+    expectPaymentCheckedFor(projectId);
+  });
+
+  test("admits an authorized Free project and retains its monitor count limit", async () => {
+    jest
+      .spyOn(PayAsYouGoBillingService, "canUsePayAsYouGo")
+      .mockResolvedValue(true);
+    await expect(
+      hooks.onBeforeCreate(createInput(MonitorType.Website)),
+    ).resolves.toBeDefined();
+    expect(MonitorService.countBy).toHaveBeenCalledTimes(1);
+    jest
+      .spyOn(MonitorService, "countBy")
+      .mockResolvedValue(
+        new PositiveNumber(
+          EnvironmentConfig.AllowedActiveMonitorCountInFreePlan,
+        ),
+      );
+    await expect(
+      hooks.onBeforeCreate(createInput(MonitorType.Website)),
+    ).rejects.toThrow("maximum allowed monitor limit");
+  });
+
+  test("retains the existing unpaid subscription refusal after payment admission", async () => {
+    jest
+      .spyOn(PayAsYouGoBillingService, "canUsePayAsYouGo")
+      .mockResolvedValue(true);
+    jest
+      .spyOn(ProjectService, "getCurrentPlan")
+      .mockResolvedValue({ plan: PlanType.Growth, isSubscriptionUnpaid: true });
+    await expect(
+      hooks.onBeforeCreate(createInput(MonitorType.Website)),
+    ).rejects.toThrow("subscription is unpaid");
+  });
+
+  test("preserves active monitors on installations with billing disabled", async () => {
+    (EnvironmentConfig as { IsBillingEnabled: boolean }).IsBillingEnabled =
+      false;
+    await expect(
+      hooks.onBeforeCreate(createInput(MonitorType.Website)),
+    ).resolves.toBeDefined();
+    expect(PayAsYouGoBillingService.canUsePayAsYouGo).not.toHaveBeenCalled();
+    expect(ProjectService.getCurrentPlan).not.toHaveBeenCalled();
+  });
+});
+
+describe("monitor update payment admission", () => {
+  test("requires payment to re-enable an existing active monitor", async () => {
+    jest
+      .spyOn(MonitorService, "findBy")
+      .mockResolvedValue([storedMonitor(projectId, MonitorType.Website)]);
+    await expect(
+      hooks.onBeforeUpdate(updateInput({ disableActiveMonitoring: false })),
+    ).rejects.toBeInstanceOf(PaymentRequiredException);
+    expectPaymentCheckedFor(projectId);
+  });
+
+  test("guards internal Manual-to-active changes using the stored project", async () => {
+    jest
+      .spyOn(MonitorService, "findBy")
+      .mockResolvedValue([storedMonitor(otherProjectId, MonitorType.Manual)]);
+    const input: UpdateBy<Monitor> = updateInput({
+      monitorType: MonitorType.API,
+    });
+    input.props.tenantId = projectId;
+    await expect(hooks.onBeforeUpdate(input)).rejects.toBeInstanceOf(
+      PaymentRequiredException,
+    );
+    expectPaymentCheckedFor(otherProjectId);
+  });
+
+  test("scopes non-root update lookups to their tenant", async () => {
+    const input: UpdateBy<Monitor> = updateInput({
+      disableActiveMonitoring: false,
+    });
+    input.props = { tenantId: projectId };
+    await hooks.onBeforeUpdate(input);
+    expect(MonitorService.findBy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        query: { ...input.query, projectId },
+        limit: input.limit,
+        skip: input.skip,
+      }),
+    );
+  });
+
+  test("checks every distinct project in an internal bulk update", async () => {
+    jest
+      .spyOn(MonitorService, "findBy")
+      .mockResolvedValue([
+        storedMonitor(projectId, MonitorType.Website),
+        storedMonitor(projectId, MonitorType.API),
+        storedMonitor(otherProjectId, MonitorType.Website),
+      ]);
+    jest
+      .spyOn(PayAsYouGoBillingService, "canUsePayAsYouGo")
+      .mockImplementation(async (id: ObjectID): Promise<boolean> => {
+        return id.toString() === projectId.toString();
+      });
+    await expect(
+      hooks.onBeforeUpdate(updateInput({ disableActiveMonitoring: false })),
+    ).rejects.toBeInstanceOf(PaymentRequiredException);
+    expect(PayAsYouGoBillingService.canUsePayAsYouGo).toHaveBeenCalledTimes(2);
+  });
+
+  test("allows re-enabling Manual monitors without payment setup", async () => {
+    jest
+      .spyOn(MonitorService, "findBy")
+      .mockResolvedValue([storedMonitor(projectId, MonitorType.Manual)]);
+    await expect(
+      hooks.onBeforeUpdate(updateInput({ disableActiveMonitoring: false })),
+    ).resolves.toBeDefined();
+    expect(PayAsYouGoBillingService.canUsePayAsYouGo).not.toHaveBeenCalled();
+  });
+
+  test.each([
+    { disableActiveMonitoring: true },
+    { name: "Renamed monitor" },
+    { monitorType: MonitorType.Manual },
+  ])(
+    "allows nonbillable updates %j without consulting billing",
+    async (data: UpdateBy<Monitor>["data"]) => {
+      await expect(
+        hooks.onBeforeUpdate(updateInput(data)),
+      ).resolves.toBeDefined();
+      expect(PayAsYouGoBillingService.canUsePayAsYouGo).not.toHaveBeenCalled();
+      expect(MonitorService.findBy).not.toHaveBeenCalled();
+    },
+  );
+
+  test("does not block self-hosted re-enabling or load billing records", async () => {
+    (EnvironmentConfig as { IsBillingEnabled: boolean }).IsBillingEnabled =
+      false;
+    await hooks.onBeforeUpdate(updateInput({ disableActiveMonitoring: false }));
+    expect(MonitorService.findBy).not.toHaveBeenCalled();
+  });
+});