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

queries.debounce.test.tsx

239 lines8.4 KB

1import { AuthFilesystemReadScope, EnvironmentId } from "@t3tools/contracts";
2import { RegistryContext } from "@effect/atom-react";
3import type { VcsRefTarget } from "@t3tools/client-runtime/state/vcs";
4import { AsyncResult, Atom, AtomRegistry } from "effect/reactivity";
5import { act, useLayoutEffect } from "react";
6import { createRoot } from "react-dom/client";
7import { expect, it, vi } from "vite-plus/test";
8​
9const mocks = vi.hoisted(() => ({
10 sessionAtom: {},
11 searchEntriesAtom: {},
12 searchEntries: vi.fn((): unknown => mocks.searchEntriesAtom),
13 listRefs: vi.fn(),
14 refresh: vi.fn(),
15}));
16​
17vi.mock("./session", () => ({
18 environmentSession: { sessionStateAtom: () => mocks.sessionAtom },
19}));
20vi.mock("./presentation", () => ({
21 useEnvironmentPresentation: () => ({
22 isReady: true,
23 presentation: { connection: { phase: "connected", error: null } },
24 }),
25}));
26vi.mock("./pull-requests", () => ({ composerPullRequests: {} }));
27vi.mock("./projects", () => ({
28 projectEnvironment: { searchEntries: mocks.searchEntries },
29}));
30vi.mock("./atom-registry", () => ({ appAtomRegistry: { refresh: mocks.refresh } }));
31vi.mock("./orchestration", () => ({ orchestrationEnvironment: {} }));
32vi.mock("./vcs", () => ({ vcsEnvironment: { listRefs: mocks.listRefs } }));
33vi.mock("./threads", () => ({ olderSettledThreads: {}, threadFamilies: {} }));
34vi.mock("./query", () => ({
35 useEnvironmentQuery: (atom: unknown) => ({
36 data:
37 atom === mocks.sessionAtom
38 ? { authenticated: true, scopes: [AuthFilesystemReadScope] }
39 : atom === mocks.searchEntriesAtom
40 ? { entries: [{ path: "src/only-in-original.ts", kind: "file" }] }
41 : null,
42 error: null,
43 isPending: false,
44 refresh: () => {},
45 }),
46}));
47​
48import {
49 useComposerPathSearch,
50 usePaginatedBranches,
51 type ComposerPathSearchTarget,
52} from "./queries";
53​
54function setup() {
55 (globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
56 vi.useFakeTimers();
57 mocks.searchEntries.mockClear();
58 const root = createRoot(document.createElement("div"));
59 let latest: ReturnType<typeof useComposerPathSearch> | null = null;
60 function Probe({ target }: { readonly target: ComposerPathSearchTarget }) {
61 latest = useComposerPathSearch(target);
62 return null;
63 }
64​
65 return {
66 get result() {
67 return latest;
68 },
69 render(target: ComposerPathSearchTarget) {
70 act(() => root.render(<Probe target={{ ...target }} />));
71 },
72 [Symbol.dispose]() {
73 act(() => root.unmount());
74 vi.useRealTimers();
75 },
76 };
78​
79const target = {
80 environmentId: EnvironmentId.make("test-environment"),
81 cwd: "/repo",
82 query: "src",
83};
84​
85it.each([
86 { query: "src", expected: "src" },
87 { query: "a".repeat(256), expected: "a".repeat(256) },
88 {
89 query: ["a".repeat(86), "b".repeat(86), "c".repeat(86), "unique.ts"].join("/"),
90 expected: ["a".repeat(86), "b".repeat(86), "c".repeat(82)].join("/"),
91 },
92 { query: `${"a".repeat(255)}πŸ˜€/boundary.ts`, expected: "a".repeat(255) },
93 { query: `${"a".repeat(254)}πŸ˜€/boundary.ts`, expected: `${"a".repeat(254)}πŸ˜€` },
94])("keeps the search deadline and bounds the request for query: $query", ({ query, expected }) => {
95 using harness = setup();
96 harness.render({ ...target, query: null });
97 harness.render({ ...target, query: ` ${query} ` });
98 act(() => vi.advanceTimersByTime(100));
99 harness.render({ ...target, query });
100 act(() => vi.advanceTimersByTime(99));
101 expect(mocks.searchEntries).not.toHaveBeenCalled();
102​
103 act(() => vi.advanceTimersByTime(1));
104 expect(mocks.searchEntries).toHaveBeenCalledExactlyOnceWith({
105 environmentId: target.environmentId,
106 input: { cwd: target.cwd, query: expected, limit: 20 },
107 });
108});
109​
110it.each([
111 { field: "environment", changed: { ...target, environmentId: EnvironmentId.make("other") } },
112 { field: "project directory", changed: { ...target, cwd: "/other" } },
113 { field: "query", changed: { ...target, query: "test" } },
114 {
115 field: "query suffix beyond the request limit",
116 initial: { ...target, query: `${"src/".repeat(65)}first.ts` },
117 changed: { ...target, query: `${"src/".repeat(65)}other.ts` },
118 },
119])("restarts the search deadline when the $field changes", ({ initial = target, changed }) => {
120 using harness = setup();
121 harness.render({ ...target, query: null });
122 harness.render(initial);
123 act(() => vi.advanceTimersByTime(100));
124 harness.render(changed);
125​
126 act(() => vi.advanceTimersByTime(100));
127 expect(mocks.searchEntries).not.toHaveBeenCalled();
128 act(() => vi.advanceTimersByTime(99));
129 expect(mocks.searchEntries).not.toHaveBeenCalled();
130​
131 act(() => vi.advanceTimersByTime(1));
132 expect(mocks.searchEntries).toHaveBeenCalledExactlyOnceWith({
133 environmentId: changed.environmentId,
134 input: { cwd: changed.cwd, query: changed.query.slice(0, 256), limit: 20 },
135 });
136});
137​
138it.each([
139 { field: "environment", changed: { ...target, environmentId: EnvironmentId.make("other") } },
140 { field: "project directory", changed: { ...target, cwd: "/other" } },
141])("reports settled results as pending when the $field changes", ({ changed }) => {
142 using harness = setup();
143 harness.render(target);
144 act(() => vi.advanceTimersByTime(200));
145 expect(harness.result?.isPending).toBe(false);
146 expect(harness.result?.entries).toHaveLength(1);
147​
148 harness.render(changed);
149 expect(harness.result?.isPending).toBe(true);
150 expect(harness.result?.entries).toEqual([]);
151});
152​
153it("keeps compiled branch results stable and resets pagination for a new target or refresh", () => {
154 (globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
155 const registry = AtomRegistry.make();
156 const pages = Atom.family((key: string) => {
157 const [, cwd, cursor] = JSON.parse(key) as [string, string, number | null];
158 return Atom.make(
159 AsyncResult.success({
160 refs: [
161 { name: `${cwd}-${cursor ?? 0}`, current: false, isDefault: false, worktreePath: null },
162 ],
163 isRepo: true,
164 hasPrimaryRemote: true,
165 nextCursor: cursor === null ? 100 : null,
166 totalCount: 2,
167 }),
168 );
169 });
170 mocks.listRefs.mockImplementation(
171 ({
172 environmentId,
173 input,
174 }: {
175 environmentId: EnvironmentId;
176 input: { cwd: string; cursor?: number };
177 }) => pages(JSON.stringify([environmentId, input.cwd, input.cursor ?? null])),
178 );
179 mocks.refresh.mockClear();
180 const root = createRoot(document.createElement("div"));
181 using _cleanup = {
182 [Symbol.dispose]() {
183 act(() => root.unmount());
184 registry.dispose();
185 },
186 };
187 let current: ReturnType<typeof usePaginatedBranches>;
188 function Probe({ target }: { target: VcsRefTarget }) {
189 const result = usePaginatedBranches(target);
190 useLayoutEffect(() => {
191 current = result;
192 });
193 return null;
194 }
195 const render = (cwd: string | null, options: Partial<VcsRefTarget> = {}) =>
196 act(() =>
197 root.render(
198 <RegistryContext.Provider value={registry}>
199 <Probe target={{ environmentId: target.environmentId, cwd, ...options }} />
200 </RegistryContext.Provider>,
201 ),
202 );
203 render("/repo");
204 const first = current!;
205 render("/repo");
206 expect(current!.data).toBe(first.data);
207 expect(current!.refs).toBe(first.refs);
208 expect(current!.refresh).toBe(first.refresh);
209 expect(current!.loadNext).toBe(first.loadNext);
210 act(() =>
211 registry.set(
212 pages(JSON.stringify([target.environmentId, "/repo", null])),
213 AsyncResult.success({
214 ...first.data!,
215 refs: [{ name: "/repo-0", current: true, isDefault: false, worktreePath: null }],
216 }),
217 ),
218 );
219 expect(current!.refs[0]?.current).toBe(true);
220 act(() => current!.loadNext());
221 expect(current!.refs.map((ref) => ref.name)).toEqual(["/repo-0", "/repo-100"]);
222 act(() => current!.refresh());
223 expect(current!.refs.map((ref) => ref.name)).toEqual(["/repo-0"]);
224 expect(mocks.refresh).toHaveBeenCalledExactlyOnceWith(
225 pages(JSON.stringify([target.environmentId, "/repo", null])),
226 );
227 act(() => current!.loadNext());
228 render("/other");
229 expect(current!.refs.map((ref) => ref.name)).toEqual(["/other-0"]);
230 act(() => current!.loadNext());
231 render("/other", { query: "feature" });
232 expect(current!.refs).toHaveLength(1);
233 act(() => current!.loadNext());
234 render("/other", { environmentId: EnvironmentId.make("other-environment"), query: "feature" });
235 expect(current!.refs).toHaveLength(1);
236 render(null);
237 expect(current!.data).toBeNull();
238 expect(current!.refs).toEqual([]);
239});