@oneuptime/common 13.0.5 → 13.0.6

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

@@ -3,6 +3,7 @@ import "@testing-library/jest-dom";
 import { cleanup, render, screen } from "@testing-library/react";
 import * as React from "react";
 import ChatActivityFeed, {
+  countActivitySteps,
   hasRenderableActivity,
 } from "../../../../App/FeatureSet/Dashboard/src/Components/AIChat/ChatActivityFeed";
 import AIRunEvent from "../../../Models/DatabaseModels/AIRunEvent";
@@ -21,7 +22,11 @@ interface StepEvent {
   eventType: AIRunEventType;
   toolName?: string | undefined;
   resultSummary?:
-    | { rowCount?: number | undefined; durationInMs?: number | undefined }
+    | {
+        rowCount?: number | undefined;
+        durationInMs?: number | undefined;
+        message?: string | undefined;
+      }
     | undefined;
 }
 
@@ -52,6 +57,54 @@ const SEARCH_LOGS_RUN: Array<AIRunEvent> = events([
   },
 ]);
 
+/*
+ * Twelve events that draw six steps: the completion halves close steps an
+ * earlier event opened, a progress log without a message and an approval
+ * request draw nothing, and RunCompleted only ends the run.
+ */
+const MIXED_RUN: Array<AIRunEvent> = events([
+  { eventType: AIRunEventType.RunStarted },
+  { eventType: AIRunEventType.LlmCallStarted },
+  { eventType: AIRunEventType.LlmCallCompleted },
+  { eventType: AIRunEventType.ToolCallStarted, toolName: "query_traces" },
+  { eventType: AIRunEventType.ToolCallFailed, toolName: "query_traces" },
+  { eventType: AIRunEventType.ToolCallStarted, toolName: "search_logs" },
+  {
+    eventType: AIRunEventType.ToolCallCompleted,
+    toolName: "search_logs",
+    resultSummary: { rowCount: 3 },
+  },
+  {
+    eventType: AIRunEventType.ProgressLog,
+    resultSummary: { message: "Cloning repository" },
+  },
+  { eventType: AIRunEventType.ProgressLog },
+  { eventType: AIRunEventType.ApprovalRequested },
+  {
+    eventType: AIRunEventType.ActionExecuted,
+    resultSummary: { message: "Opened pull request" },
+  },
+  { eventType: AIRunEventType.RunCompleted },
+]);
+
+const MIXED_RUN_STEP_TEXTS: Array<string> = [
+  "Starting investigation",
+  "Thinking",
+  "Analyzing traces",
+  "Searching logs",
+  "Cloning repository",
+  "Opened pull request",
+];
+
+// Every event type whose only job is to close a step an earlier event opened.
+const CLOSING_ONLY_EVENT_TYPES: Array<AIRunEventType> = [
+  AIRunEventType.LlmCallCompleted,
+  AIRunEventType.ToolCallCompleted,
+  AIRunEventType.ToolCallFailed,
+  AIRunEventType.RunCompleted,
+  AIRunEventType.RunFailed,
+];
+
 function bubble(container: HTMLElement): Element | null {
   return container.querySelector(".rounded-xl.border.border-gray-200");
 }
@@ -99,6 +152,120 @@ describe("hasRenderableActivity", () => {
   });
 });
 
+/*
+ * The investigation panel labels its Activity tab with countActivitySteps and
+ * sizes the feed with it so every step shows. It has to count what the feed
+ * draws: the raw event list also holds the halves that only close a step, so
+ * counting events would inflate the tab count and, if it ever undercounted,
+ * the sized feed would hide steps behind a "+ N earlier steps" line.
+ */
+describe("countActivitySteps", () => {
+  test("no events count zero steps", () => {
+    expect(countActivitySteps([])).toBe(0);
+  });
+
+  test.each(CLOSING_ONLY_EVENT_TYPES)(
+    "a lone %s closes nothing and counts zero steps",
+    (eventType: AIRunEventType) => {
+      expect(
+        countActivitySteps(events([{ eventType, toolName: "search_logs" }])),
+      ).toBe(0);
+    },
+  );
+
+  test("a trail made only of closing events counts zero steps", () => {
+    const closingOnly: Array<AIRunEvent> = events(
+      CLOSING_ONLY_EVENT_TYPES.map((eventType: AIRunEventType): StepEvent => {
+        return { eventType, toolName: "search_logs" };
+      }),
+    );
+
+    expect(closingOnly).toHaveLength(5);
+    expect(countActivitySteps(closingOnly)).toBe(0);
+  });
+
+  test("counts the steps drawn, not the raw events", () => {
+    expect(SEARCH_LOGS_RUN).toHaveLength(3);
+    expect(countActivitySteps(SEARCH_LOGS_RUN)).toBe(2);
+
+    expect(MIXED_RUN).toHaveLength(12);
+    expect(countActivitySteps(MIXED_RUN)).toBe(MIXED_RUN_STEP_TEXTS.length);
+  });
+
+  test("a progress log only counts when it carries a message", () => {
+    expect(
+      countActivitySteps(events([{ eventType: AIRunEventType.ProgressLog }])),
+    ).toBe(0);
+    expect(
+      countActivitySteps(
+        events([
+          {
+            eventType: AIRunEventType.ProgressLog,
+            resultSummary: { message: "Cloning repository" },
+          },
+        ]),
+      ),
+    ).toBe(1);
+  });
+
+  /*
+   * Both predicates are read by the same host: one decides whether the
+   * activity panel exists, the other labels it. If they disagreed the panel
+   * could render with a "0" count, or be dropped while still having steps.
+   */
+  const agreementTrails: Array<[string, Array<AIRunEvent>]> = [
+    ["no events", []],
+    [
+      "a terminal-only trail",
+      events([{ eventType: AIRunEventType.RunFailed }]),
+    ],
+    [
+      "a message-less progress log",
+      events([{ eventType: AIRunEventType.ProgressLog }]),
+    ],
+    ["a search-logs run", SEARCH_LOGS_RUN],
+    ["a mixed run", MIXED_RUN],
+  ];
+
+  test.each(agreementTrails)(
+    "agrees with hasRenderableActivity for %s",
+    (_name: string, trail: Array<AIRunEvent>) => {
+      expect(hasRenderableActivity(trail)).toBe(countActivitySteps(trail) > 0);
+    },
+  );
+
+  test("a feed sized to the count lists every step and hides none", () => {
+    render(
+      <ChatActivityFeed
+        events={MIXED_RUN}
+        hideChrome={true}
+        maxVisibleSteps={countActivitySteps(MIXED_RUN)}
+      />,
+    );
+
+    for (const text of MIXED_RUN_STEP_TEXTS) {
+      expect(screen.getByText(text)).toBeVisible();
+    }
+
+    expect(screen.queryByText(/earlier step/)).toBeNull();
+  });
+
+  // The other direction: the count is exact, not merely large enough.
+  test("a feed sized one below the count hides exactly one step", () => {
+    render(
+      <ChatActivityFeed
+        events={MIXED_RUN}
+        hideChrome={true}
+        maxVisibleSteps={countActivitySteps(MIXED_RUN) - 1}
+      />,
+    );
+
+    expect(screen.getByText("+ 1 earlier step")).toBeVisible();
+    expect(screen.queryByText("Starting investigation")).toBeNull();
+    expect(screen.getByText("Opened pull request")).toBeVisible();
+  });
+});
+
 describe("ChatActivityFeed default chrome (chat panel and copilot)", () => {
   test("keeps its avatar, bubble, title and live indicator", () => {
     const { container } = render(<ChatActivityFeed events={SEARCH_LOGS_RUN} />);

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

@@ -595,7 +595,7 @@ describe("runConnectionTestRequest", () => {
 
       await expect(
         runConnectionTestRequest({
-          route: "/google-secops-connection/test",
+          route: "/security-event-connection/test",
           body: { connectionId: CONNECTION_ID },
         }),
       ).rejects.toThrow("The server did not return a test report");

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

@@ -68,7 +68,7 @@ function check(
 }
 
 /*
- * The counts GoogleSecOpsConnectionTester.availabilityCheck emits: the
+ * The counts the Google SecOps connector's availability check emits: the
  * saved Data to import choice at the top level, the other choice nested
  * under otherScope. Rule detection counts are strings because a full page
  * is reported as "1000+".
@@ -284,7 +284,12 @@ describe("ConnectorTestReportView", () => {
     ).not.toBeInTheDocument();
   });
 
-  test("Google SecOps reports read as Google SecOps even though it is not in the catalog", (): void => {
+  /*
+   * Google SecOps is a catalog provider now, so its reports (including
+   * those stored before the move, which carry the same "google-secops"
+   * identifier) read by the catalog title with no special case.
+   */
+  test("Google SecOps reports read by their catalog title", (): void => {
     render(
       <ConnectorTestReportView
         report={report({ provider: "google-secops", status: "pass" })}
@@ -297,6 +302,18 @@ describe("ConnectorTestReportView", () => {
     expect(screen.getByRole("status")).toHaveTextContent("Google SecOps");
   });
 
+  test("a provider the catalog does not list reads as its identifier", (): void => {
+    render(
+      <ConnectorTestReportView
+        report={report({ provider: "future-provider", status: "pass" })}
+      />,
+    );
+
+    expect(
+      screen.getByRole("region", { name: "Access to future-provider" }),
+    ).toBeVisible();
+  });
+
   test("an explicit provider title wins over the report's provider", (): void => {
     render(
       <ConnectorTestReportView
@@ -604,7 +621,7 @@ describe("diagnostics util vocabulary", () => {
   /*
    * report-counts-nested-object: the known labels were keyed on
    * ruleDetectionsLast24h and baselineAlertsLast24h, which no tester emits.
-   * They now match GoogleSecOpsConnectionTester's keys and the generic
+   * They now match the Google SecOps connector's keys and the generic
    * connectors' detections-available details, and the fallback spells out
    * the Last24h / Last7d suffixes instead of printing "last7d".
    */