Skip to content

🪢 Open source agent evals & observability: Trace, evaluate, and improve LLM applications with one open platform.

37.6 KB
Raw Blame
import type { ReactNode } from "react";
import {
  fireEvent,
  render,
  screen,
  waitFor,
  within,
} from "@testing-library/react";
import { afterEach, beforeEach, expect, it, vi } from "vitest";
import TopicsPage from "./TopicsPage";
import { LayerProvider } from "@/src/context/LayerContext/LayerContext";
import { useGlobalDateRangeStore } from "@/src/features/global-time-range/globalDateRangeStore";
import { rangeToString, type TimeRange } from "@/src/utils/date-range-utils";
import { type TopicFacet } from "@langfuse/shared/topics";

const state = vi.hoisted(() => ({
  canViewTopics: true,
  status: "failed",
  executionUpdatedAt: 110,
  updatedAt: "2026-09-23T12:00:00Z",
  retry: vi.fn(),
  refetchExecution: vi.fn(),
  dateRange: undefined as string | undefined,
  executionId: undefined as string | undefined,
  setQueryParams: vi.fn(),
  currentTopics: vi.fn(),
  showGenerateCTA: false,
  hasStoredSummaries: true,
  resultsDataAvailable: true,
  mobileHeader: false,
  resultFacets: [] as Array<{ facetId: string; name: string }>,
  openAutomaticProcessing: vi.fn(),
  picker: vi.fn(),
  push: vi.fn(),
  openConfigure: vi.fn(),
  canWrite: true,
  facets: [] as TopicFacet[],
  executions: [] as unknown[] | undefined,
  executionsError: null as Error | null,
  rulesPending: false,
  rulesError: null as Error | null,
  configurationFailure: null as "settings" | "readiness" | "connections" | null,
  settings: {} as Record<string, unknown>,
  rules: [] as Array<{ facetIds: string[] }>,
  countsPending: false,
  countsFetching: false,
  summaryCountInput: vi.fn(),
  invalidateSummaryCounts: vi.fn(),
  counts: [] as Array<{ facetId: string; facetVersion: number; count: number }>,
  trigger: vi.fn(),
}));

vi.mock("use-query-params", () => ({
  StringParam: {},
  useQueryParam: () => [undefined, vi.fn()],
  useQueryParams: () => [{ dateRange: state.dateRange }, state.setQueryParams],
}));
vi.mock("@/src/components/layouts/page-header-controls-slot", () => ({
  PageHeaderControlsPortal: ({ children }: { children: ReactNode }) => children,
}));
vi.mock("@/src/components/date-picker", () => ({
  TimeRangePicker: (props: {
    timeRange: TimeRange;
    onTimeRangeChange: (range: TimeRange) => void;
  }) => {
    state.picker(props.timeRange);
    return (
      <>
        <button
          onClick={() => props.onTimeRangeChange({ range: "last30Days" })}
        >
          Select last 30 days
        </button>
        <button
          onClick={() =>
            props.onTimeRangeChange({
              from: new Date("2026-10-01T00:00:00Z"),
              to: new Date("2026-10-08T00:00:00Z"),
            })
          }
        >
          Select custom dates
        </button>
      </>
    );
  },
}));
vi.mock("next/router", () => ({
  useRouter: () => ({
    query: { projectId: "project", executionId: state.executionId },
    push: state.push,
  }),
}));
vi.mock("@/src/components/layouts/Page", () => ({
  default: ({
    children,
    headerProps,
  }: {
    children: ReactNode;
    headerProps?: {
      actionButtonsRight?: ReactNode;
      actionButtonsMenu?: (controls: { closeMenu: () => void }) => ReactNode;
    };
  }) => (
    <>
      {state.mobileHeader
        ? headerProps?.actionButtonsMenu?.({ closeMenu: vi.fn() })
        : headerProps?.actionButtonsRight}
      {children}
    </>
  ),
}));
vi.mock("@/src/components/table/peek/hooks/usePeekNavigation", () => ({
  usePeekNavigation: () => ({}),
}));
vi.mock("@/src/components/table/peek/TablePeekViewTraceDetail", () => ({
  TablePeekViewTraceDetail: () => null,
}));
vi.mock("@/src/features/rbac/utils/checkProjectAccess", () => ({
  useHasProjectAccess: () => state.canWrite,
}));
vi.mock("@/src/components/error-page", () => ({
  ErrorPage: ({ message }: { message: string }) => <p>{message}</p>,
}));
vi.mock("@/src/features/topics/topicsAccess", () => ({
  useCanViewTopics: () => state.canViewTopics,
}));
vi.mock("./TopicTraceSelector", () => ({
  useTopicTraceSelector: () => ({
    selection: {
      count: 2,
      selection: {
        filter: [],
        from: new Date("2026-10-01T00:00:00Z"),
        to: new Date("2026-10-09T12:00:00Z"),
        limit: 2,
        sampling: "random",
        seed: "frozen-preview",
        excludedTraceIds: ["excluded-trace"],
      },
    },
    controls: <div>Trace selection</div>,
    reset: vi.fn(),
  }),
}));
vi.mock("./ConfigureTopicsDialogController", () => ({
  ConfigureTopicsDialogController: ({
    children,
  }: {
    children: (control: { openDialog: () => void }) => ReactNode;
  }) => children({ openDialog: state.openConfigure }),
}));
vi.mock("./TopicSetupFlowController", () => ({
  TopicSetupFlowController: ({
    children,
  }: {
    children: (control: { openSetup: () => void }) => ReactNode;
  }) => children({ openSetup: () => {} }),
}));
vi.mock("./AutomaticProcessingDialogController", () => ({
  AutomaticProcessingDialogController: ({
    children,
  }: {
    children: (control: { openDialog: () => void }) => ReactNode;
  }) => children({ openDialog: state.openAutomaticProcessing }),
}));
vi.mock("./CurrentTopics", () => ({
  useCurrentTopics: (input: {
    running: boolean;
    refreshAfter: number;
    timeRange: { from: Date; to: Date };
  }) => {
    state.currentTopics(input);
    return {
      ...input,
      data: state.resultsDataAvailable
        ? {
            hasStoredSummaries: state.hasStoredSummaries,
            facets: state.resultFacets,
          }
        : undefined,
      isLoading: false,
    };
  },
  CurrentTopics: ({
    result,
    onGenerateTopics,
  }: {
    result: { running: boolean; refreshAfter: number };
    onGenerateTopics: () => void;
  }) => (
    <div
      data-testid="current-topics"
      data-running={result.running}
      data-refresh-after={result.refreshAfter}
    >
      {state.showGenerateCTA && (
        <button onClick={onGenerateTopics}>Generate topics</button>
      )}
    </div>
  ),
}));
vi.mock("@/src/utils/api", () => ({
  api: {
    topics: {
      facets: {
        useQuery: () => ({
          data: state.facets,
          isLoading: false,
          isSuccess: true,
        }),
      },
      executions: {
        useQuery: () => ({
          data: state.executions,
          error: state.executionsError,
        }),
      },
      modelSettings: {
        useQuery: () => ({
          isPending: false,
          data:
            state.configurationFailure === "settings"
              ? undefined
              : state.settings,
          error:
            state.configurationFailure === "settings"
              ? new Error("Configuration unavailable.")
              : null,
        }),
      },
      tracingReadinessSettings: {
        useQuery: () => ({
          data:
            state.configurationFailure === "readiness"
              ? undefined
              : { traceIdleMs: 600_000 },
          error:
            state.configurationFailure === "readiness"
              ? new Error("Configuration unavailable.")
              : null,
        }),
      },
      setAutomaticProcessing: {
        useMutation: () => ({
          isPending: false,
          mutate: vi.fn(),
          mutateAsync: vi.fn(),
        }),
      },
      rules: {
        useQuery: () => ({
          data: state.rulesPending ? undefined : state.rules,
          isPending: state.rulesPending,
          isSuccess: !state.rulesPending && !state.rulesError,
          error: state.rulesError,
        }),
      },
      summaryCounts: {
        useQuery: (input: unknown) => {
          state.summaryCountInput(input);
          return typeof input === "symbol"
            ? { isPending: true }
            : {
                isPending: state.countsPending,
                isFetching: state.countsFetching,
                data: state.countsPending ? undefined : state.counts,
              };
        },
      },
      trigger: {
        useMutation: () => ({ mutateAsync: state.trigger, isPending: false }),
      },
      execution: {
        useQuery: () => ({
          data: {
            id: "execution",
            status: state.status,
            phase: state.status === "queued" ? "queued" : "summarizing",
            createdAt: "2026-09-23T12:00:00Z",
            updatedAt: state.updatedAt,
            input: {
              operation: "process",
              embeddingConfig: { embeddingDimensions: 1024 },
            },
            facets: [],
            error: null,
          },
          dataUpdatedAt: state.executionUpdatedAt,
          refetch: state.refetchExecution,
        }),
      },
      traceErrors: { useQuery: () => ({}) },
      retry: {
        useMutation: ({ onSuccess }: { onSuccess: () => void }) => ({
          mutate: (input: unknown) => {
            state.retry(input);
            state.status = "queued";
            state.executionUpdatedAt = 120;
            onSuccess();
          },
        }),
      },
    },
    llmApiKey: {
      effective: {
        useQuery: () => ({
          data:
            state.configurationFailure === "connections"
              ? undefined
              : { data: [] },
          error:
            state.configurationFailure === "connections"
              ? new Error("Configuration unavailable.")
              : null,
        }),
      },
    },
    useUtils: () => ({
      topics: {
        modelSettings: { invalidate: vi.fn() },
        rules: { invalidate: vi.fn() },
        executions: { invalidate: vi.fn() },
        summaryCounts: { invalidate: state.invalidateSummaryCounts },
      },
    }),
  },
}));

beforeEach(() => {
  vi.clearAllMocks();
  vi.useFakeTimers({ toFake: ["Date"] });
  vi.setSystemTime(new Date("2026-10-09T12:00:00Z"));
  vi.stubGlobal(
    "ResizeObserver",
    class {
      observe() {}
      unobserve() {}
      disconnect() {}
    },
  );
  state.showGenerateCTA = false;
  state.canViewTopics = true;
  state.resultsDataAvailable = true;
  state.mobileHeader = false;
  state.resultFacets = [];
  state.hasStoredSummaries = true;
  state.status = "failed";
  state.executionUpdatedAt = 110;
  state.updatedAt = "2026-09-23T12:00:00Z";
  state.dateRange = undefined;
  state.executionId = undefined;
  state.canWrite = true;
  state.facets = [];
  state.executions = [];
  state.executionsError = null;
  state.rulesPending = false;
  state.rulesError = null;
  state.configurationFailure = null;
  state.settings = {
    summary: { model: "summary" },
    embedding: { model: "embedding" },
    embeddingDimensions: 1024,
    clustering: { model: "clustering" },
    blockedAt: null,
    blockMessage: null,
  };
  state.rules = [];
  state.counts = [];
  state.countsPending = false;
  state.countsFetching = false;
  state.trigger.mockReset().mockResolvedValue({ id: "regenerated" });
  state.setQueryParams.mockImplementation(
    ({ dateRange }: { dateRange: string }) => {
      state.dateRange = dateRange;
    },
  );
  useGlobalDateRangeStore.persist.setOptions({
    storage: { getItem: () => null, setItem: vi.fn(), removeItem: vi.fn() },
  });
  useGlobalDateRangeStore.setState({ defaultsByProject: {} });
});

afterEach(() => {
  vi.unstubAllGlobals();
  vi.useRealTimers();
});

it("shows Not found instead of the workspace when the Topics gate is closed", () => {
  state.canViewTopics = false;
  render(<TopicsPage />, { wrapper: LayerProvider });
  expect(screen.getByText("This page is not available.")).toBeTruthy();
  expect(state.currentTopics).not.toHaveBeenCalled();
});

it("keeps facet, view, and automatic processing reachable with the mobile header", () => {
  state.mobileHeader = true;
  state.resultFacets = [{ facetId: "intent", name: "Intent" }];
  state.rules = [{ facetIds: ["intent"] }];
  const view = render(<TopicsPage />);
  expect(screen.getByRole("combobox", { name: "Topics facet" })).toBeTruthy();
  expect(screen.getByRole("combobox", { name: "Topics view" })).toBeTruthy();
  fireEvent.click(screen.getByRole("button", { name: /^Analyze/ }));
  expect(state.openAutomaticProcessing).toHaveBeenCalledWith(false);
  state.canWrite = false;
  view.rerender(<TopicsPage />);
  expect(
    screen.getByRole("button", { name: /^Analyze/ }).hasAttribute("disabled"),
  ).toBe(true);
});

it.each([
  ["30d", 30 * 24 * 60],
  ["5m", 5],
  ["6h", 6 * 60],
])(
  "uses the shared project range %s for results and processing",
  (token, minutes) => {
    useGlobalDateRangeStore
      .getState()
      .actions.setProjectDefault("project", token);
    render(<TopicsPage />, { wrapper: LayerProvider });
    const { timeRange } = state.currentTopics.mock.lastCall![0];
    expect(timeRange.to.getTime() - timeRange.from.getTime()).toBe(
      minutes * 60_000,
    );

    fireEvent.click(
      screen.getByRole("button", { name: "Select last 30 days" }),
    );
    expect(state.dateRange).toBe("30d");
    expect(useGlobalDateRangeStore.getState().defaultsByProject.project).toBe(
      "30d",
    );
  },
);

it("keeps a URL custom range fixed when an execution completes", () => {
  const timeRange = {
    from: new Date("2026-09-01T12:34:00Z"),
    to: new Date("2026-09-02T15:45:00Z"),
  };
  state.dateRange = rangeToString(timeRange);
  state.status = "running";
  const view = render(<TopicsPage />, { wrapper: LayerProvider });
  expect(state.currentTopics).toHaveBeenLastCalledWith(
    expect.objectContaining({ timeRange }),
  );

  state.status = "completed";
  view.rerender(<TopicsPage />);
  expect(state.currentTopics).toHaveBeenLastCalledWith(
    expect.objectContaining({ timeRange }),
  );
});

it.each(["stored", "URL"])(
  "caps an inherited one-year %s range without changing the shared selection",
  (source) => {
    useGlobalDateRangeStore
      .getState()
      .actions.setProjectDefault("project", "1y");
    state.dateRange = source === "URL" ? "1y" : undefined;
    render(<TopicsPage />, { wrapper: LayerProvider });

    const { timeRange } = state.currentTopics.mock.lastCall![0];
    expect(timeRange).toEqual({
      from: new Date(Date.now() - 90 * 86_400_000),
      to: new Date(),
    });
    expect(state.picker).toHaveBeenLastCalledWith({ range: "last90Days" });
    expect(screen.getByTestId("current-topics")).toBeInTheDocument();
    expect(screen.getByRole("status", { name: "" })).toHaveTextContent(
      "Your selection is preserved on other pages.",
    );
    expect(state.setQueryParams).not.toHaveBeenCalled();
    expect(state.dateRange).toBe(source === "URL" ? "1y" : undefined);
    expect(useGlobalDateRangeStore.getState().defaultsByProject.project).toBe(
      "1y",
    );

    fireEvent.click(
      screen.getByRole("button", { name: "Select last 30 days" }),
    );
    expect(state.dateRange).toBe("30d");
    expect(useGlobalDateRangeStore.getState().defaultsByProject.project).toBe(
      "30d",
    );
    expect(state.picker).toHaveBeenLastCalledWith({ range: "last30Days" });
    expect(screen.queryByRole("status", { name: "" })).not.toBeInTheDocument();
  },
);

it("caps a custom range at its original end and preserves its URL through completion", () => {
  const requested = {
    from: new Date("2026-03-01T12:34:00Z"),
    to: new Date("2026-09-02T15:45:00Z"),
  };
  const expected = {
    from: new Date(requested.to.getTime() - 90 * 86_400_000),
    to: requested.to,
  };
  state.dateRange = rangeToString(requested);
  state.status = "running";
  const view = render(<TopicsPage />, { wrapper: LayerProvider });
  expect(state.currentTopics).toHaveBeenLastCalledWith(
    expect.objectContaining({ timeRange: expected }),
  );
  expect(state.picker).toHaveBeenLastCalledWith(expected);
  expect(screen.getByRole("status", { name: "" })).toHaveTextContent(
    "final 90 days of your selected range",
  );

  state.status = "completed";
  view.rerender(<TopicsPage />);
  expect(state.currentTopics).toHaveBeenLastCalledWith(
    expect.objectContaining({ timeRange: expected }),
  );
  expect(state.setQueryParams).not.toHaveBeenCalled();
  expect(state.dateRange).toBe(rangeToString(requested));
  expect(useGlobalDateRangeStore.getState().defaultsByProject).toEqual({});
});

it.each([
  { range: "last90Days" },
  {
    from: new Date("2026-04-01T15:45:00Z"),
    to: new Date(new Date("2026-04-01T15:45:00Z").getTime() + 90 * 86_400_000),
  },
] satisfies TimeRange[])(
  "leaves an exact 90-day range unchanged: %j",
  (timeRange) => {
    state.dateRange = rangeToString(timeRange);
    render(<TopicsPage />, { wrapper: LayerProvider });
    expect(state.picker).toHaveBeenLastCalledWith(timeRange);
    expect(screen.queryByRole("status", { name: "" })).not.toBeInTheDocument();
    expect(state.setQueryParams).not.toHaveBeenCalled();
    expect(screen.getByTestId("current-topics")).toBeInTheDocument();
  },
);

it("refreshes current results through retry and completion for a selected run outside history", () => {
  state.executionId = "execution";
  const view = render(<TopicsPage />, { wrapper: LayerProvider });
  const status = screen.getByRole("dialog", { name: "Analyze traces" });
  fireEvent.click(within(status).getByRole("button", { name: "Resume run" }));
  expect(state.retry).toHaveBeenCalledWith({
    projectId: "project",
    executionId: "execution",
  });
  expect(state.refetchExecution).toHaveBeenCalledOnce();
  view.rerender(<TopicsPage />);
  expect(within(status).getByRole("status")).toHaveTextContent(
    "Waiting for a worker",
  );
  const current = screen.getByTestId("current-topics");
  expect(current).toHaveAttribute("data-running", "true");
  expect(current).toHaveAttribute("data-refresh-after", "0");

  state.status = "completed";
  state.updatedAt = "2026-09-23T12:01:00Z";
  state.executionUpdatedAt = 130;
  view.rerender(<TopicsPage />);
  expect(current).toHaveAttribute("data-running", "false");
  const completedAt = String(new Date(state.updatedAt).getTime());
  expect(current).toHaveAttribute("data-refresh-after", completedAt);

  state.executionUpdatedAt = 140;
  view.rerender(<TopicsPage />);
  expect(current).toHaveAttribute("data-refresh-after", completedAt);
});

it("holds relative bounds between renders and advances them after completion", () => {
  state.status = "running";
  const view = render(<TopicsPage />, { wrapper: LayerProvider });
  const initialRange = state.currentTopics.mock.lastCall![0].timeRange;

  vi.setSystemTime(new Date("2026-10-09T12:01:00Z"));
  view.rerender(<TopicsPage />);
  expect(state.currentTopics.mock.lastCall![0].timeRange).toEqual(initialRange);

  state.status = "completed";
  state.updatedAt = "2026-10-09T12:01:00Z";
  view.rerender(<TopicsPage />);
  expect(state.currentTopics.mock.lastCall![0].timeRange).toEqual({
    from: new Date("2026-10-02T12:01:00Z"),
    to: new Date("2026-10-09T12:01:00Z"),
  });
});

const facet = (id: string, versions: number[]): TopicFacet => ({
  id,
  projectId: "project",
  name: id,
  description: "",
  isBuiltIn: true,
  versions: versions.map((version) => ({
    projectId: "project",
    facetId: id,
    version,
    prompt: "",
    createdAt: "2026-10-01T00:00:00Z",
  })),
});
const execution = (status: string, operation: "process" | "update") => ({
  id: `${operation}-${status}`,
  status,
  createdAt: "2026-10-09T11:00:00Z",
  updatedAt: "2026-10-09T11:00:00Z",
  input: { operation },
  facets: [],
});
/** Opens the manual dialog from the header menu; "process" switches to its summarize tab. */
async function openManualDialog(operation: "process" | "update" = "update") {
  fireEvent.click(screen.getByRole("button", { name: "Topics actions" }));
  fireEvent.click(
    await screen.findByRole("menuitem", { name: "Regenerate topics" }),
  );
  if (operation === "process")
    fireEvent.mouseDown(
      screen.getByRole("tab", { name: "Summarize traces & embed" }),
      { button: 0, ctrlKey: false },
    );
}
function withSummaries() {
  state.facets = [
    facet("intent", [2, 1]),
    facet("outcome", [1]),
    facet("language", [1]),
  ];
  state.rules = [{ facetIds: ["intent", "outcome"] }];
  state.counts = [
    { facetId: "intent", facetVersion: 2, count: 240 },
    { facetId: "outcome", facetVersion: 1, count: 0 },
  ];
}

it("shows Analyze in the header while auto-analyze is off and keeps Analyze, regenerate, history and settings in the menu", async () => {
  withSummaries();
  render(<TopicsPage />, { wrapper: LayerProvider });
  fireEvent.click(screen.getByRole("button", { name: "Analyze" }));
  expect(state.openAutomaticProcessing).toHaveBeenCalledWith(false);
  fireEvent.click(screen.getByRole("button", { name: "Topics actions" }));
  const items = await screen.findAllByRole("menuitem");
  expect(items.map((item) => item.textContent)).toEqual([
    "AnalyzeOff",
    "Regenerate topics",
    "History",
    "Settings",
  ]);
});

it("shows a paused auto-analyze status with its short reason", () => {
  withSummaries();
  state.settings.blockedAt = "2026-10-09T10:00:00Z";
  state.settings.blockMessage = "Fix the connection.";
  render(<TopicsPage />, { wrapper: LayerProvider });
  const control = screen.getByRole("button", { name: "Auto-analyze: Paused" });
  expect(control).toHaveAttribute("title", "Paused");
  fireEvent.click(control);
  expect(state.openAutomaticProcessing).toHaveBeenCalledWith(false);
});

it.each([
  {
    name: "without topics:CUD",
    setup: () => {
      state.canWrite = false;
    },
    reason: "You need permission to manage Topics in this project.",
  },
  {
    name: "while Topics is paused",
    setup: () => {
      state.settings.blockedAt = "2026-10-09T10:00:00Z";
      state.settings.blockMessage = "Fix the connection.";
    },
    reason: "Topics is paused. Fix the connection.",
  },
  {
    name: "while any Topics run is in progress",
    setup: () => {
      state.executions = [execution("running", "process")];
    },
    reason: "A Topics run is in progress. Wait for it to finish.",
  },
  {
    name: "before any summaries exist",
    setup: () => {
      state.counts = [];
    },
    reason:
      "No trace summaries in the selected time range yet. Summarize traces first, then regenerate.",
  },
])("disables Generate topics $name", async ({ setup, reason }) => {
  withSummaries();
  setup();
  render(<TopicsPage />, { wrapper: LayerProvider });
  await openManualDialog();
  fireEvent.mouseDown(screen.getByRole("tab", { name: "Generate topics" }), {
    button: 0,
    ctrlKey: false,
  });
  expect(
    screen.getByRole("button", { name: "Generate topics" }),
  ).toBeDisabled();
  expect(screen.getByText(reason)).toBeInTheDocument();
});

it("requires an eligible selected facet and applies the small-sample threshold before generating topics", async () => {
  withSummaries();
  state.counts = [
    { facetId: "intent", facetVersion: 2, count: 13 },
    { facetId: "outcome", facetVersion: 1, count: 9 },
  ];
  render(<TopicsPage />, { wrapper: LayerProvider });
  await openManualDialog();
  fireEvent.mouseDown(screen.getByRole("tab", { name: "Generate topics" }), {
    button: 0,
    ctrlKey: false,
  });
  const submit = screen.getByRole("button", { name: "Generate topics" });
  expect(submit).toBeDisabled();
  fireEvent.click(submit);
  expect(state.trigger).not.toHaveBeenCalled();

  fireEvent.click(screen.getByRole("switch", { name: "Small sample mode" }));
  expect(submit).toBeEnabled();
  fireEvent.click(screen.getByRole("checkbox", { name: "intent" }));
  expect(submit).toBeDisabled();
  fireEvent.click(submit);
  expect(state.trigger).not.toHaveBeenCalled();

  fireEvent.click(screen.getByRole("checkbox", { name: "intent" }));
  fireEvent.click(submit);
  await waitFor(() =>
    expect(state.trigger).toHaveBeenCalledWith(
      expect.objectContaining({ exploratory: true, minimumTraceCount: 10 }),
    ),
  );
});

it("counts summaries only while the open manual dialog is generating topics", async () => {
  withSummaries();
  render(<TopicsPage />, { wrapper: LayerProvider });
  const countRequests = () =>
    state.summaryCountInput.mock.calls.filter(
      ([input]) => typeof input !== "symbol",
    );
  expect(countRequests()).toHaveLength(0);
  await openManualDialog();
  expect(countRequests().length).toBeGreaterThan(0);
  const generatingRequests = countRequests().length;
  fireEvent.mouseDown(
    screen.getByRole("tab", { name: "Summarize traces & embed" }),
    { button: 0, ctrlKey: false },
  );
  expect(countRequests()).toHaveLength(generatingRequests);
  fireEvent.click(screen.getByRole("button", { name: "Cancel" }));
  await waitFor(() => expect(screen.queryByRole("dialog")).toBeNull());
  expect(countRequests()).toHaveLength(generatingRequests);
});

it("keeps summary loading and refetching out of validation warnings", async () => {
  withSummaries();
  state.counts = state.counts.map((count) => ({ ...count, count: 240 }));
  state.countsPending = true;
  state.countsFetching = true;
  const page = render(<TopicsPage />, { wrapper: LayerProvider });
  await openManualDialog();
  fireEvent.mouseDown(screen.getByRole("tab", { name: "Generate topics" }), {
    button: 0,
    ctrlKey: false,
  });
  const dialog = within(
    screen.getByRole("dialog", { name: "Manual processing" }),
  );
  expect(
    dialog.getByRole("button", { name: "Generate topics" }),
  ).toBeDisabled();
  expect(dialog.queryByRole("alert")).toBeNull();
  expect(dialog.getByRole("status")).toHaveTextContent(/^2 facets selected$/);
  state.countsPending = false;
  state.countsFetching = false;
  page.rerender(<TopicsPage />);
  expect(dialog.getByRole("button", { name: "Generate topics" })).toBeEnabled();
  expect(dialog.getAllByText("240 summaries")[0]).toBeVisible();
  expect(dialog.getByRole("status")).toHaveTextContent(
    "2 facets selected · 480 stored summaries",
  );
  state.countsFetching = true;
  page.rerender(<TopicsPage />);
  expect(dialog.getAllByText("240 summaries")[0]).toBeVisible();
  expect(dialog.getByRole("status")).toHaveTextContent(
    "2 facets selected · 480 stored summaries",
  );
  expect(dialog.queryByRole("alert")).toBeNull();
  expect(
    dialog.getByRole("button", { name: "Generate topics" }),
  ).toBeDisabled();
});

it("regenerates the rule's facets that have summaries, at their latest version, over its default seven-day range, then opens the run", async () => {
  withSummaries();
  state.executions = [execution("completed", "update")];
  render(<TopicsPage />, { wrapper: LayerProvider });
  await openManualDialog();
  fireEvent.mouseDown(screen.getByRole("tab", { name: "Generate topics" }), {
    button: 0,
    ctrlKey: false,
  });

  const dialog = screen.getByRole("dialog", { name: "Manual processing" });
  expect(
    within(dialog).getByRole("checkbox", { name: "outcome" }),
  ).toBeChecked();
  expect(
    within(dialog).queryByRole("checkbox", { name: "language" }),
  ).toBeNull();
  fireEvent.click(
    within(dialog).getByRole("button", { name: "Generate topics" }),
  );

  await waitFor(() =>
    expect(state.push).toHaveBeenCalledWith(
      expect.objectContaining({
        query: expect.objectContaining({ executionId: "regenerated" }),
      }),
      undefined,
      { shallow: true },
    ),
  );
  expect(state.trigger).toHaveBeenCalledWith({
    projectId: "project",
    operation: "update",
    facets: [
      { facetId: "intent", version: 2 },
      { facetId: "outcome", version: 1 },
    ],
    exploratory: false,
    timeRange: {
      from: new Date("2026-10-02T12:00:00Z"),
      to: new Date("2026-10-09T12:00:00Z"),
    },
    minimumTraceCount: 100,
    requestId: expect.any(String),
  });
});

it("shows a regenerate failure that settles after the dialog was closed and reopened, and retries with the same requestId", async () => {
  withSummaries();
  let fail: (error: Error) => void = () => {};
  state.trigger.mockImplementationOnce(
    () => new Promise((_, reject) => (fail = reject)),
  );
  render(<TopicsPage />, { wrapper: LayerProvider });
  const open = async () => {
    await openManualDialog();
    fireEvent.mouseDown(screen.getByRole("tab", { name: "Generate topics" }), {
      button: 0,
      ctrlKey: false,
    });
    return screen.getByRole("dialog", { name: "Manual processing" });
  };

  fireEvent.click(
    within(await open()).getByRole("button", { name: "Generate topics" }),
  );
  fireEvent.click(screen.getByRole("button", { name: "Cancel" }));
  await waitFor(() => expect(screen.queryByRole("dialog")).toBeNull());
  const reopened = await open();
  fail(new Error("Clustering connection failed."));

  expect(
    await within(reopened).findByText("Clustering connection failed."),
  ).toBeInTheDocument();
  fireEvent.click(
    within(reopened).getByRole("button", { name: "Generate topics" }),
  );
  await waitFor(() => expect(state.trigger).toHaveBeenCalledTimes(2));
  const [first, second] = state.trigger.mock.calls.map(
    ([input]) => (input as { requestId: string }).requestId,
  );
  expect(second).toBe(first);
});

it("summarizes the frozen trace selection for active facets and opens the progress drawer", async () => {
  withSummaries();
  render(<TopicsPage />, { wrapper: LayerProvider });
  await openManualDialog("process");
  const dialog = screen.getByRole("dialog", { name: "Manual processing" });
  fireEvent.click(
    within(dialog).getByRole("button", { name: "Summarize & embed" }),
  );

  await waitFor(() =>
    expect(state.push).toHaveBeenCalledWith(
      expect.objectContaining({
        query: expect.objectContaining({ executionId: "regenerated" }),
      }),
      undefined,
      { shallow: true },
    ),
  );
  expect(state.trigger).toHaveBeenCalledWith({
    projectId: "project",
    operation: "process",
    facets: [
      { facetId: "intent", version: 2 },
      { facetId: "outcome", version: 1 },
    ],
    reuseExistingSummaries: true,
    selection: {
      filter: [],
      from: new Date("2026-10-01T00:00:00Z"),
      to: new Date("2026-10-09T12:00:00Z"),
      limit: 2,
      sampling: "random",
      seed: "frozen-preview",
      excludedTraceIds: ["excluded-trace"],
    },
    requestId: expect.any(String),
  });
  expect(screen.queryByRole("dialog")).toBeNull();
});

it("hands off from manual processing to Topics model configuration", async () => {
  withSummaries();
  render(<TopicsPage />, { wrapper: LayerProvider });
  await openManualDialog("process");
  const dialog = screen.getByRole("dialog", { name: "Manual processing" });
  fireEvent.click(
    within(dialog).getByRole("button", { name: "Configure Topics" }),
  );
  expect(state.openConfigure).toHaveBeenCalledOnce();
  await waitFor(() =>
    expect(
      screen.queryByRole("dialog", { name: "Manual processing" }),
    ).toBeNull(),
  );
  expect(state.trigger).not.toHaveBeenCalled();
});

it("freezes an independent generation range for summary counts and submission", async () => {
  withSummaries();
  render(<TopicsPage />, { wrapper: LayerProvider });
  await openManualDialog();
  fireEvent.mouseDown(screen.getByRole("tab", { name: "Generate topics" }), {
    button: 0,
    ctrlKey: false,
  });
  const dialog = screen.getByRole("dialog", { name: "Manual processing" });
  fireEvent.click(
    within(dialog).getByRole("button", { name: "Select last 30 days" }),
  );
  const expectedRange = {
    from: new Date("2026-09-09T12:00:00Z"),
    to: new Date("2026-10-09T12:00:00Z"),
  };
  expect(state.summaryCountInput).toHaveBeenLastCalledWith(
    expect.objectContaining({ timeRange: expectedRange }),
  );
  vi.setSystemTime(new Date("2026-10-09T12:05:00Z"));
  fireEvent.click(
    within(dialog).getByRole("button", { name: "Generate topics" }),
  );
  await waitFor(() => expect(state.trigger).toHaveBeenCalled());
  expect(state.trigger.mock.lastCall![0].timeRange).toEqual({
    from: new Date("2026-09-09T12:00:00Z"),
    to: new Date("2026-10-09T12:00:00Z"),
  });
  expect(state.setQueryParams).not.toHaveBeenCalled();
});

it.each(["relative", "absolute"])(
  "refreshes summary counts on reopening and preserves %s range semantics",
  async (rangeKind) => {
    withSummaries();
    state.counts = [];
    const view = render(<TopicsPage />, { wrapper: LayerProvider });
    await openManualDialog();
    if (rangeKind === "absolute") {
      fireEvent.mouseDown(
        screen.getByRole("tab", { name: "Generate topics" }),
        { button: 0, ctrlKey: false },
      );
      fireEvent.click(
        within(screen.getByRole("dialog")).getByRole("button", {
          name: "Select custom dates",
        }),
      );
    }
    expect(state.invalidateSummaryCounts).toHaveBeenCalledWith({
      projectId: "project",
    });
    fireEvent.click(screen.getByRole("button", { name: "Cancel" }));
    await waitFor(() => expect(screen.queryByRole("dialog")).toBeNull());
    state.counts = [{ facetId: "intent", facetVersion: 2, count: 120 }];
    vi.setSystemTime(new Date("2026-10-10T12:00:00Z"));
    view.rerender(<TopicsPage />);
    await openManualDialog();
    expect(state.invalidateSummaryCounts).toHaveBeenCalledTimes(2);
    fireEvent.mouseDown(screen.getByRole("tab", { name: "Generate topics" }), {
      button: 0,
      ctrlKey: false,
    });
    expect(
      screen.getByRole("button", { name: "Generate topics" }),
    ).toBeEnabled();
    const expectedRange =
      rangeKind === "relative"
        ? {
            from: new Date("2026-10-03T12:00:00Z"),
            to: new Date("2026-10-10T12:00:00Z"),
          }
        : {
            from: new Date("2026-10-01T00:00:00Z"),
            to: new Date("2026-10-08T00:00:00Z"),
          };
    expect(state.summaryCountInput.mock.lastCall![0].timeRange).toEqual(
      expectedRange,
    );
    vi.setSystemTime(new Date("2026-10-10T12:05:00Z"));
    fireEvent.click(screen.getByRole("button", { name: "Generate topics" }));
    await waitFor(() => expect(state.trigger).toHaveBeenCalled());
    expect(state.trigger.mock.lastCall![0].timeRange).toEqual(expectedRange);
  },
);

it.each(["settings", "readiness", "connections"] as const)(
  "shows a failed %s configuration query and recovers after it succeeds",
  async (query) => {
    withSummaries();
    state.configurationFailure = query;
    const view = render(<TopicsPage />, { wrapper: LayerProvider });
    await openManualDialog("process");
    expect(
      screen.getByText(
        /Could not load Topics configuration: Configuration unavailable\./,
      ),
    ).toBeInTheDocument();
    expect(
      screen.queryByText("Loading Topics configuration…"),
    ).not.toBeInTheDocument();
    expect(
      screen.getByRole("button", { name: "Summarize & embed" }),
    ).toBeDisabled();
    fireEvent.mouseDown(screen.getByRole("tab", { name: "Generate topics" }), {
      button: 0,
      ctrlKey: false,
    });
    expect(
      screen.getByRole("button", { name: "Generate topics" }),
    ).toBeDisabled();
    expect(state.trigger).not.toHaveBeenCalled();
    state.configurationFailure = null;
    view.rerender(<TopicsPage />);
    expect(
      screen.getByRole("button", { name: "Generate topics" }),
    ).toBeEnabled();
    expect(
      screen.queryByText(/Could not load Topics configuration/),
    ).not.toBeInTheDocument();
  },
);

it.each([
  ["loading rules", "Checking the active Topics facets…"],
  ["failed rules", "Could not load active Topics facets: Rules unavailable."],
  ["loading runs", "Checking for Topics runs in progress…"],
  ["failed runs", "Could not check Topics runs: Runs unavailable."],
])(
  "blocks both operations while prerequisites are unknown: %s",
  async (condition, reason) => {
    withSummaries();
    if (condition === "loading rules") state.rulesPending = true;
    if (condition === "failed rules")
      state.rulesError = new Error("Rules unavailable.");
    if (condition === "loading runs") state.executions = undefined;
    if (condition === "failed runs")
      state.executionsError = new Error("Runs unavailable.");
    const { rerender } = render(<TopicsPage />, { wrapper: LayerProvider });
    await openManualDialog("process");
    expect(
      screen.getByRole("button", { name: "Summarize & embed" }),
    ).toBeDisabled();
    expect(screen.getByText(reason)).toBeInTheDocument();
    fireEvent.mouseDown(screen.getByRole("tab", { name: "Generate topics" }), {
      button: 0,
      ctrlKey: false,
    });
    expect(
      screen.getByRole("button", { name: "Generate topics" }),
    ).toBeDisabled();
    expect(state.summaryCountInput.mock.lastCall![0]).toEqual(
      expect.any(Symbol),
    );
    expect(state.trigger).not.toHaveBeenCalled();
    state.rulesPending = false;
    state.rulesError = null;
    state.executions = [];
    state.executionsError = null;
    rerender(<TopicsPage />);
    expect(
      screen.getByRole("button", { name: "Generate topics" }),
    ).toBeEnabled();
    expect(
      screen.queryByRole("checkbox", { name: "language" }),
    ).not.toBeInTheDocument();
  },
);

it("shows the setup landing until the project's first stored summary exists", () => {
  state.hasStoredSummaries = false;
  const view = render(<TopicsPage />, { wrapper: LayerProvider });
  expect(screen.getByRole("button", { name: "Set up topics" })).toBeEnabled();
  expect(screen.queryByRole("button", { name: /^Analyze/ })).toBeNull();
  expect(screen.queryByTestId("current-topics")).toBeNull();
  state.hasStoredSummaries = true;
  view.rerender(<TopicsPage />);
  expect(screen.getByTestId("current-topics")).toBeVisible();
  expect(screen.queryByRole("button", { name: "Set up topics" })).toBeNull();
});

it("opens generation directly from the empty topics panel", () => {
  withSummaries();
  state.showGenerateCTA = true;
  render(<TopicsPage />, { wrapper: LayerProvider });
  fireEvent.click(screen.getByRole("button", { name: "Generate topics" }));
  const dialog = within(
    screen.getByRole("dialog", { name: "Manual processing" }),
  );
  expect(dialog.getByRole("tab", { name: "Generate topics" })).toHaveAttribute(
    "aria-selected",
    "true",
  );
  expect(dialog.getByRole("button", { name: "Generate topics" })).toBeEnabled();
});

it("keeps date controls reachable when a disabled results query has no data", () => {
  state.resultsDataAvailable = false;
  state.dateRange = rangeToString({
    from: new Date("2026-10-10T00:00:00Z"),
    to: new Date("2026-10-09T00:00:00Z"),
  });
  render(<TopicsPage />, { wrapper: LayerProvider });
  expect(
    screen.getByRole("button", { name: "Select last 30 days" }),
  ).toBeVisible();
  expect(screen.queryByText("See what your traces are about")).toBeNull();
});