@oneuptime/common 12.0.25 → 12.0.27

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

@@ -0,0 +1,230 @@
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+import "@testing-library/jest-dom";
+import { cleanup, render, screen, waitFor } from "@testing-library/react";
+import * as React from "react";
+
+/*
+ * ModelAPI is the only thing between this component and the network. Stubbed
+ * inline rather than through a helper because jest.mock is hoisted above the
+ * imports - a helper imported from another module is not initialised yet when
+ * the factory runs. The names carry the "mock" prefix jest requires of
+ * anything a hoisted factory closes over.
+ */
+type GetListRequest = Record<string, Record<string, unknown>>;
+
+const mockGetListCalls: Array<GetListRequest> = [];
+
+let mockGetListResponse: () => Promise<unknown> = (): Promise<unknown> => {
+  return Promise.resolve({ data: [], count: 0 });
+};
+
+jest.mock("../../../UI/Utils/ModelAPI/ModelAPI", () => {
+  return {
+    __esModule: true,
+    default: {
+      getList: (request: GetListRequest): Promise<unknown> => {
+        mockGetListCalls.push(request);
+        return mockGetListResponse();
+      },
+    },
+  };
+});
+
+import ResourceFeed, {
+  getIconForEventType,
+} from "../../../../App/FeatureSet/Dashboard/src/Components/ResourceFeed/ResourceFeed";
+import KubernetesClusterFeed, {
+  KubernetesClusterFeedEventType,
+} from "../../../Models/DatabaseModels/KubernetesClusterFeed";
+import IconProp from "../../../Types/Icon/IconProp";
+import ObjectID from "../../../Types/ObjectID";
+import { Green500 } from "../../../Types/BrandColors";
+
+/*
+ * One component serves all nine resource feeds, parameterised by the two
+ * column names that differ between them. That is what makes it worth testing
+ * once and worth testing carefully: the query column and the event-type column
+ * arrive as strings, so a typo in either compiles perfectly and produces an
+ * empty feed (wrong query column) or an every-item-looks-the-same timeline
+ * (wrong event-type column).
+ */
+
+const CLUSTER_ID: ObjectID = ObjectID.generate();
+
+function feedItem(
+  eventType: KubernetesClusterFeedEventType,
+  markdown: string,
+): KubernetesClusterFeed {
+  const item: KubernetesClusterFeed = new KubernetesClusterFeed(
+    ObjectID.generate(),
+  );
+  item.feedInfoInMarkdown = markdown;
+  item.kubernetesClusterFeedEventType = eventType;
+  item.displayColor = Green500;
+  item.postedAt = new Date("2024-01-15T10:30:00.000Z");
+  return item;
+}
+
+function renderFeed(): void {
+  render(
+    <ResourceFeed<KubernetesClusterFeed>
+      modelType={KubernetesClusterFeed}
+      resourceIdColumn="kubernetesClusterId"
+      resourceId={CLUSTER_ID}
+      eventTypeColumn="kubernetesClusterFeedEventType"
+      title="Kubernetes Cluster Feed"
+      description="Everything that has happened to this Kubernetes cluster."
+      noItemsMessage="No activity has been recorded for this Kubernetes cluster yet."
+    />,
+  );
+}
+
+beforeEach(() => {
+  mockGetListCalls.length = 0;
+  mockGetListResponse = (): Promise<unknown> => {
+    return Promise.resolve({ data: [], count: 0 });
+  };
+});
+
+afterEach(() => {
+  cleanup();
+});
+
+describe("ResourceFeed", () => {
+  test("queries the feed for the resource it was given", async () => {
+    renderFeed();
+
+    await waitFor(() => {
+      expect(mockGetListCalls.length).toBe(1);
+    });
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const request: any = mockGetListCalls[0]!;
+
+    expect(request.modelType).toBe(KubernetesClusterFeed);
+    expect(request.query.kubernetesClusterId).toBe(CLUSTER_ID);
+
+    /*
+     * The event type drives the icon. Forgetting to select it renders every
+     * item with the fallback dot and nothing else goes wrong, so nothing else
+     * would catch it.
+     */
+    expect(request.select.kubernetesClusterFeedEventType).toBe(true);
+    expect(request.select.feedInfoInMarkdown).toBe(true);
+    expect(request.select.postedAt).toBe(true);
+  });
+
+  test("renders the items it is given", async () => {
+    mockGetListResponse = (): Promise<unknown> => {
+      return Promise.resolve({
+        data: [
+          feedItem(
+            KubernetesClusterFeedEventType.KubernetesClusterCreated,
+            "cluster was created automatically",
+          ),
+          feedItem(
+            KubernetesClusterFeedEventType.OwnerUserAdded,
+            "Jane Doe was added as an owner",
+          ),
+        ],
+        count: 2,
+      });
+    };
+
+    renderFeed();
+
+    await waitFor(() => {
+      expect(
+        screen.getByText(/cluster was created automatically/),
+      ).toBeInTheDocument();
+    });
+
+    expect(
+      screen.getByText(/Jane Doe was added as an owner/),
+    ).toBeInTheDocument();
+  });
+
+  test("says so when the resource has no history yet", async () => {
+    renderFeed();
+
+    await waitFor(() => {
+      expect(
+        screen.getByText(
+          "No activity has been recorded for this Kubernetes cluster yet.",
+        ),
+      ).toBeInTheDocument();
+    });
+  });
+
+  test("surfaces a failed load instead of an empty timeline", async () => {
+    /*
+     * An error rendered as "no activity" is worse than an error: it tells the
+     * reader the resource has no history when the truth is unknown.
+     */
+    mockGetListResponse = (): Promise<unknown> => {
+      return Promise.reject(new Error("nope"));
+    };
+
+    renderFeed();
+
+    await waitFor(() => {
+      expect(
+        screen.queryByText(
+          "No activity has been recorded for this Kubernetes cluster yet.",
+        ),
+      ).not.toBeInTheDocument();
+    });
+  });
+});
+
+describe("getIconForEventType", () => {
+  test("gives each resource lifecycle event its own icon", () => {
+    /*
+     * Matched on the suffix, because every family names these after its own
+     * model - KubernetesClusterCreated, DockerHostCreated, ServiceCreated and
+     * so on. One mapping, nine enums.
+     */
+    for (const model of [
+      "KubernetesCluster",
+      "DockerHost",
+      "DockerSwarmCluster",
+      "CephCluster",
+      "PodmanHost",
+      "ProxmoxCluster",
+      "Host",
+      "CloudResource",
+      "Service",
+    ]) {
+      expect(getIconForEventType(`${model}Created`)).toBe(IconProp.Add);
+      expect(getIconForEventType(`${model}Updated`)).toBe(IconProp.Edit);
+      expect(getIconForEventType(`${model}Archived`)).toBe(IconProp.Archive);
+      expect(getIconForEventType(`${model}Restored`)).toBe(IconProp.Refresh);
+    }
+  });
+
+  test("distinguishes owners being added from owners being removed", () => {
+    expect(getIconForEventType("OwnerUserAdded")).toBe(IconProp.User);
+    expect(getIconForEventType("OwnerTeamAdded")).toBe(IconProp.Team);
+    expect(getIconForEventType("OwnerUserRemoved")).toBe(IconProp.Close);
+    expect(getIconForEventType("OwnerTeamRemoved")).toBe(IconProp.Close);
+  });
+
+  test("marks rule-driven events apart from hand-made ones", () => {
+    expect(getIconForEventType("OwnerRuleExecuted")).toBe(IconProp.Team);
+    expect(getIconForEventType("LabelRuleExecuted")).toBe(IconProp.Label);
+  });
+
+  test("falls back rather than throwing on an event it has never seen", () => {
+    expect(getIconForEventType("SomethingNobodyHasWrittenYet")).toBe(
+      IconProp.Circle,
+    );
+    expect(getIconForEventType("")).toBe(IconProp.Circle);
+  });
+});

package/Tests/App/Dashboard/ResourceFeedPageWiring.test.ts

@@ -0,0 +1,216 @@
+import fs from "fs";
+import path from "path";
+import { describe, expect, test } from "@jest/globals";
+import PageMap from "../../../../App/FeatureSet/Dashboard/src/Utils/PageMap";
+import RouteMap, {
+  RouteUtil,
+} from "../../../../App/FeatureSet/Dashboard/src/Utils/RouteMap";
+import Route from "../../../Types/API/Route";
+import ObjectID from "../../../Types/ObjectID";
+
+/*
+ * The Feed page is deliberately a page of its own rather than another card on
+ * the overview, which already carries more than a screenful. That makes it
+ * reachable only if five separate things line up: a PageMap key, a RouteMap
+ * entry, a <PageRoute> in the product's routes file, a side menu link, and the
+ * page component itself.
+ *
+ * Miss any one and there is no error anywhere - the menu entry is simply
+ * absent, or the link 404s inside the layout. Nine products got this wiring at
+ * once, so the sweep is the point: whichever one was fumbled fails by name.
+ */
+
+const DASHBOARD_SRC: string = path.join(
+  __dirname,
+  "..",
+  "..",
+  "..",
+  "..",
+  "App",
+  "FeatureSet",
+  "Dashboard",
+  "src",
+);
+
+interface FeedPageSpec {
+  product: string;
+  pageMapKey: string;
+  /** Product segment in the dashboard URL. */
+  urlPrefix: string;
+  pagesDirectory: string;
+  routesFile: string;
+}
+
+const FEED_PAGES: Array<FeedPageSpec> = [
+  {
+    product: "Kubernetes",
+    pageMapKey: "KUBERNETES_CLUSTER_VIEW_FEED",
+    urlPrefix: "kubernetes",
+    pagesDirectory: "Kubernetes",
+    routesFile: "KubernetesRoutes.tsx",
+  },
+  {
+    product: "Docker",
+    pageMapKey: "DOCKER_HOST_VIEW_FEED",
+    urlPrefix: "docker",
+    pagesDirectory: "Docker",
+    routesFile: "DockerRoutes.tsx",
+  },
+  {
+    product: "Docker Swarm",
+    pageMapKey: "DOCKER_SWARM_CLUSTER_VIEW_FEED",
+    urlPrefix: "docker-swarm",
+    pagesDirectory: "DockerSwarm",
+    routesFile: "DockerSwarmRoutes.tsx",
+  },
+  {
+    product: "Ceph",
+    pageMapKey: "CEPH_CLUSTER_VIEW_FEED",
+    urlPrefix: "ceph",
+    pagesDirectory: "Ceph",
+    routesFile: "CephRoutes.tsx",
+  },
+  {
+    product: "Podman",
+    pageMapKey: "PODMAN_HOST_VIEW_FEED",
+    urlPrefix: "podman",
+    pagesDirectory: "Podman",
+    routesFile: "PodmanRoutes.tsx",
+  },
+  {
+    product: "Proxmox",
+    pageMapKey: "PROXMOX_CLUSTER_VIEW_FEED",
+    urlPrefix: "proxmox",
+    pagesDirectory: "Proxmox",
+    routesFile: "ProxmoxRoutes.tsx",
+  },
+  {
+    product: "Host",
+    pageMapKey: "HOST_VIEW_FEED",
+    urlPrefix: "host",
+    pagesDirectory: "Host",
+    routesFile: "HostRoutes.tsx",
+  },
+  {
+    product: "Cloud",
+    pageMapKey: "CLOUD_RESOURCE_VIEW_FEED",
+    urlPrefix: "cloud",
+    pagesDirectory: "Cloud",
+    routesFile: "CloudResourceRoutes.tsx",
+  },
+  {
+    product: "Service Catalog",
+    pageMapKey: "SERVICE_VIEW_FEED",
+    urlPrefix: "service",
+    pagesDirectory: "Service",
+    routesFile: "ServiceRoutes.tsx",
+  },
+];
+
+const MODEL_ID: ObjectID = ObjectID.generate();
+
+function read(...segments: Array<string>): string {
+  return fs.readFileSync(path.join(DASHBOARD_SRC, ...segments), "utf8");
+}
+
+describe("Resource feed pages", () => {
+  test("every product that grew a feed is covered here", () => {
+    expect(FEED_PAGES.length).toBe(9);
+  });
+
+  test.each(FEED_PAGES)(
+    "$product has a Feed page key and route",
+    (spec: FeedPageSpec) => {
+      const key: string = spec.pageMapKey;
+
+      expect(Object.keys(PageMap)).toContain(key);
+
+      const route: Route | undefined = RouteMap[
+        PageMap[key as keyof typeof PageMap]
+      ] as Route | undefined;
+
+      expect(route).toBeTruthy();
+
+      const populated: string = RouteUtil.populateRouteParams(route!, {
+        modelId: MODEL_ID,
+      }).toString();
+
+      expect(populated).toContain(`/${spec.urlPrefix}/`);
+      expect(populated.endsWith("/feed")).toBe(true);
+      expect(populated).toContain(MODEL_ID.toString());
+    },
+  );
+
+  test("no two products share a feed route", () => {
+    const routes: Array<string> = FEED_PAGES.map((spec: FeedPageSpec) => {
+      return (
+        RouteMap[PageMap[spec.pageMapKey as keyof typeof PageMap]] as Route
+      ).toString();
+    });
+
+    expect(new Set(routes).size).toBe(routes.length);
+  });
+
+  test.each(FEED_PAGES)(
+    "$product renders a page component at that route",
+    (spec: FeedPageSpec) => {
+      const pageFile: string = path.join(
+        DASHBOARD_SRC,
+        "Pages",
+        spec.pagesDirectory,
+        "View",
+        "Feed.tsx",
+      );
+
+      expect(fs.existsSync(pageFile)).toBe(true);
+
+      const routes: string = read("Routes", spec.routesFile);
+
+      expect(routes).toContain(`PageMap.${spec.pageMapKey}`);
+      expect(routes).toContain(
+        `from "../Pages/${spec.pagesDirectory}/View/Feed"`,
+      );
+    },
+  );
+
+  test.each(FEED_PAGES)(
+    "$product links to the feed from its side menu",
+    (spec: FeedPageSpec) => {
+      /*
+       * A page with no menu entry is a page nobody finds. This asserts the
+       * link exists AND that it points at the feed key rather than being a
+       * copy of the neighbouring entry.
+       */
+      const sideMenu: string = read(
+        "Pages",
+        spec.pagesDirectory,
+        "View",
+        "SideMenu.tsx",
+      );
+
+      expect(sideMenu).toContain('title: "Feed"');
+      expect(sideMenu).toContain(
+        `RouteMap[PageMap.${spec.pageMapKey}] as Route`,
+      );
+    },
+  );
+
+  test.each(FEED_PAGES)(
+    "$product's feed page reads the model id from the route",
+    (spec: FeedPageSpec) => {
+      const page: string = read(
+        "Pages",
+        spec.pagesDirectory,
+        "View",
+        "Feed.tsx",
+      );
+
+      /*
+       * The feed route is <modelId>/feed, so the id is one segment back.
+       * getLastParamAsObjectID(0) would read the literal string "feed".
+       */
+      expect(page).toContain("Navigation.getLastParamAsObjectID(1)");
+      expect(page).toContain("ResourceFeed");
+    },
+  );
+});

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

@@ -0,0 +1,192 @@
+import "@testing-library/jest-dom";
+import { afterEach, describe, expect, jest, test } from "@jest/globals";
+import { cleanup, fireEvent, 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 #3435, from the operator's side.
+ *
+ * The topology detail drawer for an unmanaged neighbour used to be a dead
+ * end: it showed what the device was ("IP phone", "Cisco IP Phone 8811") and
+ * which switch port it hung off, and the only thing anybody could do about it
+ * was hide it from the map. This asserts what a person can actually SEE and
+ * PRESS in that drawer now — not which props were passed — because the two
+ * ways of getting it wrong are both invisible to a source-text check:
+ *
+ *   - offering the action on a MANAGED device, which already has a device
+ *     page and cannot be created again;
+ *   - rendering the action for a viewer with no create permission, whose
+ *     click can only ever end in a permission error.
+ *
+ * The panel takes the handler as an optional prop precisely so its caller can
+ * make both of those decisions, and this pins that the prop actually gates
+ * the button.
+ */
+
+const SWITCH_NODE: NetworkTopologyNode = {
+  id: "switch-1",
+  name: "UN1289LANSWI01",
+  isManaged: true,
+  kind: "device",
+  role: "switch",
+  status: "up",
+};
+
+const PHONE_NODE: NetworkTopologyNode = {
+  id: "unmanaged:sep6026aaf2b46b",
+  name: "SEP6026AAF2B46B",
+  isManaged: false,
+  kind: "unmanaged",
+  role: "phone",
+  status: "unknown",
+  deviceModel: "Cisco IP Phone 8811",
+  ipAddress: "10.0.12.41",
+};
+
+const PHONE_EDGE: NetworkTopologyEdge = {
+  fromNodeId: "switch-1",
+  toNodeId: "unmanaged:sep6026aaf2b46b",
+  fromPort: "GigabitEthernet1/0/12",
+  toPort: "SW PORT",
+  protocols: ["cdp"],
+};
+
+type RenderPanelOptions = {
+  node: NetworkTopologyNode;
+  onAddToMonitoring?: ((node: NetworkTopologyNode) => void) | 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],
+  ]);
+
+  render(
+    <MemoryRouter>
+      <NetworkDeviceDetailPanel
+        node={options.node}
+        edges={[PHONE_EDGE]}
+        nodeById={nodeById}
+        onClose={() => {}}
+        onSelectEdge={() => {}}
+        onHideNode={options.onHideNode}
+        onAddToMonitoring={options.onAddToMonitoring}
+      />
+    </MemoryRouter>,
+  );
+}
+
+describe("the topology drawer for an unmanaged neighbour", () => {
+  afterEach(() => {
+    cleanup();
+  });
+
+  test("offers to bring the device into monitoring", () => {
+    renderPanel({
+      node: PHONE_NODE,
+      onAddToMonitoring: () => {},
+    });
+
+    expect(
+      screen.getByTestId("network-topology-add-to-monitoring"),
+    ).toBeInTheDocument();
+    expect(screen.getByText("Add to Monitoring")).toBeInTheDocument();
+  });
+
+  test("hands the node back so the dialog knows what to pre-fill from", () => {
+    const onAddToMonitoring: jest.Mock<any, any> = jest.fn() as jest.Mock<
+      any,
+      any
+    >;
+
+    renderPanel({
+      node: PHONE_NODE,
+      onAddToMonitoring: onAddToMonitoring as unknown as (
+        node: NetworkTopologyNode,
+      ) => void,
+    });
+
+    fireEvent.click(screen.getByTestId("network-topology-add-to-monitoring"));
+
+    expect(onAddToMonitoring).toHaveBeenCalledWith(PHONE_NODE);
+  });
+
+  /*
+   * Hidden rather than disabled. PermissionGate returns "not allowed, and
+   * nothing honest to say" while the permission snapshot is still in flight —
+   * every first paint after a login or a project switch — so a disabled
+   * button would accuse a permitted user of lacking a permission they hold.
+   */
+  test("shows no such action to a viewer who cannot create devices", () => {
+    renderPanel({ node: PHONE_NODE });
+
+    expect(
+      screen.queryByTestId("network-topology-add-to-monitoring"),
+    ).not.toBeInTheDocument();
+  });
+
+  /*
+   * A device already under management has a device page, and the drawer
+   * offers that instead. Offering both would invite the operator to create a
+   * duplicate of a device they are already monitoring.
+   */
+  test("a managed device is offered its device page, not an adoption", () => {
+    renderPanel({
+      node: SWITCH_NODE,
+      onAddToMonitoring: () => {},
+    });
+
+    expect(
+      screen.queryByTestId("network-topology-add-to-monitoring"),
+    ).not.toBeInTheDocument();
+    expect(screen.getByText("Device details")).toBeInTheDocument();
+  });
+
+  /*
+   * The address is what makes the action worth having — it is the field a
+   * device cannot be monitored without — so the drawer has to show it, and
+   * for an unmanaged peer it now comes from what the neighbours advertised
+   * rather than from an ARP table.
+   */
+  test("shows the discovered address and platform it will carry over", () => {
+    renderPanel({
+      node: PHONE_NODE,
+      onAddToMonitoring: () => {},
+    });
+
+    expect(screen.getByText("10.0.12.41")).toBeInTheDocument();
+    expect(screen.getByText("Cisco IP Phone 8811")).toBeInTheDocument();
+    expect(screen.getByText("IP phone")).toBeInTheDocument();
+  });
+
+  /*
+   * Hiding was the only action this drawer had, and it is still the right
+   * answer for a peer nobody wants to monitor — a printer, a contractor's
+   * laptop. The new action is an addition, not a replacement.
+   */
+  test("still offers to hide the node, which was the only action before", () => {
+    renderPanel({
+      node: PHONE_NODE,
+      onAddToMonitoring: () => {},
+      onHideNode: () => {},
+    });
+
+    expect(
+      screen.getByTestId("network-topology-hide-node"),
+    ).toBeInTheDocument();
+    expect(
+      screen.getByTestId("network-topology-add-to-monitoring"),
+    ).toBeInTheDocument();
+  });
+});