Skip to content
Source
Sign inSign up
Open History to see the last commit

AddProjectScreen.test.ts

758 lines28.4 KB

1import * as NodeFS from "node:fs";
2import * as NodeFSP from "node:fs/promises";
3import * as NodeOS from "node:os";
4import * as NodePath from "node:path";
5import * as NodeModule from "node:module";
6import type { EnvironmentConnectionPhase } from "@t3tools/client-runtime/connection";
7import { workspaceDetailRouter } from "../layout/workspace/workspace-detail-selection";
8import type { NavigationState } from "@react-navigation/native";
9import { AuthOrchestrationOperateScope, AuthSourceControlWriteScope } from "@t3tools/contracts";
10import * as Cause from "effect/Cause";
11import { AsyncResult } from "effect/reactivity";
12import { act, createElement, isValidElement, type ReactNode } from "react";
13import { createRoot } from "react-dom/client";
14import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";
15​
16const state = vi.hoisted(() => ({
17 scopes: new Set<string>(),
18 baseDirectory: "",
19 projects: [] as string[],
20 existingProjects: [] as {
21 environmentId: string;
22 id: string;
23 title: string;
24 workspaceRoot: string;
25 }[],
26 createResult: null as Promise<unknown> | null,
27 createNewResult: null as Promise<unknown> | null,
28 startCloneResult: null as Promise<unknown> | null,
29 connectionStates: {} as Record<string, EnvironmentConnectionPhase>,
30 newProjectsRoot: null as string | null,
31 waitForProject: vi.fn(),
32 dispatch: vi.fn(),
33 alert: vi.fn(),
34 navigationState: undefined as NavigationState | undefined,
35 environments: [{ environmentId: "environment", environmentLabel: "Environment" }],
36}));
37​
38function loadRouters() {
39 const requireNavigation = NodeModule.createRequire(
40 NodeModule.createRequire(import.meta.url).resolve("@react-navigation/native/package.json"),
41 );
42 return requireNavigation("@react-navigation/routers") as {
43 StackRouter: typeof import("@react-navigation/native").StackRouter;
44 StackActions: typeof import("@react-navigation/native").StackActions;
45 CommonActions: typeof import("@react-navigation/native").CommonActions;
46 };
48​
49vi.mock("../layout/workspace/useSelectWorkspaceDetail", async () => {
50 const { selectWorkspaceDetail } = await import("../layout/workspace/workspace-detail-selection");
51 return {
52 useSelectWorkspaceDetail: () => (detail: Parameters<typeof selectWorkspaceDetail>[0]) =>
53 state.dispatch(selectWorkspaceDetail(detail)),
54 };
55});
56vi.mock("../../native/StackHeader", () => ({
57 nativeHeaderScrollEdgeEffects: () => undefined,
58}));
59vi.mock("../../components/ui/NavigationRow", () => ({ NavigationRow: "NavigationRow" }));
60vi.mock("../../components/ui/Button", () => ({ Button: "Button" }));
61vi.mock("../../components/ui/ScreenScrollView", () => ({ ScreenScrollView: "ScrollView" }));
62vi.mock("../settings/components/SettingsScreen", () => ({ SettingsScreen: "SettingsScreen" }));
63vi.mock("../../components/ui/ThemedSwitch", () => ({ ThemedSwitch: "Switch" }));
64vi.mock("react-native", () => ({
65 Platform: { OS: "ios" },
66 ActivityIndicator: "ActivityIndicator",
67 Alert: { alert: state.alert },
68 Pressable: "Pressable",
69 ScrollView: "ScrollView",
70 View: "View",
71}));
72vi.mock("@react-navigation/native", () => ({
73 useNavigation: () => ({
74 dispatch: state.dispatch,
75 getState: () =>
76 state.navigationState ?? {
77 index: 4,
78 routes: [
79 { key: "home", name: "Home" },
80 { key: "draft", name: "Thread", params: { draft: {} } },
81 { key: "picker", name: "NewTaskProject" },
82 { key: "add", name: "AddProject" },
83 { key: "local", name: "AddProjectLocal" },
84 ],
85 },
86 }),
87 CommonActions: { reset: (input: unknown) => input },
88 StackActions: {
89 push: (name: string, params: unknown) => ({ type: "PUSH", payload: { name, params } }),
90 },
91}));
92vi.mock("react-native-safe-area-context", () => ({
93 useSafeAreaInsets: () => ({ bottom: 0 }),
94}));
95vi.mock("../../components/ui/AppSymbol", () => ({ SymbolView: "SymbolView" }));
96vi.mock("../../components/ui/AppText", () => ({ AppText: "Text", AppTextInput: "TextInput" }));
97vi.mock("../../components/EnvironmentMachineSymbol", () => ({
98 EnvironmentMachineSymbol: "EnvironmentMachineSymbol",
99}));
100vi.mock("../../components/ui/ErrorBanner", () => ({ ErrorBanner: "ErrorBanner" }));
101vi.mock("./SourceControlIcon", () => ({ SourceControlIcon: "SourceControlIcon" }));
102vi.mock("../../lib/uuid", () => ({ uuidv4: () => "project" }));
103vi.mock("../../state/session", () => ({
104 useEnvironmentScope: (_environmentId: string, scope: string) => state.scopes.has(scope),
105 readEnvironmentScope: (_environmentId: string, scope: string) => state.scopes.has(scope),
106}));
107vi.mock("../../state/entities", () => ({
108 useProjects: () => state.existingProjects,
109 waitForProject: state.waitForProject,
110 useServerConfigs: () =>
111 new Map([
112 [
113 "environment",
114 {
115 environment: { platform: { os: "linux" }, capabilities: {} },
116 newProjectsRoot: state.newProjectsRoot,
117 settings: { addProjectBaseDirectory: state.baseDirectory },
118 },
119 ],
120 ]),
121}));
122vi.mock("../../state/use-remote-environment-registry", () => ({
123 useRemoteEnvironmentRuntime: () => ({ connectionState: "connected" }),
124 useRemoteConnectionStatus: () => ({
125 connectedEnvironments: state.environments.map((environment) => ({
126 environmentId: environment.environmentId,
127 connectionState: state.connectionStates[environment.environmentId] ?? "connected",
128 })),
129 }),
130 useSavedRemoteConnections: () => ({
131 savedConnectionsById: Object.fromEntries(
132 state.environments.map((environment) => [environment.environmentId, environment]),
133 ),
134 }),
135}));
136vi.mock("../../state/use-atom-command", () => ({ useAtomCommand: (command: unknown) => command }));
137vi.mock("../../state/use-atom-query-runner", () => ({ useAtomQueryRunner: () => () => {} }));
138vi.mock("../../state/query", () => ({ useEnvironmentQuery: () => ({ data: null }) }));
139vi.mock("../../state/presentation", () => ({
140 useEnvironmentPresentation: () => ({ isReady: true, presentation: null }),
141}));
142vi.mock("../../state/filesystem", () => ({ filesystemEnvironment: {} }));
143vi.mock("../../state/sourceControl", () => ({
144 sourceControlEnvironment: {
145 discovery: (input: unknown) => input,
146 startProjectClone: async ({ input }: { input: { destinationPath: string } }) => {
147 if (state.startCloneResult) return state.startCloneResult;
148 NodeFS.mkdirSync(input.destinationPath);
149 return AsyncResult.success(undefined);
150 },
151 },
152}));
153vi.mock("../../state/projects", () => ({
154 projectEnvironment: {
155 createNew: () => state.createNewResult,
156 create: ({ input }: { input: { workspaceRoot: string } }) => {
157 if (!state.scopes.has(AuthOrchestrationOperateScope)) {
158 return Promise.resolve(
159 AsyncResult.failure(Cause.fail(new Error("Project creation denied"))),
160 );
161 }
162 state.projects.push(input.workspaceRoot);
163 return state.createResult ?? Promise.resolve(AsyncResult.success(undefined));
164 },
165 },
166}));
167​
168vi.mock("../../state/use-composer-drafts", () => ({
169 waitForComposerDraftsLoaded: async () => {},
170 createNewTaskDraft: () => "prompt-draft",
171 setComposerDraftText: () => {},
172}));
173​
174import {
175 AddProjectNewScreen,
176 AddProjectDestinationScreen,
177 AddProjectLocalFolderScreen,
178 AddProjectSourceScreen,
179} from "./AddProjectScreen";
180import { AddProjectSourceRoute } from "./AddProjectSourceRoute";
181​
182function findAction(
183 node: ReactNode,
184 label: string,
185 includeDisabled = false,
186): (() => unknown) | null {
187 if (Array.isArray(node)) {
188 for (const child of node) {
189 const action = findAction(child, label, includeDisabled);
190 if (action) return action;
191 }
192 return null;
193 }
194 if (
195 !isValidElement<{
196 label?: string;
197 title?: string;
198 onPress?: () => unknown;
199 disabled?: boolean;
200 children?: ReactNode;
201 }>(node)
202 ) {
203 return null;
204 }
205 if ((node.props.label ?? node.props.title) === label) {
206 return node.props.disabled && !includeDisabled ? null : (node.props.onPress ?? null);
207 }
208 return findAction(node.props.children, label, includeDisabled);
210​
211const mountedRoots: ReturnType<typeof createRoot>[] = [];
212afterEach(() => {
213 for (const root of mountedRoots.splice(0)) act(() => root.unmount());
214});
215function renderScreen(render: () => ReactNode) {
216 (globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
217 const root = createRoot(document.createElement("div"));
218 mountedRoots.push(root);
219 let screen: ReactNode;
220 function Observer() {
221 screen = render();
222 return null;
223 }
224 act(() => root.render(createElement(Observer)));
225 return screen;
227​
228function cloneAction() {
229 const action = findAction(
230 renderScreen(() =>
231 AddProjectDestinationScreen({
232 environmentId: "environment",
233 remoteUrl: "https://example.com/repo.git",
234 repositoryName: "repo",
235 }),
236 ),
237 "Clone project",
238 true,
239 );
240 if (!action) throw new Error("Clone action missing");
241 return action;
243​
244describe("clone project permissions", () => {
245 beforeEach(async () => {
246 state.baseDirectory = await NodeFSP.mkdtemp(
247 NodePath.join(NodeOS.tmpdir(), "t3-clone-permissions-"),
248 );
249 state.scopes = new Set([AuthSourceControlWriteScope]);
250 state.projects = [];
251 state.createResult = null;
252 });
253​
254 afterEach(async () => {
255 await NodeFSP.rm(state.baseDirectory, { recursive: true, force: true });
256 });
257​
258 it("does not leave a clone on disk when project creation is denied", async () => {
259 await cloneAction()();
260​
261 expect(NodeFS.existsSync(NodePath.join(state.baseDirectory, "repo"))).toBe(false);
262 expect(state.projects).toEqual([]);
263 });
264​
265 it.each([AuthSourceControlWriteScope, AuthOrchestrationOperateScope])(
266 "rechecks %s before a retained clone action creates a directory",
267 async (scope) => {
268 state.scopes.add(AuthOrchestrationOperateScope);
269 const submit = cloneAction();
270 state.scopes.delete(scope);
271 await submit();
272​
273 expect(NodeFS.existsSync(NodePath.join(state.baseDirectory, "repo"))).toBe(false);
274 expect(state.projects).toEqual([]);
275 },
276 );
277});
278​
279function mountProjectFlow(
280 withDraft: boolean,
281 withChooser = true,
282 withPullRequest = false,
283 screenName = "AddProjectLocal",
284) {
285 const { StackRouter, StackActions, CommonActions } = loadRouters();
286 const base = StackRouter({});
287 const router = { ...base, ...workspaceDetailRouter(base) };
288 const options = {
289 routeNames: [
290 "Home",
291 "Thread",
292 "PullRequest",
293 "PullRequestFile",
294 "NewTaskProject",
295 "AddProject",
296 "AddProjectLocal",
297 "AddProjectNew",
298 "AddProjectDestination",
299 ],
300 routeParamList: {},
301 routeGetIdList: {},
302 };
303 let current = router.getInitialState(options);
304 const home = current.routes[0]!;
305 const apply = (action: Parameters<typeof router.getStateForAction>[1]) => {
306 const next = router.getStateForAction(current, action, options);
307 if (!next || next.stale !== false) throw new Error("Navigation action rejected");
308 current = next;
309 state.navigationState = current;
310 };
311 if (withPullRequest) {
312 apply(StackActions.push("PullRequest", { number: 123 }));
313 apply(StackActions.push("PullRequestFile", { path: "file.ts" }));
314 }
315 const underlyingRoutes = current.routes;
316 if (withDraft) {
317 apply(StackActions.push("Thread", { draft: { projectId: "previous-project" } }));
318 }
319 const draftKey = withDraft ? current.routes[current.index]!.key : null;
320 for (const name of [...(withChooser ? ["NewTaskProject"] : []), "AddProject", screenName]) {
321 apply(StackActions.push(name));
322 }
323 state.navigationState = current;
324 state.dispatch.mockImplementation((action) =>
325 apply(
326 action.type === "PUSH" || action.type === "SELECT_WORKSPACE_DETAIL"
327 ? action
328 : CommonActions.reset(action),
329 ),
330 );
331 return {
332 home,
333 draftKey,
334 underlyingRoutes,
335 flowRoutes: current.routes.slice(underlyingRoutes.length),
336 getState: () => current,
337 back: () => apply(StackActions.pop()),
338 setParams: (params: object) => apply(CommonActions.setParams(params)),
339 push: (name: string) => apply(StackActions.push(name)),
340 };
342​
343describe("add project source environment", () => {
344 it("blocks local add on a requested unavailable host until reconnect or manual choice", async () => {
345 state.scopes = new Set([AuthOrchestrationOperateScope]);
346 state.dispatch.mockReset();
347 state.environments = [
348 { environmentId: "environment", environmentLabel: "Environment" },
349 { environmentId: "another-environment", environmentLabel: "Another environment" },
350 ];
351 (globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
352 const root = createRoot(document.createElement("div"));
353 let screen: ReactNode;
354 function SourceObserver() {
355 screen = AddProjectSourceScreen({ environmentId: "environment" });
356 return null;
357 }
358 try {
359 for (const phase of ["available", "offline", "error"] as const) {
360 state.connectionStates = { environment: phase };
361 await act(() => root.render(createElement(SourceObserver)));
362 expect(findAction(screen, "Local folder")).toBeNull();
363 expect(state.dispatch).not.toHaveBeenCalled();
364 }
365 state.connectionStates = {};
366 await act(() => root.render(createElement(SourceObserver)));
367 const reconnectedLocal = findAction(screen, "Local folder");
368 if (!reconnectedLocal) throw new Error("Reconnected local folder action missing");
369 reconnectedLocal();
370 expect(state.dispatch).toHaveBeenLastCalledWith({
371 type: "PUSH",
372 payload: { name: "AddProjectLocal", params: { environmentId: "environment" } },
373 });
374 state.connectionStates = { environment: "offline" };
375 await act(() => root.render(createElement(SourceObserver)));
376 expect(findAction(screen, "Local folder")).toBeNull();
377 const select = findAction(screen, "Another environment");
378 if (!select) throw new Error("Connected environment selection missing");
379 await act(() => select());
380 const local = findAction(screen, "Local folder");
381 if (!local) throw new Error("Manually selected local folder action missing");
382 local();
383 expect(state.dispatch).toHaveBeenLastCalledWith({
384 type: "PUSH",
385 payload: { name: "AddProjectLocal", params: { environmentId: "another-environment" } },
386 });
387 } finally {
388 await act(() => root.unmount());
389 state.connectionStates = {};
390 state.environments = [{ environmentId: "environment", environmentLabel: "Environment" }];
391 }
392 });
393​
394 it("keeps a manual host selection when the requested host finishes connecting", async () => {
395 state.scopes = new Set([AuthOrchestrationOperateScope]);
396 state.dispatch.mockReset();
397 const navigation = mountProjectFlow(false, true, false, "AddProject");
398 state.environments = [
399 { environmentId: "environment", environmentLabel: "Environment" },
400 { environmentId: "another-environment", environmentLabel: "Another environment" },
401 ];
402 state.connectionStates = { environment: "connecting" };
403 (globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
404 const root = createRoot(document.createElement("div"));
405 let screen: ReactNode;
406 function SourceObserver() {
407 screen = AddProjectSourceScreen({ environmentId: "environment" });
408 return null;
409 }
410 try {
411 await act(() => root.render(createElement(SourceObserver)));
412 expect(findAction(screen, "Local folder")).toBeNull();
413 expect(navigation.getState().routes.at(-1)?.name).toBe("AddProject");
414 const select = findAction(screen, "Another environment");
415 if (!select) throw new Error("Connected environment selection missing");
416 await act(() => select());
417 state.connectionStates = {};
418 await act(() => root.render(createElement(SourceObserver)));
419 const local = findAction(screen, "Local folder");
420 if (!local) throw new Error("Local folder action missing");
421 local();
422 expect(navigation.getState().routes.at(-1)).toMatchObject({
423 name: "AddProjectLocal",
424 params: { environmentId: "another-environment" },
425 });
426 } finally {
427 await act(() => root.unmount());
428 state.connectionStates = {};
429 state.environments = [{ environmentId: "environment", environmentLabel: "Environment" }];
430 }
431 });
432​
433 it("follows warm environment requests while preserving manual selection between requests", async () => {
434 state.scopes = new Set([AuthOrchestrationOperateScope]);
435 state.dispatch.mockReset();
436 const navigation = mountProjectFlow(false, true, false, "AddProject");
437 state.environments = [
438 { environmentId: "environment", environmentLabel: "Environment" },
439 { environmentId: "another-environment", environmentLabel: "Another environment" },
440 ];
441 (globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
442 const root = createRoot(document.createElement("div"));
443 let actions: { local: () => unknown; selectEnvironment: () => unknown } | undefined;
444 function SourceRouteObserver(props: { environmentId?: string | string[] }) {
445 const route = AddProjectSourceRoute({ route: { params: props } });
446 const screen = AddProjectSourceScreen(route.props);
447 const local = findAction(screen, "Local folder");
448 const selectEnvironment = findAction(screen, "Environment");
449 if (!local || !selectEnvironment) throw new Error("Source actions missing");
450 actions = { local, selectEnvironment };
451 return null;
452 }
453 const openLocalFolder = (environmentId: string) => {
454 state.dispatch.mockClear();
455 actions!.local();
456 expect(navigation.getState().routes.at(-1)).toMatchObject({
457 name: "AddProjectLocal",
458 params: { environmentId },
459 });
460 navigation.back();
461 };
462 try {
463 await act(() =>
464 root.render(createElement(SourceRouteObserver, { environmentId: "environment" })),
465 );
466 openLocalFolder("environment");
467 await act(() =>
468 root.render(createElement(SourceRouteObserver, { environmentId: "another-environment" })),
469 );
470 openLocalFolder("another-environment");
471 await act(() => actions!.selectEnvironment());
472 await act(() =>
473 root.render(createElement(SourceRouteObserver, { environmentId: ["another-environment"] })),
474 );
475 openLocalFolder("environment");
476 await act(() =>
477 root.render(createElement(SourceRouteObserver, { environmentId: "environment" })),
478 );
479 await act(() =>
480 root.render(createElement(SourceRouteObserver, { environmentId: "another-environment" })),
481 );
482 openLocalFolder("another-environment");
483 } finally {
484 await act(() => root.unmount());
485 state.environments = [{ environmentId: "environment", environmentLabel: "Environment" }];
486 }
487 });
488});
489​
490describe("local project navigation", () => {
491 function setup() {
492 state.navigationState = undefined;
493 state.scopes = new Set([AuthOrchestrationOperateScope]);
494 state.baseDirectory = "/tmp/t3-mobile-audit-fixture";
495 state.projects = [];
496 state.dispatch.mockReset();
497 state.alert.mockReset();
498 state.waitForProject.mockReset();
499 const created = Promise.withResolvers<ReturnType<typeof AsyncResult.success<void>>>();
500 const projected = Promise.withResolvers<unknown>();
501 state.createResult = created.promise;
502 state.waitForProject.mockReturnValue(projected.promise);
503 const submit = findAction(
504 renderScreen(() => AddProjectLocalFolderScreen({ environmentId: "environment" })),
505 "Add project",
506 );
507 if (!submit) throw new Error("Add project action missing");
508 return { created, projected, submit };
509 }
510​
511 it("keeps navigation in place and explains a project projection timeout", async () => {
512 const { created, projected, submit } = setup();
513 const submission = submit();
514 created.resolve(AsyncResult.success(undefined));
515 projected.resolve(null);
516 await submission;
517​
518 expect(state.projects).toEqual(["/tmp/t3-mobile-audit-fixture"]);
519 expect(state.dispatch).not.toHaveBeenCalled();
520 expect(state.alert).toHaveBeenCalledExactlyOnceWith(
521 "Project added",
522 "The project was created but has not reached this device yet. It will appear in the project list once the connection catches up.",
523 );
524 });
525​
526 it("does not replace a reopened flow when the previous submission finishes", async () => {
527 const { created, projected, submit } = setup();
528 const navigation = mountProjectFlow(false);
529 const submission = submit();
530 created.resolve(AsyncResult.success(undefined));
531 await created.promise;
532 navigation.back();
533 navigation.push("AddProjectLocal");
534 const remaining = navigation.getState();
535 projected.resolve({ environmentId: "environment", id: "project" });
536 await submission;
537​
538 expect(state.projects).toEqual(["/tmp/t3-mobile-audit-fixture"]);
539 expect(navigation.getState()).toEqual(remaining);
540 expect(state.dispatch).not.toHaveBeenCalled();
541 });
542​
543 it("does not replace a warm-linked flow sharing the original route key", async () => {
544 const { created, projected, submit } = setup();
545 const navigation = mountProjectFlow(false);
546 const submission = submit();
547 created.resolve(AsyncResult.success(undefined));
548 await created.promise;
549 const originalKey = navigation.getState().routes.at(-1)!.key;
550 navigation.setParams({ environmentId: "other-environment" });
551 const remaining = navigation.getState();
552 expect(remaining.routes.at(-1)!.key).toBe(originalKey);
553 projected.resolve({ environmentId: "environment", id: "project" });
554 await submission;
555​
556 expect(navigation.getState()).toEqual(remaining);
557 expect(state.dispatch).not.toHaveBeenCalled();
558 });
559​
560 it("does not redirect a reopened flow when an earlier new project finishes", async () => {
561 const { projected } = setup();
562 state.newProjectsRoot = "/projects";
563 const created = Promise.withResolvers<unknown>();
564 const waitingForProject = Promise.withResolvers<void>();
565 state.createNewResult = created.promise;
566 state.waitForProject.mockImplementation(() => {
567 waitingForProject.resolve();
568 return projected.promise;
569 });
570 const navigation = mountProjectFlow(false, true, true, "AddProjectNew");
571 (globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
572 const root = createRoot(document.createElement("div"));
573 let screen: ReactNode;
574 function NewProjectObserver() {
575 screen = AddProjectNewScreen({ environmentId: "environment" });
576 return null;
577 }
578 function enterName(node: ReactNode): boolean {
579 if (Array.isArray(node)) return node.some(enterName);
580 if (
581 !isValidElement<{
582 placeholder?: string;
583 onChangeText?: (text: string) => void;
584 children?: ReactNode;
585 }>(node)
586 )
587 return false;
588 if (node.props.placeholder === "Project name") {
589 node.props.onChangeText!("new-project");
590 return true;
591 }
592 return enterName(node.props.children);
593 }
594 try {
595 await act(() => root.render(createElement(NewProjectObserver)));
596 await act(() => {
597 expect(enterName(screen)).toBe(true);
598 });
599 const submit = findAction(screen, "Create project");
600 if (!submit) throw new Error("Create project action missing");
601 await act(async () => {
602 submit();
603 created.resolve(
604 AsyncResult.success({
605 projectId: "project",
606 workspaceRoot: "/projects/new-project",
607 }),
608 );
609 await waitingForProject.promise;
610 });
611 navigation.back();
612 navigation.push("AddProjectNew");
613 const remaining = navigation.getState();
614 await act(async () => {
615 projected.resolve({ environmentId: "environment", id: "project" });
616 await projected.promise;
617 });
618​
619 expect(navigation.getState()).toEqual(remaining);
620 expect(state.dispatch).not.toHaveBeenCalled();
621 } finally {
622 await act(() => root.unmount());
623 state.newProjectsRoot = null;
624 state.createNewResult = null;
625 }
626 });
627​
628 it.each([
629 { origin: "Thread", withDraft: true, withChooser: true },
630 { origin: "NewTaskProject", withDraft: false, withChooser: true },
631 { origin: "AddProject", withDraft: false, withChooser: false },
632 ])(
633 "waits for projection then selects the draft from $origin",
634 async ({ withDraft, withChooser }) => {
635 const { created, projected, submit } = setup();
636 const navigation = mountProjectFlow(withDraft, withChooser, true);
637 const before = navigation.getState();
638 const submission = submit();
639 created.resolve(AsyncResult.success(undefined));
640 await created.promise;
641 expect(state.projects).toEqual(["/tmp/t3-mobile-audit-fixture"]);
642 expect(navigation.getState()).toBe(before);
643 projected.resolve({ environmentId: "environment", id: "project" });
644 await submission;
645 expect(state.dispatch).toHaveBeenCalledTimes(1);
646 expect(navigation.getState().routes.map((route) => route.name)).toEqual(["Home", "Thread"]);
647 expect(navigation.getState().routes[1]?.params).toEqual({
648 draft: {
649 environmentId: "environment",
650 projectId: "project",
651 title: "t3-mobile-audit-fixture",
652 },
653 });
654 navigation.back();
655 expect(navigation.getState().routes).toEqual([navigation.home]);
656 },
657 );
658});
659​
660describe("local folder path", () => {
661 function findPathInput(
662 node: ReactNode,
663 ): { value: string; onChangeText: (value: string) => void } | null {
664 if (Array.isArray(node)) {
665 for (const child of node) {
666 const input = findPathInput(child);
667 if (input) return input;
668 }
669 return null;
670 }
671 if (
672 !isValidElement<{
673 value?: string;
674 onChangeText?: (value: string) => void;
675 onSubmit?: () => void;
676 children?: ReactNode;
677 }>(node)
678 ) {
679 return null;
680 }
681 const { value, onChangeText, onSubmit } = node.props;
682 if (typeof value === "string" && onChangeText && onSubmit) return { value, onChangeText };
683 return findPathInput(node.props.children);
684 }
685​
686 function mountLocalFolder() {
687 state.scopes = new Set([AuthOrchestrationOperateScope]);
688 state.baseDirectory = "/work";
689 state.connectionStates = {};
690 state.environments = [
691 { environmentId: "environment", environmentLabel: "Environment" },
692 { environmentId: "another-environment", environmentLabel: "Another environment" },
693 ];
694 (globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
695 const root = createRoot(document.createElement("div"));
696 const renderedPaths: string[] = [];
697 let input: ReturnType<typeof findPathInput> = null;
698 function LocalFolderObserver(props: { environmentId?: string }) {
699 input = findPathInput(AddProjectLocalFolderScreen(props));
700 if (input) renderedPaths.push(input.value);
701 return null;
702 }
703 return {
704 renderedPaths,
705 get path() {
706 return input?.value;
707 },
708 type: (value: string) => act(() => input!.onChangeText(value)),
709 render: (environmentId?: string) =>
710 act(() => root.render(createElement(LocalFolderObserver, { environmentId }))),
711 [Symbol.asyncDispose]: async () => {
712 await act(() => root.unmount());
713 state.connectionStates = {};
714 state.environments = [{ environmentId: "environment", environmentLabel: "Environment" }];
715 },
716 };
717 }
718​
719 it("shows the new host's default path on the first render after the host changes", async () => {
720 await using screen = mountLocalFolder();
721 await screen.render("environment");
722 await screen.type("/work/edited");
723 screen.renderedPaths.length = 0;
724​
725 await screen.render("another-environment");
726​
727 expect(screen.renderedPaths).not.toContain("/work/edited");
728 expect(screen.path).toBe("~/");
729 });
730​
731 it("keeps each host's typed path when switching between hosts", async () => {
732 await using screen = mountLocalFolder();
733 await screen.render("environment");
734 await screen.type("/work/a");
735 await screen.render("another-environment");
736 await screen.type("~/b");
737​
738 await screen.render("environment");
739 expect(screen.path).toBe("/work/a");
740 await screen.render("another-environment");
741 expect(screen.path).toBe("~/b");
742 });
743​
744 it("keeps a typed path when the default host drops out and comes back", async () => {
745 await using screen = mountLocalFolder();
746 await screen.render();
747 expect(screen.path).toBe("~/");
748 await screen.type("~/code/app");
749​
750 state.connectionStates = { "another-environment": "offline" };
751 await screen.render();
752 expect(screen.path).toBe("/work/");
753​
754 state.connectionStates = {};
755 await screen.render();
756 expect(screen.path).toBe("~/code/app");
757 });
758});