@oneuptime/common 11.0.1 → 11.0.2

package/Tests/Server/Infrastructure/GlobalCache.test.ts

@@ -0,0 +1,100 @@
+import GlobalCache from "../../../Server/Infrastructure/GlobalCache";
+import Redis from "../../../Server/Infrastructure/Redis";
+import OneUptimeDate from "../../../Types/Date";
+import DatabaseNotConnectedException from "../../../Types/Exception/DatabaseNotConnectedException";
+
+jest.mock("../../../Server/Infrastructure/Redis", () => {
+  return {
+    __esModule: true,
+    default: {
+      getClient: jest.fn(),
+      isConnected: jest.fn(),
+    },
+  };
+});
+
+type MockClient = {
+  set: jest.Mock;
+  expire: jest.Mock;
+  get: jest.Mock;
+};
+
+describe("GlobalCache.setString", () => {
+  let client: MockClient;
+
+  beforeEach(() => {
+    client = {
+      set: jest.fn().mockResolvedValue("OK"),
+      expire: jest.fn().mockResolvedValue(1),
+      get: jest.fn(),
+    };
+    (Redis.getClient as jest.Mock).mockReturnValue(client);
+    (Redis.isConnected as jest.Mock).mockReturnValue(true);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  /*
+   * The TTL must be applied atomically with the SET. A separate
+   * SET + EXPIRE pair can crash in between and leave a key that
+   * never expires — for fence/throttle keys (e.g. the OTel ingest
+   * maintenance fence) that permanently suppresses the work the
+   * key gates.
+   */
+  test("sets the value and TTL in one atomic SET ... EX call", async () => {
+    await GlobalCache.setString("ns", "key", "value", {
+      expiresInSeconds: 60,
+    });
+
+    expect(client.set).toHaveBeenCalledTimes(1);
+    expect(client.set).toHaveBeenCalledWith("ns-key", "value", "EX", 60);
+    expect(client.expire).not.toHaveBeenCalled();
+  });
+
+  test("defaults the TTL to 30 days when no option is passed", async () => {
+    await GlobalCache.setString("ns", "key", "value");
+
+    expect(client.set).toHaveBeenCalledTimes(1);
+    expect(client.set).toHaveBeenCalledWith(
+      "ns-key",
+      "value",
+      "EX",
+      OneUptimeDate.getSecondsInDays(30),
+    );
+    expect(client.expire).not.toHaveBeenCalled();
+  });
+
+  test("throws when the cache is not connected", async () => {
+    (Redis.isConnected as jest.Mock).mockReturnValue(false);
+
+    await expect(GlobalCache.setString("ns", "key", "value")).rejects.toThrow(
+      DatabaseNotConnectedException,
+    );
+    expect(client.set).not.toHaveBeenCalled();
+  });
+
+  test("setStringArray and setJSON funnel through the atomic setString", async () => {
+    await GlobalCache.setStringArray("ns", "arr", ["a", "b"], {
+      expiresInSeconds: 120,
+    });
+    await GlobalCache.setJSON("ns", "obj", { a: 1 }, { expiresInSeconds: 180 });
+
+    expect(client.set).toHaveBeenNthCalledWith(
+      1,
+      "ns-arr",
+      JSON.stringify(["a", "b"]),
+      "EX",
+      120,
+    );
+    expect(client.set).toHaveBeenNthCalledWith(
+      2,
+      "ns-obj",
+      expect.any(String),
+      "EX",
+      180,
+    );
+    expect(client.expire).not.toHaveBeenCalled();
+  });
+});

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

@@ -1057,6 +1057,111 @@ describe("BillingService", () => {
         });
       });
 
+      it("should mark the customer's default payment method and order it first", async () => {
+        const mockPaymentMethodsResponse: {
+          data: Array<Stripe.PaymentMethod>;
+        } = {
+          data: [
+            {
+              id: "pm_123",
+              type: "card",
+              // @ts-expect-error - Simplified mock card object for testing without all required Stripe card properties
+              card: { last4: "4242", brand: "mastercard" },
+            },
+            {
+              id: "pm_456",
+              type: "card",
+              // @ts-expect-error - Simplified mock card object for testing without all required Stripe card properties
+              card: { last4: "4343", brand: "mastercard" },
+            },
+          ],
+        };
+        mockStripe.paymentMethods.list = getJestMockFunction()
+          .mockResolvedValueOnce(mockPaymentMethodsResponse)
+          .mockResolvedValue({ data: [] });
+
+        const customerWithDefault: Stripe.Customer = getStripeCustomer(
+          customer.id.toString(),
+        );
+        customerWithDefault.invoice_settings.default_payment_method = "pm_456";
+        mockStripe.customers.retrieve =
+          getJestMockFunction().mockResolvedValue(customerWithDefault);
+
+        const paymentMethods: PaymentMethod[] =
+          await billingService.getPaymentMethods(customerId);
+
+        expect(paymentMethods).toHaveLength(2);
+        expect(paymentMethods[0]?.id).toBe("pm_456");
+        expect(paymentMethods[0]?.isDefault).toBe(true);
+        expect(paymentMethods[1]?.id).toBe("pm_123");
+        expect(paymentMethods[1]?.isDefault).toBe(false);
+        expect(mockStripe.customers.update).not.toHaveBeenCalled();
+      });
+
+      it("should not mark any payment method as default when the default is not in the list", async () => {
+        const mockPaymentMethodsResponse: {
+          data: Array<Stripe.PaymentMethod>;
+        } = {
+          data: [
+            {
+              id: "pm_123",
+              type: "card",
+              // @ts-expect-error - Simplified mock card object for testing without all required Stripe card properties
+              card: { last4: "4242", brand: "mastercard" },
+            },
+          ],
+        };
+        mockStripe.paymentMethods.list = getJestMockFunction()
+          .mockResolvedValueOnce(mockPaymentMethodsResponse)
+          .mockResolvedValue({ data: [] });
+
+        const customerWithDetachedDefault: Stripe.Customer = getStripeCustomer(
+          customer.id.toString(),
+        );
+        customerWithDetachedDefault.invoice_settings.default_payment_method =
+          "pm_detached";
+        mockStripe.customers.retrieve = getJestMockFunction().mockResolvedValue(
+          customerWithDetachedDefault,
+        );
+
+        const paymentMethods: PaymentMethod[] =
+          await billingService.getPaymentMethods(customerId);
+
+        expect(paymentMethods).toHaveLength(1);
+        expect(paymentMethods[0]?.isDefault).toBe(false);
+        expect(mockStripe.customers.update).not.toHaveBeenCalled();
+      });
+
+      it("should set the first payment method as default when none is set", async () => {
+        const mockPaymentMethodsResponse: {
+          data: Array<Stripe.PaymentMethod>;
+        } = {
+          data: [
+            {
+              id: "pm_123",
+              type: "card",
+              // @ts-expect-error - Simplified mock card object for testing without all required Stripe card properties
+              card: { last4: "4242", brand: "mastercard" },
+            },
+          ],
+        };
+        mockStripe.paymentMethods.list = getJestMockFunction()
+          .mockResolvedValueOnce(mockPaymentMethodsResponse)
+          .mockResolvedValue({ data: [] });
+        mockStripe.customers.retrieve =
+          getJestMockFunction().mockResolvedValue(mockCustomer);
+
+        const paymentMethods: PaymentMethod[] =
+          await billingService.getPaymentMethods(customerId);
+
+        expect(paymentMethods[0]?.isDefault).toBe(true);
+        expect(mockStripe.customers.update).toHaveBeenCalledWith(customerId, {
+          invoice_settings: {
+            default_payment_method: "pm_123",
+          },
+        });
+      });
+
       it("should return an empty array if no payment methods are present", async () => {
         const mockEmptyPaymentMethodsResponse: {
           data: Array<PaymentMethod>;
@@ -1440,6 +1545,224 @@ describe("BillingService", () => {
           },
         );
       });
+
+      const mockTwoPaymentMethodsResponse: PaymentMethodsResponse = {
+        data: [
+          {
+            id: "pm_123",
+            type: "card",
+            last4Digits: "4242",
+            isDefault: false,
+          },
+          {
+            id: "pm_456",
+            type: "card",
+            last4Digits: "4343",
+            isDefault: false,
+          },
+        ],
+      };
+
+      type GetCardDeclinedErrorFunction = () => Error;
+
+      const getCardDeclinedError: GetCardDeclinedErrorFunction = (): Error => {
+        return Object.assign(new Error("Your card was declined."), {
+          type: "StripeCardError",
+          code: "card_declined",
+        });
+      };
+
+      it("should fall back to the next payment method when the first is declined", async () => {
+        mockStripe.paymentMethods.list = getJestMockFunction()
+          .mockResolvedValueOnce(mockTwoPaymentMethodsResponse)
+          .mockResolvedValue({ data: [] });
+        mockStripe.customers.retrieve =
+          getJestMockFunction().mockResolvedValue(mockCustomer);
+
+        const mockPaidInvoice: Stripe.Invoice = getStripeInvoice();
+        mockStripe.invoices.pay = getJestMockFunction()
+          .mockRejectedValueOnce(getCardDeclinedError())
+          .mockResolvedValue(mockPaidInvoice);
+
+        const paidInvoice: Invoice = await billingService.payInvoice(
+          customerId,
+          mockPaidInvoice.id || "",
+        );
+
+        expect(paidInvoice.id).toBe(mockPaidInvoice.id);
+        expect(mockStripe.invoices.pay).toHaveBeenCalledTimes(2);
+        expect(mockStripe.invoices.pay).toHaveBeenNthCalledWith(
+          1,
+          mockPaidInvoice.id,
+          {
+            payment_method: "pm_123",
+          },
+        );
+        expect(mockStripe.invoices.pay).toHaveBeenNthCalledWith(
+          2,
+          mockPaidInvoice.id,
+          {
+            payment_method: "pm_456",
+          },
+        );
+      });
+
+      it("should charge the customer's default payment method first", async () => {
+        mockStripe.paymentMethods.list = getJestMockFunction()
+          .mockResolvedValueOnce(mockTwoPaymentMethodsResponse)
+          .mockResolvedValue({ data: [] });
+
+        const customerWithDefault: Stripe.Customer = getStripeCustomer(
+          customer.id.toString(),
+        );
+        customerWithDefault.invoice_settings.default_payment_method = "pm_456";
+        mockStripe.customers.retrieve =
+          getJestMockFunction().mockResolvedValue(customerWithDefault);
+
+        const mockPaidInvoice: Stripe.Invoice = getStripeInvoice();
+        mockStripe.invoices.pay =
+          getJestMockFunction().mockResolvedValue(mockPaidInvoice);
+
+        await billingService.payInvoice(customerId, mockPaidInvoice.id || "");
+
+        expect(mockStripe.invoices.pay).toHaveBeenCalledTimes(1);
+        expect(mockStripe.invoices.pay).toHaveBeenCalledWith(
+          mockPaidInvoice.id,
+          {
+            payment_method: "pm_456",
+          },
+        );
+      });
+
+      it("should throw the last error when all payment methods are declined", async () => {
+        mockStripe.paymentMethods.list = getJestMockFunction()
+          .mockResolvedValueOnce(mockTwoPaymentMethodsResponse)
+          .mockResolvedValue({ data: [] });
+        mockStripe.customers.retrieve =
+          getJestMockFunction().mockResolvedValue(mockCustomer);
+
+        const lastError: Error = Object.assign(
+          new Error("Insufficient funds."),
+          {
+            type: "StripeCardError",
+            code: "card_declined",
+          },
+        );
+        mockStripe.invoices.pay = getJestMockFunction()
+          .mockRejectedValueOnce(getCardDeclinedError())
+          .mockRejectedValueOnce(lastError);
+
+        await expect(
+          billingService.payInvoice(customerId, invoiceId),
+        ).rejects.toThrow(lastError);
+        expect(mockStripe.invoices.pay).toHaveBeenCalledTimes(2);
+      });
+
+      it("should not try other payment methods on errors unrelated to the payment method", async () => {
+        mockStripe.paymentMethods.list = getJestMockFunction()
+          .mockResolvedValueOnce(mockTwoPaymentMethodsResponse)
+          .mockResolvedValue({ data: [] });
+        mockStripe.customers.retrieve =
+          getJestMockFunction().mockResolvedValue(mockCustomer);
+
+        const invoiceStateError: Error = Object.assign(
+          new Error("Invoice is already paid."),
+          {
+            type: "StripeInvalidRequestError",
+            code: "invoice_already_paid",
+          },
+        );
+        mockStripe.invoices.pay =
+          getJestMockFunction().mockRejectedValue(invoiceStateError);
+
+        await expect(
+          billingService.payInvoice(customerId, invoiceId),
+        ).rejects.toThrow(invoiceStateError);
+        expect(mockStripe.invoices.pay).toHaveBeenCalledTimes(1);
+      });
+
+      it("should fall back to the next payment method on payment method and bank account errors", async () => {
+        mockStripe.paymentMethods.list = getJestMockFunction()
+          .mockResolvedValueOnce(mockTwoPaymentMethodsResponse)
+          .mockResolvedValue({ data: [] });
+        mockStripe.customers.retrieve =
+          getJestMockFunction().mockResolvedValue(mockCustomer);
+
+        const bankAccountError: Error = Object.assign(
+          new Error("This bank account cannot be used."),
+          {
+            type: "StripeInvalidRequestError",
+            code: "bank_account_unusable",
+          },
+        );
+
+        const mockPaidInvoice: Stripe.Invoice = getStripeInvoice();
+        mockStripe.invoices.pay = getJestMockFunction()
+          .mockRejectedValueOnce(bankAccountError)
+          .mockResolvedValue(mockPaidInvoice);
+
+        const paidInvoice: Invoice = await billingService.payInvoice(
+          customerId,
+          mockPaidInvoice.id || "",
+        );
+
+        expect(paidInvoice.id).toBe(mockPaidInvoice.id);
+        expect(mockStripe.invoices.pay).toHaveBeenCalledTimes(2);
+      });
+
+      it("should not try other payment methods when authentication is required", async () => {
+        /*
+         * the interactive 3DS flow in BillingInvoiceAPI must surface
+         * authentication for the default payment method instead.
+         */
+        mockStripe.paymentMethods.list = getJestMockFunction()
+          .mockResolvedValueOnce(mockTwoPaymentMethodsResponse)
+          .mockResolvedValue({ data: [] });
+        mockStripe.customers.retrieve =
+          getJestMockFunction().mockResolvedValue(mockCustomer);
+
+        const requiresActionError: Error = Object.assign(
+          new Error("This payment requires additional authentication."),
+          {
+            type: "StripeInvalidRequestError",
+            code: "invoice_payment_intent_requires_action",
+          },
+        );
+        mockStripe.invoices.pay =
+          getJestMockFunction().mockRejectedValue(requiresActionError);
+
+        await expect(
+          billingService.payInvoice(customerId, invoiceId),
+        ).rejects.toThrow(requiresActionError);
+        expect(mockStripe.invoices.pay).toHaveBeenCalledTimes(1);
+      });
+
+      it("should try at most three payment methods", async () => {
+        const mockFourPaymentMethodsResponse: PaymentMethodsResponse = {
+          data: ["pm_1", "pm_2", "pm_3", "pm_4"].map((id: string) => {
+            return {
+              id,
+              type: "card",
+              last4Digits: "4242",
+              isDefault: false,
+            };
+          }),
+        };
+        mockStripe.paymentMethods.list = getJestMockFunction()
+          .mockResolvedValueOnce(mockFourPaymentMethodsResponse)
+          .mockResolvedValue({ data: [] });
+        mockStripe.customers.retrieve =
+          getJestMockFunction().mockResolvedValue(mockCustomer);
+
+        mockStripe.invoices.pay = getJestMockFunction().mockRejectedValue(
+          getCardDeclinedError(),
+        );
+
+        await expect(
+          billingService.payInvoice(customerId, invoiceId),
+        ).rejects.toThrow("Your card was declined.");
+        expect(mockStripe.invoices.pay).toHaveBeenCalledTimes(3);
+      });
     });
   });
 });

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

@@ -0,0 +1,264 @@
+import CephResourceService, {
+  ParsedCephResource,
+  CephResourceLatestMetric,
+} from "../../../Server/Services/CephResourceService";
+import ObjectID from "../../../Types/ObjectID";
+
+/*
+ * WI-21: the CephResource inventory write path — same mocked-query-
+ * runner shape as the ProxmoxResourceService tests. Locks in the
+ * COALESCE-per-column upsert (a batch lacking a *_metadata series must
+ * not blank hostname/deviceClass/daemonVersion), the lastSeenAt
+ * dominance guard, exact parameter ordering, and the bigint-as-string
+ * convention on the latest-metric mirror.
+ */
+
+const PROJECT_ID: ObjectID = ObjectID.generate();
+const CLUSTER_ID: ObjectID = ObjectID.generate();
+
+type QueryCall = [string, Array<unknown>];
+
+function mockQueryRunner(result: unknown = []): jest.Mock {
+  const query: jest.Mock = jest.fn().mockResolvedValue(result);
+  jest
+    .spyOn(CephResourceService, "getRepository")
+    .mockReturnValue({ manager: { query } } as any);
+  return query;
+}
+
+function parsedResource(
+  overrides: Partial<ParsedCephResource> = {},
+): ParsedCephResource {
+  return {
+    kind: "Osd",
+    externalId: "osd.3",
+    name: null,
+    hostname: "ceph-node-1",
+    daemonVersion: "ceph version 18.2.2 reef",
+    deviceClass: "ssd",
+    isUp: true,
+    isIn: true,
+    inQuorum: null,
+    lastSeenAt: new Date("2026-06-13T00:00:00.000Z"),
+    ...overrides,
+  };
+}
+
+afterEach(() => {
+  jest.restoreAllMocks();
+});
+
+describe("CephResourceService.bulkUpsert", () => {
+  test("does nothing for an empty batch", async () => {
+    const query: jest.Mock = mockQueryRunner();
+    await CephResourceService.bulkUpsert({
+      projectId: PROJECT_ID,
+      cephClusterId: CLUSTER_ID,
+      resources: [],
+    });
+    expect(query).not.toHaveBeenCalled();
+  });
+
+  test("emits an ON CONFLICT upsert with COALESCE per identity/status column", async () => {
+    const query: jest.Mock = mockQueryRunner();
+    await CephResourceService.bulkUpsert({
+      projectId: PROJECT_ID,
+      cephClusterId: CLUSTER_ID,
+      resources: [parsedResource()],
+    });
+
+    expect(query).toHaveBeenCalledTimes(1);
+    const [sql] = query.mock.calls[0] as QueryCall;
+
+    expect(sql).toContain('INSERT INTO "CephResource"');
+    expect(sql).toContain(
+      'ON CONFLICT ("projectId", "cephClusterId", "kind", "externalId")',
+    );
+
+    for (const column of [
+      "name",
+      "hostname",
+      "daemonVersion",
+      "deviceClass",
+      "isUp",
+      "isIn",
+      "inQuorum",
+    ]) {
+      expect(sql).toContain(
+        `"${column}" = COALESCE(EXCLUDED."${column}", "CephResource"."${column}")`,
+      );
+    }
+
+    expect(sql).toContain('"lastSeenAt" = EXCLUDED."lastSeenAt"');
+    expect(sql).toContain(
+      'WHERE EXCLUDED."lastSeenAt" >= "CephResource"."lastSeenAt"',
+    );
+  });
+
+  test("parameter tuple matches the INSERT column order exactly", async () => {
+    const query: jest.Mock = mockQueryRunner();
+    const lastSeenAt: Date = new Date("2026-06-13T00:00:00.000Z");
+    await CephResourceService.bulkUpsert({
+      projectId: PROJECT_ID,
+      cephClusterId: CLUSTER_ID,
+      resources: [parsedResource({ lastSeenAt })],
+    });
+
+    const [sql, params] = query.mock.calls[0] as QueryCall;
+
+    // 13 columns per row: a 1-row batch carries exactly $1..$13.
+    expect(params).toHaveLength(13);
+    expect(sql).toContain(
+      "($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)",
+    );
+    expect(params).toEqual([
+      PROJECT_ID.toString(),
+      CLUSTER_ID.toString(),
+      "Osd",
+      "osd.3",
+      null, // name — pool-only identity, NULL for daemons
+      "ceph-node-1",
+      "ceph version 18.2.2 reef",
+      "ssd",
+      true, // isUp
+      true, // isIn
+      null, // inQuorum — mon-only, NULL for OSDs
+      lastSeenAt,
+      0, // version
+    ]);
+  });
+
+  test("chunks batches of more than 500 rows into multiple statements", async () => {
+    const query: jest.Mock = mockQueryRunner();
+    const resources: Array<ParsedCephResource> = [];
+    for (let i: number = 0; i < 501; i++) {
+      resources.push(parsedResource({ externalId: `osd.${i}` }));
+    }
+
+    await CephResourceService.bulkUpsert({
+      projectId: PROJECT_ID,
+      cephClusterId: CLUSTER_ID,
+      resources,
+    });
+
+    expect(query).toHaveBeenCalledTimes(2);
+    const [, firstParams] = query.mock.calls[0] as QueryCall;
+    const [, secondParams] = query.mock.calls[1] as QueryCall;
+    expect(firstParams).toHaveLength(500 * 13);
+    expect(secondParams).toHaveLength(13);
+  });
+});
+
+describe("CephResourceService.bulkUpdateLatestMetrics", () => {
+  function latestMetric(
+    overrides: Partial<CephResourceLatestMetric> = {},
+  ): CephResourceLatestMetric {
+    return {
+      kind: "Osd",
+      externalId: "osd.3",
+      statBytes: 4000000000,
+      statBytesUsed: 1000000000,
+      applyLatencyMs: 12.5,
+      commitLatencyMs: 10,
+      pgCount: 96.7,
+      storedBytes: null,
+      maxAvailBytes: null,
+      objects: null,
+      readOpsCounter: null,
+      writeOpsCounter: null,
+      observedAt: new Date("2026-06-13T00:00:00.000Z"),
+      ...overrides,
+    };
+  }
+
+  test("COALESCEs every mirror column and guards on metricsUpdatedAt", async () => {
+    const query: jest.Mock = mockQueryRunner();
+    await CephResourceService.bulkUpdateLatestMetrics({
+      projectId: PROJECT_ID,
+      cephClusterId: CLUSTER_ID,
+      metrics: [latestMetric()],
+    });
+
+    const [sql] = query.mock.calls[0] as QueryCall;
+    expect(sql).toContain('UPDATE "CephResource"');
+    for (const column of [
+      "statBytes",
+      "statBytesUsed",
+      "applyLatencyMs",
+      "commitLatencyMs",
+      "pgCount",
+      "storedBytes",
+      "maxAvailBytes",
+      "objects",
+      "readOpsCounter",
+      "writeOpsCounter",
+    ]) {
+      expect(sql).toContain(
+        `"${column}" = COALESCE(v."${column}", c."${column}")`,
+      );
+    }
+    expect(sql).toContain(
+      '(c."metricsUpdatedAt" IS NULL OR v."observedAt" >= c."metricsUpdatedAt")',
+    );
+  });
+
+  test("bigints ride as strings, integers truncate, missing series stay NULL", async () => {
+    const query: jest.Mock = mockQueryRunner();
+    await CephResourceService.bulkUpdateLatestMetrics({
+      projectId: PROJECT_ID,
+      cephClusterId: CLUSTER_ID,
+      metrics: [latestMetric()],
+    });
+
+    const [, params] = query.mock.calls[0] as QueryCall;
+    /*
+     * Params: projectId, clusterId, then per row (kind, externalId,
+     * statBytes, statBytesUsed, applyLatencyMs, commitLatencyMs,
+     * pgCount, storedBytes, maxAvailBytes, objects, readOpsCounter,
+     * writeOpsCounter, observedAt).
+     */
+    expect(params).toHaveLength(2 + 13);
+    expect(params[4]).toBe("4000000000"); // statBytes as string
+    expect(params[6]).toBe(12.5); // latency stays numeric
+    expect(params[8]).toBe(96); // pgCount truncated
+    expect(params[9]).toBeNull(); // storedBytes — OSD row, not a pool
+    expect(params[12]).toBeNull(); // readOpsCounter
+  });
+});
+
+describe("CephResourceService.deleteStaleForCluster", () => {
+  test("normalizes the postgres [rows, affected] DELETE result", async () => {
+    mockQueryRunner([[], 3]);
+    const affected: number = await CephResourceService.deleteStaleForCluster({
+      cephClusterId: CLUSTER_ID,
+      olderThan: new Date("2026-06-13T00:00:00.000Z"),
+    });
+    expect(affected).toBe(3);
+  });
+});
+
+describe("CephResourceService.getStaleThresholdMinutes", () => {
+  const ENV_KEY: string = "CEPH_INVENTORY_STALE_MINUTES";
+  let savedValue: string | undefined;
+
+  beforeEach(() => {
+    savedValue = process.env[ENV_KEY];
+  });
+
+  afterEach(() => {
+    if (savedValue === undefined) {
+      delete process.env[ENV_KEY];
+    } else {
+      process.env[ENV_KEY] = savedValue;
+    }
+  });
+
+  test("defaults to 15 minutes and clamps bad overrides", () => {
+    delete process.env[ENV_KEY];
+    expect(CephResourceService.getStaleThresholdMinutes()).toBe(15);
+    process.env[ENV_KEY] = "45";
+    expect(CephResourceService.getStaleThresholdMinutes()).toBe(45);
+    process.env[ENV_KEY] = "1";
+    expect(CephResourceService.getStaleThresholdMinutes()).toBe(15);
+  });
+});