@oneuptime/common 13.0.4 → 13.0.6

package/Tests/App/Dashboard/TopErrorsPanelResourceNames.test.tsx

@@ -0,0 +1,316 @@
+import "@testing-library/jest-dom";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+import { cleanup, render, screen, waitFor } from "@testing-library/react";
+import * as React from "react";
+import getJestMockFunction, { MockFunction } from "../../MockType";
+
+/*
+ * The Logs Insights "Top errors" rows named each pattern's sources from the
+ * page's Service list only, so a pattern seen on a RUM application read
+ * "2 sources · 84858d6c-…, payments-api" while the drawer it opened (and
+ * the "Sources reporting logs" cards) named it "checkout-web".
+ *
+ * This renders the real panel fed the way LogsDashboard feeds it: the
+ * displayed pattern ids go through collectLogsInsightsResourceRefs, the
+ * Service-named ids are skipped, the rest are resolved with the generic
+ * entity-name hook against a mocked ModelAPI, and the map reaches the panel
+ * as `resourceNames`. The wiring inside LogsDashboard itself is pinned by
+ * App/Tests/Dashboard/LogsEntityNamesWiring.test.ts.
+ */
+
+const getListMock: MockFunction = getJestMockFunction();
+
+/*
+ * The arrow wrapper is load bearing: jest.mock is hoisted above the
+ * compiled requires, so getListMock is still unassigned when the factory
+ * runs.
+ */
+jest.mock("../../../UI/Utils/ModelAPI/ModelAPI", () => {
+  return {
+    __esModule: true,
+    default: {
+      getList: (...args: Array<any>) => {
+        return getListMock(...args);
+      },
+    },
+  };
+});
+
+/*
+ * The panel only needs two sentence builders from Utils/LogsInsights; the
+ * real module pulls in the Dashboard's RouteMap, which this suite has no use
+ * for.
+ */
+jest.mock("../../../../App/FeatureSet/Dashboard/src/Utils/LogsInsights", () => {
+  return {
+    __esModule: true,
+    describeTimeRange: () => {
+      return "the past 1 hour";
+    },
+    describeOccurrenceCount: (count: number) => {
+      return `${count} times in the past 1 hour`;
+    },
+  };
+});
+
+import TopErrorsPanel from "../../../../App/FeatureSet/Dashboard/src/Components/Logs/TopErrorsPanel";
+import {
+  LogsResourceRef,
+  buildLogsResourceTypeHints,
+  collectLogsInsightsResourceRefs,
+  collectLogsResourceIds,
+} from "../../../../App/FeatureSet/Dashboard/src/Components/Logs/LogsResourceDisplay";
+import { TopErrorPatternRow } from "../../../../App/FeatureSet/Dashboard/src/Utils/LogsInsights";
+import useTelemetryEntityNames from "../../../UI/Utils/Telemetry/UseTelemetryEntityNames";
+import TelemetryEntityNameResolver, {
+  TelemetryEntityNameMap,
+} from "../../../UI/Utils/Telemetry/TelemetryEntityNames";
+import Service from "../../../Models/DatabaseModels/Service";
+import ObjectID from "../../../Types/ObjectID";
+import ServiceType from "../../../Types/Telemetry/ServiceType";
+import TimeRange from "../../../Types/Time/TimeRange";
+import RangeStartAndEndDateTime from "../../../Types/Time/RangeStartAndEndDateTime";
+import ProjectUtil from "../../../UI/Utils/Project";
+
+const PROJECT_ID: string = "9e1b6b0e-0000-4000-8000-000000000031";
+const RUM_APP_ID: string = "84858d6c-0000-4000-8000-000000000031";
+const SERVICE_ID: string = "11111111-0000-4000-8000-000000000031";
+const HOST_ID: string = "33333333-0000-4000-8000-000000000031";
+const UNSHOWN_ID: string = "55555555-0000-4000-8000-000000000031";
+
+interface GetListArgs {
+  modelType: { name: string };
+}
+
+/*
+ * One row per table the resolver may consult; any other table answers with
+ * nothing, the way an id that is not there would.
+ */
+const ROWS_BY_MODEL: Record<string, Array<{ id: string; name: string }>> = {
+  RumApplication: [{ id: RUM_APP_ID, name: "checkout-web" }],
+  Host: [{ id: HOST_ID, name: "web-01" }],
+};
+
+const TIME_RANGE: RangeStartAndEndDateTime = {
+  range: TimeRange.PAST_ONE_HOUR,
+};
+
+const makePattern: (
+  pattern: string,
+  resourceIds: Array<string>,
+) => TopErrorPatternRow = (
+  pattern: string,
+  resourceIds: Array<string>,
+): TopErrorPatternRow => {
+  return {
+    pattern,
+    sampleBody: pattern,
+    count: 3,
+    firstSeenAt: null,
+    lastSeenAt: null,
+    resourceCount: resourceIds.length,
+    resourceIds,
+    severities: ["Error"],
+    traceCount: 0,
+    sampleTraceIds: [],
+  };
+};
+
+const makeService: (id: string, name: string) => Service = (
+  id: string,
+  name: string,
+): Service => {
+  const service: Service = new Service();
+  service.id = new ObjectID(id);
+  service.name = name;
+  return service;
+};
+
+interface HarnessProps {
+  patterns: Array<TopErrorPatternRow>;
+  services: Array<Service>;
+  onSelect?: ((row: TopErrorPatternRow) => void) | undefined;
+}
+
+/*
+ * LogsDashboard's naming pipeline, reduced to the Top errors inputs (no
+ * cards, no facets, no selection).
+ */
+const Harness: React.FunctionComponent<HarnessProps> = (
+  props: HarnessProps,
+): React.ReactElement => {
+  const serviceById: Map<string, Service> = React.useMemo(() => {
+    const map: Map<string, Service> = new Map<string, Service>();
+    for (const service of props.services) {
+      map.set(service.id!.toString(), service);
+    }
+    return map;
+  }, [props.services]);
+
+  const refs: Array<LogsResourceRef> = React.useMemo(() => {
+    return collectLogsInsightsResourceRefs({
+      breakdownResourceIds: [],
+      errorPatterns: props.patterns,
+      scopeFacets: {},
+      selectedScopeValues: [],
+    });
+  }, [props.patterns]);
+
+  const unnamedIds: Array<string> = React.useMemo(() => {
+    return collectLogsResourceIds(refs, (resourceId: string): boolean => {
+      return Boolean(serviceById.get(resourceId)?.name);
+    });
+  }, [refs, serviceById]);
+
+  const typeHints: Record<string, ServiceType> | undefined =
+    React.useMemo(() => {
+      return buildLogsResourceTypeHints(refs);
+    }, [refs]);
+
+  const resourceNames: TelemetryEntityNameMap = useTelemetryEntityNames(
+    unnamedIds,
+    { typeHints },
+  );
+
+  return (
+    <TopErrorsPanel
+      patterns={props.patterns}
+      timeRange={TIME_RANGE}
+      isLoading={false}
+      serviceNameById={serviceById}
+      resourceNames={resourceNames}
+      onSelect={(row: TopErrorPatternRow): void => {
+        props.onSelect?.(row);
+      }}
+    />
+  );
+};
+
+const queriedIds: () => Array<string> = (): Array<string> => {
+  const ids: Set<string> = new Set<string>();
+  for (const call of getListMock.mock.calls) {
+    const query: { _id?: { values?: Array<unknown> } } | undefined = (
+      call[0] as { query?: { _id?: { values?: Array<unknown> } } }
+    ).query;
+    for (const value of query?._id?.values || []) {
+      ids.add(`${value}`);
+    }
+  }
+  return Array.from(ids);
+};
+
+beforeEach(() => {
+  TelemetryEntityNameResolver.clearCache();
+  getListMock.mockReset();
+  getListMock.mockImplementation((args: GetListArgs) => {
+    return Promise.resolve({
+      data: (ROWS_BY_MODEL[args.modelType.name] || []).map(
+        (row: { id: string; name: string }) => {
+          return { id: new ObjectID(row.id), name: row.name };
+        },
+      ),
+      count: 0,
+    });
+  });
+  jest
+    .spyOn(ProjectUtil, "getCurrentProjectId")
+    .mockReturnValue(new ObjectID(PROJECT_ID));
+});
+
+afterEach(() => {
+  cleanup();
+  jest.restoreAllMocks();
+});
+
+describe("Top errors rows name their sources (rendered)", () => {
+  test("a RUM application reads by name next to a loaded Service, never as its id", async () => {
+    render(
+      <Harness
+        patterns={[
+          makePattern("TypeError: x is undefined", [RUM_APP_ID, SERVICE_ID]),
+        ]}
+        services={[makeService(SERVICE_ID, "payments-api")]}
+      />,
+    );
+
+    await waitFor(() => {
+      expect(
+        screen.getByText("2 sources · checkout-web, payments-api"),
+      ).toBeInTheDocument();
+    });
+
+    expect(document.body.textContent || "").not.toContain(RUM_APP_ID);
+    expect(document.body.textContent || "").not.toContain(SERVICE_ID);
+  });
+
+  test("only the two ids a row prints are looked up; the Service-named one is not", async () => {
+    render(
+      <Harness
+        patterns={[makePattern("disk full", [HOST_ID, SERVICE_ID, UNSHOWN_ID])]}
+        services={[makeService(SERVICE_ID, "payments-api")]}
+      />,
+    );
+
+    await waitFor(() => {
+      expect(
+        screen.getByText("3 sources · web-01, payments-api"),
+      ).toBeInTheDocument();
+    });
+
+    const ids: Array<string> = queriedIds();
+    expect(ids).toContain(HOST_ID);
+    expect(ids).not.toContain(SERVICE_ID);
+    expect(ids).not.toContain(UNSHOWN_ID);
+  });
+
+  test("without resolved names (prop omitted) the row keeps its old Service-or-id label", () => {
+    render(
+      <TopErrorsPanel
+        patterns={[makePattern("boom", [RUM_APP_ID, SERVICE_ID])]}
+        timeRange={TIME_RANGE}
+        isLoading={false}
+        serviceNameById={
+          new Map<string, Service>([
+            [SERVICE_ID, makeService(SERVICE_ID, "payments-api")],
+          ])
+        }
+        onSelect={(): void => {}}
+      />,
+    );
+
+    expect(
+      screen.getByText(`2 sources · ${RUM_APP_ID}, payments-api`),
+    ).toBeInTheDocument();
+  });
+
+  test("selecting a row hands back the row with its ids untouched", async () => {
+    const selected: Array<TopErrorPatternRow> = [];
+    const row: TopErrorPatternRow = makePattern("timeout", [RUM_APP_ID]);
+
+    render(
+      <Harness
+        patterns={[row]}
+        services={[]}
+        onSelect={(picked: TopErrorPatternRow): void => {
+          selected.push(picked);
+        }}
+      />,
+    );
+
+    await waitFor(() => {
+      expect(screen.getByText("1 source · checkout-web")).toBeInTheDocument();
+    });
+
+    screen.getByText("1 source · checkout-web").closest("button")!.click();
+
+    expect(selected).toHaveLength(1);
+    expect(selected[0]!.resourceIds).toEqual([RUM_APP_ID]);
+  });
+});

package/Tests/App/Dashboard/TopologyConnectivitySection.test.tsx

@@ -0,0 +1,206 @@
+import "@testing-library/jest-dom";
+import { afterEach, describe, expect, jest, test } from "@jest/globals";
+import { cleanup, render, screen } from "@testing-library/react";
+import * as React from "react";
+import { MemoryRouter } from "react-router-dom";
+import {
+  NetworkTopologyEdge,
+  NetworkTopologyNode,
+} from "../../../Types/Monitor/SnmpMonitor/NetworkTopology";
+import NetworkDeviceDetailPanel from "../../../../App/FeatureSet/Dashboard/src/Components/Topology/NetworkDeviceDetailPanel";
+
+/*
+ * Issue #3745, from the operator's side of the drawer.
+ *
+ * The Connectivity section is two children — a read-only latency trend and
+ * the Ping / Traceroute buttons — and the two things worth defending are
+ * WHO gets it (a managed device, never a neighbour or an endpoint) and
+ * WHICH half a viewer without the create permission gets (the trend, not
+ * the buttons). Both children are stubbed to strings so the assertions are
+ * about the panel's decisions, not about metrics or polling — those have
+ * their own tests — and so the stubs can echo the props they were handed.
+ */
+
+jest.mock(
+  "../../../../App/FeatureSet/Dashboard/src/Components/NetworkDevice/DeviceLatencyTrend",
+  () => {
+    return {
+      __esModule: true,
+      default: (props: { networkDeviceId: { toString: () => string } }) => {
+        return `latency-trend-stub:${props.networkDeviceId.toString()}`;
+      },
+    };
+  },
+);
+
+jest.mock(
+  "../../../../App/FeatureSet/Dashboard/src/Components/NetworkDevice/DeviceDiagnostics",
+  () => {
+    return {
+      __esModule: true,
+      default: (props: { networkDeviceId: { toString: () => string } }) => {
+        return `diagnostics-stub:${props.networkDeviceId.toString()}`;
+      },
+    };
+  },
+);
+
+const SWITCH_NODE: NetworkTopologyNode = {
+  id: "11111111-1111-4111-8111-111111111111",
+  name: "core-sw-01",
+  isManaged: true,
+  kind: "device",
+  role: "switch",
+  status: "up",
+  ipAddress: "10.0.0.1",
+};
+
+const PHONE_NODE: NetworkTopologyNode = {
+  id: "unmanaged:sep6026aaf2b46b",
+  name: "SEP6026AAF2B46B",
+  isManaged: false,
+  kind: "unmanaged",
+  role: "phone",
+  status: "unknown",
+  ipAddress: "10.0.12.41",
+};
+
+const ENDPOINT_NODE: NetworkTopologyNode = {
+  id: "endpoint:aabbccddeeff",
+  name: "aa:bb:cc:dd:ee:ff",
+  isManaged: true,
+  kind: "endpoint",
+  status: "unknown",
+  macAddress: "aa:bb:cc:dd:ee:ff",
+};
+
+const EDGE: NetworkTopologyEdge = {
+  fromNodeId: SWITCH_NODE.id,
+  toNodeId: PHONE_NODE.id,
+  fromPort: "Gi1/0/12",
+  protocols: ["cdp"],
+};
+
+type RenderPanelOptions = {
+  node: NetworkTopologyNode;
+  canRunDiagnostics?: boolean | undefined;
+  onHideNode?: ((node: NetworkTopologyNode) => void) | undefined;
+};
+
+function renderPanel(options: RenderPanelOptions): void {
+  const nodeById: Map<string, NetworkTopologyNode> = new Map<
+    string,
+    NetworkTopologyNode
+  >([
+    [SWITCH_NODE.id, SWITCH_NODE],
+    [PHONE_NODE.id, PHONE_NODE],
+    [ENDPOINT_NODE.id, ENDPOINT_NODE],
+  ]);
+
+  render(
+    <MemoryRouter>
+      <NetworkDeviceDetailPanel
+        node={options.node}
+        edges={[EDGE]}
+        nodeById={nodeById}
+        onClose={() => {}}
+        onSelectEdge={() => {}}
+        onHideNode={options.onHideNode}
+        canRunDiagnostics={options.canRunDiagnostics}
+      />
+    </MemoryRouter>,
+  );
+}
+
+describe("the Connectivity section of the topology drawer", () => {
+  afterEach(() => {
+    cleanup();
+  });
+
+  test("a managed device gets the trend and, with permission, the buttons", () => {
+    renderPanel({ node: SWITCH_NODE, canRunDiagnostics: true });
+
+    const section: HTMLElement = screen.getByTestId(
+      "network-topology-connectivity",
+    );
+
+    expect(section).toBeInTheDocument();
+    expect(screen.getByText("Connectivity")).toBeInTheDocument();
+    expect(section).toHaveTextContent(`latency-trend-stub:${SWITCH_NODE.id}`);
+    expect(section).toHaveTextContent(`diagnostics-stub:${SWITCH_NODE.id}`);
+  });
+
+  /*
+   * Hidden, not disabled — the trend is read-only and stays; only the
+   * buttons that create a row go. PermissionGate says "not allowed, nothing
+   * honest to say" on every first paint after a login, and a disabled Ping
+   * would accuse a permitted operator of lacking a permission they hold.
+   */
+  test("without the permission the trend stays and the buttons go", () => {
+    renderPanel({ node: SWITCH_NODE, canRunDiagnostics: false });
+
+    const section: HTMLElement = screen.getByTestId(
+      "network-topology-connectivity",
+    );
+
+    expect(section).toHaveTextContent(`latency-trend-stub:${SWITCH_NODE.id}`);
+    expect(section).not.toHaveTextContent("diagnostics-stub");
+  });
+
+  test("the prop is optional, and absent means no buttons", () => {
+    renderPanel({ node: SWITCH_NODE });
+
+    expect(
+      screen.getByTestId("network-topology-connectivity"),
+    ).toHaveTextContent("latency-trend-stub");
+    expect(screen.queryByText(/diagnostics-stub/)).not.toBeInTheDocument();
+  });
+
+  test("an unmanaged neighbour has no row to ping from, so no section", () => {
+    renderPanel({ node: PHONE_NODE, canRunDiagnostics: true });
+
+    expect(
+      screen.queryByTestId("network-topology-connectivity"),
+    ).not.toBeInTheDocument();
+    expect(screen.queryByText(/latency-trend-stub/)).not.toBeInTheDocument();
+    expect(screen.queryByText(/diagnostics-stub/)).not.toBeInTheDocument();
+  });
+
+  test("an endpoint learned from a forwarding table gets no section either", () => {
+    renderPanel({ node: ENDPOINT_NODE, canRunDiagnostics: true });
+
+    expect(
+      screen.queryByTestId("network-topology-connectivity"),
+    ).not.toBeInTheDocument();
+    expect(screen.queryByText(/latency-trend-stub/)).not.toBeInTheDocument();
+  });
+
+  test("the rest of the drawer is as it was", () => {
+    renderPanel({
+      node: SWITCH_NODE,
+      canRunDiagnostics: true,
+      onHideNode: () => {},
+    });
+
+    expect(screen.getByText("Device details")).toBeInTheDocument();
+    expect(
+      screen.getByTestId("network-topology-hide-node"),
+    ).toBeInTheDocument();
+    expect(screen.getByText("Links (1)")).toBeInTheDocument();
+    expect(screen.getByText("10.0.0.1")).toBeInTheDocument();
+  });
+
+  test("the section sits above the Links list", () => {
+    renderPanel({ node: SWITCH_NODE, canRunDiagnostics: true });
+
+    const section: HTMLElement = screen.getByTestId(
+      "network-topology-connectivity",
+    );
+    const links: HTMLElement = screen.getByText("Links (1)");
+
+    // Not contained in the section, so the mask is exactly "following".
+    expect(section.compareDocumentPosition(links)).toBe(
+      Node.DOCUMENT_POSITION_FOLLOWING,
+    );
+  });
+});

package/Tests/App/Dashboard/TopologyDataLoading.test.tsx

@@ -135,6 +135,9 @@ function Probe(props: { range: RangeStartAndEndDateTime }): React.ReactElement {
       <span data-testid="updated">
         {data.lastUpdatedAt?.toISOString() || ""}
       </span>
+      <span data-testid="range-start">
+        {data.rangeStart?.toISOString() || ""}
+      </span>
       <button type="button" onClick={data.reload}>
         Reload topology
       </button>
@@ -175,6 +178,33 @@ describe("topology inventory loading", () => {
     expect(screen.getByTestId("updated").textContent).not.toBe("");
   });
 
+  test("loads what the maps need to judge activity and describe resources", async () => {
+    render(<Probe range={FIRST_RANGE} />);
+    await waitFor(() => {
+      expect(screen.getByTestId("loading")).toHaveTextContent("false");
+    });
+    const entityRequest: { select: Record<string, boolean> } =
+      getListMock.mock.calls[0]![0];
+    const relationshipRequest: { select: Record<string, boolean> } =
+      getListMock.mock.calls[1]![0];
+    expect(entityRequest.select).toMatchObject({
+      entityKey: true,
+      entityType: true,
+      source: true,
+      lastSeenAt: true,
+      descriptiveAttributes: true,
+      identifyingAttributes: true,
+    });
+    expect(relationshipRequest.select).toMatchObject({
+      callCount: true,
+      lastSeenAt: true,
+    });
+    // The snapshot remembers the range start it was loaded for.
+    expect(screen.getByTestId("range-start")).toHaveTextContent(
+      FIRST_RANGE.startAndEndDate!.startValue.toISOString(),
+    );
+  });
+
   test("only publishes a snapshot after inventory and relationships both finish", async () => {
     const relationships: DeferredResult = deferred();
     getListMock.mockResolvedValueOnce(result("Checkout API"));