The best way to control Claude Code, Codex and more from any computer or phone

main
tsx 302 lines 11 KB
Raw
1 import {
2 NavigationContext,
3 type NavigationProp,
4 type ParamListBase,
5 } from "@react-navigation/native";
6 import { AsyncResult } from "effect/reactivity";
7 import { act, useLayoutEffect } from "react";
8 import { createRoot } from "react-dom/client";
9 import { expect, it, vi } from "vite-plus/test";
10
11 const mocks = vi.hoisted(() => ({
12 enabled: true,
13 generate: vi.fn(),
14 query: {
15 data: null as { run: { _tag: "Running" | "Completed" | "Failed" } | null } | null,
16 isPending: false,
17 refresh: vi.fn<() => void>(),
18 },
19 otherQuery: {
20 data: null as { run: { _tag: "Running" | "Completed" | "Failed" } | null } | null,
21 isPending: false,
22 refresh: vi.fn<() => void>(),
23 },
24 }));
25
26 vi.mock("@react-navigation/native", async () => {
27 const { createRequire } = await import("node:module");
28 const { realpathSync } = await import("node:fs");
29 const require = createRequire(import.meta.url);
30 const nativeRequire = createRequire(
31 realpathSync(require.resolve("@react-navigation/native/package.json")),
32 );
33 // Use the shipped focus hook without importing the React Native view layer.
34 const { NavigationContext, useFocusEffect }: typeof import("@react-navigation/native") =
35 nativeRequire("@react-navigation/core");
36 return { NavigationContext, useFocusEffect };
37 });
38 vi.mock("@effect/atom-react", () => ({
39 useAtomValue: (atom: unknown) =>
40 atom === "settings" ? { reviewGuidesEnabled: mocks.enabled } : true,
41 }));
42 vi.mock("../../../state/server", () => ({
43 serverEnvironment: { settingsValueAtom: () => "settings" },
44 }));
45 vi.mock("../../../state/pull-requests", () => ({
46 composerPullRequests: {
47 reviewGuide: (target: { number: number; environmentId: string }) =>
48 target.environmentId === "environment" && target.number === 1 ? 1 : 2,
49 generateReviewGuide: { permissionAtom: () => "permission" },
50 },
51 }));
52 vi.mock("../../../state/query", () => ({
53 useEnvironmentQuery: (number: number) => ({ ...(number === 1 ? mocks.query : mocks.otherQuery) }),
54 }));
55 vi.mock("../../../state/use-atom-command", () => ({ useAtomCommand: () => mocks.generate }));
56 vi.mock("../usePullRequestConnected", () => ({ usePullRequestConnected: () => true }));
57 vi.mock("../usePullRequestDiff", () => ({
58 pullRequestTarget: (params: unknown) => params,
59 }));
60
61 import { useReviewGuide } from "./useReviewGuide";
62
63 function createNavigation() {
64 const listeners = { focus: new Set<() => void>(), blur: new Set<() => void>() };
65 let focused = true;
66 return {
67 value: {
68 isFocused: () => focused,
69 addListener: (event: keyof typeof listeners, listener: () => void) => {
70 listeners[event].add(listener);
71 return () => listeners[event].delete(listener);
72 },
73 } as unknown as NavigationProp<ParamListBase>,
74 focus(next: boolean) {
75 focused = next;
76 act(() => {
77 for (const listener of listeners[next ? "focus" : "blur"]) listener();
78 });
79 },
80 };
81 }
82
83 function setup() {
84 (globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
85 mocks.enabled = true;
86 mocks.generate = vi.fn().mockResolvedValue(AsyncResult.success(undefined));
87 mocks.query = { data: null, isPending: false, refresh: vi.fn() };
88 mocks.otherQuery = { data: null, isPending: false, refresh: vi.fn() };
89 const root = createRoot(document.createElement("div"));
90 const navigation = createNavigation();
91 const params = {
92 environmentId: "environment",
93 projectId: "project",
94 repository: "repo",
95 number: 1,
96 };
97 let current: ReturnType<typeof useReviewGuide>;
98 function Probe({
99 number,
100 environmentId,
101 visible,
102 }: {
103 number: number;
104 environmentId: string;
105 visible?: boolean;
106 }) {
107 const state = useReviewGuide({ ...params, number, environmentId }, visible);
108 useLayoutEffect(() => {
109 current = state;
110 });
111 return null;
112 }
113 return {
114 render(number = 1, environmentId = params.environmentId, visible?: boolean) {
115 act(() =>
116 root.render(
117 <NavigationContext.Provider value={navigation.value}>
118 <Probe number={number} environmentId={environmentId} visible={visible} />
119 </NavigationContext.Provider>,
120 ),
121 );
122 },
123 get current() {
124 return current;
125 },
126 focus: navigation.focus,
127 [Symbol.dispose]() {
128 act(() => root.unmount());
129 },
130 };
131 }
132
133 it("refreshes on focus and PR changes without refreshing again for query rerenders", () => {
134 using screen = setup();
135 screen.render();
136 expect(mocks.query.refresh).toHaveBeenCalledTimes(1);
137
138 mocks.query = { ...mocks.query, isPending: true };
139 screen.render();
140 mocks.query = { ...mocks.query, isPending: false, data: { run: { _tag: "Completed" } } };
141 screen.render();
142 expect(mocks.query.refresh).toHaveBeenCalledTimes(1);
143
144 screen.focus(false);
145 screen.render();
146 expect(mocks.query.refresh).toHaveBeenCalledTimes(1);
147 screen.focus(true);
148 expect(mocks.query.refresh).toHaveBeenCalledTimes(2);
149
150 screen.render(2);
151 expect(mocks.otherQuery.refresh).toHaveBeenCalledTimes(1);
152 screen.render(2);
153 expect(mocks.otherQuery.refresh).toHaveBeenCalledTimes(1);
154 expect(mocks.query.refresh).toHaveBeenCalledTimes(2);
155 });
156
157 it("preserves the polling deadline across rerenders and stops polling on blur or completion", () => {
158 vi.useFakeTimers();
159 using _timers = { [Symbol.dispose]: () => vi.useRealTimers() };
160 using screen = setup();
161 mocks.query.data = { run: { _tag: "Running" } };
162 screen.render();
163 expect(mocks.query.refresh).toHaveBeenCalledTimes(1);
164
165 act(() => vi.advanceTimersByTime(4_000));
166 mocks.query = { ...mocks.query, isPending: true, data: { run: { _tag: "Running" } } };
167 screen.render();
168 expect(mocks.query.refresh).toHaveBeenCalledTimes(1);
169 act(() => vi.advanceTimersByTime(1_000));
170 expect(mocks.query.refresh).toHaveBeenCalledTimes(2);
171
172 screen.focus(false);
173 act(() => vi.advanceTimersByTime(10_000));
174 expect(mocks.query.refresh).toHaveBeenCalledTimes(2);
175 screen.focus(true);
176 expect(mocks.query.refresh).toHaveBeenCalledTimes(3);
177 act(() => vi.advanceTimersByTime(5_000));
178 expect(mocks.query.refresh).toHaveBeenCalledTimes(4);
179
180 mocks.query = { ...mocks.query, isPending: false, data: { run: { _tag: "Completed" } } };
181 screen.render();
182 const refreshesOnCompletion = mocks.query.refresh.mock.calls.length;
183 act(() => vi.advanceTimersByTime(10_000));
184 expect(mocks.query.refresh).toHaveBeenCalledTimes(refreshesOnCompletion);
185 });
186
187 it("retires the old environment's polling on target change and clears polling on unmount", () => {
188 vi.useFakeTimers();
189 using _timers = { [Symbol.dispose]: () => vi.useRealTimers() };
190 {
191 using screen = setup();
192 mocks.query.data = { run: { _tag: "Running" } };
193 mocks.otherQuery.data = { run: { _tag: "Running" } };
194 screen.render();
195 act(() => vi.advanceTimersByTime(4_000));
196
197 screen.render(1, "other-environment");
198 expect(mocks.query.refresh).toHaveBeenCalledTimes(1);
199 expect(mocks.otherQuery.refresh).toHaveBeenCalledTimes(1);
200 act(() => vi.advanceTimersByTime(1_000));
201 expect(mocks.query.refresh).toHaveBeenCalledTimes(1);
202 expect(mocks.otherQuery.refresh).toHaveBeenCalledTimes(1);
203 act(() => vi.advanceTimersByTime(4_000));
204 expect(mocks.query.refresh).toHaveBeenCalledTimes(1);
205 expect(mocks.otherQuery.refresh).toHaveBeenCalledTimes(2);
206 }
207 act(() => vi.advanceTimersByTime(10_000));
208 expect(mocks.query.refresh).toHaveBeenCalledTimes(1);
209 expect(mocks.otherQuery.refresh).toHaveBeenCalledTimes(2);
210 expect(vi.getTimerCount()).toBe(0);
211 });
212
213 it("suspends only manual refresh while hidden, including focus and target changes", () => {
214 vi.useFakeTimers();
215 using _timers = { [Symbol.dispose]: () => vi.useRealTimers() };
216 {
217 using screen = setup();
218 mocks.query.data = { run: { _tag: "Running" } };
219 mocks.otherQuery.data = { run: { _tag: "Running" } };
220 screen.render();
221 const cached = screen.current.data;
222 screen.render(1, "environment", false);
223 act(() => vi.advanceTimersByTime(60_000));
224 expect(mocks.query.refresh).toHaveBeenCalledTimes(1);
225 expect(screen.current.data).toBe(cached);
226 screen.render();
227 expect(mocks.query.refresh).toHaveBeenCalledTimes(2);
228 act(() => vi.advanceTimersByTime(5_000));
229 expect(mocks.query.refresh).toHaveBeenCalledTimes(3);
230 screen.render(1, "environment", false);
231 screen.focus(false);
232 screen.focus(true);
233 expect(mocks.query.refresh).toHaveBeenCalledTimes(3);
234
235 screen.render(2, "other-environment", false);
236 act(() => vi.advanceTimersByTime(5_000));
237 expect(mocks.otherQuery.refresh).not.toHaveBeenCalled();
238 screen.focus(false);
239 screen.render(2, "other-environment", true);
240 expect(mocks.otherQuery.refresh).not.toHaveBeenCalled();
241 screen.focus(true);
242 expect(mocks.otherQuery.refresh).toHaveBeenCalledTimes(1);
243 act(() => vi.advanceTimersByTime(5_000));
244 expect(mocks.otherQuery.refresh).toHaveBeenCalledTimes(2);
245 expect(mocks.query.refresh).toHaveBeenCalledTimes(3);
246 }
247 expect(vi.getTimerCount()).toBe(0);
248 });
249
250 it("keeps disabled, completed and failed guides idle and refreshes once on reveal", () => {
251 vi.useFakeTimers();
252 using _timers = { [Symbol.dispose]: () => vi.useRealTimers() };
253 using screen = setup();
254 mocks.enabled = false;
255 screen.render();
256 act(() => vi.advanceTimersByTime(5_000));
257 expect(mocks.query.refresh).not.toHaveBeenCalled();
258 mocks.enabled = true;
259 mocks.query.data = { run: null };
260 screen.render();
261 expect(mocks.query.refresh).toHaveBeenCalledTimes(1);
262 act(() => vi.advanceTimersByTime(10_000));
263 expect(mocks.query.refresh).toHaveBeenCalledTimes(1);
264 screen.render(1, "environment", false);
265 mocks.query.data = { run: { _tag: "Failed" } };
266 screen.render(1, "environment", false);
267 expect(mocks.query.refresh).toHaveBeenCalledTimes(1);
268 screen.render();
269 expect(mocks.query.refresh).toHaveBeenCalledTimes(2);
270 act(() => vi.advanceTimersByTime(10_000));
271 expect(mocks.query.refresh).toHaveBeenCalledTimes(2);
272 expect(vi.getTimerCount()).toBe(0);
273 });
274
275 it("leaves generation running when hidden and accepts its completion without a refresh", async () => {
276 vi.useFakeTimers();
277 using _timers = { [Symbol.dispose]: () => vi.useRealTimers() };
278 using screen = setup();
279 const generated = Promise.withResolvers<ReturnType<typeof AsyncResult.success<void>>>();
280 mocks.generate.mockReturnValue(generated.promise);
281 screen.render();
282 let writing: Promise<void>;
283 act(() => {
284 writing = screen.current.write();
285 });
286 expect(screen.current.running).toBe(true);
287 screen.render(1, "environment", false);
288 const beforeHidden = mocks.query.refresh.mock.calls.length;
289 act(() => vi.advanceTimersByTime(60_000));
290 expect(mocks.query.refresh).toHaveBeenCalledTimes(beforeHidden);
291 expect(mocks.generate).toHaveBeenCalledTimes(1);
292 expect(screen.current.running).toBe(true);
293 await act(async () => {
294 generated.resolve(AsyncResult.success(undefined));
295 await writing;
296 });
297 expect(screen.current.running).toBe(false);
298 expect(mocks.query.refresh).toHaveBeenCalledTimes(beforeHidden);
299 screen.render();
300 expect(mocks.query.refresh).toHaveBeenCalledTimes(beforeHidden + 1);
301 expect(vi.getTimerCount()).toBe(0);
302 });