The best way to control Claude Code, Codex and more from any computer or phone
Mirrored from https://github.com/Camo67/t3code.git
Synced Nov 21, 03:37 UTC
| 1 | // Render scenarios that mount the whole app (AppRoot with the app's router) on a thread, |
| 2 | // against the in-process environment in fakeEnvironment.ts. Counts cover ChatView, the |
| 3 | // chat and settings routes, the sidebar and the right panel, through the same stores and |
| 4 | // atoms the app reads. See renderScenarios.renders.tsx for the counting rules. |
| 5 | import { createMemoryHistory } from "@tanstack/react-router"; |
| 6 | import { scopeProjectRef, scopeThreadRef } from "@t3tools/client-runtime/environment"; |
| 7 | import { NodeId, RuntimeRequestId, TurnItemId, type ThreadId } from "@t3tools/contracts"; |
| 8 | import { DEFAULT_CLIENT_SETTINGS } from "@t3tools/contracts/settings"; |
| 9 | import type * as Context from "effect/Context"; |
| 10 | import * as DateTime from "effect/DateTime"; |
| 11 | import { AsyncResult } from "effect/reactivity"; |
| 12 | import { expect, it, vi } from "vite-plus/test"; |
| 13 | import { commands, page, userEvent } from "vite-plus/test/browser"; |
| 14 | |
| 15 | import "~/index.css"; |
| 16 | |
| 17 | import { AppRoot } from "~/AppRoot"; |
| 18 | import { DraftId, useComposerDraftStore } from "~/composerDraftStore"; |
| 19 | import { __setClientSettingsForTests } from "~/hooks/useSettings"; |
| 20 | import { useRightPanelStore } from "~/rightPanelStore"; |
| 21 | import { getRouter, type AppRouter } from "~/router"; |
| 22 | import { appAtomRegistry } from "~/rpc/atomRegistry"; |
| 23 | import { vcsEnvironment } from "~/state/vcs"; |
| 24 | import { |
| 25 | ENVIRONMENT_ID, |
| 26 | PROJECT_ID, |
| 27 | assistantItem, |
| 28 | emitTerminalMetadata, |
| 29 | emitThreadEvent, |
| 30 | emitVcsStatus, |
| 31 | installFakeEnvironment, |
| 32 | isThreadSubscribed, |
| 33 | runningRun, |
| 34 | threadWithHistory, |
| 35 | userItem, |
| 36 | type FakeDriver, |
| 37 | type FakeThread, |
| 38 | } from "./fakeEnvironment"; |
| 39 | import { commitsSoFar, startCounting, stopCounting, type RenderReport } from "./renderCounter"; |
| 40 | import { act, fakeTimers, render } from "./render"; |
| 41 | |
| 42 | // The socket is the only fake layer: client-runtime's driver hands every connection the |
| 43 | // in-process session. A string path, since a typed import pulls client-runtime's sources |
| 44 | // into this project, and imports inside, since the factory runs before this file's own. |
| 45 | vi.mock("../../../packages/client-runtime/src/connection/driver.ts", async (importOriginal) => { |
| 46 | const [actual, { fakeDriver }, Layer] = await Promise.all([ |
| 47 | importOriginal<{ readonly ConnectionDriver: Context.Key<unknown, FakeDriver> }>(), |
| 48 | import("./fakeEnvironment"), |
| 49 | import("effect/Layer"), |
| 50 | ]); |
| 51 | return { ...actual, layer: Layer.succeed(actual.ConnectionDriver, fakeDriver) }; |
| 52 | }); |
| 53 | |
| 54 | // The fake server leaves most requests unanswered, which would raise the slow-request toast |
| 55 | // 15s of wall clock after each one, at a different point in every run. |
| 56 | vi.mock(import("~/rpc/requestLatencyState"), async (original) => ({ |
| 57 | ...(await original()), |
| 58 | trackRpcRequestSent: () => {}, |
| 59 | })); |
| 60 | |
| 61 | const GIT_STATUS_UPDATES = 20; |
| 62 | const HISTORY_TURNS = 20; |
| 63 | const STREAM_DELTAS = 30; |
| 64 | const TYPED_TEXT = "fix the flaky tests!"; |
| 65 | const TERMINAL_UPDATES = 20; |
| 66 | // The stream scenario leaves a turn on its thread, so it streams into one no other scenario opens. |
| 67 | const THREADS = ["thread-warm", "thread-a", "thread-b", "thread-live"].map((name) => |
| 68 | threadWithHistory(name, HISTORY_TURNS), |
| 69 | ); |
| 70 | const [WARM, A, B, LIVE] = THREADS.map((thread) => thread.id) as [ |
| 71 | ThreadId, |
| 72 | ThreadId, |
| 73 | ThreadId, |
| 74 | ThreadId, |
| 75 | ]; |
| 76 | |
| 77 | const SIDE_CHAT = { ...threadWithHistory("thread-side", HISTORY_TURNS), sideChatOf: WARM }; |
| 78 | |
| 79 | // The agent waits on two questions: an option to pick, then a typed answer. They take the same |
| 80 | // height, so moving between them leaves the composer inset that ChatView lays out unchanged. |
| 81 | const QUESTION_AT = DateTime.makeUnsafe("2026-03-17T19:12:28.000Z"); |
| 82 | const QUESTION_THREAD = threadWithHistory("thread-question", HISTORY_TURNS); |
| 83 | const QUESTION_REQUEST = RuntimeRequestId.make("thread-question-request"); |
| 84 | const QUESTION = { |
| 85 | ...QUESTION_THREAD, |
| 86 | items: [ |
| 87 | ...QUESTION_THREAD.items, |
| 88 | { |
| 89 | id: TurnItemId.make(QUESTION_REQUEST), |
| 90 | threadId: QUESTION_THREAD.id, |
| 91 | runId: null, |
| 92 | nodeId: NodeId.make(QUESTION_REQUEST), |
| 93 | providerThreadId: null, |
| 94 | providerTurnId: null, |
| 95 | nativeItemRef: null, |
| 96 | parentItemId: null, |
| 97 | ordinal: HISTORY_TURNS * 2, |
| 98 | status: "completed", |
| 99 | title: null, |
| 100 | startedAt: QUESTION_AT, |
| 101 | completedAt: QUESTION_AT, |
| 102 | updatedAt: QUESTION_AT, |
| 103 | type: "user_input_request", |
| 104 | requestId: QUESTION_REQUEST, |
| 105 | questions: [ |
| 106 | { |
| 107 | id: "approach", |
| 108 | header: "Approach", |
| 109 | question: "Which approach should I take?", |
| 110 | options: [ |
| 111 | { label: "Incremental", description: "One module at a time" }, |
| 112 | { label: "Rewrite", description: "Everything at once" }, |
| 113 | ], |
| 114 | }, |
| 115 | { |
| 116 | id: "tests", |
| 117 | header: "Tests", |
| 118 | question: "Which tests should I run?", |
| 119 | options: [ |
| 120 | { label: "Changed", description: "Only what this touches" }, |
| 121 | { label: "All", description: "The whole suite" }, |
| 122 | ], |
| 123 | }, |
| 124 | ], |
| 125 | }, |
| 126 | ], |
| 127 | runtimeRequests: [ |
| 128 | { |
| 129 | id: QUESTION_REQUEST, |
| 130 | nodeId: NodeId.make(QUESTION_REQUEST), |
| 131 | providerTurnId: null, |
| 132 | nativeRequestRef: null, |
| 133 | kind: "user_input", |
| 134 | status: "pending", |
| 135 | responseCapability: { type: "message" }, |
| 136 | createdAt: QUESTION_AT, |
| 137 | resolvedAt: null, |
| 138 | }, |
| 139 | ], |
| 140 | } satisfies FakeThread; |
| 141 | |
| 142 | installFakeEnvironment([...THREADS, SIDE_CHAT, QUESTION]); |
| 143 | // Desktop-sized, so the sidebar, composer and right panel lay out as they do in the app. |
| 144 | await page.viewport(1400, 900); |
| 145 | // A returning user: the first-run gate would otherwise wait on onboarding evidence. |
| 146 | __setClientSettingsForTests({ |
| 147 | ...DEFAULT_CLIENT_SETTINGS, |
| 148 | onboardingCompletedAt: "2026-01-01T00:00:00.000Z", |
| 149 | }); |
| 150 | |
| 151 | async function quiet() { |
| 152 | let seen = -1; |
| 153 | await vi.waitFor( |
| 154 | () => { |
| 155 | const now = commitsSoFar(); |
| 156 | const settled = now === seen; |
| 157 | seen = now; |
| 158 | expect(settled).toBe(true); |
| 159 | }, |
| 160 | { interval: 100, timeout: 15_000 }, |
| 161 | ); |
| 162 | } |
| 163 | |
| 164 | // Relative times and durations re-render on minute and second ticks of the wall clock, so a |
| 165 | // window that spans a tick counts extra renders. Only Date is frozen; timers run for real. |
| 166 | const frozenClock = () => |
| 167 | fakeTimers({ toFake: ["Date"], now: new Date("2026-03-18T09:00:30.000Z") }); |
| 168 | |
| 169 | const threadPath = (threadId: ThreadId) => `/${ENVIRONMENT_ID}/${threadId}`; |
| 170 | const lastAnswer = (threadId: ThreadId) => |
| 171 | page.getByText(`Answer ${HISTORY_TURNS - 1} for ${threadId}.`); |
| 172 | |
| 173 | // The app owns its router, as main.tsx does, so render() adds none. |
| 174 | async function mountApp(path: string) { |
| 175 | const router = getRouter(createMemoryHistory({ initialEntries: [path] })); |
| 176 | await router.load(); |
| 177 | const container = document.createElement("div"); |
| 178 | container.style.cssText = "height: 900px; width: 1400px;"; |
| 179 | const screen = await render(<AppRoot router={router} />, { container, router: false }); |
| 180 | return { screen, router }; |
| 181 | } |
| 182 | |
| 183 | async function openThread(threadId: ThreadId) { |
| 184 | const app = await mountApp(threadPath(threadId)); |
| 185 | await expect.element(lastAnswer(threadId)).toBeVisible(); |
| 186 | await quiet(); |
| 187 | return app; |
| 188 | } |
| 189 | |
| 190 | const goToThread = (router: AppRouter, threadId: ThreadId) => async () => { |
| 191 | await act(() => |
| 192 | router.navigate({ |
| 193 | to: "/$environmentId/$threadId", |
| 194 | params: { environmentId: ENVIRONMENT_ID, threadId }, |
| 195 | }), |
| 196 | ); |
| 197 | await expect.element(lastAnswer(threadId)).toBeVisible(); |
| 198 | }; |
| 199 | |
| 200 | async function measure(action: () => Promise<void>): Promise<RenderReport> { |
| 201 | await quiet(); |
| 202 | startCounting(); |
| 203 | await action(); |
| 204 | await quiet(); |
| 205 | return stopCounting(); |
| 206 | } |
| 207 | |
| 208 | // Commits are left out across several windows, and where frame batching splits a window's |
| 209 | // commits differently from run to run while its renders stay identical. |
| 210 | async function report( |
| 211 | scenario: string, |
| 212 | windows: ReadonlyArray<RenderReport>, |
| 213 | { commits: countCommits = windows.length === 1 } = {}, |
| 214 | ) { |
| 215 | const components: Record<string, number> = {}; |
| 216 | for (const window of windows) { |
| 217 | for (const [name, count] of Object.entries(window.components)) { |
| 218 | components[name] = (components[name] ?? 0) + count; |
| 219 | } |
| 220 | } |
| 221 | const total = windows.reduce((sum, window) => sum + window.renders, 0); |
| 222 | const commits = countCommits ? windows[0]!.commits : null; |
| 223 | await commands.writeRenderReport( |
| 224 | scenario, |
| 225 | JSON.stringify({ commits, renders: total, components }), |
| 226 | ); |
| 227 | } |
| 228 | |
| 229 | // A first mount loads lazy route chunks, fonts and the connection at varying times. The diff |
| 230 | // panel and settings load more chunks on first open (the T3 Connect sidebar, the terminal |
| 231 | // preview's renderer), which can land after a window has gone quiet, so the warm-up opens |
| 232 | // each once and lets it settle. |
| 233 | it("warm up", async () => { |
| 234 | using _clock = frozenClock(); |
| 235 | const { screen, router } = await openThread(WARM); |
| 236 | await using _app = screen; |
| 237 | await document.fonts.ready; |
| 238 | await quiet(); |
| 239 | await toggleDiff("open")(); |
| 240 | await quiet(); |
| 241 | await toggleDiff("close")(); |
| 242 | await quiet(); |
| 243 | await openSettings(router, "/settings/general")(); |
| 244 | await openSettings(router, "/settings/appearance")(); |
| 245 | await quiet(); |
| 246 | }); |
| 247 | |
| 248 | it("app-mount-thread", async () => { |
| 249 | using _clock = frozenClock(); |
| 250 | startCounting(); |
| 251 | await using _app = (await mountApp(threadPath(A))).screen; |
| 252 | await expect.element(lastAnswer(A)).toBeVisible(); |
| 253 | await quiet(); |
| 254 | await report("app-mount-thread", [stopCounting()]); |
| 255 | }); |
| 256 | |
| 257 | it("app-stream-assistant-turn", async () => { |
| 258 | using _clock = frozenClock(); |
| 259 | await using _app = (await openThread(LIVE)).screen; |
| 260 | expect(isThreadSubscribed(LIVE)).toBe(true); |
| 261 | const live = runningRun(LIVE, "live-run", HISTORY_TURNS + 1, "live-user"); |
| 262 | await act(async () => { |
| 263 | await emitThreadEvent(LIVE, { type: "run.created", payload: live }); |
| 264 | await emitThreadEvent(LIVE, { |
| 265 | type: "turn-item.updated", |
| 266 | payload: userItem(LIVE, live.id, "live-user", HISTORY_TURNS * 2, "Continue"), |
| 267 | }); |
| 268 | }); |
| 269 | await expect.element(page.getByText("Continue", { exact: true })).toBeVisible(); |
| 270 | const counted = await measure(async () => { |
| 271 | let text = ""; |
| 272 | for (let delta = 0; delta < STREAM_DELTAS; delta++) { |
| 273 | text += `word${delta}\n\n`; |
| 274 | await act(() => |
| 275 | emitThreadEvent(LIVE, { |
| 276 | type: "turn-item.updated", |
| 277 | payload: assistantItem( |
| 278 | LIVE, |
| 279 | live.id, |
| 280 | "live-assistant", |
| 281 | HISTORY_TURNS * 2 + 1, |
| 282 | text, |
| 283 | true, |
| 284 | ), |
| 285 | }), |
| 286 | ); |
| 287 | } |
| 288 | await expect |
| 289 | .element(page.getByText(`word${STREAM_DELTAS - 1}`, { exact: false })) |
| 290 | .toBeVisible(); |
| 291 | }); |
| 292 | // Only the streaming row changes. The timeline renders for the new item and its layout, not |
| 293 | // per delta, and history rows not at all. |
| 294 | expect(counted.components.ConversationTimeline).toBeLessThanOrEqual(3); |
| 295 | expect(counted.components.UserTimelineRow).toBeUndefined(); |
| 296 | expect(counted.components.AssistantTimelineRow).toBe(STREAM_DELTAS); |
| 297 | // Each delta adds a paragraph; finished blocks keep their render. |
| 298 | expect(counted.components.MarkdownParagraph).toBe(STREAM_DELTAS); |
| 299 | await report("app-stream-assistant-turn", [counted], { commits: false }); |
| 300 | }); |
| 301 | |
| 302 | it("app-terminal-updates-in-other-thread", async () => { |
| 303 | using _clock = frozenClock(); |
| 304 | await using _app = (await openThread(A)).screen; |
| 305 | const counted = await measure(async () => { |
| 306 | for (let update = 0; update < TERMINAL_UPDATES; update++) { |
| 307 | await act(() => |
| 308 | emitTerminalMetadata({ |
| 309 | type: "upsert", |
| 310 | terminal: { |
| 311 | threadId: B, |
| 312 | terminalId: "default", |
| 313 | cwd: "/repo", |
| 314 | worktreePath: null, |
| 315 | status: "running", |
| 316 | pid: 42, |
| 317 | exitCode: null, |
| 318 | exitSignal: null, |
| 319 | hasRunningSubprocess: true, |
| 320 | label: `command ${update}`, |
| 321 | updatedAt: `2026-03-18T09:01:${String(update).padStart(2, "0")}.000Z`, |
| 322 | }, |
| 323 | }), |
| 324 | ); |
| 325 | } |
| 326 | }); |
| 327 | // Only thread B's sidebar row shows these updates. |
| 328 | expect(counted.components.ChatView).toBeUndefined(); |
| 329 | expect(counted.components.SidebarThreadRow).toBe(TERMINAL_UPDATES); |
| 330 | await report("app-terminal-updates-in-other-thread", [counted]); |
| 331 | }); |
| 332 | |
| 333 | it("app-type-in-composer", async () => { |
| 334 | using _clock = frozenClock(); |
| 335 | await using _app = (await openThread(A)).screen; |
| 336 | const editor = page.getByTestId("composer-editor"); |
| 337 | await userEvent.click(editor); |
| 338 | const counted = await measure(async () => { |
| 339 | await userEvent.type(editor, TYPED_TEXT); |
| 340 | await expect.element(editor).toHaveTextContent(TYPED_TEXT); |
| 341 | }); |
| 342 | // The footer controls re-render for the first character only, not per keystroke. |
| 343 | expect(counted.components.ComposerControlsBar).toBe(1); |
| 344 | await report("app-type-in-composer", [counted]); |
| 345 | }); |
| 346 | |
| 347 | it("app-answer-question", async () => { |
| 348 | using _clock = frozenClock(); |
| 349 | await using _app = (await openThread(QUESTION.id)).screen; |
| 350 | const pick = await measure(async () => { |
| 351 | await userEvent.click(page.getByRole("button", { name: /Incremental/ })); |
| 352 | await expect.element(page.getByText("Which tests should I run?")).toBeVisible(); |
| 353 | }); |
| 354 | const editor = page.getByTestId("composer-editor"); |
| 355 | await userEvent.click(editor); |
| 356 | const type = await measure(async () => { |
| 357 | await userEvent.type(editor, TYPED_TEXT); |
| 358 | await expect.element(editor).toHaveTextContent(TYPED_TEXT); |
| 359 | }); |
| 360 | // Answers live in the composer; the chat view renders for the request, not its answers. |
| 361 | expect(pick.components.ChatView).toBeUndefined(); |
| 362 | expect(type.components.ChatView).toBeUndefined(); |
| 363 | await report("app-answer-question", [pick, type]); |
| 364 | }); |
| 365 | |
| 366 | it("app-switch-thread", async () => { |
| 367 | using _clock = frozenClock(); |
| 368 | const { screen, router } = await openThread(A); |
| 369 | await using _app = screen; |
| 370 | const windows = [await measure(goToThread(router, B)), await measure(goToThread(router, A))]; |
| 371 | // Only the rows losing and gaining the active highlight change. |
| 372 | for (const window of windows) expect(window.components.SidebarThreadRow).toBe(2); |
| 373 | await report("app-switch-thread", windows); |
| 374 | }); |
| 375 | |
| 376 | // A row reads whether a thread is open only when its PR badge is clicked, so opening a thread |
| 377 | // from a draft changes only the row that gains the highlight. |
| 378 | it("app-open-thread-from-draft", async () => { |
| 379 | using _clock = frozenClock(); |
| 380 | const drafts = useComposerDraftStore.getState(); |
| 381 | const draftId = DraftId.make("draft-render"); |
| 382 | drafts.setProjectDraftThreadId(scopeProjectRef(ENVIRONMENT_ID, PROJECT_ID), draftId); |
| 383 | using _draft = { [Symbol.dispose]: () => drafts.clearDraftThread(draftId) }; |
| 384 | const { screen, router } = await mountApp(`/draft/${draftId}`); |
| 385 | await using _app = screen; |
| 386 | // The sidebar lists the project once the shell snapshot has arrived. |
| 387 | await expect.element(page.getByText("render", { exact: true }).first()).toBeVisible(); |
| 388 | const counted = await measure(goToThread(router, A)); |
| 389 | expect(counted.components.SidebarThreadRow).toBe(1); |
| 390 | await report("app-open-thread-from-draft", [counted], { commits: false }); |
| 391 | }); |
| 392 | |
| 393 | // Through the diff.toggle shortcut, the same handler as the header's diff button. |
| 394 | const toggleDiff = (to: "open" | "close") => async () => { |
| 395 | await userEvent.keyboard("{Control>}d{/Control}"); |
| 396 | const diff = page.getByRole("group", { name: "Diff layout" }); |
| 397 | if (to === "open") await expect.element(diff).toBeVisible(); |
| 398 | else await expect.element(diff).not.toBeInTheDocument(); |
| 399 | }; |
| 400 | |
| 401 | it("app-toggle-diff-panel", async () => { |
| 402 | using _clock = frozenClock(); |
| 403 | await using _app = (await openThread(A)).screen; |
| 404 | const open = await measure(toggleDiff("open")); |
| 405 | const close = await measure(toggleDiff("close")); |
| 406 | await report("app-toggle-diff-panel", [open, close]); |
| 407 | }); |
| 408 | |
| 409 | const openSettings = |
| 410 | (router: AppRouter, to: "/settings/general" | "/settings/appearance") => async () => { |
| 411 | await act(() => router.navigate({ to })); |
| 412 | // A section title from each page, since neither page has a heading that names it. |
| 413 | const name = to === "/settings/general" ? "Time format" : "Interface"; |
| 414 | await expect.element(page.getByRole("heading", { name, exact: true })).toBeVisible(); |
| 415 | // Appearance highlights its code font preview off-thread, then attaches it in a shadow root. |
| 416 | if (to === "/settings/appearance") { |
| 417 | await vi.waitFor( |
| 418 | () => |
| 419 | expect([...document.querySelectorAll("div")].some((node) => node.shadowRoot)).toBe(true), |
| 420 | { interval: 100, timeout: 15_000 }, |
| 421 | ); |
| 422 | } |
| 423 | }; |
| 424 | |
| 425 | it("app-open-settings", async () => { |
| 426 | using _clock = frozenClock(); |
| 427 | const { screen, router } = await openThread(A); |
| 428 | await using _app = screen; |
| 429 | await report("app-open-settings", [await measure(openSettings(router, "/settings/general"))]); |
| 430 | }); |
| 431 | |
| 432 | it("app-switch-settings-section", async () => { |
| 433 | using _clock = frozenClock(); |
| 434 | const { screen, router } = await openThread(A); |
| 435 | await using _app = screen; |
| 436 | await openSettings(router, "/settings/general")(); |
| 437 | await report("app-switch-settings-section", [ |
| 438 | await measure(openSettings(router, "/settings/appearance")), |
| 439 | ]); |
| 440 | }); |
| 441 | |
| 442 | // ChatView reads only a few status fields, so changing file counts should not reach it. |
| 443 | // Keep git scenarios last: the status they leave cached adds renders to later scenarios. |
| 444 | it("app-git-file-counts-with-side-chat", async () => { |
| 445 | using _clock = frozenClock(); |
| 446 | useRightPanelStore.getState().openThread(scopeThreadRef(ENVIRONMENT_ID, WARM), SIDE_CHAT.id); |
| 447 | await using _app = (await openThread(WARM)).screen; |
| 448 | await expect.element(lastAnswer(SIDE_CHAT.id)).toBeVisible(); |
| 449 | const gitStatus = vcsEnvironment.status({ |
| 450 | environmentId: ENVIRONMENT_ID, |
| 451 | input: { cwd: "/workspace/render" }, |
| 452 | }); |
| 453 | const local = (insertions: number, refName = "main") => ({ |
| 454 | isRepo: true, |
| 455 | hasPrimaryRemote: true, |
| 456 | isDefaultRef: true, |
| 457 | refName, |
| 458 | hasWorkingTreeChanges: true, |
| 459 | workingTree: { |
| 460 | files: [{ path: "src/app.ts", insertions, deletions: 0 }], |
| 461 | insertions, |
| 462 | deletions: 0, |
| 463 | }, |
| 464 | }); |
| 465 | await act(() => emitVcsStatus({ _tag: "snapshot", local: local(0), remote: null })); |
| 466 | const counted = await measure(async () => { |
| 467 | for (let update = 1; update <= GIT_STATUS_UPDATES; update++) { |
| 468 | await act(() => emitVcsStatus({ _tag: "localUpdated", local: local(update) })); |
| 469 | } |
| 470 | // Zero renders only counts if the last update arrived inside this window. |
| 471 | await vi.waitFor(() => { |
| 472 | const status = AsyncResult.getOrElse(appAtomRegistry.get(gitStatus), () => null); |
| 473 | expect(status?.workingTree.insertions).toBe(GIT_STATUS_UPDATES); |
| 474 | }); |
| 475 | }); |
| 476 | expect(counted.components.ChatView).toBeUndefined(); |
| 477 | // A field the chat view does read still reaches both chats. |
| 478 | const branchSwitch = await measure(() => |
| 479 | act(() => emitVcsStatus({ _tag: "localUpdated", local: local(0, "feature") })), |
| 480 | ); |
| 481 | expect(branchSwitch.components.ChatView).toBe(2); |
| 482 | await report("app-git-file-counts-with-side-chat", [counted]); |
| 483 | }); |
| 484 | |
| 485 | // ChatView re-renders when the tree goes dirty or clean; the composer and side chat timeline should not. |
| 486 | it("app-git-status-updates-with-side-chat", async () => { |
| 487 | using _clock = frozenClock(); |
| 488 | useRightPanelStore.getState().openThread(scopeThreadRef(ENVIRONMENT_ID, WARM), SIDE_CHAT.id); |
| 489 | await using _app = (await openThread(WARM)).screen; |
| 490 | await expect.element(lastAnswer(SIDE_CHAT.id)).toBeVisible(); |
| 491 | const local = (insertions: number) => ({ |
| 492 | isRepo: true, |
| 493 | hasPrimaryRemote: true, |
| 494 | isDefaultRef: true, |
| 495 | refName: "main", |
| 496 | hasWorkingTreeChanges: insertions % 2 === 1, |
| 497 | workingTree: { |
| 498 | files: [{ path: "src/app.ts", insertions, deletions: 0 }], |
| 499 | insertions, |
| 500 | deletions: 0, |
| 501 | }, |
| 502 | }); |
| 503 | await act(() => emitVcsStatus({ _tag: "snapshot", local: local(0), remote: null })); |
| 504 | const counted = await measure(async () => { |
| 505 | for (let update = 1; update <= GIT_STATUS_UPDATES; update++) { |
| 506 | await act(() => emitVcsStatus({ _tag: "localUpdated", local: local(update) })); |
| 507 | } |
| 508 | }); |
| 509 | expect(counted.components.ChatView).toBe(GIT_STATUS_UPDATES * 2); |
| 510 | expect(counted.components.ChatComposer).toBeUndefined(); |
| 511 | expect(counted.components.ConversationTimeline).toBeUndefined(); |
| 512 | await report("app-git-status-updates-with-side-chat", [counted]); |
| 513 | }); |