`d8daf2f`

tests: store pty lifecycle + parallel-threads regression guard

Authored by

espadonne 1 month ago

SHA: d8daf2fed2444c95a92356257f629115cad22d8a
Parents: d4c1f7d
Tree: 7c3b2e3

1 changed file

Status	File	+	-
M	`src/lib/store/sessions.test.ts`	204	1

src/lib/store/sessions.test.tsmodified

  // events into it on demand.
  let chatEventCb: ((ev: any) => void) | null = null;
  let sessionsChangedCb: ((ev: any) => void) | null = null;
 +let ptyExitCb: ((ev: any) => void) | null = null;
  const startTurnMock = vi.fn().mockResolvedValue(undefined);
  const cancelTurnMock = vi.fn().mockResolvedValue(undefined);
  const readSessionMock = vi.fn();
  const listProjectsMock = vi.fn().mockResolvedValue([]);
  const rescanMock = vi.fn().mockResolvedValue([]);
 +const closePtyMock = vi.fn().mockResolvedValue(undefined);
 +const listPtysMock = vi.fn().mockResolvedValue([]);
  vi.mock("@/lib/ipc/client", () => ({
    listProjects: (...args: unknown[]) => listProjectsMock(...args),
      chatEventCb = cb;
      return () => {};
    }),
 +  spawnPty: vi.fn().mockResolvedValue(undefined),
 +  writePty: vi.fn().mockResolvedValue(undefined),
 +  resizePty: vi.fn().mockResolvedValue(undefined),
 +  closePty: (...args: unknown[]) => closePtyMock(...args),
 +  getPtyBuffer: vi.fn().mockResolvedValue(""),
 +  listPtys: (...args: unknown[]) => listPtysMock(...args),
 +  onPtyData: vi.fn().mockResolvedValue(() => {}),
 +  onPtyExit: vi.fn().mockImplementation(async (cb) => {
 +    ptyExitCb = cb;
 +    return () => {};
 +  }),
  }));
  import { useSessionStore } from "./sessions";
 -import type { Message, SessionDetail } from "@/lib/ipc/types";
 +import type { Message, SessionDetail, SessionSummary } from "@/lib/ipc/types";
  function seedSelectedSession(sessionId: string): SessionDetail {
    const detail: SessionDetail = {
      expect((userMsg as Extract<Message, { kind: "user" }>).text).toBe("hello");
    });
  });
++
 +function makeSessionSummary(
 +  id: string,
 +  overrides: Partial<SessionSummary> = {},
 +): SessionSummary {
 +  return {
 +    id,
 +    projectId: "-enc-test",
 +    title: `session ${id}`,
 +    startedAt: null,
 +    lastActivityAt: null,
 +    model: null,
 +    messageCount: 0,
 +    gitBranch: null,
 +    version: null,
 +    slug: null,
 +    cwd: "/tmp/test",
 +    customTitle: null,
 +    entrypoint: "cli",
 +    source: "disk",
 +    ...overrides,
 +  };
 +}
++
 +function dispatchPtyExit(ev: any) {
 +  if (!ptyExitCb) throw new Error("pty exit subscriber not attached");
 +  ptyExitCb(ev);
 +}
++
 +describe("useSessionStore pty lifecycle", () => {
 +  beforeAll(async () => {
 +    await useSessionStore.getState().subscribeToPtyEvents();
 +  });
++
 +  beforeEach(() => {
 +    useSessionStore.setState({
 +      projects: [],
 +      expandedProjectIds: new Set(),
 +      selectedSessionId: null,
 +      detail: null,
 +      inFlightTurns: new Map(),
 +      viewerMode: new Map(),
 +      ptyIds: new Map(),
 +      ptyInfos: new Map(),
 +      loading: { projects: false, detail: false },
 +      error: null,
 +    });
 +    closePtyMock.mockClear();
 +    listPtysMock.mockClear();
 +    readSessionMock.mockReset();
 +  });
++
 +  it("toggleViewerMode flips cards → terminal → cards", () => {
 +    useSessionStore.getState().toggleViewerMode("s-1");
 +    expect(useSessionStore.getState().viewerMode.get("s-1")).toBe("terminal");
 +    useSessionStore.getState().toggleViewerMode("s-1");
 +    expect(useSessionStore.getState().viewerMode.get("s-1")).toBe("cards");
 +  });
++
 +  it("toggleViewerMode is a no-op for archive sessions", () => {
 +    const detail: SessionDetail = {
 +      summary: makeSessionSummary("arc-1", { source: "archive" }),
 +      messages: [],
 +    };
 +    useSessionStore.setState({ detail });
 +    useSessionStore.getState().setViewerMode("arc-1", "cards");
 +    useSessionStore.getState().toggleViewerMode("arc-1");
 +    expect(useSessionStore.getState().viewerMode.get("arc-1")).toBe("cards");
 +  });
++
 +  it("beginNewSession defaults the new session's mode to terminal", () => {
 +    useSessionStore.getState().beginNewSession("/tmp/proj", "proj");
 +    const { selectedSessionId, viewerMode } = useSessionStore.getState();
 +    expect(selectedSessionId).toMatch(/^pending-/);
 +    expect(viewerMode.get(selectedSessionId!)).toBe("terminal");
 +  });
++
 +  it("selectSession defaults a disk session to cards mode", async () => {
 +    const summary = makeSessionSummary("s-disk");
 +    readSessionMock.mockResolvedValueOnce({ summary, messages: [] });
 +    await useSessionStore.getState().selectSession(summary);
 +    expect(useSessionStore.getState().viewerMode.get("s-disk")).toBe("cards");
 +  });
++
 +  it("selectSession does NOT kill the previous session's PTY (parallel threads)", async () => {
 +    // Seed a live PTY bound to session A.
 +    useSessionStore.getState().registerPty("s-a", {
 +      ptyId: "pty-a",
 +      sessionId: "s-a",
 +      cwd: "/tmp/a",
 +      startedAt: new Date().toISOString(),
 +    });
 +    expect(useSessionStore.getState().ptyIds.get("s-a")).toBe("pty-a");
++
 +    // Now switch to session B.
 +    const summaryB = makeSessionSummary("s-b", { cwd: "/tmp/b" });
 +    readSessionMock.mockResolvedValueOnce({
 +      summary: summaryB,
 +      messages: [],
 +    });
 +    await useSessionStore.getState().selectSession(summaryB);
++
 +    // Session A's PTY must still be registered — this is the
 +    // codex-parallel-threads regression guard.
 +    expect(useSessionStore.getState().ptyIds.get("s-a")).toBe("pty-a");
 +    expect(useSessionStore.getState().selectedSessionId).toBe("s-b");
 +    expect(closePtyMock).not.toHaveBeenCalled();
 +  });
++
 +  it("switching away and back preserves the registered pty id", async () => {
 +    const summaryA = makeSessionSummary("s-keep", { cwd: "/tmp/keep" });
 +    readSessionMock.mockResolvedValue({ summary: summaryA, messages: [] });
 +    await useSessionStore.getState().selectSession(summaryA);
 +    useSessionStore.getState().registerPty("s-keep", {
 +      ptyId: "pty-keep",
 +      sessionId: "s-keep",
 +      cwd: "/tmp/keep",
 +      startedAt: new Date().toISOString(),
 +    });
++
 +    const summaryB = makeSessionSummary("s-other", { cwd: "/tmp/other" });
 +    readSessionMock.mockResolvedValueOnce({
 +      summary: summaryB,
 +      messages: [],
 +    });
 +    await useSessionStore.getState().selectSession(summaryB);
 +    readSessionMock.mockResolvedValueOnce({
 +      summary: summaryA,
 +      messages: [],
 +    });
 +    await useSessionStore.getState().selectSession(summaryA);
 +    expect(useSessionStore.getState().ptyIds.get("s-keep")).toBe("pty-keep");
 +  });
++
 +  it("pty:exit clears the ptyIds entry for the exited subprocess", () => {
 +    useSessionStore.getState().registerPty("s-exit", {
 +      ptyId: "pty-exit",
 +      sessionId: "s-exit",
 +      cwd: "/tmp/exit",
 +      startedAt: new Date().toISOString(),
 +    });
 +    dispatchPtyExit({ ptyId: "pty-exit", exitCode: 0 });
 +    expect(useSessionStore.getState().ptyIds.has("s-exit")).toBe(false);
 +    expect(useSessionStore.getState().ptyInfos.has("pty-exit")).toBe(false);
 +  });
++
 +  it("pty:exit for an unknown ptyId is a harmless no-op", () => {
 +    useSessionStore.getState().registerPty("s-live", {
 +      ptyId: "pty-live",
 +      sessionId: "s-live",
 +      cwd: "/tmp/live",
 +      startedAt: new Date().toISOString(),
 +    });
 +    dispatchPtyExit({ ptyId: "pty-ghost", exitCode: 0 });
 +    expect(useSessionStore.getState().ptyIds.get("s-live")).toBe("pty-live");
 +  });
++
 +  it("closeSessionPty fires the backend command and flips mode to cards", async () => {
 +    useSessionStore.getState().registerPty("s-close", {
 +      ptyId: "pty-close",
 +      sessionId: "s-close",
 +      cwd: "/tmp/close",
 +      startedAt: new Date().toISOString(),
 +    });
 +    useSessionStore.getState().setViewerMode("s-close", "terminal");
 +    await useSessionStore.getState().closeSessionPty("s-close");
 +    expect(closePtyMock).toHaveBeenCalledWith("pty-close");
 +    expect(useSessionStore.getState().ptyIds.has("s-close")).toBe(false);
 +    expect(useSessionStore.getState().ptyInfos.has("pty-close")).toBe(false);
 +    expect(useSessionStore.getState().viewerMode.get("s-close")).toBe("cards");
 +  });
++
 +  it("closeSessionPty is a no-op when the session has no live pty", async () => {
 +    await useSessionStore.getState().closeSessionPty("s-none");
 +    expect(closePtyMock).not.toHaveBeenCalled();
 +  });
++
 +  it("registerPty populates both ptyIds and ptyInfos", () => {
 +    useSessionStore.getState().registerPty("s-reg", {
 +      ptyId: "pty-reg",
 +      sessionId: "s-reg",
 +      cwd: "/tmp/reg",
 +      startedAt: "2026-04-10T12:00:00.000Z",
 +    });
 +    const state = useSessionStore.getState();
 +    expect(state.ptyIds.get("s-reg")).toBe("pty-reg");
 +    expect(state.ptyInfos.get("pty-reg")?.cwd).toBe("/tmp/reg");
 +  });
 +});