@oneuptime/common 14.0.6 → 14.0.8

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

@@ -0,0 +1,289 @@
+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 IP from "../../../Types/IP/IP";
+import MonitorType from "../../../Types/Monitor/MonitorType";
+import NetworkPathTrace, {
+  TraceRoute,
+  TraceRouteHop,
+} from "../../../Types/Monitor/NetworkMonitor/NetworkPathTrace";
+import ObjectID from "../../../Types/ObjectID";
+import ProbeAttempt from "../../../Types/Probe/ProbeAttempt";
+import ProbeMonitorResponse from "../../../Types/Probe/ProbeMonitorResponse";
+import ProbeNetworkFailureUtil, {
+  ProbeNetworkOperation,
+} from "../../../Utils/ProbeNetworkFailureUtil";
+import NetworkPathView from "../../../../App/FeatureSet/Dashboard/src/Components/Monitor/SummaryView/NetworkPathView";
+import SummaryInfo from "../../../../App/FeatureSet/Dashboard/src/Components/Monitor/SummaryView/SummaryInfo";
+
+/*
+ * "Network Path at Time of Failure" under a failed Ping or Port check.
+ *
+ * The customer's IPv6 Ping monitor ran on a probe with no usable IPv6, so
+ * traceroute -6 failed "connect: Cannot assign requested address" before
+ * one packet left the probe. The card still said "Route did not reach the
+ * destination." in front of that, which reads as the customer's host being
+ * off the network. A trace with no hops walked no path, so the card must
+ * claim nothing about the route and let the trace's own message say why.
+ */
+
+const MONITORED_AT: Date = new Date("2026-09-20T09:15:00.000Z");
+const CUSTOMER_ADDRESS: string = "2001:518:2800:9::2";
+const MONITOR_ID: string = "22222222-2222-4222-8222-222222222222";
+
+// What NetworkPathMonitor records for the customer's traceroute -6.
+const TRACEROUTE_COULD_NOT_RUN: string =
+  "Traceroute could not run: this probe cannot send IPv6 traffic (connect: Cannot assign requested address).";
+
+const HOPS: Array<TraceRouteHop> = [
+  {
+    hopNumber: 1,
+    address: "192.168.1.1",
+    hostName: "gw.example.com",
+    roundTripTimeInMS: 1,
+    isTimeout: false,
+  },
+  {
+    hopNumber: 2,
+    address: undefined,
+    hostName: undefined,
+    roundTripTimeInMS: undefined,
+    isTimeout: true,
+  },
+  {
+    hopNumber: 3,
+    address: "198.51.100.7",
+    hostName: undefined,
+    roundTripTimeInMS: 14,
+    isTimeout: false,
+  },
+];
+
+function buildTraceRoute(overrides: Partial<TraceRoute> = {}): TraceRoute {
+  return {
+    hops: [],
+    destinationAddress: CUSTOMER_ADDRESS,
+    destinationHostName: undefined,
+    isComplete: false,
+    totalHops: 0,
+    failedHop: undefined,
+    failureMessage: undefined,
+    ...overrides,
+  };
+}
+
+function renderPath(traceRoute: TraceRoute | undefined): HTMLElement {
+  const trace: NetworkPathTrace = {
+    timestamp: MONITORED_AT,
+    traceRoute,
+  };
+
+  return render(<NetworkPathView networkPathTrace={trace} />).container;
+}
+
+describe("Network path card when traceroute recorded no hops", () => {
+  it("shows the customer's IPv6 check without a route verdict on top of the probe's reason", () => {
+    // The cause PingMonitor now gives for the customer's ping6 output.
+    const probeCause: string | null = ProbeNetworkFailureUtil.describeOutput({
+      host: CUSTOMER_ADDRESS,
+      output: "ping6: connect: Cannot assign requested address\n",
+      operation: ProbeNetworkOperation.PingOrTraceroute,
+    });
+
+    expect(probeCause).not.toBeNull();
+
+    const failureCause: string = `Error: ${probeCause} Monitor ID: ${MONITOR_ID}`;
+
+    const response: ProbeMonitorResponse = {
+      projectId: new ObjectID("11111111-1111-4111-8111-111111111111"),
+      monitorId: new ObjectID(MONITOR_ID),
+      monitorStepId: new ObjectID("33333333-3333-4333-8333-333333333333"),
+      probeId: new ObjectID("44444444-4444-4444-8444-444444444444"),
+      monitorDestination: new IP(CUSTOMER_ADDRESS),
+      isOnline: false,
+      failureCause,
+      monitoredAt: MONITORED_AT,
+      networkPathTrace: {
+        timestamp: MONITORED_AT,
+        traceRoute: buildTraceRoute({
+          failureMessage: TRACEROUTE_COULD_NOT_RUN,
+        }),
+      },
+      probeAttempts: [1, 2, 3, 4].map((attemptNumber: number): ProbeAttempt => {
+        return {
+          attemptNumber,
+          attemptedAt: MONITORED_AT,
+          responseReceivedAt: MONITORED_AT,
+          responseTimeInMs: 13,
+          isOnline: false,
+          failureCause,
+        };
+      }),
+      totalAttempts: 4,
+    };
+
+    render(
+      <SummaryInfo
+        monitorType={MonitorType.Ping}
+        probeMonitorResponses={[response]}
+        probeName="Global Probe"
+      />,
+    );
+
+    expect(
+      screen.getByText("Network Path at Time of Failure"),
+    ).toBeInTheDocument();
+    expect(
+      screen.getByText(`No path was recorded. ${TRACEROUTE_COULD_NOT_RUN}`),
+    ).toBeInTheDocument();
+
+    /*
+     * The check is still Offline (the probe could not verify the host), but
+     * every card shows the probe's own cause verbatim: none of them adds a
+     * verdict about the host or its route on top of it.
+     */
+    expect(screen.getByText("Offline")).toBeInTheDocument();
+    expect(screen.getAllByText(failureCause)).toHaveLength(5);
+
+    const pageText: string = document.body.textContent || "";
+
+    expect(pageText).not.toMatch(/did not reach the destination/i);
+    expect(pageText).not.toMatch(/Route broke/);
+    expect(pageText).not.toContain("Unable to reach host");
+    expect(pageText).not.toContain("No ICMP echo reply");
+  });
+
+  it("puts the neutral lead-in before an older probe's raw execFile message", () => {
+    const container: HTMLElement = renderPath(
+      buildTraceRoute({
+        failureMessage: `Command failed: traceroute -6 -m 20 -w 3 ${CUSTOMER_ADDRESS}\n\nconnect: Cannot assign requested address\n`,
+      }),
+    );
+
+    expect(screen.getByText(/^No path was recorded\./)).toHaveTextContent(
+      `No path was recorded. Command failed: traceroute -6 -m 20 -w 3 ${CUSTOMER_ADDRESS} connect: Cannot assign requested address`,
+    );
+    expect(container.textContent).not.toMatch(/did not reach/i);
+  });
+
+  it("says no path was recorded when traceroute hit its deadline before any hop", () => {
+    renderPath(buildTraceRoute({ failureMessage: "Traceroute timed out" }));
+
+    expect(
+      screen.getByText("No path was recorded. Traceroute timed out"),
+    ).toBeInTheDocument();
+  });
+
+  it("shows the lead-in alone, and no hop table, when there is no message either", () => {
+    renderPath(buildTraceRoute());
+
+    expect(screen.getByText("No path was recorded.")).toBeInTheDocument();
+    expect(screen.queryByText("Hop")).not.toBeInTheDocument();
+  });
+
+  it("claims nothing about the route even if a hop-less payload says it completed", () => {
+    const container: HTMLElement = renderPath(
+      buildTraceRoute({ isComplete: true }),
+    );
+
+    expect(screen.getByText("No path was recorded.")).toBeInTheDocument();
+    expect(container.textContent).not.toContain("Route reached");
+  });
+
+  it("renders a stored trace with no hops array instead of throwing", () => {
+    renderPath(
+      buildTraceRoute({
+        hops: undefined as unknown as Array<TraceRouteHop>,
+        failureMessage: "Traceroute timed out",
+      }),
+    );
+
+    expect(
+      screen.getByText("No path was recorded. Traceroute timed out"),
+    ).toBeInTheDocument();
+  });
+});
+
+describe("Network path card when traceroute recorded hops", () => {
+  it("says the route reached the destination, under the hop table", () => {
+    renderPath(
+      buildTraceRoute({
+        hops: [HOPS[0]!, HOPS[2]!],
+        destinationAddress: "198.51.100.7",
+        isComplete: true,
+        totalHops: 2,
+      }),
+    );
+
+    expect(screen.getByText("Hop")).toBeInTheDocument();
+    expect(
+      screen.getByText("gw.example.com (192.168.1.1)"),
+    ).toBeInTheDocument();
+    expect(
+      screen.getByText("Route reached the destination."),
+    ).toBeInTheDocument();
+  });
+
+  it("names the hop the route broke at, with the trace's own message", () => {
+    renderPath(
+      buildTraceRoute({
+        hops: HOPS,
+        destinationAddress: "203.0.113.9",
+        totalHops: 3,
+        failedHop: 2,
+        failureMessage: "Hop 2 timed out",
+      }),
+    );
+
+    expect(screen.getByText("* * *")).toBeInTheDocument();
+    expect(
+      screen.getByText("Route broke at hop 2. Hop 2 timed out"),
+    ).toBeInTheDocument();
+  });
+
+  it("keeps 'did not reach' for a walked route that fell short with no failed hop", () => {
+    renderPath(
+      buildTraceRoute({
+        hops: [HOPS[0]!, HOPS[2]!],
+        destinationAddress: "203.0.113.9",
+        totalHops: 2,
+      }),
+    );
+
+    expect(
+      screen.getByText("Route did not reach the destination."),
+    ).toBeInTheDocument();
+  });
+});
+
+describe("Network path card without a traceroute", () => {
+  it("shows the DNS lookup and no route line at all", () => {
+    const container: HTMLElement = render(
+      <NetworkPathView
+        networkPathTrace={{
+          timestamp: MONITORED_AT,
+          dnsLookup: {
+            hostName: "api.example.com",
+            resolvedAddresses: [],
+            resolvedInMS: 4,
+            isSuccess: false,
+            errorMessage: "ENOTFOUND",
+          },
+        }}
+      />,
+    ).container;
+
+    expect(
+      screen.getByText("Lookup for api.example.com failed — ENOTFOUND"),
+    ).toBeInTheDocument();
+    expect(container.textContent).not.toContain("No path was recorded");
+    expect(container.textContent).not.toMatch(/Route (reached|broke|did not)/);
+  });
+
+  it("renders nothing when the probe captured neither", () => {
+    const container: HTMLElement = renderPath(undefined);
+
+    expect(container).toBeEmptyDOMElement();
+  });
+});

package/Tests/Utils/Incident/IncidentFromAlerts.test.ts

@@ -1,6 +1,9 @@
 import { describe, expect, test } from "@jest/globals";
 import IncidentFromAlerts, {
+  AlertForAcknowledgement,
   AlertForIncidentPrefill,
+  AlertsToAcknowledge,
+  AlertStateForAcknowledgement,
   INCIDENT_PREFILL_RESOURCE_KEYS,
   IncidentPrefillFromAlerts,
   NamedResource,
@@ -694,3 +697,302 @@ describe("IncidentFromAlerts", () => {
     });
   });
 });
+
+/*
+ * Which alerts the create page offers to acknowledge as the incident is
+ * declared. States are compared by order, as the server does: anything at or
+ * after the project's Acknowledged state (Resolved, or a custom state in
+ * between) has been acknowledged already. An alert whose state cannot be
+ * placed is offered - the server skips it if it turns out to be acknowledged.
+ */
+describe("IncidentFromAlerts.getAlertsToAcknowledge", () => {
+  const CREATED: AlertStateForAcknowledgement = {
+    id: "state-created",
+    order: 1,
+    isAcknowledgedState: false,
+  };
+  const ACKNOWLEDGED: AlertStateForAcknowledgement = {
+    id: "state-acknowledged",
+    order: 2,
+    isAcknowledgedState: true,
+  };
+  const RESOLVED: AlertStateForAcknowledgement = {
+    id: "state-resolved",
+    order: 3,
+    isAcknowledgedState: false,
+  };
+
+  const DEFAULT_ALERT_STATES: Array<AlertStateForAcknowledgement> = [
+    CREATED,
+    ACKNOWLEDGED,
+    RESOLVED,
+  ];
+
+  type AlertInStateFunction = (
+    id: string,
+    currentAlertStateId?: string | undefined,
+  ) => AlertForAcknowledgement;
+
+  const alertIn: AlertInStateFunction = (
+    id: string,
+    currentAlertStateId?: string | undefined,
+  ): AlertForAcknowledgement => {
+    return { id: id, currentAlertStateId: currentAlertStateId };
+  };
+
+  type GetFunction = (
+    alerts: Array<AlertForAcknowledgement>,
+    alertStates?: Array<AlertStateForAcknowledgement>,
+  ) => AlertsToAcknowledge | null;
+
+  const get: GetFunction = (
+    alerts: Array<AlertForAcknowledgement>,
+    alertStates?: Array<AlertStateForAcknowledgement>,
+  ): AlertsToAcknowledge | null => {
+    return IncidentFromAlerts.getAlertsToAcknowledge({
+      alerts: alerts,
+      alertStates: alertStates || DEFAULT_ALERT_STATES,
+    });
+  };
+
+  describe("when nothing could be acknowledged", () => {
+    test("is null when the project has no alert states at all", () => {
+      expect(get([alertIn("a1", CREATED.id)], [])).toBeNull();
+    });
+
+    test("is null when no state is the Acknowledged state", () => {
+      expect(
+        get(
+          [alertIn("a1", CREATED.id)],
+          [CREATED, { ...ACKNOWLEDGED, isAcknowledgedState: false }, RESOLVED],
+        ),
+      ).toBeNull();
+    });
+
+    test("is null when the Acknowledged flag is missing rather than false", () => {
+      expect(
+        get(
+          [alertIn("a1", CREATED.id)],
+          [
+            CREATED,
+            { id: ACKNOWLEDGED.id, order: ACKNOWLEDGED.order },
+            RESOLVED,
+          ],
+        ),
+      ).toBeNull();
+    });
+
+    test("is null when the Acknowledged state has no order to compare by", () => {
+      expect(
+        get(
+          [alertIn("a1", CREATED.id)],
+          [CREATED, { ...ACKNOWLEDGED, order: undefined }, RESOLVED],
+        ),
+      ).toBeNull();
+    });
+
+    test("is null without an Acknowledged state even when there are no alerts", () => {
+      expect(get([], [CREATED, RESOLVED])).toBeNull();
+    });
+  });
+
+  describe("comparing by order", () => {
+    test("offers an alert whose state comes before Acknowledged", () => {
+      expect(get([alertIn("a1", CREATED.id)])).toEqual({
+        alertIds: ["a1"],
+        alreadyAcknowledgedCount: 0,
+      });
+    });
+
+    test("leaves out an alert that is in the Acknowledged state itself", () => {
+      expect(get([alertIn("a1", ACKNOWLEDGED.id)])).toEqual({
+        alertIds: [],
+        alreadyAcknowledgedCount: 1,
+      });
+    });
+
+    test("leaves out an alert that is resolved", () => {
+      expect(get([alertIn("a1", RESOLVED.id)])).toEqual({
+        alertIds: [],
+        alreadyAcknowledgedCount: 1,
+      });
+    });
+
+    test("treats a custom state between Acknowledged and Resolved as acknowledged already", () => {
+      const investigating: AlertStateForAcknowledgement = {
+        id: "state-investigating",
+        order: 3,
+      };
+      const resolved: AlertStateForAcknowledgement = {
+        id: "state-resolved",
+        order: 4,
+      };
+
+      expect(
+        get(
+          [alertIn("a1", investigating.id), alertIn("a2", resolved.id)],
+          [CREATED, ACKNOWLEDGED, investigating, resolved],
+        ),
+      ).toEqual({ alertIds: [], alreadyAcknowledgedCount: 2 });
+    });
+
+    test("offers an alert in a custom state before Acknowledged", () => {
+      const triaged: AlertStateForAcknowledgement = {
+        id: "state-triaged",
+        order: 2,
+      };
+      const acknowledged: AlertStateForAcknowledgement = {
+        id: "state-acknowledged",
+        order: 3,
+        isAcknowledgedState: true,
+      };
+
+      expect(
+        get(
+          [alertIn("a1", triaged.id), alertIn("a2", CREATED.id)],
+          [CREATED, triaged, acknowledged, { ...RESOLVED, order: 4 }],
+        ),
+      ).toEqual({ alertIds: ["a1", "a2"], alreadyAcknowledgedCount: 0 });
+    });
+
+    test("compares by order, not by where the state sits in the list", () => {
+      // Listed newest-first: the list position must not decide anything.
+      const reversed: Array<AlertStateForAcknowledgement> = [
+        RESOLVED,
+        ACKNOWLEDGED,
+        CREATED,
+      ];
+
+      expect(
+        get(
+          [
+            alertIn("a1", RESOLVED.id),
+            alertIn("a2", CREATED.id),
+            alertIn("a3", ACKNOWLEDGED.id),
+          ],
+          reversed,
+        ),
+      ).toEqual({ alertIds: ["a2"], alreadyAcknowledgedCount: 2 });
+    });
+
+    test("an Acknowledged order of 0 is still an order", () => {
+      const acknowledgedAtZero: AlertStateForAcknowledgement = {
+        id: "state-acknowledged",
+        order: 0,
+        isAcknowledgedState: true,
+      };
+      const before: AlertStateForAcknowledgement = {
+        id: "state-before",
+        order: -1,
+      };
+
+      expect(
+        get(
+          [
+            alertIn("a1", acknowledgedAtZero.id),
+            alertIn("a2", before.id),
+            alertIn("a3", RESOLVED.id),
+          ],
+          [before, acknowledgedAtZero, RESOLVED],
+        ),
+      ).toEqual({ alertIds: ["a2"], alreadyAcknowledgedCount: 2 });
+    });
+  });
+
+  describe("alerts whose state cannot be placed", () => {
+    test("offers an alert whose current state is not one of the project's states", () => {
+      expect(get([alertIn("a1", "state-from-another-project")])).toEqual({
+        alertIds: ["a1"],
+        alreadyAcknowledgedCount: 0,
+      });
+    });
+
+    test("offers an alert with no current state id", () => {
+      expect(get([alertIn("a1", undefined), alertIn("a2", "")])).toEqual({
+        alertIds: ["a1", "a2"],
+        alreadyAcknowledgedCount: 0,
+      });
+    });
+
+    test("offers an alert whose current state has no order", () => {
+      const unordered: AlertStateForAcknowledgement = {
+        id: "state-unordered",
+      };
+
+      expect(
+        get(
+          [alertIn("a1", unordered.id)],
+          [CREATED, ACKNOWLEDGED, RESOLVED, unordered],
+        ),
+      ).toEqual({ alertIds: ["a1"], alreadyAcknowledgedCount: 0 });
+    });
+  });
+
+  test("matches state ids case-insensitively and ignoring surrounding spaces", () => {
+    const upperAcknowledged: AlertStateForAcknowledgement = {
+      id: "AAAAAAAA-AAAA-4AAA-8AAA-000000000002",
+      order: 2,
+      isAcknowledgedState: true,
+    };
+    const upperCreated: AlertStateForAcknowledgement = {
+      id: "AAAAAAAA-AAAA-4AAA-8AAA-000000000001",
+      order: 1,
+    };
+
+    expect(
+      get(
+        [
+          alertIn("a1", " aaaaaaaa-aaaa-4aaa-8aaa-000000000002 "),
+          alertIn("a2", "aaaaaaaa-aaaa-4aaa-8aaa-000000000001"),
+        ],
+        [upperCreated, upperAcknowledged],
+      ),
+    ).toEqual({ alertIds: ["a2"], alreadyAcknowledgedCount: 1 });
+  });
+
+  test("keeps the alerts in the order they were given and counts the rest", () => {
+    const result: AlertsToAcknowledge | null = get([
+      alertIn("a5", CREATED.id),
+      alertIn("a1", ACKNOWLEDGED.id),
+      alertIn("a4", undefined),
+      alertIn("a2", RESOLVED.id),
+      alertIn("a3", CREATED.id),
+      alertIn("a6", RESOLVED.id),
+    ]);
+
+    expect(result).toEqual({
+      alertIds: ["a5", "a4", "a3"],
+      alreadyAcknowledgedCount: 3,
+    });
+  });
+
+  test("returns the alert ids exactly as given", () => {
+    expect(get([alertIn("ALERT-One", CREATED.id)])!.alertIds).toEqual([
+      "ALERT-One",
+    ]);
+  });
+
+  test("is empty, not null, when there are no alerts", () => {
+    expect(get([])).toEqual({ alertIds: [], alreadyAcknowledgedCount: 0 });
+  });
+
+  test("does not change its input", () => {
+    const alerts: Array<AlertForAcknowledgement> = [
+      alertIn("a1", CREATED.id),
+      alertIn("a2", ACKNOWLEDGED.id),
+    ];
+    const alertStates: Array<AlertStateForAcknowledgement> = [
+      RESOLVED,
+      CREATED,
+      ACKNOWLEDGED,
+    ];
+
+    get(alerts, alertStates);
+
+    expect(alerts).toEqual([
+      { id: "a1", currentAlertStateId: CREATED.id },
+      { id: "a2", currentAlertStateId: ACKNOWLEDGED.id },
+    ]);
+    expect(alertStates).toEqual([RESOLVED, CREATED, ACKNOWLEDGED]);
+  });
+});