@oneuptime/common 12.0.3 → 12.0.5

package/Tests/UI/Components/StatusPage/ResourceGroupSection.test.tsx

@@ -660,6 +660,68 @@ describe("ResourceGroupSection", () => {
     });
   });
 
+  /*
+   * A status page whose hierarchy is built but whose monitors are not added
+   * yet. This used to be a page that rendered nothing at all; the section has
+   * to draw the structure on its own, because that structure is the only thing
+   * the operator has put there so far.
+   */
+  describe("a hierarchy with no resources anywhere in it", () => {
+    type RenderEmptyFunction = (depth: number) => ReactElement;
+
+    const renderEmpty: RenderEmptyFunction = (depth: number): ReactElement => {
+      return (
+        <ResourceGroupSection
+          depth={depth}
+          name={`Level ${depth}`}
+          isInitiallyExpanded={true}
+          subGroupCount={depth < 3 ? 1 : 0}
+          testId={`empty-level-${depth}`}
+          subGroupsElement={depth < 3 ? renderEmpty(depth + 1) : undefined}
+          hasOwnResources={false}
+        />
+      );
+    };
+
+    test("every level is still drawn, and named", () => {
+      render(renderEmpty(0));
+
+      for (let depth: number = 0; depth <= 3; depth++) {
+        expect(screen.getByTestId(`empty-level-${depth}`)).toBeInTheDocument();
+        expect(screen.getByText(`Level ${depth}`)).toBeInTheDocument();
+      }
+    });
+
+    test("each level is still a working disclosure control", () => {
+      render(renderEmpty(0));
+
+      const header: HTMLElement = screen
+        .getByTestId("empty-level-1")
+        .querySelector("[data-testid='status-page-group-header']")!;
+
+      expect(header.getAttribute("aria-expanded")).toBe("true");
+      expect(screen.getByTestId("empty-level-3")).toBeInTheDocument();
+
+      fireEvent.click(header);
+
+      expect(header.getAttribute("aria-expanded")).toBe("false");
+      expect(screen.queryByTestId("empty-level-3")).not.toBeInTheDocument();
+      expect(screen.getByTestId("empty-level-1")).toBeInTheDocument();
+    });
+
+    /*
+     * No resources means no rolled up reading to show. A group header with a
+     * number on it that came from nowhere is worse than a header without one.
+     */
+    test("no rollup is drawn when the caller has none to give", () => {
+      render(renderEmpty(0));
+
+      expect(
+        screen.queryByTestId("status-page-group-rollup"),
+      ).not.toBeInTheDocument();
+    });
+  });
+
   describe("test ids", () => {
     test("the caller can override the default", () => {
       renderSection({ testId: "my-group" });

package/Tests/UI/Monitor/PortMonitorView.test.tsx

@@ -0,0 +1,237 @@
+import "@testing-library/jest-dom";
+import { render, screen } from "@testing-library/react";
+import { describe, expect, it } from "@jest/globals";
+import * as React from "react";
+import Hostname from "../../../Types/API/Hostname";
+import MonitorType from "../../../Types/Monitor/MonitorType";
+import ObjectID from "../../../Types/ObjectID";
+import Port from "../../../Types/Port";
+import ProbeMonitorResponse from "../../../Types/Probe/ProbeMonitorResponse";
+import { RequestFailedPhase } from "../../../Types/Probe/RequestFailedDetails";
+import SummaryInfo from "../../../../App/FeatureSet/Dashboard/src/Components/Monitor/SummaryView/SummaryInfo";
+
+const MONITORED_AT: Date = new Date("2026-08-07T12:30:00.000Z");
+
+function buildResponse(
+  overrides: Partial<ProbeMonitorResponse> = {},
+): ProbeMonitorResponse {
+  return {
+    projectId: new ObjectID("11111111-1111-4111-8111-111111111111"),
+    monitorId: new ObjectID("22222222-2222-4222-8222-222222222222"),
+    monitorStepId: new ObjectID("33333333-3333-4333-8333-333333333333"),
+    probeId: new ObjectID("44444444-4444-4444-8444-444444444444"),
+    monitorDestination: new Hostname("db.example.com"),
+    monitorDestinationPort: new Port(5432),
+    isOnline: true,
+    responseTimeInMs: 31.27,
+    failureCause: "",
+    monitoredAt: MONITORED_AT,
+    ...overrides,
+  };
+}
+
+function renderSummary(
+  monitorType: MonitorType,
+  response: ProbeMonitorResponse,
+): void {
+  render(
+    <SummaryInfo
+      monitorType={monitorType}
+      probeMonitorResponses={[response]}
+      probeName="London Probe"
+    />,
+  );
+}
+
+describe("Port monitor summary", () => {
+  it("labels the existing response time as the DNS plus TCP total", () => {
+    renderSummary(
+      MonitorType.Port,
+      buildResponse({
+        portTimings: {
+          dnsLookupInMs: 8.12,
+          tcpConnectInMs: 23.15,
+          totalConnectionInMs: 31.27,
+        },
+      }),
+    );
+
+    expect(screen.getByText("db.example.com:5432")).toBeInTheDocument();
+    expect(
+      screen.getByText("Total Connection Time (DNS + TCP)"),
+    ).toBeInTheDocument();
+    expect(screen.getByText("31.27 ms")).toBeInTheDocument();
+    expect(screen.queryByText("Response Time (in ms)")).not.toBeInTheDocument();
+  });
+
+  it("shows the measured DNS and TCP phases", () => {
+    renderSummary(
+      MonitorType.Port,
+      buildResponse({
+        portTimings: {
+          dnsLookupInMs: 8.123,
+          tcpConnectInMs: 23.147,
+          totalConnectionInMs: 31.27,
+        },
+      }),
+    );
+
+    expect(screen.getByText("Connection Phase Breakdown")).toBeInTheDocument();
+    expect(screen.getByText("DNS Lookup")).toBeInTheDocument();
+    expect(screen.getByText("8.12 ms")).toBeInTheDocument();
+    expect(screen.getByText("TCP Connect")).toBeInTheDocument();
+    expect(screen.getByText("23.15 ms")).toBeInTheDocument();
+  });
+
+  it("omits DNS for an IP target while retaining the TCP phase", () => {
+    renderSummary(
+      MonitorType.Port,
+      buildResponse({
+        monitorDestination: new Hostname("192.0.2.10"),
+        responseTimeInMs: 4.25,
+        portTimings: {
+          tcpConnectInMs: 4.25,
+          totalConnectionInMs: 4.25,
+        },
+      }),
+    );
+
+    expect(screen.getByText("192.0.2.10:5432")).toBeInTheDocument();
+    expect(screen.queryByText("DNS Lookup")).not.toBeInTheDocument();
+    expect(screen.getByText("TCP Connect")).toBeInTheDocument();
+  });
+
+  it("renders valid zero-duration measurements instead of missing data", () => {
+    renderSummary(
+      MonitorType.Port,
+      buildResponse({
+        responseTimeInMs: 0,
+        portTimings: {
+          dnsLookupInMs: 0,
+          tcpConnectInMs: 0,
+          totalConnectionInMs: 0,
+        },
+      }),
+    );
+
+    expect(screen.getAllByText("0 ms")).toHaveLength(3);
+  });
+
+  it("does not invent a missing TCP duration after a DNS-only failure", () => {
+    renderSummary(
+      MonitorType.Port,
+      buildResponse({
+        isOnline: false,
+        responseTimeInMs: 19,
+        failureCause: "DNS lookup failed",
+        portTimings: {
+          dnsLookupInMs: 19,
+          totalConnectionInMs: 19,
+        },
+      }),
+    );
+
+    expect(screen.getByText("DNS Lookup")).toBeInTheDocument();
+    expect(screen.queryByText("TCP Connect")).not.toBeInTheDocument();
+  });
+
+  it("keeps older results useful when no phase timings were recorded", () => {
+    renderSummary(MonitorType.Port, buildResponse());
+
+    expect(
+      screen.getByText("Total Connection Time (DNS + TCP)"),
+    ).toBeInTheDocument();
+    expect(screen.getByText("31.27 ms")).toBeInTheDocument();
+    expect(
+      screen.queryByText("Connection Phase Breakdown"),
+    ).not.toBeInTheDocument();
+  });
+
+  it("uses the compatibility response time for the displayed total", () => {
+    renderSummary(
+      MonitorType.Port,
+      buildResponse({
+        responseTimeInMs: 25,
+        portTimings: {
+          dnsLookupInMs: 5,
+          tcpConnectInMs: 20,
+          totalConnectionInMs: 999,
+        },
+      }),
+    );
+
+    expect(screen.getByText("25 ms")).toBeInTheDocument();
+    expect(screen.queryByText("999 ms")).not.toBeInTheDocument();
+  });
+
+  it("retains failure details and retry evidence in the dedicated view", () => {
+    renderSummary(
+      MonitorType.Port,
+      buildResponse({
+        isOnline: false,
+        failureCause: "Connection refused",
+        requestFailedDetails: {
+          failedPhase: RequestFailedPhase.TCPConnection,
+          errorCode: "ECONNREFUSED",
+          errorDescription: "The target rejected the TCP connection.",
+        },
+        probeAttempts: [
+          {
+            attemptNumber: 1,
+            attemptedAt: MONITORED_AT,
+            responseReceivedAt: MONITORED_AT,
+            responseTimeInMs: 11,
+            isOnline: false,
+            failureCause: "Connection refused",
+          },
+          {
+            attemptNumber: 2,
+            attemptedAt: MONITORED_AT,
+            responseReceivedAt: MONITORED_AT,
+            responseTimeInMs: 12,
+            isOnline: false,
+            failureCause: "Connection refused",
+          },
+        ],
+        totalAttempts: 2,
+      }),
+    );
+
+    expect(screen.getByText("Offline")).toBeInTheDocument();
+    expect(screen.getAllByText("Connection refused").length).toBeGreaterThan(0);
+    expect(screen.getByText("TCP Connection")).toBeInTheDocument();
+    expect(screen.getByText("ECONNREFUSED")).toBeInTheDocument();
+    expect(
+      screen.getByText("The target rejected the TCP connection."),
+    ).toBeInTheDocument();
+    expect(screen.getByText("Retry Attempts")).toBeInTheDocument();
+    expect(screen.getByText("Attempt 1/2")).toBeInTheDocument();
+    expect(screen.getByText("Attempt 2/2")).toBeInTheDocument();
+  });
+});
+
+describe("Ping and IP summaries", () => {
+  it.each([MonitorType.Ping, MonitorType.IP])(
+    "keeps %s on the existing Ping view",
+    (monitorType: MonitorType) => {
+      renderSummary(
+        monitorType,
+        buildResponse({
+          portTimings: {
+            dnsLookupInMs: 8,
+            tcpConnectInMs: 23,
+            totalConnectionInMs: 31,
+          },
+        }),
+      );
+
+      expect(screen.getByText("Response Time (in ms)")).toBeInTheDocument();
+      expect(
+        screen.queryByText("Total Connection Time (DNS + TCP)"),
+      ).not.toBeInTheDocument();
+      expect(
+        screen.queryByText("Connection Phase Breakdown"),
+      ).not.toBeInTheDocument();
+    },
+  );
+});

package/Tests/UI/Telemetry/TelemetrySnapshotWindowAlert.test.tsx

@@ -0,0 +1,91 @@
+import "@testing-library/jest-dom/extend-expect";
+import { render, RenderResult } from "@testing-library/react";
+/*
+ * The Dashboard has its own copy of react, so a component imported from there
+ * would otherwise call hooks on a DIFFERENT React instance than the one
+ * react-dom renders with. Common's jest moduleNameMapper pins react and
+ * react-dom to this project's single copy for every importer, which is what
+ * makes importing Dashboard source from here work (same arrangement as
+ * Common/Tests/UI/Rum/ReplayStage.test.tsx).
+ */
+import * as React from "react";
+import { describe, expect, it } from "@jest/globals";
+import InBetween from "../../../Types/BaseDatabase/InBetween";
+import OneUptimeDate from "../../../Types/Date";
+import TelemetrySnapshotWindowAlert from "../../../../App/FeatureSet/Dashboard/src/Components/Telemetry/TelemetrySnapshotWindowAlert";
+
+/*
+ * The badge that tells someone reading an incident WHICH slice of time the
+ * telemetry cards below are showing. Its absence on the log card is a large
+ * part of why the rolling-window bug went unnoticed for so long: with nothing
+ * on screen claiming a window, an hour of unrelated logs read as the
+ * incident's own logs.
+ *
+ * Two behaviours matter and neither is reachable from a pure test: that it
+ * renders the stored window, and that it renders NOTHING when there is no
+ * window — the backwards-compatible path for incidents created before monitors
+ * stamped one, where a badge would be worse than no badge.
+ */
+describe("TelemetrySnapshotWindowAlert", () => {
+  const START_DATE: Date = new Date("2026-08-04T10:00:00.000Z");
+  const END_DATE: Date = new Date("2026-08-04T10:01:00.000Z");
+
+  it("renders the snapshot window", () => {
+    const result: RenderResult = render(
+      <TelemetrySnapshotWindowAlert
+        window={new InBetween<Date>(START_DATE, END_DATE)}
+      />,
+    );
+
+    /*
+     * Assert against the app's own formatter rather than a hard-coded string:
+     * the output is timezone- and 12/24h-preference dependent, and pinning a
+     * literal here would make this test a clock/locale trap rather than a
+     * check that the window reaches the screen.
+     */
+    const expected: string = OneUptimeDate.getInBetweenDatesAsFormattedString(
+      new InBetween<Date>(START_DATE, END_DATE),
+    );
+
+    expect(result.container.textContent).toContain(expected);
+
+    // Both edges are named, not just the start.
+    expect(expected).toContain(" - ");
+  });
+
+  it("renders nothing when the incident stored no window", () => {
+    for (const value of [null, undefined]) {
+      const result: RenderResult = render(
+        <TelemetrySnapshotWindowAlert window={value} />,
+      );
+
+      expect(result.container.textContent).toBe("");
+      result.unmount();
+    }
+  });
+
+  it("renders a window restored from storage, whose bounds are ISO strings", () => {
+    /*
+     * The shape the incident page actually holds if hydration were ever
+     * skipped. The formatter normalizes strings, so the badge must still show
+     * real dates rather than "Invalid Date".
+     */
+    const result: RenderResult = render(
+      <TelemetrySnapshotWindowAlert
+        window={
+          new InBetween<Date>(
+            START_DATE.toISOString() as unknown as Date,
+            END_DATE.toISOString() as unknown as Date,
+          )
+        }
+      />,
+    );
+
+    expect(result.container.textContent).not.toContain("Invalid Date");
+    expect(result.container.textContent).toContain(
+      OneUptimeDate.getInBetweenDatesAsFormattedString(
+        new InBetween<Date>(START_DATE, END_DATE),
+      ),
+    );
+  });
+});

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

@@ -0,0 +1,103 @@
+import downloadFile from "../../../UI/Utils/DownloadFile";
+
+describe("downloadFile", () => {
+  let createObjectUrlMock: jest.Mock;
+  let revokeObjectUrlMock: jest.Mock;
+  let clickSpy: jest.SpyInstance;
+  let capturedAnchor: HTMLAnchorElement | null;
+  let originalCreateObjectUrl: typeof window.URL.createObjectURL | undefined;
+  let originalRevokeObjectUrl: typeof window.URL.revokeObjectURL | undefined;
+
+  beforeEach(() => {
+    capturedAnchor = null;
+    originalCreateObjectUrl = window.URL.createObjectURL;
+    originalRevokeObjectUrl = window.URL.revokeObjectURL;
+    createObjectUrlMock = jest.fn().mockReturnValue("blob:support-bundle");
+    revokeObjectUrlMock = jest.fn();
+
+    window.URL.createObjectURL = createObjectUrlMock;
+    window.URL.revokeObjectURL = revokeObjectUrlMock;
+
+    clickSpy = jest
+      .spyOn(HTMLAnchorElement.prototype, "click")
+      .mockImplementation(() => {});
+
+    const originalCreateElement: typeof document.createElement =
+      document.createElement.bind(document);
+
+    jest.spyOn(document, "createElement").mockImplementation(((
+      tagName: string,
+    ): HTMLElement => {
+      const element: HTMLElement = originalCreateElement(tagName);
+
+      if (tagName === "a") {
+        capturedAnchor = element as HTMLAnchorElement;
+      }
+
+      return element;
+    }) as typeof document.createElement);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+
+    if (originalCreateObjectUrl) {
+      window.URL.createObjectURL = originalCreateObjectUrl;
+    } else {
+      delete (window.URL as { createObjectURL?: unknown }).createObjectURL;
+    }
+
+    if (originalRevokeObjectUrl) {
+      window.URL.revokeObjectURL = originalRevokeObjectUrl;
+    } else {
+      delete (window.URL as { revokeObjectURL?: unknown }).revokeObjectURL;
+    }
+  });
+
+  test("creates a Blob with the requested MIME type for string content", () => {
+    downloadFile({
+      content: "diagnostics",
+      filename: "support.json",
+      mimeType: "application/json;charset=utf-8;",
+    });
+
+    const blob: Blob = createObjectUrlMock.mock.calls[0]![0] as Blob;
+    expect(blob).toBeInstanceOf(Blob);
+    expect(blob.type).toBe("application/json;charset=utf-8;");
+  });
+
+  test("reuses Blob content rather than wrapping it in another Blob", () => {
+    const blob: Blob = new Blob(["diagnostics"], {
+      type: "application/json",
+    });
+
+    downloadFile({ content: blob, filename: "support.json" });
+
+    expect(createObjectUrlMock).toHaveBeenCalledWith(blob);
+  });
+
+  test("clicks a safe download anchor and cleans it up", () => {
+    downloadFile({ content: "diagnostics", filename: "support.json" });
+
+    expect(clickSpy).toHaveBeenCalledTimes(1);
+    expect(capturedAnchor).not.toBeNull();
+    expect(capturedAnchor!.href).toContain("blob:support-bundle");
+    expect(capturedAnchor!.download).toBe("support.json");
+    expect(capturedAnchor!.rel).toBe("noopener");
+    expect(document.body.contains(capturedAnchor)).toBe(false);
+    expect(revokeObjectUrlMock).toHaveBeenCalledWith("blob:support-bundle");
+  });
+
+  test("still removes the anchor and revokes the object URL when click fails", () => {
+    clickSpy.mockImplementation(() => {
+      throw new Error("Download blocked");
+    });
+
+    expect(() => {
+      downloadFile({ content: "diagnostics", filename: "support.json" });
+    }).toThrow("Download blocked");
+
+    expect(document.body.contains(capturedAnchor)).toBe(false);
+    expect(revokeObjectUrlMock).toHaveBeenCalledWith("blob:support-bundle");
+  });
+});