@oneuptime/common 12.0.4 → 12.0.6

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/Breadcrumb/fixtures/RealBreadcrumbTrails.ts

@@ -164,6 +164,16 @@ const realBreadcrumbTrails: Array<BreadcrumbTrailFixture> = [
     pagePattern: "/dashboard/:projectId/alerts/episodes/unresolved",
     titles: ["Project", "Alerts", "Active Episodes"],
   },
+  {
+    getter: "getAlertsBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/alerts/settings/ai",
+    titles: ["Project", "Alerts", "AI", "Investigation"],
+  },
+  {
+    getter: "getAlertsBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/alerts/settings/auto-remediation-rules",
+    titles: ["Project", "Alerts", "AI", "Remediation"],
+  },
   {
     getter: "getAlertsBreadcrumbs",
     pagePattern: "/dashboard/:projectId/alerts/settings/custom-fields",
@@ -172,7 +182,12 @@ const realBreadcrumbTrails: Array<BreadcrumbTrailFixture> = [
   {
     getter: "getAlertsBreadcrumbs",
     pagePattern: "/dashboard/:projectId/alerts/settings/grouping-rules",
-    titles: ["Project", "Alerts", "Settings", "Grouping Rules"],
+    titles: ["Project", "Alerts", "Rules", "Grouping Rules"],
+  },
+  {
+    getter: "getAlertsBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/alerts/settings/label-rules",
+    titles: ["Project", "Alerts", "Rules", "Label Rules"],
   },
   {
     getter: "getAlertsBreadcrumbs",
@@ -190,6 +205,31 @@ const realBreadcrumbTrails: Array<BreadcrumbTrailFixture> = [
       "View Template",
     ],
   },
+  {
+    getter: "getAlertsBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/alerts/settings/on-call-rules",
+    titles: ["Project", "Alerts", "Rules", "On-Call Rules"],
+  },
+  {
+    getter: "getAlertsBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/alerts/settings/owner-rules",
+    titles: ["Project", "Alerts", "Rules", "Owner Rules"],
+  },
+  {
+    getter: "getAlertsBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/alerts/settings/privacy-rules",
+    titles: ["Project", "Alerts", "Rules", "Privacy Rules"],
+  },
+  {
+    getter: "getAlertsBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/alerts/settings/reminder-rules",
+    titles: ["Project", "Alerts", "Rules", "Reminder Rules"],
+  },
+  {
+    getter: "getAlertsBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/alerts/settings/runbook-rules",
+    titles: ["Project", "Alerts", "Rules", "Runbook Rules"],
+  },
   {
     getter: "getAlertsBreadcrumbs",
     pagePattern: "/dashboard/:projectId/alerts/settings/severity",
@@ -803,11 +843,32 @@ const realBreadcrumbTrails: Array<BreadcrumbTrailFixture> = [
     pagePattern: "/dashboard/:projectId/incidents/create",
     titles: ["Project", "Incidents", "Declare New Incident"],
   },
+  {
+    getter: "getIncidentsBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/incidents/settings/ai",
+    titles: ["Project", "Incidents", "AI", "Investigation"],
+  },
+  {
+    getter: "getIncidentsBreadcrumbs",
+    pagePattern:
+      "/dashboard/:projectId/incidents/settings/auto-remediation-rules",
+    titles: ["Project", "Incidents", "AI", "Remediation"],
+  },
   {
     getter: "getIncidentsBreadcrumbs",
     pagePattern: "/dashboard/:projectId/incidents/settings/custom-fields",
     titles: ["Project", "Incidents", "Settings", "Custom Fields"],
   },
+  {
+    getter: "getIncidentsBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/incidents/settings/grouping-rules",
+    titles: ["Project", "Incidents", "Rules", "Grouping Rules"],
+  },
+  {
+    getter: "getIncidentsBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/incidents/settings/label-rules",
+    titles: ["Project", "Incidents", "Rules", "Label Rules"],
+  },
   {
     getter: "getIncidentsBreadcrumbs",
     pagePattern: "/dashboard/:projectId/incidents/settings/note-templates",
@@ -824,6 +885,16 @@ const realBreadcrumbTrails: Array<BreadcrumbTrailFixture> = [
       "View Template",
     ],
   },
+  {
+    getter: "getIncidentsBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/incidents/settings/on-call-rules",
+    titles: ["Project", "Incidents", "Rules", "On-Call Rules"],
+  },
+  {
+    getter: "getIncidentsBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/incidents/settings/owner-rules",
+    titles: ["Project", "Incidents", "Rules", "Owner Rules"],
+  },
   {
     getter: "getIncidentsBreadcrumbs",
     pagePattern:
@@ -842,11 +913,31 @@ const realBreadcrumbTrails: Array<BreadcrumbTrailFixture> = [
       "View Template",
     ],
   },
+  {
+    getter: "getIncidentsBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/incidents/settings/privacy-rules",
+    titles: ["Project", "Incidents", "Rules", "Privacy Rules"],
+  },
+  {
+    getter: "getIncidentsBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/incidents/settings/reminder-rules",
+    titles: ["Project", "Incidents", "Rules", "Reminder Rules"],
+  },
+  {
+    getter: "getIncidentsBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/incidents/settings/runbook-rules",
+    titles: ["Project", "Incidents", "Rules", "Runbook Rules"],
+  },
   {
     getter: "getIncidentsBreadcrumbs",
     pagePattern: "/dashboard/:projectId/incidents/settings/severity",
     titles: ["Project", "Incidents", "Settings", "Incident Severity"],
   },
+  {
+    getter: "getIncidentsBreadcrumbs",
+    pagePattern: "/dashboard/:projectId/incidents/settings/sla-rules",
+    titles: ["Project", "Incidents", "Rules", "SLA Rules"],
+  },
   {
     getter: "getIncidentsBreadcrumbs",
     pagePattern: "/dashboard/:projectId/incidents/settings/state",
@@ -2055,12 +2146,36 @@ const realBreadcrumbTrails: Array<BreadcrumbTrailFixture> = [
       "/dashboard/:projectId/scheduled-maintenance-events/settings/custom-fields",
     titles: ["Project", "Scheduled Maintenance", "Settings", "Custom Fields"],
   },
+  {
+    getter: "getScheduleMaintenanceBreadcrumbs",
+    pagePattern:
+      "/dashboard/:projectId/scheduled-maintenance-events/settings/label-rules",
+    titles: ["Project", "Scheduled Maintenance", "Rules", "Label Rules"],
+  },
   {
     getter: "getScheduleMaintenanceBreadcrumbs",
     pagePattern:
       "/dashboard/:projectId/scheduled-maintenance-events/settings/note-templates",
     titles: ["Project", "Scheduled Maintenance", "Settings", "Note Templates"],
   },
+  {
+    getter: "getScheduleMaintenanceBreadcrumbs",
+    pagePattern:
+      "/dashboard/:projectId/scheduled-maintenance-events/settings/owner-rules",
+    titles: ["Project", "Scheduled Maintenance", "Rules", "Owner Rules"],
+  },
+  {
+    getter: "getScheduleMaintenanceBreadcrumbs",
+    pagePattern:
+      "/dashboard/:projectId/scheduled-maintenance-events/settings/reminder-rules",
+    titles: ["Project", "Scheduled Maintenance", "Rules", "Reminder Rules"],
+  },
+  {
+    getter: "getScheduleMaintenanceBreadcrumbs",
+    pagePattern:
+      "/dashboard/:projectId/scheduled-maintenance-events/settings/runbook-rules",
+    titles: ["Project", "Scheduled Maintenance", "Rules", "Runbook Rules"],
+  },
   {
     getter: "getScheduleMaintenanceBreadcrumbs",
     pagePattern:

package/Tests/UI/Utils/Breadcrumb/fixtures/RealRoutePatterns.ts

@@ -76,6 +76,7 @@ const realRoutePatterns: Array<string> = [
   "/dashboard/:projectId/alerts/settings/note-templates/:id",
   "/dashboard/:projectId/alerts/settings/custom-fields",
   "/dashboard/:projectId/alerts/settings/grouping-rules",
+  "/dashboard/:projectId/alerts/settings/auto-remediation-rules",
   "/dashboard/:projectId/alerts/settings/on-call-rules",
   "/dashboard/:projectId/alerts/settings/owner-rules",
   "/dashboard/:projectId/alerts/settings/runbook-rules",
@@ -163,6 +164,7 @@ const realRoutePatterns: Array<string> = [
   "/dashboard/:projectId/incidents/settings/postmortem-templates/:id",
   "/dashboard/:projectId/incidents/settings/custom-fields",
   "/dashboard/:projectId/incidents/settings/grouping-rules",
+  "/dashboard/:projectId/incidents/settings/auto-remediation-rules",
   "/dashboard/:projectId/incidents/settings/on-call-rules",
   "/dashboard/:projectId/incidents/settings/owner-rules",
   "/dashboard/:projectId/incidents/settings/runbook-rules",