Skip to content
Python
8.9 KB
Raw Blame
import {
  cleanup,
  fireEvent,
  render,
  screen,
  within,
} from "@testing-library/react";
import { afterEach, describe, expect, it, vi } from "vitest";
import { getI18n } from "react-i18next";
import { Markdown } from "./Markdown";
import { TaskBoardContext, OPEN_TASK_EVENT } from "./TaskChip";
import {
  TeamUpdateLine,
  foldTeamUpdates,
  summarizeUpdates,
  TeamCreatedLine,
} from "./TeamUpdateLine";
import { TeamQuickLook, TeamView } from "./TeamView";
import { sampleTeam } from "../gallery/states/team-view";
import type { Item } from "../types";
import type { MessageSource } from "../api";
import { itemsFromMessages } from "../itemsFromMessages";

const source: MessageSource = {
  connector: "board",
  kind: "channel",
  channel_id: "acme",
  channel_name: "Acme",
  sender_id: "board",
  sender_name: "Board",
  text: "",
  ts: 1,
  board: {
    rows: [
      {
        kind: "moved",
        item: 1,
        title: "Refund rounding",
        from: "open",
        to: "in_progress",
        actor: "sam",
      },
    ],
  },
};
const wake: Item = { kind: "connector", source };
const tool: Item = {
  kind: "tool",
  id: "tool",
  name: "list_items",
  args: {},
  status: "ok",
};
afterEach(cleanup);

describe("team update lines", () => {
  it("folds adjacent wakes across tools without dropping the steps", () => {
    const result = foldTeamUpdates([wake, tool, wake]);
    expect(result).toHaveLength(1);
    expect(result[0].sources).toHaveLength(2);
    expect(result[0].steps).toEqual([tool]);
  });
  it.each<Item>([
    { kind: "user", text: "Keep the scope narrow" },
    { kind: "assistant", text: "Ready for review" },
    { kind: "assistant", text: "", reasoning: "Reviewing the evidence" },
    { kind: "notice", text: "Interrupted", tone: "warn" },
    {
      kind: "approval",
      name: "run_shell",
      args: {},
      reason: "Approval",
      resolved: "once",
    },
    { kind: "connector", source: { ...source, connector: "slack" } },
  ])(
    "does not fold across a visible or decision boundary: $kind",
    (boundary) => {
      expect(
        foldTeamUpdates([wake, boundary, wake]).filter((r) => r.sources),
      ).toHaveLength(2);
    },
  );
  it("does not join different boards", () => {
    expect(
      foldTeamUpdates([
        wake,
        { kind: "connector", source: { ...source, channel_id: "other" } },
      ]),
    ).toHaveLength(2);
  });
  it("folds routine narration and trailing steps but preserves the final answer", () => {
    const narration: Item = { kind: "assistant", text: "I will check the board." };
    const answer: Item = { kind: "assistant", text: "The release is ready." };
    const result = foldTeamUpdates([wake, narration, tool, wake, tool, answer]);
    expect(result).toHaveLength(2);
    expect(result[0].sources).toHaveLength(2);
    expect(result[0].steps).toEqual([narration, tool, tool]);
    expect(result[1].item).toBe(answer);
  });
  it("does not hide a verdict before a final board transition or a pending approval", () => {
    const answer: Item = { kind: "assistant", text: "The tests pass. Accepted." };
    const transition: Item = { ...tool, name: "transition", args: { to: "done" } };
    expect(foldTeamUpdates([wake, answer, transition])[1].item).toBe(answer);
    const approval: Item = { kind: "approval", name: "run_shell", args: {}, reason: "Review" };
    expect(foldTeamUpdates([wake, tool, approval, wake])).toHaveLength(3);
  });
  it("retains a typed timer reminder when expanded, including on replay", () => {
    const timer = { ...source, text: "Check the verification result", board: { rows: [], check_in: true } };
    render(<TeamUpdateLine sources={[timer]} />);
    expect(screen.getByTestId("team-update").textContent).toContain(timer.text);
    const replay = itemsFromMessages([{ role: "user", content: timer.text, source: timer }]);
    expect(foldTeamUpdates([...replay, tool, wake])[0].sources).toHaveLength(2);
  });
  it("renders a quiet disclosure and no worker note", () => {
    render(
      <TeamUpdateLine
        sources={[
          {
            ...source,
            board: {
              rows: [
                {
                  kind: "comment",
                  item: 1,
                  title: "Refund",
                  actor: "sam",
                  note: "PRIVATE LONG NOTE",
                },
              ],
            },
          },
        ]}
      />,
    );
    expect(screen.getByTestId("team-update").tagName).toBe("DETAILS");
    expect(screen.getByTestId("team-update").hasAttribute("open")).toBe(false);
    expect(screen.queryByText(/PRIVATE LONG NOTE/)).toBeNull();
  });
  it.each([
    "assigned",
    "claimed",
    "filed",
    "comment",
    "chat",
    "waiting",
    "future_kind",
  ])("handles %s without raw note parsing", (kind) => {
    const text = summarizeUpdates(
      [{ kind, actor: "sam", note: "DO NOT RENDER" }],
      getI18n().t.bind(getI18n()),
    );
    expect(text).not.toContain("DO NOT RENDER");
    expect(text).not.toContain("teamview.");
  });
  it("uses successful staffing data on replay", () => {
    const items = itemsFromMessages([
      {
        role: "tool",
        content: "ok",
        _display: {
          team_created: {
            team_id: "t",
            workers: [{ actor: "sam", persona: "swe-worker" }],
          },
        },
      },
    ]);
    expect(items[0].kind).toBe("teamcreated");
    render(
      <TeamCreatedLine workers={[{ actor: "sam", persona: "swe-worker" }]} />,
    );
    expect(screen.getByTestId("team-created").textContent).toContain(
      "1 worker",
    );
  });
});

describe("task chips", () => {
  it("uses the current title and a scoped click event", () => {
    const s = sampleTeam();
    const listener = vi.fn();
    window.addEventListener(OPEN_TASK_EVENT, listener);
    const { rerender } = render(
      <TaskBoardContext.Provider
        value={{
          board: { space: s.space, name: "Acme", items: s.items },
          sessionId: s.lead_session,
        }}
      >
        <Markdown text="[Old title](task:1)" />
      </TaskBoardContext.Provider>,
    );
    fireEvent.click(screen.getByTestId("task-chip-1"));
    expect(screen.getByTestId("task-chip-1").textContent).toBe(
      "Fix refund rounding",
    );
    expect((listener.mock.calls[0][0] as CustomEvent).detail).toEqual({
      id: 1,
      sessionId: s.lead_session,
      space: s.space,
    });
    rerender(
      <TaskBoardContext.Provider value={{ board: null, sessionId: "other" }}>
        <Markdown text="[Old title](task:1)" />
      </TaskBoardContext.Provider>,
    );
    expect(screen.queryByRole("button")).toBeNull();
    expect(screen.getByText("Old title")).toBeTruthy();
    window.removeEventListener(OPEN_TASK_EVENT, listener);
  });
  it("unknown/malformed ids are plain text and unsafe URLs stay stripped", () => {
    render(
      <Markdown text="[Unknown](task:999) [Malformed](task:-2) [Unsafe](javascript:alert)" />,
    );
    expect(screen.queryByRole("button")).toBeNull();
    expect(screen.getByText("Unsafe").getAttribute("href")).toBe("");
  });
});

describe("team view", () => {
  it("quick look opens by click, never automatically; Escape closes and restores focus", () => {
    render(<TeamQuickLook summary={sampleTeam()} onOpen={vi.fn()} />);
    const button = screen.getByRole("button", { name: "Team quick look" });
    expect(screen.queryByRole("region")).toBeNull();
    fireEvent.click(button);
    expect(
      screen.getByRole("region", { name: "Team quick look" }),
    ).toBeTruthy();
    fireEvent.keyDown(document, { key: "Escape" });
    expect(screen.queryByRole("region")).toBeNull();
    expect(document.activeElement).toBe(button);
  });
  it("a hundred workers use role rows in quick look", () => {
    render(<TeamQuickLook summary={sampleTeam(100)} onOpen={vi.fn()} />);
    fireEvent.click(screen.getByRole("button", { name: "Team quick look" }));
    expect(screen.getAllByTestId(/team-task-/)).toHaveLength(1);
    expect(screen.getByText("swe-worker × 40")).toBeTruthy();
  });
  it("all tabs work, completed tasks are collapsed, large workers expand by role", () => {
    render(
      <TeamView
        summary={sampleTeam(100)}
        sessions={[]}
        sessionId="sample"
        onClose={vi.fn()}
        onRefresh={vi.fn()}
      />,
    );
    expect(screen.getByText("1 task is waiting on you.")).toBeTruthy();
    fireEvent.click(screen.getByRole("tab", { name: "Workers" }));
    expect(screen.getByRole("searchbox")).toBeTruthy();
    expect(screen.getAllByTestId(/^team-worker-/)).toHaveLength(8);
    expect(screen.getByTestId("team-worker-sam")).toBeTruthy();
    fireEvent.click(screen.getByRole("tab", { name: "Stats" }));
    expect(screen.getByText("Top five of 100 workers")).toBeTruthy();
    fireEvent.click(screen.getByText("Show tokens over time"));
    expect(
      screen.getByRole("img", { name: "Cumulative tokens by role over time" }),
    ).toBeTruthy();
    expect(
      within(screen.getByRole("table")).getByText("Staffing"),
    ).toBeTruthy();
  });
});