@oneuptime/common 12.0.14 → 12.0.15

package/Tests/Server/Utils/Monitor/MonitorResourceIngestedStepSelection.test.ts

@@ -33,6 +33,16 @@
  * MonitorResourceProbeAgreementReuse.test.ts. Pure in-memory model instances.
  */
 
+/*
+ * MonitorResource's import chain reaches the native isolated-vm addon
+ * through the sandbox runner. Nothing here touches the sandbox and the
+ * prebuilt binary cannot always dlopen in the test environment, so stub it
+ * out before anything imports it.
+ */
+jest.mock("isolated-vm", () => {
+  return {};
+});
+
 jest.mock("../../../../Server/Utils/Monitor/MonitorCriteriaEvaluator", () => {
   return {
     __esModule: true,
@@ -452,4 +462,80 @@ describe("MonitorResourceUtil.monitorResource ingested monitor step selection",
       );
     });
   });
+
+  /*
+   * Over-time criteria size their evaluation window from the monitor's
+   * polling schedule, so the monitor load on this path has to select it.
+   * Without it the cadence is always inferred from the samples, and a
+   * monitor that can only ever produce one sample per window can never
+   * satisfy "All Values" - alerting goes quiet with nothing logged.
+   */
+  describe("monitor load", () => {
+    test("selects the monitoring interval", async () => {
+      const step: MonitorStep = makeStep("Step one criteria");
+      const monitor: Monitor = makeMonitor({
+        monitorType: MonitorType.Website,
+        steps: [step],
+      });
+      monitor.monitoringInterval = "*/5 * * * *";
+
+      const probeId: ObjectID = ObjectID.generate();
+
+      const monitorProbe: MonitorProbe = new MonitorProbe();
+      monitorProbe.id = ObjectID.generate();
+      monitorProbe.probeId = probeId;
+      monitorProbe.isEnabled = true;
+
+      findOneByIdMock.mockResolvedValue(monitor);
+      findByMock.mockResolvedValue([monitorProbe]);
+
+      await MonitorResourceUtil.monitorResource(
+        makeProbeResult({
+          monitor: monitor,
+          probeId: probeId,
+          monitorStepId: step.id,
+        }),
+      );
+
+      const select: Record<string, unknown> = (
+        findOneByIdMock.mock.calls[0]![0] as {
+          select: Record<string, unknown>;
+        }
+      ).select;
+
+      expect(select["monitoringInterval"]).toBe(true);
+    });
+
+    test("hands the monitoring interval to the criteria evaluator", async () => {
+      const step: MonitorStep = makeStep("Step one criteria");
+      const monitor: Monitor = makeMonitor({
+        monitorType: MonitorType.Website,
+        steps: [step],
+      });
+      monitor.monitoringInterval = "*/5 * * * *";
+
+      const probeId: ObjectID = ObjectID.generate();
+
+      const monitorProbe: MonitorProbe = new MonitorProbe();
+      monitorProbe.id = ObjectID.generate();
+      monitorProbe.probeId = probeId;
+      monitorProbe.isEnabled = true;
+
+      findOneByIdMock.mockResolvedValue(monitor);
+      findByMock.mockResolvedValue([monitorProbe]);
+
+      await MonitorResourceUtil.monitorResource(
+        makeProbeResult({
+          monitor: monitor,
+          probeId: probeId,
+          monitorStepId: step.id,
+        }),
+      );
+
+      const evaluatorInput: { monitor: Monitor } = processMonitorStepMock.mock
+        .calls[0]![0] as { monitor: Monitor };
+
+      expect(evaluatorInput.monitor.monitoringInterval).toBe("*/5 * * * *");
+    });
+  });
 });

package/Tests/Server/Utils/StatusPageContentSecurityPolicy.test.ts

@@ -0,0 +1,136 @@
+import applyStatusPageContentSecurityPolicy, {
+  isStatusPageFallbackDocumentPath,
+  STATUS_PAGE_CONTENT_SECURITY_POLICY_HEADER_NAME,
+  STATUS_PAGE_FALLBACK_CONTENT_SECURITY_POLICY,
+} from "../../../Server/Utils/StatusPageContentSecurityPolicy";
+import { ExpressRequest, ExpressResponse } from "../../../Server/Utils/Express";
+import { describe, expect, it, jest } from "@jest/globals";
+
+type FakeResponse = {
+  set: ReturnType<typeof jest.fn>;
+  headersSent: boolean;
+};
+
+function fakeRequest(path: string): ExpressRequest {
+  return { path } as unknown as ExpressRequest;
+}
+
+function fakeResponse(headersSent: boolean = false): FakeResponse {
+  return {
+    set: jest.fn(),
+    headersSent,
+  };
+}
+
+function policyDirectives(): Map<string, Array<string>> {
+  const directives: Map<string, Array<string>> = new Map();
+
+  for (const rawDirective of STATUS_PAGE_FALLBACK_CONTENT_SECURITY_POLICY.split(
+    ";",
+  )) {
+    const parts: Array<string> = rawDirective.trim().split(/\s+/);
+    const name: string | undefined = parts.shift();
+
+    if (name) {
+      directives.set(name, parts);
+    }
+  }
+
+  return directives;
+}
+
+describe("status page fallback Content Security Policy", () => {
+  it.each([
+    "/status-page",
+    "/status-page/",
+    "/status-page/aaaaaaaa-bbbb-4ccc-8ddd-eeeeeeeeeeee",
+    "/status-page/aaaaaaaa-bbbb-4ccc-8ddd-eeeeeeeeeeee/incidents",
+    "/status-page/aaaaaaaa-bbbb-4ccc-8ddd-eeeeeeeeeeee?lang=en",
+  ])("classifies %s as a fallback document path", (path: string) => {
+    expect(isStatusPageFallbackDocumentPath(path)).toBe(true);
+  });
+
+  it.each([
+    "",
+    "/",
+    "/incidents",
+    "/rss",
+    "/llms.txt",
+    "/status-page-api/master-page/id",
+    "/status-pages/id",
+  ])(
+    "does not classify custom-domain or sibling path %s as fallback",
+    (path: string) => {
+      expect(isStatusPageFallbackDocumentPath(path)).toBe(false);
+    },
+  );
+
+  it("sets the policy on a fallback document", () => {
+    const res: FakeResponse = fakeResponse();
+
+    applyStatusPageContentSecurityPolicy(
+      fakeRequest("/status-page/aaaaaaaa-bbbb-4ccc-8ddd-eeeeeeeeeeee"),
+      res as unknown as ExpressResponse,
+    );
+
+    expect(res.set).toHaveBeenCalledTimes(1);
+    expect(res.set).toHaveBeenCalledWith(
+      STATUS_PAGE_CONTENT_SECURITY_POLICY_HEADER_NAME,
+      STATUS_PAGE_FALLBACK_CONTENT_SECURITY_POLICY,
+    );
+  });
+
+  it("leaves a custom-domain document unchanged", () => {
+    const res: FakeResponse = fakeResponse();
+
+    applyStatusPageContentSecurityPolicy(
+      fakeRequest("/"),
+      res as unknown as ExpressResponse,
+    );
+
+    expect(res.set).not.toHaveBeenCalled();
+  });
+
+  it("does not touch a response whose headers were already sent", () => {
+    const res: FakeResponse = fakeResponse(true);
+
+    applyStatusPageContentSecurityPolicy(
+      fakeRequest("/status-page/aaaaaaaa-bbbb-4ccc-8ddd-eeeeeeeeeeee"),
+      res as unknown as ExpressResponse,
+    );
+
+    expect(res.set).not.toHaveBeenCalled();
+  });
+
+  it("blocks dynamic JavaScript evaluation", () => {
+    const scriptSources: Array<string> =
+      policyDirectives().get("script-src") || [];
+
+    expect(scriptSources).not.toContain("'unsafe-eval'");
+    expect(STATUS_PAGE_FALLBACK_CONTENT_SECURITY_POLICY).not.toContain(
+      "unsafe-eval",
+    );
+  });
+
+  it("blocks inline event-handler attributes even though template scripts remain inline", () => {
+    const directives: Map<string, Array<string>> = policyDirectives();
+
+    expect(directives.get("script-src")).toContain("'unsafe-inline'");
+    expect(directives.get("script-src-attr")).toEqual(["'none'"]);
+  });
+
+  it("keeps the template bundle and HTTPS Tag Manager dependencies loadable", () => {
+    const scriptSources: Array<string> =
+      policyDirectives().get("script-src") || [];
+
+    expect(scriptSources).toContain("'self'");
+    expect(scriptSources).toContain("https:");
+  });
+
+  it("forbids plugin documents and attacker-controlled base URLs", () => {
+    const directives: Map<string, Array<string>> = policyDirectives();
+
+    expect(directives.get("object-src")).toEqual(["'none'"]);
+    expect(directives.get("base-uri")).toEqual(["'none'"]);
+  });
+});

package/Tests/Server/Utils/StatusPageCustomizationAccess.test.ts

@@ -0,0 +1,223 @@
+import StatusPageDomain from "../../../Models/DatabaseModels/StatusPageDomain";
+import StatusPageDomainService from "../../../Server/Services/StatusPageDomainService";
+import {
+  canServeStatusPageCustomizations,
+  isPrimaryStatusPageHost,
+  normalizeStatusPageRequestHost,
+} from "../../../Server/Utils/StatusPageCustomizationAccess";
+import { ExpressRequest } from "../../../Server/Utils/Express";
+import ObjectID from "../../../Types/ObjectID";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  jest,
+} from "@jest/globals";
+
+const makeRequest: (host?: string, forwardedHost?: string) => ExpressRequest = (
+  host?: string,
+  forwardedHost?: string,
+): ExpressRequest => {
+  const headers: Record<string, string> = {};
+
+  if (host !== undefined) {
+    headers["host"] = host;
+  }
+
+  if (forwardedHost !== undefined) {
+    headers["x-forwarded-host"] = forwardedHost;
+  }
+
+  return {
+    headers,
+    get: (name: string): string | undefined => {
+      return headers[name.toLowerCase()];
+    },
+  } as unknown as ExpressRequest;
+};
+
+describe("normalizeStatusPageRequestHost", () => {
+  it.each([
+    ["status.example.com", "status.example.com"],
+    [" STATUS.Example.COM ", "status.example.com"],
+    ["status.example.com:443", "status.example.com"],
+    ["status.example.com.:8443", "status.example.com"],
+    ["[::1]", "[::1]"],
+    ["[::1]:8080", "[::1]"],
+  ])("normalizes %s", (rawHost: string, expected: string) => {
+    expect(normalizeStatusPageRequestHost(rawHost)).toBe(expected);
+  });
+
+  it.each([
+    undefined,
+    "",
+    "   ",
+    "https://status.example.com",
+    "status.example.com/path",
+    "status.example.com?query=true",
+    "status.example.com#fragment",
+    "user@status.example.com",
+    "status.example.com,evil.example.com",
+    "status example.com",
+    "status.example.com:not-a-port",
+    "status.example.com:99999",
+    "status..example.com",
+  ])("rejects malformed authority %p", (rawHost: string | undefined) => {
+    expect(normalizeStatusPageRequestHost(rawHost)).toBeNull();
+  });
+});
+
+describe("isPrimaryStatusPageHost", () => {
+  const originalHost: string | undefined = process.env["HOST"];
+
+  afterEach(() => {
+    if (originalHost === undefined) {
+      delete process.env["HOST"];
+    } else {
+      process.env["HOST"] = originalHost;
+    }
+  });
+
+  it("recognizes the configured application host", () => {
+    process.env["HOST"] = "APP.Example.com:443";
+
+    expect(isPrimaryStatusPageHost("app.example.com")).toBe(true);
+    expect(isPrimaryStatusPageHost("status.example.com")).toBe(false);
+  });
+
+  it.each(["localhost", "ingress"])(
+    "always recognizes the built-in primary host %s",
+    (hostname: string) => {
+      process.env["HOST"] = "app.example.com";
+
+      expect(isPrimaryStatusPageHost(hostname)).toBe(true);
+    },
+  );
+
+  it("fails closed when the configured application host is malformed", () => {
+    process.env["HOST"] = "https://app.example.com/path";
+
+    expect(isPrimaryStatusPageHost("status.example.com")).toBe(true);
+  });
+});
+
+describe("canServeStatusPageCustomizations", () => {
+  const originalHost: string | undefined = process.env["HOST"];
+  let statusPageId: ObjectID;
+
+  beforeEach(() => {
+    process.env["HOST"] = "app.example.com";
+    statusPageId = ObjectID.generate();
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+
+    if (originalHost === undefined) {
+      delete process.env["HOST"];
+    } else {
+      process.env["HOST"] = originalHost;
+    }
+  });
+
+  it.each([
+    ["the configured application host", "APP.EXAMPLE.COM:443"],
+    ["localhost", "localhost:3000"],
+    ["the internal ingress host", "ingress"],
+    ["a missing Host", undefined],
+    ["a malformed Host", "status.example.com/path"],
+  ])(
+    "denies %s without consulting status-page domains",
+    async (_label: string, host: string | undefined) => {
+      const lookupSpy: ReturnType<typeof jest.spyOn> = jest.spyOn(
+        StatusPageDomainService,
+        "findOneBy",
+      );
+
+      await expect(
+        canServeStatusPageCustomizations({
+          req: makeRequest(host),
+          statusPageId,
+        }),
+      ).resolves.toBe(false);
+
+      expect(lookupSpy).not.toHaveBeenCalled();
+    },
+  );
+
+  it("requires a verified domain bound to the exact status page and normalized host", async () => {
+    const statusPageDomain: StatusPageDomain = new StatusPageDomain();
+    statusPageDomain.id = ObjectID.generate();
+
+    const lookupSpy: ReturnType<typeof jest.spyOn> = jest
+      .spyOn(StatusPageDomainService, "findOneBy")
+      .mockResolvedValue(statusPageDomain);
+
+    await expect(
+      canServeStatusPageCustomizations({
+        req: makeRequest("STATUS.Customer.Example.:443"),
+        statusPageId,
+      }),
+    ).resolves.toBe(true);
+
+    expect(lookupSpy).toHaveBeenCalledTimes(1);
+    expect(lookupSpy).toHaveBeenCalledWith({
+      query: {
+        fullDomain: "status.customer.example",
+        statusPageId,
+        isCnameVerified: true,
+        domain: {
+          isVerified: true,
+        },
+      },
+      select: {
+        _id: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+  });
+
+  it("denies an unknown or unverified custom domain", async () => {
+    jest.spyOn(StatusPageDomainService, "findOneBy").mockResolvedValue(null);
+
+    await expect(
+      canServeStatusPageCustomizations({
+        req: makeRequest("status.customer.example"),
+        statusPageId,
+      }),
+    ).resolves.toBe(false);
+  });
+
+  it("fails closed when the status-page-domain lookup throws", async () => {
+    jest
+      .spyOn(StatusPageDomainService, "findOneBy")
+      .mockRejectedValue(new Error("database unavailable"));
+
+    await expect(
+      canServeStatusPageCustomizations({
+        req: makeRequest("status.customer.example"),
+        statusPageId,
+      }),
+    ).resolves.toBe(false);
+  });
+
+  it("never lets X-Forwarded-Host override the raw primary Host", async () => {
+    const lookupSpy: ReturnType<typeof jest.spyOn> = jest.spyOn(
+      StatusPageDomainService,
+      "findOneBy",
+    );
+
+    await expect(
+      canServeStatusPageCustomizations({
+        req: makeRequest("app.example.com", "status.customer.example"),
+        statusPageId,
+      }),
+    ).resolves.toBe(false);
+
+    expect(lookupSpy).not.toHaveBeenCalled();
+  });
+});

package/Tests/Types/Monitor/MonitorStepConfigHelpers.test.ts

@@ -0,0 +1,165 @@
+import {
+  DEFAULT_MONITOR_REQUEST_TIMEOUT_IN_MS,
+  MAX_MONITOR_REQUEST_TIMEOUT_IN_MS,
+  clampMonitorRequestTimeoutInMs,
+} from "../../../Types/Monitor/MonitorStep";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * clampMonitorRequestTimeoutInMs constrains a per-step request timeout to the
+ * range the probe accepts. It has three decision points:
+ *   1. a falsy value (0 / NaN and, defensively, null / undefined) -> DEFAULT
+ *   2. a non-positive value (value <= 0) -> DEFAULT
+ *   3. a value above the cap (value > MAX) -> MAX
+ * anything else passes through unchanged. These tests walk each branch, both
+ * boundaries and the defensive coercions the callers can hand it.
+ *
+ * Note: with the current config DEFAULT and MAX happen to share the value
+ * 60000, so every assertion checks the constant that names the branch under
+ * test rather than the bare number, keeping the intent readable even if the
+ * two constants diverge later.
+ */
+
+describe("clampMonitorRequestTimeoutInMs", () => {
+  describe("invalid / non-positive inputs fall back to the default", () => {
+    test("zero returns the default (caught by the falsy check)", () => {
+      const result: number = clampMonitorRequestTimeoutInMs(0);
+      expect(result).toBe(DEFAULT_MONITOR_REQUEST_TIMEOUT_IN_MS);
+    });
+
+    test("negative zero returns the default", () => {
+      const result: number = clampMonitorRequestTimeoutInMs(-0);
+      expect(result).toBe(DEFAULT_MONITOR_REQUEST_TIMEOUT_IN_MS);
+    });
+
+    test("NaN returns the default (NaN is falsy)", () => {
+      const result: number = clampMonitorRequestTimeoutInMs(NaN);
+      expect(result).toBe(DEFAULT_MONITOR_REQUEST_TIMEOUT_IN_MS);
+    });
+
+    test("a small negative value returns the default (value <= 0 branch)", () => {
+      const result: number = clampMonitorRequestTimeoutInMs(-1);
+      expect(result).toBe(DEFAULT_MONITOR_REQUEST_TIMEOUT_IN_MS);
+    });
+
+    test("a negative fraction returns the default", () => {
+      const result: number = clampMonitorRequestTimeoutInMs(-0.5);
+      expect(result).toBe(DEFAULT_MONITOR_REQUEST_TIMEOUT_IN_MS);
+    });
+
+    test("a large negative value returns the default, not a clamp", () => {
+      const result: number = clampMonitorRequestTimeoutInMs(-999999);
+      expect(result).toBe(DEFAULT_MONITOR_REQUEST_TIMEOUT_IN_MS);
+    });
+
+    test("negative Infinity returns the default", () => {
+      const result: number = clampMonitorRequestTimeoutInMs(-Infinity);
+      expect(result).toBe(DEFAULT_MONITOR_REQUEST_TIMEOUT_IN_MS);
+    });
+
+    /*
+     * The signature is typed as number, but real callers (JSON / DB rows,
+     * loosely typed UI state) can hand it a missing value. The falsy guard is
+     * what protects the probe here, so exercise it explicitly.
+     */
+    test("undefined coerced through the signature returns the default", () => {
+      const result: number = clampMonitorRequestTimeoutInMs(
+        undefined as unknown as number,
+      );
+      expect(result).toBe(DEFAULT_MONITOR_REQUEST_TIMEOUT_IN_MS);
+    });
+
+    test("null coerced through the signature returns the default", () => {
+      const result: number = clampMonitorRequestTimeoutInMs(
+        null as unknown as number,
+      );
+      expect(result).toBe(DEFAULT_MONITOR_REQUEST_TIMEOUT_IN_MS);
+    });
+  });
+
+  describe("in-range values pass through unchanged", () => {
+    test("the smallest positive integer is returned as-is", () => {
+      const result: number = clampMonitorRequestTimeoutInMs(1);
+      expect(result).toBe(1);
+    });
+
+    test("a fractional millisecond value is preserved", () => {
+      const result: number = clampMonitorRequestTimeoutInMs(1500.75);
+      expect(result).toBe(1500.75);
+    });
+
+    test("a typical mid-range timeout is returned unchanged", () => {
+      const result: number = clampMonitorRequestTimeoutInMs(30000);
+      expect(result).toBe(30000);
+    });
+
+    test("a value just below the cap is not clamped", () => {
+      const justUnder: number = MAX_MONITOR_REQUEST_TIMEOUT_IN_MS - 1;
+      const result: number = clampMonitorRequestTimeoutInMs(justUnder);
+      expect(result).toBe(justUnder);
+    });
+  });
+
+  describe("the upper boundary", () => {
+    test("a value exactly at the cap is returned, not clamped (> is strict)", () => {
+      const result: number = clampMonitorRequestTimeoutInMs(
+        MAX_MONITOR_REQUEST_TIMEOUT_IN_MS,
+      );
+      expect(result).toBe(MAX_MONITOR_REQUEST_TIMEOUT_IN_MS);
+    });
+
+    test("one millisecond over the cap is clamped down to the cap", () => {
+      const result: number = clampMonitorRequestTimeoutInMs(
+        MAX_MONITOR_REQUEST_TIMEOUT_IN_MS + 1,
+      );
+      expect(result).toBe(MAX_MONITOR_REQUEST_TIMEOUT_IN_MS);
+    });
+  });
+
+  describe("values well above the cap are clamped", () => {
+    test("a value far above the cap is clamped to the cap", () => {
+      const result: number = clampMonitorRequestTimeoutInMs(
+        MAX_MONITOR_REQUEST_TIMEOUT_IN_MS * 10,
+      );
+      expect(result).toBe(MAX_MONITOR_REQUEST_TIMEOUT_IN_MS);
+    });
+
+    test("positive Infinity is clamped to the cap", () => {
+      const result: number = clampMonitorRequestTimeoutInMs(Infinity);
+      expect(result).toBe(MAX_MONITOR_REQUEST_TIMEOUT_IN_MS);
+    });
+  });
+
+  describe("purity and stability", () => {
+    test("the same input always yields the same output", () => {
+      const first: number = clampMonitorRequestTimeoutInMs(45000);
+      const second: number = clampMonitorRequestTimeoutInMs(45000);
+      expect(first).toBe(second);
+      expect(first).toBe(45000);
+    });
+
+    test("the exported cap is a positive finite number", () => {
+      expect(Number.isFinite(MAX_MONITOR_REQUEST_TIMEOUT_IN_MS)).toBe(true);
+      expect(MAX_MONITOR_REQUEST_TIMEOUT_IN_MS).toBeGreaterThan(0);
+    });
+
+    test("the clamped result never exceeds the cap across a sweep", () => {
+      const samples: Array<number> = [
+        -5000,
+        0,
+        1,
+        500,
+        60000,
+        60001,
+        250000,
+        Infinity,
+        NaN,
+      ];
+      for (const sample of samples) {
+        const result: number = clampMonitorRequestTimeoutInMs(sample);
+        expect(result).toBeLessThanOrEqual(MAX_MONITOR_REQUEST_TIMEOUT_IN_MS);
+        expect(result).toBeGreaterThan(0);
+      }
+    });
+  });
+});