Open History to see the last commit
1import { RegistryContext } from "@effect/atom-react";
2import type {
3 DeleteProjectInput,
4 UpdateProjectInput,
5} from "@t3tools/client-runtime/state/projects";
6import {
7 AuthOrchestrationOperateScope,
8 AuthSettingsWriteScope,
9 DEFAULT_SERVER_SETTINGS,
10 EnvironmentId,
11 ProjectId,
12 ProviderInstanceId,
13 type AuthEnvironmentScope,
14 type AuthSessionState,
15} from "@t3tools/contracts";
16import { DEFAULT_CLIENT_SETTINGS } from "@t3tools/contracts/settings";
17import { DEFAULT_RESOLVED_KEYBINDINGS } from "@t3tools/shared/keybindings";
18import {
19 createMemoryHistory,
20 createRootRoute,
21 createRoute,
22 createRouter,
23 RouterProvider,
24} from "@tanstack/react-router";
25import * as Cause from "effect/Cause";
26import { AsyncResult, Atom } from "effect/reactivity";
27import { describe, expect, it, vi } from "vite-plus/test";
28import { page, userEvent } from "vite-plus/test/browser";
29
30import { act, render, type Screen } from "../../../test/render";
31import type { Project } from "../../types";
32
33type SessionResult = AsyncResult.AsyncResult<AuthSessionState, Error>;
34const 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> | AsyncResult.Failure<void, Error>>
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.
58vi.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});
70vi.mock(import("~/state/environments"), async (original) => ({
71 ...(await original()),
72 useEnvironments: (() => ({ environments })) as never,
73 readEnvironment: ((id: EnvironmentId) =>
74 environments.find((environment) => environment.environmentId === id) ?? null) as never,
75 usePrimaryEnvironmentId: () => primaryId,
76}));
77vi.mock(import("~/state/entities"), async (original) => ({
78 ...(await original()),
79 useProjects: (() => state.projects) as never,
80 useThreadShells: () => [],
81 useServerConfigs: (() =>
82 new Map(
83 environments.map((environment) => [environment.environmentId, environment.serverConfig]),
84 )) as never,
85 waitForProjectRemoval: async () => true,
86}));
87vi.mock(import("~/state/projects"), async (original) => {
88 const actual = await original();
89 return {
90 ...actual,
91 projectEnvironment: {
92 ...actual.projectEnvironment,
93 update: "update",
94 delete: "delete",
95 } as unknown as typeof actual.projectEnvironment,
96 };
97});
98vi.mock(import("~/state/use-atom-command"), async (original) => ({
99 ...(await original()),
100 useAtomCommand: ((command: "update" | "delete") => state[command]) as never,
101}));
102vi.mock(import("~/hooks/useSettings"), async (original) => ({
103 ...(await original()),
104 useClientSettings: ((selector?: (settings: typeof DEFAULT_CLIENT_SETTINGS) => unknown) =>
105 selector ? selector(DEFAULT_CLIENT_SETTINGS) : DEFAULT_CLIENT_SETTINGS) as never,
106}));
107vi.mock(import("~/localApi"), async (original) => ({
108 ...(await original()),
109 readLocalApi: (() => ({ dialogs: { confirm: state.confirm } })) as never,
110}));
111vi.mock(import("~/lib/composerDraftUploads"), async (original) => ({
112 ...(await original()),
113 releaseProjectDraftUploads: state.releaseUploads,
114}));
115// No toaster is mounted in these tests; the guard's error toast is read at this seam.
116vi.mock(import("../ui/toast"), async (original) => {
117 const actual = await original();
118 return { ...actual, toastManager: { ...actual.toastManager, add: state.toast } };
119});
120// These sections have separate data sources and their own tests.
121vi.mock(import("./ProjectDefaultsSettings"), async (original) => ({
122 ...(await original()),
123 ProjectDefaultsSettings: (() => null) as never,
124}));
125vi.mock(import("./ProjectActionsSettings"), async (original) => ({
126 ...(await original()),
127 ProjectActionsSettings: (() => null) as never,
128}));
129
130vi.mock(import("../files/projectFilesQueryState"), async (original) => ({
131 ...(await original()),
132 getProjectFileQueryAtom: () => missingProjectFile,
133}));
134
135import { useComposerDraftStore } from "../../composerDraftStore";
136import { appAtomRegistry } from "../../rpc/atomRegistry";
137import { assetEnvironment } from "../../state/assets";
138import { buildSidebarProjectSnapshots } from "../../sidebarProjectGrouping";
139import { ProjectSettingsPanel } from "./ProjectSettingsPanel";
140import { ProjectsSettings } from "./ProjectsSettings";
141import { SettingsScopeProvider } from "./SettingsScopeContext";
142import { SettingsScopeNotice } from "./SettingsScopeNotice";
143import { validateSettingsScopeSearch, type SettingsScopeSearch } from "./settingsScope";
144import { retainSettingsScope, validateSettingsRouteSearch } from "./settingsScopeNavigation";
145
146const primaryId = EnvironmentId.make("primary");
147const remoteId = EnvironmentId.make("remote");
148const instanceId = ProviderInstanceId.make("codex");
149const environments = [primaryId, remoteId].map((environmentId) => ({
150 environmentId,
151 label: environmentId,
152 connection: { phase: "connected" },
153 serverConfig: {
154 keybindings: DEFAULT_RESOLVED_KEYBINDINGS,
155 settings: DEFAULT_SERVER_SETTINGS,
156 environment: { platform: { machine: "server" }, capabilities: { projectOrganization: true } },
157 },
158}));
159const session = (scopes: ReadonlyArray<AuthEnvironmentScope>): AuthSessionState => ({
160 authenticated: true,
161 scopes,
162 auth: {
163 policy: "remote-reachable",
164 bootstrapMethods: ["one-time-token"],
165 sessionMethods: ["bearer-access-token"],
166 sessionCookieName: "t3_session",
167 },
168});
169const writable = () => AsyncResult.success(session([AuthOrchestrationOperateScope]));
170const missingProjectFile = Atom.make(AsyncResult.initial<never, never>());
171
172function deferred<T>() {
173 let resolve!: (value: T) => void;
174 const promise = new Promise<T>((complete) => {
175 resolve = complete;
176 });
177 return { promise, resolve };
178}
179
180function setup() {
181 vi.clearAllMocks();
182 state.sessions.clear();
183 for (const id of [primaryId, remoteId])
184 state.sessions.set(id, Atom.make<SessionResult>(writable()).pipe(Atom.keepAlive));
185 state.projects = [primaryId, remoteId].map((environmentId) => ({
186 id: ProjectId.make(`project-${environmentId}`),
187 environmentId,
188 title: "Shared repo",
189 workspaceRoot: `/work/${environmentId}`,
190 repositoryIdentity: {
191 canonicalKey: "github.com/example/shared-repo",
192 locator: {
193 source: "git-remote",
194 remoteName: "origin",
195 remoteUrl: "https://github.com/example/shared-repo.git",
196 },
197 },
198 defaultModelSelection: { instanceId, model: "gpt-5-codex" },
199 createdAt: "2026-01-01T00:00:00.000Z",
200 updatedAt: "2026-01-01T00:00:00.000Z",
201 scripts: [],
202 }));
203 state.update.mockImplementation(async ({ environmentId, input }) => {
204 const { projectId, ...updates } = input;
205 const patch = Object.fromEntries(
206 Object.entries(updates).filter(([, value]) => value !== undefined),
207 ) as Partial<Project>;
208 state.projects = state.projects.map((project) =>
209 project.environmentId === environmentId && project.id === projectId
210 ? { ...project, ...patch }
211 : project,
212 );
213 return AsyncResult.success(undefined);
214 });
215 state.delete.mockResolvedValue(AsyncResult.success(undefined));
216 state.confirm.mockResolvedValue(true);
217 useComposerDraftStore.setState({ clearProjectDraftThreadId: state.clearDraft });
218}
219
220function projectKey() {
221 return buildSidebarProjectSnapshots({
222 projects: state.projects,
223 settings: DEFAULT_CLIENT_SETTINGS,
224 primaryEnvironmentId: primaryId,
225 resolveEnvironmentLabel: (id) => id,
226 })[0]!.projectKey;
227}
228
229async function mountPanel(search: Omit<SettingsScopeSearch, "project"> = {}) {
230 const key = projectKey();
231 const rootRoute = createRootRoute();
232 const settingsRoute = createRoute({
233 getParentRoute: () => rootRoute,
234 path: "settings",
235 validateSearch: validateSettingsRouteSearch,
236 search: { middlewares: [retainSettingsScope] },
237 });
238 const projectsRoute = createRoute({
239 getParentRoute: () => settingsRoute,
240 path: "projects",
241 component: () => (
242 <ProjectSettingsPanel
243 projectKey={key}
244 environmentId={search.machine ? EnvironmentId.make(search.machine) : null}
245 checkoutKey={search.checkout ?? null}
246 />
247 ),
248 });
249 const query = new URLSearchParams({ project: key });
250 for (const [name, value] of Object.entries(search)) {
251 if (value !== undefined) query.set(name, value);
252 }
253 const router = createRouter({
254 routeTree: rootRoute.addChildren([settingsRoute.addChildren([projectsRoute])]),
255 history: createMemoryHistory({ initialEntries: [`/settings/projects?${query}`] }),
256 });
257 await router.load();
258 await using stack = new AsyncDisposableStack();
259 const screen = stack.use(
260 // The panel's own route tree validates settings search params, which the default router lacks.
261 await render(
262 <RegistryContext.Provider value={appAtomRegistry}>
263 <RouterProvider router={router} />
264 </RegistryContext.Provider>,
265 { router: false },
266 ),
267 );
268 await vi.waitFor(() => expect(nameInput(screen)).not.toBeNull());
269 stack.move();
270 return { ...screen, router };
271}
272
273async function mountSettings(search: SettingsScopeSearch) {
274 const searchParams = new URLSearchParams(
275 Object.entries(search).flatMap(([key, value]) => (value === undefined ? [] : [[key, value]])),
276 );
277 const route = createRootRoute({
278 validateSearch: validateSettingsScopeSearch,
279 component: () => (
280 <SettingsScopeProvider
281 search={route.useSearch()}
282 onChange={(next) => void router.navigate({ to: "/settings/projects", search: () => next })}
283 >
284 <ProjectsSettings />
285 </SettingsScopeProvider>
286 ),
287 });
288 const router = createRouter({
289 routeTree: route,
290 history: createMemoryHistory({
291 initialEntries: [`/settings/projects?${searchParams.toString()}`],
292 }),
293 });
294 await router.load();
295 // The settings route tree above validates scope search params, which the default router lacks.
296 const screen = await render(
297 <RegistryContext.Provider value={appAtomRegistry}>
298 <RouterProvider router={router} />
299 </RegistryContext.Provider>,
300 { router: false },
301 );
302 return { ...screen, router };
303}
304
305const nameInput = (screen: Screen) =>
306 screen.container.querySelector<HTMLInputElement>('[aria-label="Project name"]')!;
307const removeCheckout = (screen: Screen, root: string) =>
308 screen.container.querySelector<HTMLButtonElement>(`[aria-label="Remove checkout ${root}"]`)!;
309const removeAll = (screen: Screen) =>
310 [...screen.container.querySelectorAll("button")].find((button) =>
311 button.textContent?.includes("Remove all entries"),
312 )!;
313
314async function grant(id: EnvironmentId, result: SessionResult) {
315 await act(async () => appAtomRegistry.set(state.sessions.get(id)!, result));
316}
317
318async function rename(screen: Screen, title: string) {
319 await userEvent.fill(nameInput(screen), title);
320 await userEvent.keyboard("{Enter}");
321}
322
323// The recheck reports the denial by toast; seeing it proves the recheck ran.
324async function expectProjectAccessDeniedToast(title: string) {
325 await vi.waitFor(() =>
326 expect(state.toast).toHaveBeenCalledWith(
327 expect.objectContaining({
328 type: "error",
329 title,
330 description: "This connection cannot change projects in remote.",
331 }),
332 ),
333 );
334 expect(state.toast).toHaveBeenCalledOnce();
335}
336
337describe("project organization", () => {
338 it("archives the checkout on every machine while one machine is picked", async () => {
339 setup();
340 await using _screen = await mountPanel({ machine: primaryId });
341 await userEvent.click(page.getByRole("button", { name: "Archive" }));
342 await vi.waitFor(() => expect(state.update).toHaveBeenCalledTimes(2));
343 expect(
344 state.update.mock.calls.map(([request]) => [request.environmentId, request.input.archived]),
345 ).toEqual([
346 [primaryId, true],
347 [remoteId, true],
348 ]);
349 });
350});
351
352describe("project settings permissions", () => {
353 it("disables shared edits when any member lacks project access", async () => {
354 setup();
355 await grant(remoteId, AsyncResult.success(session([AuthSettingsWriteScope])));
356 await using screen = await mountPanel();
357
358 expect(nameInput(screen).disabled).toBe(true);
359 expect(removeAll(screen).disabled).toBe(true);
360 expect(screen.container.textContent).toContain(
361 "Shared settings require permission to change every checkout in this group.",
362 );
363 expect(state.update).not.toHaveBeenCalled();
364 });
365
366 it("renames every member when all have project access without settings access", async () => {
367 setup();
368 await using screen = await mountPanel();
369 await rename(screen, "Renamed");
370 expect(state.update.mock.calls.map(([request]) => request.environmentId)).toEqual([
371 primaryId,
372 remoteId,
373 ]);
374 expect(nameInput(screen).value).toBe("Renamed");
375 });
376
377 it("stops before the next member if its grant is revoked during an earlier update", async () => {
378 setup();
379 const firstUpdate = deferred<AsyncResult.Success<void>>();
380 state.update.mockReturnValueOnce(firstUpdate.promise);
381 await using screen = await mountPanel();
382 await rename(screen, "Renamed");
383 expect(state.update).toHaveBeenCalledOnce();
384
385 await grant(remoteId, AsyncResult.success(session([])));
386 await act(async () => {
387 firstUpdate.resolve(AsyncResult.success(undefined));
388 await firstUpdate.promise;
389 });
390 await expectProjectAccessDeniedToast("Failed to rename project");
391 expect(state.update).toHaveBeenCalledOnce();
392 expect(state.update.mock.calls[0]![0].environmentId).toBe(primaryId);
393 });
394
395 it("disables removal for a checkout whose project grant is missing", async () => {
396 setup();
397 await grant(remoteId, AsyncResult.success(session([])));
398 await using screen = await mountPanel();
399 expect(removeCheckout(screen, "/work/remote").disabled).toBe(true);
400 expect(removeCheckout(screen, "/work/primary").disabled).toBe(false);
401 });
402
403 it("removes a writable checkout while removal of the mixed group stays denied", async () => {
404 setup();
405 await grant(remoteId, AsyncResult.success(session([])));
406 await using screen = await mountPanel();
407 const initialHref = screen.router.state.location.href;
408 expect(removeAll(screen).disabled).toBe(true);
409
410 await userEvent.click(removeCheckout(screen, "/work/primary"));
411 await vi.waitFor(() => expect(state.delete).toHaveBeenCalledOnce());
412 expect(state.delete).toHaveBeenCalledWith({
413 environmentId: primaryId,
414 input: { projectId: state.projects[0]!.id, force: true },
415 });
416 await vi.waitFor(() => expect(state.releaseUploads).toHaveBeenCalledOnce());
417 expect(state.clearDraft).toHaveBeenCalledOnce();
418 expect(screen.router.state.location.href).toBe(initialHref);
419 });
420
421 it("rechecks every removal target after confirmation before deleting or clearing drafts", async () => {
422 setup();
423 const confirmed = deferred<boolean>();
424 state.confirm.mockReturnValueOnce(confirmed.promise);
425 await using screen = await mountPanel();
426 await userEvent.click(removeAll(screen));
427 expect(state.confirm).toHaveBeenCalledOnce();
428
429 await grant(remoteId, AsyncResult.success(session([])));
430 await act(async () => {
431 confirmed.resolve(true);
432 await confirmed.promise;
433 });
434 await expectProjectAccessDeniedToast("Failed to remove project");
435 expect(state.delete).not.toHaveBeenCalled();
436 expect(state.releaseUploads).not.toHaveBeenCalled();
437 expect(state.clearDraft).not.toHaveBeenCalled();
438 });
439
440 it("does not save an edit whose grant was revoked mid-edit, and recovers when restored", async () => {
441 setup();
442 await using screen = await mountPanel();
443 await userEvent.fill(nameInput(screen), "Renamed");
444 await grant(remoteId, AsyncResult.success(session([])));
445 // Chromium takes focus off a newly disabled input without firing blur. Send the
446 // focusout so the save attempt runs and hits the same recheck as a real blur.
447 await act(async () => {
448 nameInput(screen).dispatchEvent(new FocusEvent("focusout", { bubbles: true }));
449 });
450 await expectProjectAccessDeniedToast("Failed to rename project");
451 expect(state.update).not.toHaveBeenCalled();
452 expect(nameInput(screen).disabled).toBe(true);
453
454 await grant(remoteId, writable());
455 expect(nameInput(screen).disabled).toBe(false);
456 await rename(screen, "Recovered");
457 await vi.waitFor(() => expect(state.update).toHaveBeenCalledTimes(2));
458 expect(nameInput(screen).value).toBe("Recovered");
459 });
460
461 it.each([
462 ["loading", () => AsyncResult.initial<AuthSessionState, Error>(), false],
463 [
464 "failed",
465 () => AsyncResult.failure<AuthSessionState, Error>(Cause.fail(new Error("Disconnected"))),
466 false,
467 ],
468 ["refreshing", () => AsyncResult.waiting(writable()), true],
469 ] as const)(
470 "uses the current grant while a member's session is %s",
471 async (_state, result, allowed) => {
472 setup();
473 await grant(remoteId, result());
474 await using screen = await mountPanel();
475 expect(nameInput(screen).disabled).toBe(!allowed);
476 if (!allowed) return;
477 await rename(screen, "Renamed");
478 expect(state.update).toHaveBeenCalledTimes(2);
479 },
480 );
481});
482
483describe("project identity reset", () => {
484 const scratchIcon = { kind: "lucide", name: "message-square-dashed", color: "gray" } as const;
485 const resetButton = (screen: Screen, label: string) =>
486 screen.container.querySelector<HTMLButtonElement>(`[aria-label="Reset ${label} to default"]`);
487 const asScratch = (project: Project): Project => ({
488 ...project,
489 isScratch: true,
490 title: "Notes",
491 workspaceRoot: "/t3/scratch",
492 projectIcon: { kind: "emoji", emoji: "📝" },
493 });
494
495 it("restores a renamed scratch project's built-in name and icon", async () => {
496 setup();
497 state.projects = [{ ...asScratch(state.projects[0]!), faviconPath: null, projectIcon: null }];
498 await using screen = await mountPanel();
499
500 await userEvent.click(resetButton(screen, "project name")!);
501 await vi.waitFor(() =>
502 expect(state.update).toHaveBeenCalledWith({
503 environmentId: primaryId,
504 input: { projectId: state.projects[0]!.id, title: "No project" },
505 }),
506 );
507 await userEvent.click(resetButton(screen, "project icon")!);
508 await vi.waitFor(() =>
509 expect(state.update).toHaveBeenLastCalledWith({
510 environmentId: primaryId,
511 input: { projectId: state.projects[0]!.id, faviconPath: null, projectIcon: scratchIcon },
512 }),
513 );
514 });
515
516 it("resets each member of a mixed group to its own default icon", async () => {
517 setup();
518 const [primary, remote] = state.projects;
519 state.projects = [asScratch(primary!), { ...remote!, faviconPath: "logo.png" }];
520 await using screen = await mountPanel();
521
522 expect(resetButton(screen, "project name")).toBeNull();
523 await userEvent.click(resetButton(screen, "project icon")!);
524 await vi.waitFor(() => expect(state.update).toHaveBeenCalledTimes(2));
525 expect(state.update.mock.calls.map(([request]) => request)).toEqual([
526 {
527 environmentId: primaryId,
528 input: { projectId: primary!.id, faviconPath: null, projectIcon: scratchIcon },
529 },
530 {
531 environmentId: remoteId,
532 input: { projectId: remote!.id, faviconPath: null, projectIcon: null },
533 },
534 ]);
535 });
536
537 it("refreshes a saved checkout's icon when a later checkout update fails", async () => {
538 setup();
539 state.projects = state.projects.map((project) => ({ ...project, faviconPath: "logo.png" }));
540 let iconExists = false;
541 const iconUrl = Atom.make(() =>
542 AsyncResult.success({
543 expiresAt: 4_000_000_000_000,
544 relativeUrl: iconExists ? "/restored-icon.svg" : "/project-favicon-missing",
545 }),
546 );
547 using _mount = { [Symbol.dispose]: appAtomRegistry.mount(iconUrl) };
548 const createUrl = assetEnvironment.createUrl;
549 using _createUrl = vi
550 .spyOn(assetEnvironment, "createUrl")
551 .mockImplementation((target) =>
552 target.environmentId === primaryId ? iconUrl : createUrl(target),
553 );
554 state.update
555 .mockResolvedValueOnce(AsyncResult.success(undefined))
556 .mockResolvedValueOnce(AsyncResult.failure(Cause.fail(new Error("Save failed"))));
557 await using screen = await mountPanel();
558 expect(appAtomRegistry.get(iconUrl).value.relativeUrl).toBe("/project-favicon-missing");
559
560 iconExists = true;
561 await userEvent.click(resetButton(screen, "project icon")!);
562
563 await vi.waitFor(() =>
564 expect(appAtomRegistry.get(iconUrl).value.relativeUrl).toBe("/restored-icon.svg"),
565 );
566 expect(state.toast).toHaveBeenCalledWith(
567 expect.objectContaining({ title: "Failed to update project icon on remote" }),
568 );
569 });
570});
571
572it("opens the fallback search target across all environments from a checkout", async () => {
573 setup();
574 const root = createRootRoute();
575 const settings = createRoute({
576 getParentRoute: () => root,
577 path: "settings",
578 validateSearch: validateSettingsRouteSearch,
579 search: { middlewares: [retainSettingsScope] },
580 });
581 const threads = createRoute({
582 getParentRoute: () => settings,
583 path: "threads",
584 component: () => (
585 <SettingsScopeProvider search={settings.useSearch()} onChange={() => {}}>
586 <SettingsScopeNotice target="all" targetId="fallback-model">
587 Choose all environments to edit the fallback model.
588 </SettingsScopeNotice>
589 </SettingsScopeProvider>
590 ),
591 });
592 const query = new URLSearchParams({
593 project: projectKey(),
594 machine: primaryId,
595 checkout: "primary:/work/primary",
596 });
597 const router = createRouter({
598 routeTree: root.addChildren([settings.addChildren([threads])]),
599 history: createMemoryHistory({ initialEntries: [`/settings/threads?${query}#fallback-model`] }),
600 });
601 await router.load();
602 // This route needs the real scope-retention middleware used by settings search.
603 await using _screen = await render(
604 <RegistryContext.Provider value={appAtomRegistry}>
605 <RouterProvider router={router} />
606 </RegistryContext.Provider>,
607 { router: false },
608 );
609 await userEvent.click(page.getByRole("button", { name: "Open all environments" }));
610 await vi.waitFor(() => expect(router.state.location.search).toEqual({}));
611 expect(router.state.location.hash).toBe("fallback-model");
612});
613
614describe("project settings scope", () => {
615 const environmentMenu = () => page.getByRole("button", { name: /^Environment scope:/ });
616 const primaryOption = () => page.getByRole("menuitemradio", { name: /^primary/ });
617 const remoteOption = () => page.getByRole("menuitemradio", { name: /^remote/ });
618
619 it("offers every environment while no project is selected", async () => {
620 setup();
621 state.projects = state.projects.filter((project) => project.environmentId === primaryId);
622 await using _screen = await mountSettings({});
623
624 await userEvent.click(environmentMenu());
625 await expect.element(primaryOption()).toBeVisible();
626 await expect.element(remoteOption()).toBeVisible();
627 });
628
629 it("offers only the selected project's checkout environments", async () => {
630 setup();
631 state.projects = state.projects.filter((project) => project.environmentId === primaryId);
632 await using _screen = await mountSettings({ project: projectKey() });
633
634 await expect.element(page.getByRole("textbox", { name: "Project name" })).toBeVisible();
635 await userEvent.click(environmentMenu());
636 await expect.element(primaryOption()).toBeVisible();
637 await expect.element(remoteOption()).not.toBeInTheDocument();
638 });
639
640 it("reaches each checkout on one environment and returns to all of them", async () => {
641 setup();
642 const [first] = state.projects;
643 state.projects = [
644 { ...first!, id: ProjectId.make("clone-a"), workspaceRoot: "/work/clone-a" },
645 { ...first!, id: ProjectId.make("clone-b"), workspaceRoot: "/work/clone-b" },
646 ];
647 const key = projectKey();
648 await using screen = await mountSettings({ project: key, machine: primaryId });
649
650 await userEvent.click(page.getByRole("button", { name: "Checkout scope: All checkouts" }));
651 await userEvent.click(page.getByRole("menuitemradio", { name: /clone-b/ }));
652
653 await expect
654 .element(page.getByRole("button", { name: "Checkout scope: clone-b" }))
655 .toBeVisible();
656 expect(screen.router.state.location.search).toMatchObject({
657 project: key,
658 machine: primaryId,
659 checkout: expect.stringContaining("clone-b"),
660 });
661
662 await userEvent.click(page.getByRole("button", { name: "Checkout scope: clone-b" }));
663 await userEvent.click(page.getByRole("menuitemradio", { name: "All checkouts" }));
664
665 await vi.waitFor(() =>
666 expect(screen.router.state.location.search).toEqual({ project: key, machine: primaryId }),
667 );
668 });
669
670 it("keeps an unknown project recoverable from any environment", async () => {
671 setup();
672 state.projects = state.projects.filter((project) => project.environmentId === primaryId);
673 await using screen = await mountSettings({ project: "removed-project" });
674
675 await userEvent.click(environmentMenu());
676 await expect.element(primaryOption()).toBeVisible();
677 await expect.element(remoteOption()).toBeVisible();
678 await userEvent.click(remoteOption());
679 await vi.waitFor(() =>
680 expect(screen.router.state.location.search).toEqual({
681 project: "removed-project",
682 machine: remoteId,
683 }),
684 );
685 });
686
687 it.each([
688 [undefined, "This project has no checkout on this environment."],
689 [
690 "removed-checkout",
691 "This checkout is no longer available in the selected project and environment.",
692 ],
693 ])("recovers a stale environment link with checkout %s", async (checkout, message) => {
694 setup();
695 state.projects = state.projects.filter((project) => project.environmentId === primaryId);
696 const key = projectKey();
697 await using screen = await mountSettings({
698 project: key,
699 machine: remoteId,
700 ...(checkout ? { checkout } : {}),
701 });
702
703 await expect.element(page.getByText(message, { exact: true })).toBeVisible();
704 await expect.element(page.getByRole("button", { name: /^Project scope:/ })).toBeVisible();
705 await expect
706 .element(page.getByRole("button", { name: "Environment scope: remote" }))
707 .toBeVisible();
708 await userEvent.click(page.getByRole("button", { name: "Show all environments" }));
709
710 await expect
711 .element(page.getByRole("textbox", { name: "Project name" }))
712 .toHaveValue("Shared repo");
713 expect(screen.router.state.location.search).toEqual({ project: key });
714 await expect
715 .element(page.getByRole("button", { name: "Environment scope: All environments" }))
716 .toBeVisible();
717 await expect.element(page.getByText(message, { exact: true })).not.toBeInTheDocument();
718 await expect
719 .element(page.getByRole("button", { name: "Remove project", exact: true }))
720 .toBeEnabled();
721 });
722});
723
724it("returns to the project overview after removal, clearing the selection but keeping the environment", async () => {
725 setup();
726 state.projects = [state.projects[1]!];
727 await using screen = await mountPanel({ machine: remoteId, checkout: "remote:/work/remote" });
728 const removeProject = [...screen.container.querySelectorAll("button")].find(
729 (button) => button.textContent === "Remove project",
730 )!;
731
732 await userEvent.click(removeProject);
733
734 await vi.waitFor(() => {
735 expect(screen.router.state.location.pathname).toBe("/settings/projects");
736 expect(screen.router.state.location.search).toEqual({ machine: remoteId });
737 });
738});
739
740describe("project name composition", () => {
741 it.each([
742 { isComposing: true, keyCode: 13 },
743 { isComposing: false, keyCode: 229 },
744 ])("does not save a partial name for $isComposing/$keyCode", async (composition) => {
745 setup();
746 await using screen = await mountPanel();
747 const input = nameInput(screen);
748 await userEvent.fill(input, "日本");
749 await act(async () => {
750 input.dispatchEvent(
751 new KeyboardEvent("keydown", { key: "Enter", bubbles: true, ...composition }),
752 );
753 });
754 expect(state.update).not.toHaveBeenCalled();
755 await expect.element(input).toHaveFocus();
756
757 await userEvent.type(input, "語");
758 await userEvent.keyboard("{Enter}");
759 await vi.waitFor(() => expect(state.update).toHaveBeenCalledTimes(2));
760 expect(state.projects.map((project) => project.title)).toEqual(["日本語", "日本語"]);
761 await expect.element(nameInput(screen)).toHaveValue("日本語");
762
763 await userEvent.fill(nameInput(screen), "日本語の名前");
764 await userEvent.keyboard("{Tab}");
765 await vi.waitFor(() => expect(state.update).toHaveBeenCalledTimes(4));
766 expect(state.projects.map((project) => project.title)).toEqual([
767 "日本語の名前",
768 "日本語の名前",
769 ]);
770 });
771});