The best way to control Claude Code, Codex and more from any computer or phone
| 1 | import type { NavigationState, PartialState } from "@react-navigation/native"; |
| 2 | import * as Option from "effect/Option"; |
| 3 | import { AsyncResult, Atom } from "effect/reactivity"; |
| 4 | import { describe, expect, it, vi } from "vite-plus/test"; |
| 5 | |
| 6 | const fixture = vi.hoisted(() => ({ |
| 7 | applied: [] as { draftKey: string; text: string }[], |
| 8 | root: undefined as NavigationState | undefined, |
| 9 | detailOpens: 0, |
| 10 | })); |
| 11 | |
| 12 | vi.mock("../../components/ui/Dialog", () => ({ alert: () => {} })); |
| 13 | vi.mock("./prompt-link-actions", () => ({ |
| 14 | applyLinkedPromptToThreadDraft: async (draftKey: string, prompt: { text: string }) => { |
| 15 | fixture.applied.push({ draftKey, text: prompt.text }); |
| 16 | }, |
| 17 | })); |
| 18 | vi.mock("../../lib/rootNavigation", () => ({ |
| 19 | rootNavigationRef: { getRootState: () => fixture.root }, |
| 20 | })); |
| 21 | vi.mock("../../state/atom-registry", async () => { |
| 22 | const { AtomRegistry } = await import("effect/reactivity"); |
| 23 | return { appAtomRegistry: AtomRegistry.make() }; |
| 24 | }); |
| 25 | vi.mock("../../state/threads", async () => { |
| 26 | const { AsyncResult, Atom } = await import("effect/reactivity"); |
| 27 | const Option = await import("effect/Option"); |
| 28 | const shell = Atom.make<object | null>(null); |
| 29 | const detailSource = Atom.make(AsyncResult.success({ data: Option.none() })); |
| 30 | // Computing the real detail atom opens the thread's server stream. |
| 31 | const detail = Atom.make((get) => { |
| 32 | fixture.detailOpens += 1; |
| 33 | return get(detailSource); |
| 34 | }); |
| 35 | return { |
| 36 | environmentThreadShells: { threadShellAtom: () => shell }, |
| 37 | environmentThreads: { stateAtom: () => detail }, |
| 38 | fixtureShell: shell, |
| 39 | fixtureDetail: detail, |
| 40 | fixtureDetailSource: detailSource, |
| 41 | }; |
| 42 | }); |
| 43 | |
| 44 | const { appAtomRegistry } = await import("../../state/atom-registry"); |
| 45 | const { fixtureDetail, fixtureDetailSource, fixtureShell } = |
| 46 | (await import("../../state/threads")) as unknown as { |
| 47 | fixtureShell: Atom.Writable<object | null>; |
| 48 | fixtureDetail: Atom.Atom<unknown>; |
| 49 | fixtureDetailSource: Atom.Writable<AsyncResult.AsyncResult<{ data: Option.Option<object> }>>; |
| 50 | }; |
| 51 | const { resolvePendingThreadPromptLink, takeThreadPromptLink } = await import("./threadPromptLink"); |
| 52 | |
| 53 | function setup() { |
| 54 | fixture.applied.length = 0; |
| 55 | fixture.root = undefined; |
| 56 | appAtomRegistry.reset(); |
| 57 | appAtomRegistry.set(fixtureShell, null); |
| 58 | appAtomRegistry.set(fixtureDetailSource, AsyncResult.success({ data: Option.none() })); |
| 59 | fixture.detailOpens = 0; |
| 60 | } |
| 61 | |
| 62 | const loadedDetail = AsyncResult.success({ data: Option.some({}) }); |
| 63 | |
| 64 | const threadParams = { environmentId: "env-1", threadId: "thread-1" }; |
| 65 | |
| 66 | function linkedState(prompt = "Fix the bug"): PartialState<NavigationState> { |
| 67 | return { routes: [{ name: "Thread", params: { ...threadParams, prompt } }] }; |
| 68 | } |
| 69 | |
| 70 | function stack(routes: NavigationState["routes"]): NavigationState { |
| 71 | return { |
| 72 | key: "root", |
| 73 | index: routes.length - 1, |
| 74 | routeNames: routes.map((route) => route.name), |
| 75 | routes, |
| 76 | stale: false, |
| 77 | type: "stack", |
| 78 | }; |
| 79 | } |
| 80 | |
| 81 | const threadRoute = stack([{ key: "thread", name: "Thread", params: threadParams }]); |
| 82 | |
| 83 | describe("takeThreadPromptLink", () => { |
| 84 | it("writes no draft for a thread that never shows", () => { |
| 85 | setup(); |
| 86 | takeThreadPromptLink(linkedState()); |
| 87 | expect(fixture.applied).toEqual([]); |
| 88 | |
| 89 | resolvePendingThreadPromptLink(threadRoute); |
| 90 | // An unknown thread's screen replaces itself with a new-thread draft. |
| 91 | resolvePendingThreadPromptLink( |
| 92 | stack([{ key: "draft", name: "Thread", params: { draft: { draftId: "d" } } }]), |
| 93 | ); |
| 94 | appAtomRegistry.set(fixtureShell, { id: "thread-1" }); |
| 95 | expect(fixture.applied).toEqual([]); |
| 96 | }); |
| 97 | |
| 98 | it("fills the draft once the linked thread shows on its screen", () => { |
| 99 | setup(); |
| 100 | takeThreadPromptLink(linkedState()); |
| 101 | fixture.root = threadRoute; |
| 102 | resolvePendingThreadPromptLink(threadRoute); |
| 103 | expect(fixture.applied).toEqual([]); |
| 104 | |
| 105 | appAtomRegistry.set(fixtureShell, { id: "thread-1" }); |
| 106 | expect(fixture.applied).toEqual([{ draftKey: expect.any(String), text: "Fix the bug" }]); |
| 107 | appAtomRegistry.set(fixtureShell, { id: "thread-1", title: "renamed" }); |
| 108 | expect(fixture.applied).toHaveLength(1); |
| 109 | }); |
| 110 | |
| 111 | it("fills the draft of an archived thread its screen shows from detail", () => { |
| 112 | setup(); |
| 113 | takeThreadPromptLink(linkedState()); |
| 114 | fixture.root = threadRoute; |
| 115 | // Archived threads have no shell; the open screen subscribes to their detail instead. |
| 116 | using _screen = { [Symbol.dispose]: appAtomRegistry.mount(fixtureDetail) }; |
| 117 | resolvePendingThreadPromptLink(threadRoute); |
| 118 | expect(fixture.applied).toEqual([]); |
| 119 | |
| 120 | appAtomRegistry.set(fixtureDetailSource, loadedDetail); |
| 121 | expect(fixture.applied).toEqual([{ draftKey: expect.any(String), text: "Fix the bug" }]); |
| 122 | }); |
| 123 | |
| 124 | it("opens no detail for a thread no screen has loaded", () => { |
| 125 | setup(); |
| 126 | takeThreadPromptLink(linkedState()); |
| 127 | fixture.root = threadRoute; |
| 128 | resolvePendingThreadPromptLink(threadRoute); |
| 129 | appAtomRegistry.set(fixtureDetailSource, loadedDetail); |
| 130 | expect(fixture.detailOpens).toBe(0); |
| 131 | expect(fixture.applied).toEqual([]); |
| 132 | resolvePendingThreadPromptLink(stack([{ key: "home", name: "Home" }])); |
| 133 | }); |
| 134 | |
| 135 | it("drops an earlier link to the thread when a newer one is invalid", () => { |
| 136 | setup(); |
| 137 | takeThreadPromptLink(linkedState()); |
| 138 | takeThreadPromptLink(linkedState("\u200b")); |
| 139 | fixture.root = threadRoute; |
| 140 | resolvePendingThreadPromptLink(threadRoute); |
| 141 | appAtomRegistry.set(fixtureShell, { id: "thread-1" }); |
| 142 | expect(fixture.applied).toEqual([]); |
| 143 | }); |
| 144 | }); |