@oneuptime/common 14.0.0 → 14.0.2

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

@@ -0,0 +1,241 @@
+import { describe, expect, test } from "@jest/globals";
+import {
+  CLUSTER_TOOL_NAMES,
+  ClusterToolOutcome,
+  describeClusterEvidenceTool,
+  describeClusterToolOutcome,
+  formatEvidenceOutcome,
+  getClusterEvidenceNote,
+  isClusterToolName,
+  isKubectlResultUnknownMessage,
+  KUBECTL_RESULT_UNKNOWN_EVENT_PREFIX,
+} from "../../../../App/FeatureSet/Dashboard/src/Components/AI/ClusterToolFormat";
+import {
+  CLUSTER_TOOL_NAMES as FEED_CLUSTER_TOOL_NAMES,
+  isClusterToolName as feedIsClusterToolName,
+} from "../../../../App/FeatureSet/Dashboard/src/Components/AIChat/ChatActivityFeed";
+import {
+  describeEvidenceTool,
+  EvidenceToolDescription,
+} from "../../../../App/FeatureSet/Dashboard/src/Utils/InvestigationEvidenceFormat";
+import IconProp from "../../../Types/Icon/IconProp";
+import {
+  KUBECTL_RESULT_UNKNOWN_EVENT_PREFIX as SHARED_KUBECTL_RESULT_UNKNOWN_PREFIX,
+  LIST_CLUSTER_ACCESS_TOOL_NAME,
+  RUN_KUBECTL_TOOL_NAME,
+} from "../../../Types/Kubernetes/KubernetesClusterAiAccessToolNames";
+
+// The shared formatter's fallback for a tool it does not know: "Ran <words>".
+const RAN_FALLBACK_PATTERN: RegExp =
+  /^Ran run kubectl$|^Ran list cluster access$/;
+
+/*
+ * The one place the dashboard words a cluster tool call — the activity
+ * feed, the Evidence tab and the usage line all read it, so they cannot
+ * drift apart (IP-6).
+ */
+
+describe("describeClusterToolOutcome", () => {
+  test.each<[string, number | undefined, ClusterToolOutcome]>([
+    [
+      RUN_KUBECTL_TOOL_NAME,
+      1,
+      { label: "Succeeded", detail: "succeeded", isError: false },
+    ],
+    [
+      RUN_KUBECTL_TOOL_NAME,
+      0,
+      {
+        label: "kubectl returned an error",
+        detail: "kubectl returned an error",
+        isError: true,
+      },
+    ],
+    [
+      RUN_KUBECTL_TOOL_NAME,
+      undefined,
+      {
+        label: "kubectl returned an error",
+        detail: "kubectl returned an error",
+        isError: true,
+      },
+    ],
+    [
+      LIST_CLUSTER_ACCESS_TOOL_NAME,
+      2,
+      { label: "2 clusters", detail: "2 clusters", isError: false },
+    ],
+    [
+      LIST_CLUSTER_ACCESS_TOOL_NAME,
+      1,
+      { label: "1 cluster", detail: "1 cluster", isError: false },
+    ],
+    [
+      LIST_CLUSTER_ACCESS_TOOL_NAME,
+      0,
+      { label: "No clusters", detail: "no clusters", isError: false },
+    ],
+  ])(
+    "%s with rowCount %p",
+    (
+      toolName: string,
+      rowCount: number | undefined,
+      expected: ClusterToolOutcome,
+    ) => {
+      expect(describeClusterToolOutcome(toolName, rowCount)).toEqual(expected);
+    },
+  );
+
+  // Negative control: every other tool's rowCount is rows.
+  test("leaves other tools alone", () => {
+    expect(describeClusterToolOutcome("query_metrics", 5)).toBeNull();
+    expect(describeClusterToolOutcome(undefined, 5)).toBeNull();
+  });
+});
+
+describe("formatEvidenceOutcome", () => {
+  test("words cluster calls by what they did", () => {
+    expect(formatEvidenceOutcome(RUN_KUBECTL_TOOL_NAME, 1)).toBe("Succeeded");
+    expect(formatEvidenceOutcome(RUN_KUBECTL_TOOL_NAME, 0)).toBe(
+      "kubectl returned an error",
+    );
+    expect(formatEvidenceOutcome(LIST_CLUSTER_ACCESS_TOOL_NAME, 2)).toBe(
+      "2 clusters",
+    );
+  });
+
+  // Negative control: telemetry queries keep their rows.
+  test("keeps rows for telemetry queries", () => {
+    expect(formatEvidenceOutcome("query_metrics", 1)).toBe("1 row");
+    expect(formatEvidenceOutcome("query_metrics", 0)).toBe("No rows");
+    expect(formatEvidenceOutcome("search_logs", 1234)).toBe("1,234 rows");
+  });
+});
+
+describe("describeClusterEvidenceTool", () => {
+  test("describes the two cluster tools in their own words", () => {
+    expect(
+      describeClusterEvidenceTool(RUN_KUBECTL_TOOL_NAME)?.description,
+    ).toBe("Ran a read-only kubectl command");
+    expect(
+      describeClusterEvidenceTool(LIST_CLUSTER_ACCESS_TOOL_NAME)?.description,
+    ).toBe("Listed the clusters OneUptime AI can inspect");
+  });
+
+  /*
+   * The shared evidence formatter knows the cluster tools itself (it used
+   * to fall back to "Ran run kubectl" under "Other"), so a surface that
+   * only calls describeEvidenceTool — the citation chip — words them the
+   * same way the Evidence tab does.
+   */
+  test.each<[string, string, IconProp]>([
+    [
+      RUN_KUBECTL_TOOL_NAME,
+      "Ran a read-only kubectl command",
+      IconProp.Terminal,
+    ],
+    [
+      LIST_CLUSTER_ACCESS_TOOL_NAME,
+      "Listed the clusters OneUptime AI can inspect",
+      IconProp.Cube,
+    ],
+  ])(
+    "the shared formatter describes %s under Kubernetes",
+    (toolName: string, description: string, icon: IconProp) => {
+      const expected: EvidenceToolDescription = {
+        description,
+        icon,
+        category: "Kubernetes",
+      };
+
+      expect(describeEvidenceTool(toolName)).toEqual(expected);
+      expect(describeClusterEvidenceTool(toolName)).toEqual(expected);
+      // Case and surrounding space do not change the answer.
+      expect(describeEvidenceTool(` ${toolName.toUpperCase()} `)).toEqual(
+        expected,
+      );
+      expect(describeEvidenceTool(toolName).description).not.toMatch(
+        RAN_FALLBACK_PATTERN,
+      );
+    },
+  );
+
+  test("returns a copy, so a caller cannot change the shared table", () => {
+    const first: EvidenceToolDescription | null = describeClusterEvidenceTool(
+      RUN_KUBECTL_TOOL_NAME,
+    );
+    first!.description = "changed";
+
+    expect(
+      describeClusterEvidenceTool(RUN_KUBECTL_TOOL_NAME)?.description,
+    ).toBe("Ran a read-only kubectl command");
+    expect(describeEvidenceTool(RUN_KUBECTL_TOOL_NAME).description).toBe(
+      "Ran a read-only kubectl command",
+    );
+  });
+
+  // Negative control: an unknown tool still falls back to its own words.
+  test("still humanises a tool the table does not know", () => {
+    expect(describeEvidenceTool("query_kubernetes_pods")).toEqual({
+      description: "Ran query kubernetes pods",
+      icon: IconProp.Database,
+      category: "Other",
+    });
+    expect(describeClusterEvidenceTool("query_kubernetes_pods")).toBeNull();
+  });
+
+  test("leaves other tools to the shared formatter", () => {
+    expect(describeClusterEvidenceTool("query_metrics")).toBeNull();
+    expect(getClusterEvidenceNote("query_metrics")).toBeNull();
+  });
+
+  test("never promises rows for a cluster call", () => {
+    for (const toolName of CLUSTER_TOOL_NAMES) {
+      const note: string | null = getClusterEvidenceNote(toolName);
+      expect(note).toBeTruthy();
+      expect(note).not.toContain("its rows");
+    }
+  });
+});
+
+describe("the cluster tool names", () => {
+  test("are the feed's too", () => {
+    expect(FEED_CLUSTER_TOOL_NAMES).toBe(CLUSTER_TOOL_NAMES);
+    expect(feedIsClusterToolName(RUN_KUBECTL_TOOL_NAME)).toBe(true);
+    expect(isClusterToolName(LIST_CLUSTER_ACCESS_TOOL_NAME)).toBe(true);
+    expect(isClusterToolName("query_metrics")).toBe(false);
+    expect(isClusterToolName(null)).toBe(false);
+  });
+});
+
+describe("isKubectlResultUnknownMessage", () => {
+  test("recognises the server's result-unknown event", () => {
+    expect(
+      isKubectlResultUnknownMessage(
+        `${SHARED_KUBECTL_RESULT_UNKNOWN_PREFIX} the Runner of cluster "prod-us" took the command, but no result came back, so whether it ran is unknown.`,
+      ),
+    ).toBe(true);
+  });
+
+  // The panel re-exports the one shared definition for its readers.
+  test("reads the marker defined next to the shared tool names", () => {
+    expect(KUBECTL_RESULT_UNKNOWN_EVENT_PREFIX).toBe(
+      SHARED_KUBECTL_RESULT_UNKNOWN_PREFIX,
+    );
+    expect(
+      isKubectlResultUnknownMessage(
+        `  ${SHARED_KUBECTL_RESULT_UNKNOWN_PREFIX} leading space is not the event`,
+      ),
+    ).toBe(false);
+  });
+
+  test("never reads a never-ran event as unknown", () => {
+    expect(
+      isKubectlResultUnknownMessage(
+        'kubectl was not run on cluster "prod-us": its Runner did not pick up the command in time.',
+      ),
+    ).toBe(false);
+    expect(isKubectlResultUnknownMessage("")).toBe(false);
+    expect(isKubectlResultUnknownMessage(null)).toBe(false);
+  });
+});

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

@@ -0,0 +1,322 @@
+import "@testing-library/jest-dom";
+import { afterEach, describe, expect, jest, test } from "@jest/globals";
+import { cleanup, fireEvent, render, within } from "@testing-library/react";
+import * as React from "react";
+import getJestMockFunction, { MockFunction } from "../../MockType";
+
+/*
+ * IP-6: the Evidence tab lists every cited call, kubectl commands and
+ * cluster listings included. A kubectl command has no rows — its rowCount
+ * only says whether kubectl completed (1) or ran and returned an error (0)
+ * — so it must read the way the activity feed reads it ("Succeeded",
+ * "kubectl returned an error"), never "1 row" or "No rows"; a cluster
+ * listing counts clusters. Telemetry queries keep their row counts.
+ */
+
+const postMock: MockFunction = getJestMockFunction();
+
+jest.mock("../../../UI/Utils/API/API", () => {
+  return {
+    __esModule: true,
+    default: {
+      post: (...args: Array<unknown>) => {
+        return postMock(...args);
+      },
+      getFriendlyMessage: (): string => {
+        return "error";
+      },
+    },
+  };
+});
+
+jest.mock("../../../UI/Utils/ModelAPI/ModelAPI", () => {
+  return {
+    __esModule: true,
+    default: {
+      getCommonHeaders: (): Record<string, string> => {
+        return {};
+      },
+    },
+  };
+});
+
+jest.mock(
+  "../../../../App/FeatureSet/Dashboard/src/Components/AIChat/Widgets/WidgetRenderer",
+  () => {
+    return {
+      __esModule: true,
+      default: (): React.ReactElement => {
+        return React.createElement("div", { "data-testid": "evidence-widget" });
+      },
+    };
+  },
+);
+
+import InvestigationEvidenceList from "../../../../App/FeatureSet/Dashboard/src/Components/AI/InvestigationReport/InvestigationEvidenceList";
+import { InvestigationEvidenceItem } from "../../../Types/AI/InvestigationEvidence";
+import {
+  InvestigationEvidenceCheckedEntry,
+  ParsedInvestigationReport,
+  parseInvestigationReport,
+} from "../../../Utils/AI/InvestigationReport";
+import {
+  LIST_CLUSTER_ACCESS_TOOL_NAME,
+  RUN_KUBECTL_TOOL_NAME,
+} from "../../../Types/Kubernetes/KubernetesClusterAiAccessToolNames";
+
+const RUN_ID: string = "11111111-1111-4111-8111-111111111111";
+const INCIDENT_ID: string = "33333333-3333-4333-8333-333333333333";
+
+function item(
+  citationId: string,
+  toolName: string,
+  rowCount: number,
+  label: string,
+): InvestigationEvidenceItem {
+  return {
+    citationId,
+    toolName,
+    label,
+    rowCount,
+    queryArguments:
+      toolName === RUN_KUBECTL_TOOL_NAME
+        ? {
+            clusterId: "77777777-7777-4777-8777-777777777777",
+            command: label,
+            rationale: "see why the pod is pending",
+          }
+        : {},
+    canLoadRows: toolName === "query_metrics",
+  };
+}
+
+const ITEMS: Array<InvestigationEvidenceItem> = [
+  item(
+    "C1",
+    RUN_KUBECTL_TOOL_NAME,
+    0,
+    'kubectl get pods -n web on cluster "prod-us"',
+  ),
+  item(
+    "C2",
+    RUN_KUBECTL_TOOL_NAME,
+    1,
+    'kubectl describe pod web-1 -n web on cluster "prod-us"',
+  ),
+  item("C3", "query_metrics", 5, "Max(latency)"),
+  item(
+    "C4",
+    LIST_CLUSTER_ACCESS_TOOL_NAME,
+    2,
+    "Clusters OneUptime AI can inspect",
+  ),
+];
+
+function renderList(): void {
+  render(
+    <InvestigationEvidenceList
+      items={ITEMS}
+      legacyEntries={[]}
+      subjectType="incident"
+      subjectId={INCIDENT_ID}
+      runId={RUN_ID}
+    />,
+  );
+}
+
+function row(citationId: string): HTMLElement {
+  const element: Element | null = document.querySelector(
+    `[data-citation-id="${citationId}"]`,
+  );
+
+  if (!element) {
+    throw new Error(`No row for ${citationId}`);
+  }
+
+  return element as HTMLElement;
+}
+
+afterEach(() => {
+  cleanup();
+  postMock.mockReset();
+});
+
+describe("InvestigationEvidenceList kubectl items", () => {
+  test("describes a kubectl command by its outcome, never in rows", () => {
+    renderList();
+
+    const failed: HTMLElement = row("C1");
+    const succeeded: HTMLElement = row("C2");
+
+    expect(within(failed).getByText("kubectl returned an error")).toBeVisible();
+    expect(within(succeeded).getByText("Succeeded")).toBeVisible();
+
+    for (const kubectlRow of [failed, succeeded]) {
+      expect(kubectlRow).not.toHaveTextContent("No rows");
+      expect(kubectlRow).not.toHaveTextContent(/\b1 row\b/);
+      expect(kubectlRow).toHaveTextContent("Ran a read-only kubectl command");
+      expect(kubectlRow).not.toHaveTextContent("Ran run kubectl");
+    }
+  });
+
+  test("styles a kubectl error as an error, not as an empty result", () => {
+    renderList();
+
+    const pill: HTMLElement = within(row("C1")).getByText(
+      "kubectl returned an error",
+    );
+    expect(pill.className).toContain("amber");
+    expect(within(row("C1")).getByText("C1").className).toContain("amber");
+    // A kubectl command that succeeded is not styled as an error.
+    expect(within(row("C2")).getByText("Succeeded").className).not.toContain(
+      "amber",
+    );
+  });
+
+  test("counts a cluster listing in clusters", () => {
+    renderList();
+
+    expect(within(row("C4")).getByText("2 clusters")).toBeVisible();
+    expect(row("C4")).not.toHaveTextContent("2 rows");
+    expect(row("C4")).toHaveTextContent(
+      "Listed the clusters OneUptime AI can inspect",
+    );
+  });
+
+  // Negative control: a telemetry query keeps its row count.
+  test("keeps a telemetry query's row count", () => {
+    renderList();
+
+    expect(within(row("C3")).getByText("5 rows")).toBeVisible();
+    expect(row("C3")).toHaveTextContent("Queried a metric");
+  });
+
+  test("says what an expanded kubectl command was, and never promises its rows", () => {
+    renderList();
+
+    fireEvent.click(within(row("C1")).getByRole("button"));
+
+    const details: HTMLElement = within(row("C1")).getByRole("region");
+    expect(details).toHaveTextContent("What was run");
+    expect(details).toHaveTextContent(
+      "kubectl commands are not re-run from the dashboard",
+    );
+    expect(details).not.toHaveTextContent("its rows");
+    expect(details).not.toHaveTextContent("What was queried");
+    // Nothing is fetched for a kubectl command.
+    expect(postMock).not.toHaveBeenCalled();
+  });
+});
+
+/*
+ * A run that predates structured evidence shows the report's own
+ * "Evidence checked" lines. A cluster tool's line says what the call did
+ * ("— succeeded", "— kubectl returned an error", "— 2 cluster(s)") and the
+ * parser keeps that as the entry's outcome; its rowCount is only the
+ * engine's tally (1 for a kubectl command that succeeded). The pill must
+ * show the outcome, never "1 row" or "No rows" for a kubectl line.
+ */
+describe("InvestigationEvidenceList legacy kubectl lines", () => {
+  function legacyEntries(): Array<InvestigationEvidenceCheckedEntry> {
+    const parsed: ParsedInvestigationReport = parseInvestigationReport(
+      [
+        "**Summary** — web pods are pending.",
+        "",
+        "**Evidence checked**",
+        '- **[C1]** kubectl describe pod web-1 -n web on cluster "prod-us" — succeeded',
+        '- **[C2]** kubectl get pods -n web on cluster "prod-us" — kubectl returned an error',
+        "- **[C3]** Clusters OneUptime AI can inspect — 2 cluster(s)",
+        '- **[C4]** kubectl logs web-1 -n web on cluster "prod-us" — result unknown',
+        "- **[C5]** Max(latency) — 5 row(s)",
+      ].join("\n"),
+    );
+
+    return parsed.evidenceChecked;
+  }
+
+  function renderLegacyList(
+    entries: Array<InvestigationEvidenceCheckedEntry>,
+  ): void {
+    render(
+      <InvestigationEvidenceList
+        items={[]}
+        legacyEntries={entries}
+        subjectType="incident"
+        subjectId={INCIDENT_ID}
+        runId={RUN_ID}
+      />,
+    );
+  }
+
+  test("the parser keeps each cluster line's outcome (the fixture is what the list gets)", () => {
+    const entries: Array<InvestigationEvidenceCheckedEntry> = legacyEntries();
+
+    expect(
+      entries.map((entry: InvestigationEvidenceCheckedEntry) => {
+        return [entry.citationId, entry.rowCount, entry.outcome];
+      }),
+    ).toEqual([
+      ["C1", 1, "succeeded"],
+      ["C2", 0, "kubectl returned an error"],
+      ["C3", 2, "2 cluster(s)"],
+      ["C4", 0, "result unknown"],
+      ["C5", 5, undefined],
+    ]);
+  });
+
+  test("shows a kubectl line's outcome, never a row count", () => {
+    renderLegacyList(legacyEntries());
+
+    expect(within(row("C1")).getByText("Succeeded")).toBeVisible();
+    expect(
+      within(row("C2")).getByText("kubectl returned an error"),
+    ).toBeVisible();
+    expect(within(row("C4")).getByText("Result unknown")).toBeVisible();
+
+    for (const citationId of ["C1", "C2", "C4"]) {
+      expect(row(citationId)).not.toHaveTextContent(/\b1 row\b/);
+      expect(row(citationId)).not.toHaveTextContent("No rows");
+    }
+  });
+
+  test("shows a cluster listing's outcome as written, not as rows", () => {
+    renderLegacyList(legacyEntries());
+
+    expect(within(row("C3")).getByText("2 cluster(s)")).toBeVisible();
+    expect(row("C3")).not.toHaveTextContent("2 rows");
+  });
+
+  test("styles a kubectl error as an error, like the structured items do", () => {
+    renderLegacyList(legacyEntries());
+
+    expect(
+      within(row("C2")).getByText("kubectl returned an error").className,
+    ).toContain("amber");
+    expect(within(row("C2")).getByText("C2").className).toContain("amber");
+    // A kubectl command that succeeded, or whose result is unknown, is not.
+    expect(within(row("C1")).getByText("Succeeded").className).not.toContain(
+      "amber",
+    );
+    expect(
+      within(row("C4")).getByText("Result unknown").className,
+    ).not.toContain("amber");
+  });
+
+  // Negative control: a telemetry query's line has no outcome and keeps its rows.
+  test("keeps a telemetry query line's row count", () => {
+    renderLegacyList(legacyEntries());
+
+    expect(within(row("C5")).getByText("5 rows")).toBeVisible();
+  });
+
+  // Negative control: an entry without an outcome counts rows, as before.
+  test("counts rows for an entry that carries no outcome", () => {
+    renderLegacyList([
+      { citationId: "C1", label: "Active incidents (7 total)", rowCount: 7 },
+      { citationId: "C2", label: "Monitors (2 found)", rowCount: 0 },
+    ]);
+
+    expect(within(row("C1")).getByText("7 rows")).toBeVisible();
+    expect(within(row("C2")).getByText("No rows")).toBeVisible();
+  });
+});

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

@@ -1,4 +1,11 @@
-import { afterEach, describe, expect, jest, test } from "@jest/globals";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
 import "@testing-library/jest-dom";
 import { act, cleanup, render, screen, waitFor } from "@testing-library/react";
 import * as React from "react";
@@ -59,6 +66,7 @@ import IconProp from "../../../Types/Icon/IconProp";
 import ObjectID from "../../../Types/ObjectID";
 import SortOrder from "../../../Types/BaseDatabase/SortOrder";
 import { DEFAULT_LIMIT } from "../../../Types/Database/LimitMax";
+import { getSortOrderStorageKey } from "../../../UI/Components/Feed/useFeedOptions";
 
 interface RenderedFeedItem {
   key: string;
@@ -322,6 +330,15 @@ function lastRenderedFeedProps(): RenderedFeedProps {
   return calls[calls.length - 1]![0]!;
 }
 
+/*
+ * Both feeds open in the sort order the reader last chose, read from
+ * localStorage on mount, so one test's choice must not reorder the next
+ * test's requests.
+ */
+beforeEach(() => {
+  window.localStorage.clear();
+});
+
 afterEach(() => {
   cleanup();
   getListMock.mockReset();
@@ -439,6 +456,48 @@ describe("investigation reports in incident and alert feeds", () => {
     expect(getListMock).toHaveBeenCalledTimes(2);
   });
 
+  /*
+   * The refresh after an investigation re-reads the same view the reader is
+   * looking at. A reader who keeps these feeds oldest first must get the new
+   * report at the end of that order, not a feed flipped back to newest first.
+   */
+  test("a refresh re-reads the incident and alert feeds in the reader's remembered order", async () => {
+    window.localStorage.setItem(
+      getSortOrderStorageKey("incident"),
+      SortOrder.Ascending,
+    );
+    window.localStorage.setItem(
+      getSortOrderStorageKey("alert"),
+      SortOrder.Ascending,
+    );
+    getListMock.mockResolvedValue(listResult<IncidentFeed>([]) as never);
+
+    const incidentView: ReturnType<typeof render> = render(incidentElement(0));
+    await flush();
+    incidentView.rerender(incidentElement(1));
+    await flush();
+
+    const alertView: ReturnType<typeof render> = render(alertElement(0));
+    await flush();
+    alertView.rerender(alertElement(1));
+    await flush();
+
+    const requests: Array<FeedListRequest> = getListMock.mock.calls.map(
+      (call: Array<unknown>): FeedListRequest => {
+        return call[0] as FeedListRequest;
+      },
+    );
+
+    expect(
+      requests.map((request: FeedListRequest): unknown => {
+        return request.modelType;
+      }),
+    ).toEqual([IncidentFeed, IncidentFeed, AlertFeed, AlertFeed]);
+    for (const request of requests) {
+      expect(request.sort).toEqual({ postedAt: SortOrder.Ascending });
+    }
+  });
+
   test("a late mount-time incident response cannot erase the refreshed report", async () => {
     const initialRequest: Deferred<ListResult<IncidentFeed>> =
       createDeferred<ListResult<IncidentFeed>>();