The best way to control Claude Code, Codex and more from any computer or phone
test(web): restore project settings permission tests deleted in the test snap (#24011)
Theo Browne committed
Oct 23, 2026 at 03:17 UTC
30a405bbc1eb78720aaacd0049b97a44a3f2e8b0
2 files changed
+556
-2
apps/web/src/components/settings/ProjectSettingsPanel.browser.test.tsx
new
+554
@@ -0,0 +1,554 @@
1
+import { RegistryContext } from "@effect/atom-react";
2
+import type {
3
+ DeleteProjectInput,
4
+ UpdateProjectInput,
5
+} from "@t3tools/client-runtime/state/projects";
6
+import {
7
+ AuthOrchestrationOperateScope,
8
+ AuthSettingsWriteScope,
9
+ DEFAULT_SERVER_SETTINGS,
10
+ EnvironmentId,
11
+ ProjectId,
12
+ ProviderInstanceId,
13
+ type AuthEnvironmentScope,
14
+ type AuthSessionState,
15
+} from "@t3tools/contracts";
16
+import { DEFAULT_CLIENT_SETTINGS } from "@t3tools/contracts/settings";
17
+import { DEFAULT_RESOLVED_KEYBINDINGS } from "@t3tools/shared/keybindings";
18
+import {
19
+ createMemoryHistory,
20
+ createRootRoute,
21
+ createRoute,
22
+ createRouter,
23
+ RouterProvider,
24
+} from "@tanstack/react-router";
25
+import * as Cause from "effect/Cause";
26
+import { AsyncResult, Atom } from "effect/reactivity";
27
+import { describe, expect, it, vi } from "vite-plus/test";
28
+import { page, userEvent } from "vite-plus/test/browser";
29
+
30
+import { act, render, type Screen } from "../../../test/render";
31
+import type { Project } from "../../types";
32
+
33
+type SessionResult = AsyncResult.AsyncResult<AuthSessionState, Error>;
34
+const state = vi.hoisted(() => ({
35
+ sessions: new Map<EnvironmentId, Atom.Writable<SessionResult>>(),
36
+ projects: [] as Project[],
37
+ update:
38
+ vi.fn<
39
+ (request: {
40
+ environmentId: EnvironmentId;
41
+ input: UpdateProjectInput;
42
+ }) => Promise<AsyncResult.Success<void>>
43
+ >(),
44
+ delete:
45
+ vi.fn<
46
+ (request: {
47
+ environmentId: EnvironmentId;
48
+ input: DeleteProjectInput;
49
+ }) => Promise<AsyncResult.Success<void>>
50
+ >(),
51
+ confirm: vi.fn<() => Promise<boolean>>(),
52
+ releaseUploads: vi.fn(),
53
+ clearDraft: vi.fn(),
54
+ toast: vi.fn(),
55
+}));
56
+
57
+// Session grants come from the server; each test drives them through these atoms.
58
+vi.mock(import("@t3tools/client-runtime/state/session"), async (original) => {
59
+ const actual = await original();
60
+ return {
61
+ ...actual,
62
+ createEnvironmentSessionAtoms: ((
63
+ ...args: Parameters<typeof actual.createEnvironmentSessionAtoms>
64
+ ) => ({
65
+ ...actual.createEnvironmentSessionAtoms(...args),
66
+ sessionStateAtom: (id: EnvironmentId) => state.sessions.get(id)!,
67
+ })) as typeof actual.createEnvironmentSessionAtoms,
68
+ };
69
+});
70
+vi.mock(import("~/state/environments"), async (original) => ({
71
+ ...(await original()),
72
+ useEnvironments: (() => ({ environments })) as never,
73
+ usePrimaryEnvironmentId: () => primaryId,
74
+}));
75
+vi.mock(import("~/state/entities"), async (original) => ({
76
+ ...(await original()),
77
+ useProjects: (() => state.projects) as never,
78
+ useThreadShells: () => [],
79
+ waitForProjectRemoval: async () => true,
80
+}));
81
+vi.mock(import("~/state/projects"), async (original) => {
82
+ const actual = await original();
83
+ return {
84
+ ...actual,
85
+ projectEnvironment: {
86
+ ...actual.projectEnvironment,
87
+ update: "update",
88
+ delete: "delete",
89
+ } as unknown as typeof actual.projectEnvironment,
90
+ };
91
+});
92
+vi.mock(import("~/state/use-atom-command"), async (original) => ({
93
+ ...(await original()),
94
+ useAtomCommand: ((command: "update" | "delete") => state[command]) as never,
95
+}));
96
+vi.mock(import("~/hooks/useSettings"), async (original) => ({
97
+ ...(await original()),
98
+ useClientSettings: ((selector?: (settings: typeof DEFAULT_CLIENT_SETTINGS) => unknown) =>
99
+ selector ? selector(DEFAULT_CLIENT_SETTINGS) : DEFAULT_CLIENT_SETTINGS) as never,
100
+}));
101
+vi.mock(import("~/localApi"), async (original) => ({
102
+ ...(await original()),
103
+ readLocalApi: (() => ({ dialogs: { confirm: state.confirm } })) as never,
104
+}));
105
+vi.mock(import("~/lib/composerDraftUploads"), async (original) => ({
106
+ ...(await original()),
107
+ releaseProjectDraftUploads: state.releaseUploads,
108
+}));
109
+// No toaster is mounted in these tests; the guard's error toast is read at this seam.
110
+vi.mock(import("../ui/toast"), async (original) => {
111
+ const actual = await original();
112
+ return { ...actual, toastManager: { ...actual.toastManager, add: state.toast } };
113
+});
114
+// These sections have separate data sources and their own tests.
115
+vi.mock(import("./ProjectDefaultsSettings"), async (original) => ({
116
+ ...(await original()),
117
+ ProjectDefaultsSettings: (() => null) as never,
118
+}));
119
+vi.mock(import("./ProjectActionsSettings"), async (original) => ({
120
+ ...(await original()),
121
+ ProjectActionsSettings: (() => null) as never,
122
+}));
123
+
124
+vi.mock(import("../files/projectFilesQueryState"), async (original) => ({
125
+ ...(await original()),
126
+ getProjectFileQueryAtom: () => missingProjectFile,
127
+}));
128
+
129
+import { useComposerDraftStore } from "../../composerDraftStore";
130
+import { appAtomRegistry } from "../../rpc/atomRegistry";
131
+import { buildSidebarProjectSnapshots } from "../../sidebarProjectGrouping";
132
+import { ProjectSettingsPanel } from "./ProjectSettingsPanel";
133
+import { ProjectsSettings } from "./ProjectsSettings";
134
+import { SettingsScopeProvider } from "./SettingsScopeContext";
135
+import { validateSettingsScopeSearch, type SettingsScopeSearch } from "./settingsScope";
136
+import { retainSettingsScope, validateSettingsRouteSearch } from "./settingsScopeNavigation";
137
+
138
+const primaryId = EnvironmentId.make("primary");
139
+const remoteId = EnvironmentId.make("remote");
140
+const instanceId = ProviderInstanceId.make("codex");
141
+const environments = [primaryId, remoteId].map((environmentId) => ({
142
+ environmentId,
143
+ label: environmentId,
144
+ connection: { phase: "connected" },
145
+ serverConfig: {
146
+ keybindings: DEFAULT_RESOLVED_KEYBINDINGS,
147
+ settings: DEFAULT_SERVER_SETTINGS,
148
+ environment: { platform: { machine: "server" } },
149
+ },
150
+}));
151
+const session = (scopes: ReadonlyArray<AuthEnvironmentScope>): AuthSessionState => ({
152
+ authenticated: true,
153
+ scopes,
154
+ auth: {
155
+ policy: "remote-reachable",
156
+ bootstrapMethods: ["one-time-token"],
157
+ sessionMethods: ["bearer-access-token"],
158
+ sessionCookieName: "t3_session",
159
+ },
160
+});
161
+const writable = () => AsyncResult.success(session([AuthOrchestrationOperateScope]));
162
+const missingProjectFile = Atom.make(AsyncResult.initial<never, never>());
163
+
164
+function deferred<T>() {
165
+ let resolve!: (value: T) => void;
166
+ const promise = new Promise<T>((complete) => {
167
+ resolve = complete;
168
+ });
169
+ return { promise, resolve };
170
+}
171
+
172
+function setup() {
173
+ vi.clearAllMocks();
174
+ state.sessions.clear();
175
+ for (const id of [primaryId, remoteId])
176
+ state.sessions.set(id, Atom.make<SessionResult>(writable()).pipe(Atom.keepAlive));
177
+ state.projects = [primaryId, remoteId].map((environmentId) => ({
178
+ id: ProjectId.make(`project-${environmentId}`),
179
+ environmentId,
180
+ title: "Shared repo",
181
+ workspaceRoot: `/work/${environmentId}`,
182
+ repositoryIdentity: {
183
+ canonicalKey: "github.com/example/shared-repo",
184
+ locator: {
185
+ source: "git-remote",
186
+ remoteName: "origin",
187
+ remoteUrl: "https://github.com/example/shared-repo.git",
188
+ },
189
+ },
190
+ defaultModelSelection: { instanceId, model: "gpt-5-codex" },
191
+ createdAt: "2026-01-01T00:00:00.000Z",
192
+ updatedAt: "2026-01-01T00:00:00.000Z",
193
+ scripts: [],
194
+ }));
195
+ state.update.mockImplementation(async ({ environmentId, input }) => {
196
+ const { projectId, ...updates } = input;
197
+ const patch = Object.fromEntries(
198
+ Object.entries(updates).filter(([, value]) => value !== undefined),
199
+ ) as Partial<Project>;
200
+ state.projects = state.projects.map((project) =>
201
+ project.environmentId === environmentId && project.id === projectId
202
+ ? { ...project, ...patch }
203
+ : project,
204
+ );
205
+ return AsyncResult.success(undefined);
206
+ });
207
+ state.delete.mockResolvedValue(AsyncResult.success(undefined));
208
+ state.confirm.mockResolvedValue(true);
209
+ useComposerDraftStore.setState({ clearProjectDraftThreadId: state.clearDraft });
210
+}
211
+
212
+function projectKey() {
213
+ return buildSidebarProjectSnapshots({
214
+ projects: state.projects,
215
+ settings: DEFAULT_CLIENT_SETTINGS,
216
+ primaryEnvironmentId: primaryId,
217
+ resolveEnvironmentLabel: (id) => id,
218
+ })[0]!.projectKey;
219
+}
220
+
221
+async function mountPanel(search: Omit<SettingsScopeSearch, "project"> = {}) {
222
+ const key = projectKey();
223
+ const rootRoute = createRootRoute();
224
+ const settingsRoute = createRoute({
225
+ getParentRoute: () => rootRoute,
226
+ path: "settings",
227
+ validateSearch: validateSettingsRouteSearch,
228
+ search: { middlewares: [retainSettingsScope] },
229
+ });
230
+ const projectsRoute = createRoute({
231
+ getParentRoute: () => settingsRoute,
232
+ path: "projects",
233
+ component: () => (
234
+ <ProjectSettingsPanel
235
+ projectKey={key}
236
+ environmentId={search.machine ? EnvironmentId.make(search.machine) : null}
237
+ checkoutKey={search.checkout ?? null}
238
+ />
239
+ ),
240
+ });
241
+ const query = new URLSearchParams({ project: key });
242
+ for (const [name, value] of Object.entries(search)) {
243
+ if (value !== undefined) query.set(name, value);
244
+ }
245
+ const router = createRouter({
246
+ routeTree: rootRoute.addChildren([settingsRoute.addChildren([projectsRoute])]),
247
+ history: createMemoryHistory({ initialEntries: [`/settings/projects?${query}`] }),
248
+ });
249
+ await router.load();
250
+ await using stack = new AsyncDisposableStack();
251
+ const screen = stack.use(
252
+ // The panel's own route tree validates settings search params, which the default router lacks.
253
+ await render(
254
+ <RegistryContext.Provider value={appAtomRegistry}>
255
+ <RouterProvider router={router} />
256
+ </RegistryContext.Provider>,
257
+ { router: false },
258
+ ),
259
+ );
260
+ await vi.waitFor(() => expect(nameInput(screen)).not.toBeNull());
261
+ stack.move();
262
+ return { ...screen, router };
263
+}
264
+
265
+async function mountSettings(search: SettingsScopeSearch) {
266
+ const searchParams = new URLSearchParams(
267
+ Object.entries(search).flatMap(([key, value]) => (value === undefined ? [] : [[key, value]])),
268
+ );
269
+ const route = createRootRoute({
270
+ validateSearch: validateSettingsScopeSearch,
271
+ component: () => (
272
+ <SettingsScopeProvider
273
+ search={route.useSearch()}
274
+ onChange={(next) => void router.navigate({ to: "/settings/projects", search: () => next })}
275
+ >
276
+ <ProjectsSettings />
277
+ </SettingsScopeProvider>
278
+ ),
279
+ });
280
+ const router = createRouter({
281
+ routeTree: route,
282
+ history: createMemoryHistory({
283
+ initialEntries: [`/settings/projects?${searchParams.toString()}`],
284
+ }),
285
+ });
286
+ await router.load();
287
+ // The settings route tree above validates scope search params, which the default router lacks.
288
+ const screen = await render(
289
+ <RegistryContext.Provider value={appAtomRegistry}>
290
+ <RouterProvider router={router} />
291
+ </RegistryContext.Provider>,
292
+ { router: false },
293
+ );
294
+ return { ...screen, router };
295
+}
296
+
297
+const nameInput = (screen: Screen) =>
298
+ screen.container.querySelector<HTMLInputElement>('[aria-label="Project name"]')!;
299
+const removeCheckout = (screen: Screen, root: string) =>
300
+ screen.container.querySelector<HTMLButtonElement>(`[aria-label="Remove checkout ${root}"]`)!;
301
+const removeAll = (screen: Screen) =>
302
+ [...screen.container.querySelectorAll("button")].find((button) =>
303
+ button.textContent?.includes("Remove all entries"),
304
+ )!;
305
+
306
+async function grant(id: EnvironmentId, result: SessionResult) {
307
+ await act(async () => appAtomRegistry.set(state.sessions.get(id)!, result));
308
+}
309
+
310
+async function rename(screen: Screen, title: string) {
311
+ await userEvent.fill(nameInput(screen), title);
312
+ await userEvent.keyboard("{Enter}");
313
+}
314
+
315
+// The recheck reports the denial by toast; seeing it proves the recheck ran.
316
+async function expectProjectAccessDeniedToast(title: string) {
317
+ await vi.waitFor(() =>
318
+ expect(state.toast).toHaveBeenCalledWith(
319
+ expect.objectContaining({
320
+ type: "error",
321
+ title,
322
+ description: "This connection cannot change projects in remote.",
323
+ }),
324
+ ),
325
+ );
326
+ expect(state.toast).toHaveBeenCalledOnce();
327
+}
328
+
329
+describe("project settings permissions", () => {
330
+ it("disables shared edits when any member lacks project access", async () => {
331
+ setup();
332
+ await grant(remoteId, AsyncResult.success(session([AuthSettingsWriteScope])));
333
+ await using screen = await mountPanel();
334
+
335
+ expect(nameInput(screen).disabled).toBe(true);
336
+ expect(removeAll(screen).disabled).toBe(true);
337
+ expect(screen.container.textContent).toContain(
338
+ "Shared settings require permission to change every checkout in this group.",
339
+ );
340
+ expect(state.update).not.toHaveBeenCalled();
341
+ });
342
+
343
+ it("renames every member when all have project access without settings access", async () => {
344
+ setup();
345
+ await using screen = await mountPanel();
346
+ await rename(screen, "Renamed");
347
+ expect(state.update.mock.calls.map(([request]) => request.environmentId)).toEqual([
348
+ primaryId,
349
+ remoteId,
350
+ ]);
351
+ expect(nameInput(screen).value).toBe("Renamed");
352
+ });
353
+
354
+ it("stops before the next member if its grant is revoked during an earlier update", async () => {
355
+ setup();
356
+ const firstUpdate = deferred<AsyncResult.Success<void>>();
357
+ state.update.mockReturnValueOnce(firstUpdate.promise);
358
+ await using screen = await mountPanel();
359
+ await rename(screen, "Renamed");
360
+ expect(state.update).toHaveBeenCalledOnce();
361
+
362
+ await grant(remoteId, AsyncResult.success(session([])));
363
+ await act(async () => {
364
+ firstUpdate.resolve(AsyncResult.success(undefined));
365
+ await firstUpdate.promise;
366
+ });
367
+ await expectProjectAccessDeniedToast("Failed to rename project");
368
+ expect(state.update).toHaveBeenCalledOnce();
369
+ expect(state.update.mock.calls[0]![0].environmentId).toBe(primaryId);
370
+ });
371
+
372
+ it("disables removal for a checkout whose project grant is missing", async () => {
373
+ setup();
374
+ await grant(remoteId, AsyncResult.success(session([])));
375
+ await using screen = await mountPanel();
376
+ expect(removeCheckout(screen, "/work/remote").disabled).toBe(true);
377
+ expect(removeCheckout(screen, "/work/primary").disabled).toBe(false);
378
+ });
379
+
380
+ it("removes a writable checkout while removal of the mixed group stays denied", async () => {
381
+ setup();
382
+ await grant(remoteId, AsyncResult.success(session([])));
383
+ await using screen = await mountPanel();
384
+ const initialHref = screen.router.state.location.href;
385
+ expect(removeAll(screen).disabled).toBe(true);
386
+
387
+ await userEvent.click(removeCheckout(screen, "/work/primary"));
388
+ await vi.waitFor(() => expect(state.delete).toHaveBeenCalledOnce());
389
+ expect(state.delete).toHaveBeenCalledWith({
390
+ environmentId: primaryId,
391
+ input: { projectId: state.projects[0]!.id, force: true },
392
+ });
393
+ await vi.waitFor(() => expect(state.releaseUploads).toHaveBeenCalledOnce());
394
+ expect(state.clearDraft).toHaveBeenCalledOnce();
395
+ expect(screen.router.state.location.href).toBe(initialHref);
396
+ });
397
+
398
+ it("rechecks every removal target after confirmation before deleting or clearing drafts", async () => {
399
+ setup();
400
+ const confirmed = deferred<boolean>();
401
+ state.confirm.mockReturnValueOnce(confirmed.promise);
402
+ await using screen = await mountPanel();
403
+ await userEvent.click(removeAll(screen));
404
+ expect(state.confirm).toHaveBeenCalledOnce();
405
+
406
+ await grant(remoteId, AsyncResult.success(session([])));
407
+ await act(async () => {
408
+ confirmed.resolve(true);
409
+ await confirmed.promise;
410
+ });
411
+ await expectProjectAccessDeniedToast("Failed to remove project");
412
+ expect(state.delete).not.toHaveBeenCalled();
413
+ expect(state.releaseUploads).not.toHaveBeenCalled();
414
+ expect(state.clearDraft).not.toHaveBeenCalled();
415
+ });
416
+
417
+ it("does not save an edit whose grant was revoked mid-edit, and recovers when restored", async () => {
418
+ setup();
419
+ await using screen = await mountPanel();
420
+ await userEvent.fill(nameInput(screen), "Renamed");
421
+ await grant(remoteId, AsyncResult.success(session([])));
422
+ // Chromium takes focus off a newly disabled input without firing blur. Send the
423
+ // focusout so the save attempt runs and hits the same recheck as a real blur.
424
+ await act(async () => {
425
+ nameInput(screen).dispatchEvent(new FocusEvent("focusout", { bubbles: true }));
426
+ });
427
+ await expectProjectAccessDeniedToast("Failed to rename project");
428
+ expect(state.update).not.toHaveBeenCalled();
429
+ expect(nameInput(screen).disabled).toBe(true);
430
+
431
+ await grant(remoteId, writable());
432
+ expect(nameInput(screen).disabled).toBe(false);
433
+ await rename(screen, "Recovered");
434
+ await vi.waitFor(() => expect(state.update).toHaveBeenCalledTimes(2));
435
+ expect(nameInput(screen).value).toBe("Recovered");
436
+ });
437
+
438
+ it.each([
439
+ ["loading", () => AsyncResult.initial<AuthSessionState, Error>(), false],
440
+ [
441
+ "failed",
442
+ () => AsyncResult.failure<AuthSessionState, Error>(Cause.fail(new Error("Disconnected"))),
443
+ false,
444
+ ],
445
+ ["refreshing", () => AsyncResult.waiting(writable()), true],
446
+ ] as const)(
447
+ "uses the current grant while a member's session is %s",
448
+ async (_state, result, allowed) => {
449
+ setup();
450
+ await grant(remoteId, result());
451
+ await using screen = await mountPanel();
452
+ expect(nameInput(screen).disabled).toBe(!allowed);
453
+ if (!allowed) return;
454
+ await rename(screen, "Renamed");
455
+ expect(state.update).toHaveBeenCalledTimes(2);
456
+ },
457
+ );
458
+});
459
+
460
+describe("project settings scope", () => {
461
+ const environmentMenu = () => page.getByRole("button", { name: /^Environment scope:/ });
462
+ const primaryOption = () => page.getByRole("menuitemradio", { name: /^primary/ });
463
+ const remoteOption = () => page.getByRole("menuitemradio", { name: /^remote/ });
464
+
465
+ it("offers every environment while no project is selected", async () => {
466
+ setup();
467
+ state.projects = state.projects.filter((project) => project.environmentId === primaryId);
468
+ await using _screen = await mountSettings({});
469
+
470
+ await userEvent.click(environmentMenu());
471
+ await expect.element(primaryOption()).toBeVisible();
472
+ await expect.element(remoteOption()).toBeVisible();
473
+ });
474
+
475
+ it("offers only the selected project's checkout environments", async () => {
476
+ setup();
477
+ state.projects = state.projects.filter((project) => project.environmentId === primaryId);
478
+ await using _screen = await mountSettings({ project: projectKey() });
479
+
480
+ await expect.element(page.getByRole("textbox", { name: "Project name" })).toBeVisible();
481
+ await userEvent.click(environmentMenu());
482
+ await expect.element(primaryOption()).toBeVisible();
483
+ await expect.element(remoteOption()).not.toBeInTheDocument();
484
+ });
485
+
486
+ it("keeps an unknown project recoverable from any environment", async () => {
487
+ setup();
488
+ state.projects = state.projects.filter((project) => project.environmentId === primaryId);
489
+ await using screen = await mountSettings({ project: "removed-project" });
490
+
491
+ await userEvent.click(environmentMenu());
492
+ await expect.element(primaryOption()).toBeVisible();
493
+ await expect.element(remoteOption()).toBeVisible();
494
+ await userEvent.click(remoteOption());
495
+ await vi.waitFor(() =>
496
+ expect(screen.router.state.location.search).toEqual({
497
+ project: "removed-project",
498
+ machine: remoteId,
499
+ }),
500
+ );
501
+ });
502
+
503
+ it.each([
504
+ [undefined, "This project has no checkout on this environment."],
505
+ [
506
+ "removed-checkout",
507
+ "This checkout is no longer available in the selected project and environment.",
508
+ ],
509
+ ])("recovers a stale environment link with checkout %s", async (checkout, message) => {
510
+ setup();
511
+ state.projects = state.projects.filter((project) => project.environmentId === primaryId);
512
+ const key = projectKey();
513
+ await using screen = await mountSettings({
514
+ project: key,
515
+ machine: remoteId,
516
+ ...(checkout ? { checkout } : {}),
517
+ });
518
+
519
+ await expect.element(page.getByText(message, { exact: true })).toBeVisible();
520
+ await expect.element(page.getByRole("button", { name: /^Project scope:/ })).toBeVisible();
521
+ await expect
522
+ .element(page.getByRole("button", { name: "Environment scope: remote" }))
523
+ .toBeVisible();
524
+ await userEvent.click(page.getByRole("button", { name: "Show all environments" }));
525
+
526
+ await expect
527
+ .element(page.getByRole("textbox", { name: "Project name" }))
528
+ .toHaveValue("Shared repo");
529
+ expect(screen.router.state.location.search).toEqual({ project: key });
530
+ await expect
531
+ .element(page.getByRole("button", { name: "Environment scope: All environments" }))
532
+ .toBeVisible();
533
+ await expect.element(page.getByText(message, { exact: true })).not.toBeInTheDocument();
534
+ await expect
535
+ .element(page.getByRole("button", { name: "Remove project", exact: true }))
536
+ .toBeEnabled();
537
+ });
538
+});
539
+
540
+it("returns to the project overview after removal, clearing the selection but keeping the environment", async () => {
541
+ setup();
542
+ state.projects = [state.projects[1]!];
543
+ await using screen = await mountPanel({ machine: remoteId, checkout: "remote:/work/remote" });
544
+ const removeProject = [...screen.container.querySelectorAll("button")].find(
545
+ (button) => button.textContent === "Remove project",
546
+ )!;
547
+
548
+ await userEvent.click(removeProject);
549
+
550
+ await vi.waitFor(() => {
551
+ expect(screen.router.state.location.pathname).toBe("/settings/projects");
552
+ expect(screen.router.state.location.search).toEqual({ machine: remoteId });
553
+ });
554
+});
apps/web/src/reactCompilerCoverage.test.ts
+2
-2
@@ -18,8 +18,8 @@ const webSourceFiles = NodeFS.readdirSync(NodePath.join(repoRoot, "apps/web/src"
18
.filter((file) => !file.endsWith(".gen.ts"))
19
.map((file) => `apps/web/src/${file}`);
20
21
-// ChatView is ~9k lines. Compiling it takes ~9s on a fast machine and passes the
22
-// 15s project timeout on loaded CI runners.
21
+// ChatView is ~9k lines. Compiling it takes ~9s on a fast machine and can pass the
22
+// 15s project limit on loaded CI runners, so slow files get a 60s limit below.
23
const slowFiles = new Set(["apps/web/src/components/ChatView.tsx"]);
24
25
const compile = async (file: string) => {