@hyper-fetch/react 9.5.2 → 9.6.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/__tests__/features/use-infinite-fetch/use-infinite-fetch.base.spec.tsx +745 -0
- package/__tests__/features/use-infinite-fetch/use-infinite-fetch.boundaries.spec.tsx +362 -0
- package/__tests__/features/use-infinite-fetch/use-infinite-fetch.edge.spec.tsx +1043 -0
- package/__tests__/features/use-infinite-fetch/use-infinite-fetch.matrix.spec.tsx +441 -0
- package/__tests__/features/use-infinite-fetch/use-infinite-fetch.random.spec.tsx +121 -0
- package/__tests__/features/use-infinite-fetch/use-infinite-fetch.refetch.spec.tsx +567 -0
- package/__tests__/features/use-infinite-fetch/use-infinite-fetch.start-over.spec.tsx +353 -0
- package/__tests__/features/use-infinite-fetch/use-infinite-fetch.typescript.spec.ts +128 -0
- package/__tests__/features/use-submit/use-submit.unmount.spec.ts +310 -0
- package/__tests__/utils/use-infinite-fetch.modes.ts +131 -0
- package/__tests__/utils/use-infinite-fetch.utils.ts +90 -0
- package/dist/helpers/use-request-events/use-request-events.hooks.d.ts.map +1 -1
- package/dist/hooks/use-infinite-fetch/index.d.ts +4 -0
- package/dist/hooks/use-infinite-fetch/index.d.ts.map +1 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.constants.d.ts +22 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.constants.d.ts.map +1 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.hooks.d.ts +21 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.hooks.d.ts.map +1 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.requests.d.ts +19 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.requests.d.ts.map +1 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts +119 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts.map +1 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.types.d.ts +48 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.types.d.ts.map +1 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts +172 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts.map +1 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts +15 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts.map +1 -0
- package/dist/index.d.ts +1 -0
- package/dist/index.d.ts.map +1 -1
- package/dist/index.mjs +914 -2
- package/dist/index.mjs.map +1 -1
- package/dist/provider/provider.types.d.ts +2 -0
- package/dist/provider/provider.types.d.ts.map +1 -1
- package/package.json +1 -1
- package/src/helpers/use-request-events/use-request-events.hooks.ts +11 -1
- package/src/hooks/use-infinite-fetch/index.ts +3 -0
- package/src/hooks/use-infinite-fetch/use-infinite-fetch.constants.ts +25 -0
- package/src/hooks/use-infinite-fetch/use-infinite-fetch.hooks.ts +389 -0
- package/src/hooks/use-infinite-fetch/use-infinite-fetch.requests.ts +98 -0
- package/src/hooks/use-infinite-fetch/use-infinite-fetch.store.ts +780 -0
- package/src/hooks/use-infinite-fetch/use-infinite-fetch.store.types.ts +49 -0
- package/src/hooks/use-infinite-fetch/use-infinite-fetch.types.ts +195 -0
- package/src/hooks/use-infinite-fetch/use-infinite-fetch.utils.ts +44 -0
- package/src/index.ts +1 -0
- package/src/provider/provider.types.ts +3 -0
- package/__tests__/features/use-fetch/use-fetch.infinite.ts +0 -39
|
@@ -0,0 +1,1043 @@
|
|
|
1
|
+
/* eslint-disable react/state-in-constructor, react/no-set-state */
|
|
2
|
+
import { Client } from "@hyper-fetch/core";
|
|
3
|
+
import { act, render, renderHook, screen, waitFor } from "@testing-library/react";
|
|
4
|
+
import { useFetch } from "hooks/use-fetch";
|
|
5
|
+
import { useInfiniteFetch } from "hooks/use-infinite-fetch";
|
|
6
|
+
import React, { Suspense, useLayoutEffect } from "react";
|
|
7
|
+
|
|
8
|
+
import {
|
|
9
|
+
baseUrl,
|
|
10
|
+
createDeferred,
|
|
11
|
+
createListServer,
|
|
12
|
+
failure,
|
|
13
|
+
pageItems,
|
|
14
|
+
settleRequests,
|
|
15
|
+
sleep,
|
|
16
|
+
} from "../../utils/use-infinite-fetch.utils";
|
|
17
|
+
|
|
18
|
+
const { startServer, stopServer, resetMocks, mockList, calls, resetCalls } = createListServer();
|
|
19
|
+
|
|
20
|
+
type Post = { id: number; version?: number };
|
|
21
|
+
type Feed = { data: Post[]; next: string | null; previous?: string | null };
|
|
22
|
+
|
|
23
|
+
const ids = (items: Post[]) => items.map((item) => item.id);
|
|
24
|
+
|
|
25
|
+
class Boundary extends React.Component<{ children: React.ReactNode }, { hasError: boolean }> {
|
|
26
|
+
state = { hasError: false };
|
|
27
|
+
|
|
28
|
+
static getDerivedStateFromError() {
|
|
29
|
+
return { hasError: true };
|
|
30
|
+
}
|
|
31
|
+
|
|
32
|
+
render() {
|
|
33
|
+
return this.state.hasError ? <div>boundary</div> : this.props.children;
|
|
34
|
+
}
|
|
35
|
+
}
|
|
36
|
+
|
|
37
|
+
describe("useInfiniteFetch [ Edge cases ]", () => {
|
|
38
|
+
let client: Client;
|
|
39
|
+
|
|
40
|
+
const createPosts = () =>
|
|
41
|
+
client.createRequest<{ response: Post[]; queryParams: { page?: number; search?: string } }>()({
|
|
42
|
+
endpoint: "/posts",
|
|
43
|
+
});
|
|
44
|
+
|
|
45
|
+
const createFeed = () =>
|
|
46
|
+
client.createRequest<{ response: Feed; queryParams: { cursor?: string } }>()({ endpoint: "/feed" });
|
|
47
|
+
|
|
48
|
+
const pagination = { page: "page" } as const;
|
|
49
|
+
const feedPagination = { cursor: "cursor", next: "next", previous: "previous", items: "data" } as const;
|
|
50
|
+
|
|
51
|
+
const renderPosts = async (options: Record<string, unknown> = {}) => {
|
|
52
|
+
const view = renderHook(() =>
|
|
53
|
+
useInfiniteFetch(createPosts(), { pagination, dependencyTracking: false, ...options }),
|
|
54
|
+
);
|
|
55
|
+
await waitFor(() => expect(view.result.current.pageParams).toHaveLength(1));
|
|
56
|
+
return view;
|
|
57
|
+
};
|
|
58
|
+
|
|
59
|
+
const mockFeed = () => {
|
|
60
|
+
mockList("/feed", ({ query }) => {
|
|
61
|
+
const page = Number(query.cursor ?? 1);
|
|
62
|
+
return {
|
|
63
|
+
data: pageItems(page),
|
|
64
|
+
next: page < 3 ? String(page + 1) : null,
|
|
65
|
+
previous: page > 1 ? String(page - 1) : null,
|
|
66
|
+
};
|
|
67
|
+
});
|
|
68
|
+
};
|
|
69
|
+
|
|
70
|
+
beforeAll(() => startServer());
|
|
71
|
+
afterAll(() => stopServer());
|
|
72
|
+
|
|
73
|
+
beforeEach(() => {
|
|
74
|
+
client = new Client({ url: baseUrl });
|
|
75
|
+
resetCalls();
|
|
76
|
+
mockList("/posts", ({ query }) => pageItems(Number(query.page)));
|
|
77
|
+
});
|
|
78
|
+
|
|
79
|
+
afterEach(async () => {
|
|
80
|
+
await settleRequests(client);
|
|
81
|
+
resetMocks();
|
|
82
|
+
});
|
|
83
|
+
|
|
84
|
+
describe("joining requests of other hooks", () => {
|
|
85
|
+
const joined = () => createPosts().setDeduplicate(false);
|
|
86
|
+
|
|
87
|
+
const renderJoined = async () => {
|
|
88
|
+
// Without tracking, the value does not depend on being read before the response arrives
|
|
89
|
+
const owner = renderHook(() => useFetch(joined().setQueryParams({ page: 1 }), { dependencyTracking: false }));
|
|
90
|
+
await waitFor(() => expect(calls).toHaveLength(1));
|
|
91
|
+
const list = renderHook(() => useInfiniteFetch(joined(), { pagination, dependencyTracking: false }));
|
|
92
|
+
return { owner, list };
|
|
93
|
+
};
|
|
94
|
+
|
|
95
|
+
it("should only stop waiting when aborted, the request belongs to the other hook", async () => {
|
|
96
|
+
const gate = createDeferred();
|
|
97
|
+
mockList("/posts", async () => {
|
|
98
|
+
await gate.promise;
|
|
99
|
+
return pageItems(1);
|
|
100
|
+
});
|
|
101
|
+
const { owner, list } = await renderJoined();
|
|
102
|
+
|
|
103
|
+
act(() => list.result.current.abort());
|
|
104
|
+
expect(list.result.current.isFetching).toBe(false);
|
|
105
|
+
|
|
106
|
+
await act(async () => {
|
|
107
|
+
gate.resolve();
|
|
108
|
+
});
|
|
109
|
+
|
|
110
|
+
await waitFor(() => expect(owner.result.current.data).toEqual(pageItems(1)));
|
|
111
|
+
expect(calls).toHaveLength(1);
|
|
112
|
+
expect(list.result.current.error).toBeNull();
|
|
113
|
+
});
|
|
114
|
+
|
|
115
|
+
it("should send its own request when the other one is removed", async () => {
|
|
116
|
+
const gate = createDeferred();
|
|
117
|
+
mockList("/posts", async () => {
|
|
118
|
+
if (calls.length === 1) {
|
|
119
|
+
await gate.promise;
|
|
120
|
+
}
|
|
121
|
+
return pageItems(1);
|
|
122
|
+
});
|
|
123
|
+
const { list } = await renderJoined();
|
|
124
|
+
|
|
125
|
+
const queryKey = joined().setQueryParams({ page: 1 }).queryKey;
|
|
126
|
+
const [running] = client.fetchDispatcher.getRunningRequests(queryKey);
|
|
127
|
+
act(() => {
|
|
128
|
+
client.fetchDispatcher.delete(queryKey, running.requestId, joined().setQueryParams({ page: 1 }).abortKey);
|
|
129
|
+
});
|
|
130
|
+
|
|
131
|
+
await waitFor(() => expect(list.result.current.items).toHaveLength(2));
|
|
132
|
+
expect(calls).toHaveLength(2);
|
|
133
|
+
gate.resolve();
|
|
134
|
+
});
|
|
135
|
+
|
|
136
|
+
it("should report the failure of the joined request without repeating it", async () => {
|
|
137
|
+
const gate = createDeferred();
|
|
138
|
+
mockList("/posts", async () => {
|
|
139
|
+
await gate.promise;
|
|
140
|
+
return failure();
|
|
141
|
+
});
|
|
142
|
+
const { list } = await renderJoined();
|
|
143
|
+
|
|
144
|
+
await act(async () => {
|
|
145
|
+
gate.resolve();
|
|
146
|
+
});
|
|
147
|
+
|
|
148
|
+
await waitFor(() => expect(list.result.current.error).toBeTruthy());
|
|
149
|
+
expect(calls).toHaveLength(1);
|
|
150
|
+
expect(list.result.current.items).toEqual([]);
|
|
151
|
+
});
|
|
152
|
+
|
|
153
|
+
it("should wait through the retries of the joined request", async () => {
|
|
154
|
+
let attempt = 0;
|
|
155
|
+
const gate = createDeferred();
|
|
156
|
+
mockList("/posts", async () => {
|
|
157
|
+
attempt += 1;
|
|
158
|
+
await gate.promise;
|
|
159
|
+
return attempt === 1 ? failure() : pageItems(1);
|
|
160
|
+
});
|
|
161
|
+
const retried = () => joined().setRetry(1).setRetryTime(5);
|
|
162
|
+
renderHook(() => useFetch(retried().setQueryParams({ page: 1 })));
|
|
163
|
+
await waitFor(() => expect(calls).toHaveLength(1));
|
|
164
|
+
|
|
165
|
+
const list = renderHook(() => useInfiniteFetch(retried(), { pagination, dependencyTracking: false }));
|
|
166
|
+
await act(async () => {
|
|
167
|
+
gate.resolve();
|
|
168
|
+
});
|
|
169
|
+
|
|
170
|
+
await waitFor(() => expect(list.result.current.items).toHaveLength(2));
|
|
171
|
+
expect(list.result.current.error).toBeNull();
|
|
172
|
+
expect(calls).toHaveLength(2);
|
|
173
|
+
});
|
|
174
|
+
|
|
175
|
+
it("should keep waiting for a joined request postponed by going offline", async () => {
|
|
176
|
+
const gate = createDeferred();
|
|
177
|
+
let attempt = 0;
|
|
178
|
+
mockList("/posts", async () => {
|
|
179
|
+
attempt += 1;
|
|
180
|
+
if (attempt === 1) {
|
|
181
|
+
await gate.promise;
|
|
182
|
+
return failure();
|
|
183
|
+
}
|
|
184
|
+
return pageItems(1);
|
|
185
|
+
});
|
|
186
|
+
const { list } = await renderJoined();
|
|
187
|
+
|
|
188
|
+
act(() => client.appManager.setOnline(false));
|
|
189
|
+
await act(async () => {
|
|
190
|
+
gate.resolve();
|
|
191
|
+
await sleep(30);
|
|
192
|
+
});
|
|
193
|
+
|
|
194
|
+
expect(list.result.current.error).toBeNull();
|
|
195
|
+
expect(list.result.current.isFetching).toBe(true);
|
|
196
|
+
|
|
197
|
+
act(() => client.appManager.setOnline(true));
|
|
198
|
+
|
|
199
|
+
await waitFor(() => expect(list.result.current.items).toHaveLength(2));
|
|
200
|
+
});
|
|
201
|
+
});
|
|
202
|
+
|
|
203
|
+
describe("calling actions at the wrong time", () => {
|
|
204
|
+
it("should share the first request when asking for the next page too early", async () => {
|
|
205
|
+
const view = renderHook(() => useInfiniteFetch(createPosts(), { pagination, dependencyTracking: false }));
|
|
206
|
+
|
|
207
|
+
let early: Promise<unknown> = Promise.resolve();
|
|
208
|
+
act(() => {
|
|
209
|
+
early = view.result.current.fetchNextPage();
|
|
210
|
+
});
|
|
211
|
+
await act(async () => {
|
|
212
|
+
await early;
|
|
213
|
+
});
|
|
214
|
+
|
|
215
|
+
expect(view.result.current.pageParams).toEqual([1]);
|
|
216
|
+
expect(calls).toHaveLength(1);
|
|
217
|
+
});
|
|
218
|
+
|
|
219
|
+
it("should do nothing when asking for pages of a failed list", async () => {
|
|
220
|
+
mockList("/posts", () => failure());
|
|
221
|
+
const view = renderHook(() => useInfiniteFetch(createPosts(), { pagination, dependencyTracking: false }));
|
|
222
|
+
await waitFor(() => expect(view.result.current.error).toBeTruthy());
|
|
223
|
+
resetCalls();
|
|
224
|
+
|
|
225
|
+
await expect(view.result.current.fetchNextPage()).resolves.toBeNull();
|
|
226
|
+
await expect(view.result.current.fetchPreviousPage()).resolves.toBeNull();
|
|
227
|
+
|
|
228
|
+
expect(calls).toHaveLength(0);
|
|
229
|
+
});
|
|
230
|
+
|
|
231
|
+
it("should do nothing when there is no page in that direction", async () => {
|
|
232
|
+
mockList("/posts", () => []);
|
|
233
|
+
const { result } = await renderPosts();
|
|
234
|
+
resetCalls();
|
|
235
|
+
|
|
236
|
+
await expect(result.current.fetchNextPage()).resolves.toBeNull();
|
|
237
|
+
await expect(result.current.fetchPreviousPage()).resolves.toBeNull();
|
|
238
|
+
|
|
239
|
+
expect(calls).toHaveLength(0);
|
|
240
|
+
});
|
|
241
|
+
|
|
242
|
+
it("should load the first page again on reset of a failed list", async () => {
|
|
243
|
+
mockList("/posts", () => failure());
|
|
244
|
+
const view = renderHook(() => useInfiniteFetch(createPosts(), { pagination, dependencyTracking: false }));
|
|
245
|
+
await waitFor(() => expect(view.result.current.error).toBeTruthy());
|
|
246
|
+
|
|
247
|
+
mockList("/posts", ({ query }) => pageItems(Number(query.page)));
|
|
248
|
+
await act(() => view.result.current.reset());
|
|
249
|
+
|
|
250
|
+
expect(view.result.current.error).toBeNull();
|
|
251
|
+
expect(ids(view.result.current.items)).toEqual([1, 2]);
|
|
252
|
+
});
|
|
253
|
+
|
|
254
|
+
it("should ignore a refetch of a disabled list on changed dependencies", async () => {
|
|
255
|
+
const { rerender } = renderHook(
|
|
256
|
+
({ version }) =>
|
|
257
|
+
useInfiniteFetch(createPosts(), {
|
|
258
|
+
pagination,
|
|
259
|
+
disabled: true,
|
|
260
|
+
dependencies: [version],
|
|
261
|
+
dependencyTracking: false,
|
|
262
|
+
}),
|
|
263
|
+
{ initialProps: { version: 1 } },
|
|
264
|
+
);
|
|
265
|
+
|
|
266
|
+
rerender({ version: 2 });
|
|
267
|
+
|
|
268
|
+
await sleep(30);
|
|
269
|
+
expect(calls).toHaveLength(0);
|
|
270
|
+
});
|
|
271
|
+
|
|
272
|
+
it("should return the same actions between renders", async () => {
|
|
273
|
+
const { result, rerender } = await renderPosts();
|
|
274
|
+
const { fetchNextPage, refetch, reset, abort } = result.current;
|
|
275
|
+
|
|
276
|
+
rerender();
|
|
277
|
+
|
|
278
|
+
expect(result.current.fetchNextPage).toBe(fetchNextPage);
|
|
279
|
+
expect(result.current.refetch).toBe(refetch);
|
|
280
|
+
expect(result.current.reset).toBe(reset);
|
|
281
|
+
expect(result.current.abort).toBe(abort);
|
|
282
|
+
});
|
|
283
|
+
});
|
|
284
|
+
|
|
285
|
+
describe("queued fetches", () => {
|
|
286
|
+
it("should cancel fetches waiting in line on abort", async () => {
|
|
287
|
+
const { result } = await renderPosts();
|
|
288
|
+
const gate = createDeferred();
|
|
289
|
+
resetCalls();
|
|
290
|
+
mockList("/posts", async () => {
|
|
291
|
+
await gate.promise;
|
|
292
|
+
return pageItems(2);
|
|
293
|
+
});
|
|
294
|
+
|
|
295
|
+
let next: Promise<unknown> = Promise.resolve();
|
|
296
|
+
let refetch: Promise<unknown> = Promise.resolve();
|
|
297
|
+
act(() => {
|
|
298
|
+
next = result.current.fetchNextPage();
|
|
299
|
+
refetch = result.current.refetch();
|
|
300
|
+
});
|
|
301
|
+
await waitFor(() => expect(calls).toHaveLength(1));
|
|
302
|
+
|
|
303
|
+
act(() => result.current.abort());
|
|
304
|
+
gate.resolve();
|
|
305
|
+
|
|
306
|
+
await expect(next).resolves.toBeNull();
|
|
307
|
+
await expect(refetch).resolves.toBeNull();
|
|
308
|
+
await sleep(20);
|
|
309
|
+
expect(calls).toHaveLength(1);
|
|
310
|
+
expect(result.current.isFetching).toBe(false);
|
|
311
|
+
expect(result.current.pageParams).toEqual([1]);
|
|
312
|
+
});
|
|
313
|
+
|
|
314
|
+
it("should skip the next page when a refetch ended the list in the meantime", async () => {
|
|
315
|
+
const { result } = await renderPosts();
|
|
316
|
+
const gate = createDeferred();
|
|
317
|
+
resetCalls();
|
|
318
|
+
mockList("/posts", async () => {
|
|
319
|
+
await gate.promise;
|
|
320
|
+
return [];
|
|
321
|
+
});
|
|
322
|
+
|
|
323
|
+
let refetch: Promise<unknown> = Promise.resolve();
|
|
324
|
+
let next: Promise<unknown> = Promise.resolve();
|
|
325
|
+
act(() => {
|
|
326
|
+
refetch = result.current.refetch();
|
|
327
|
+
next = result.current.fetchNextPage();
|
|
328
|
+
});
|
|
329
|
+
await waitFor(() => expect(calls).toHaveLength(1));
|
|
330
|
+
|
|
331
|
+
gate.resolve();
|
|
332
|
+
await act(async () => {
|
|
333
|
+
await refetch;
|
|
334
|
+
});
|
|
335
|
+
|
|
336
|
+
await expect(next).resolves.toBeNull();
|
|
337
|
+
expect(calls).toHaveLength(1);
|
|
338
|
+
expect(result.current.hasNextPage).toBe(false);
|
|
339
|
+
});
|
|
340
|
+
|
|
341
|
+
it("should skip the previous page when a refetch removed it in the meantime", async () => {
|
|
342
|
+
mockFeed();
|
|
343
|
+
const { result } = renderHook(() =>
|
|
344
|
+
useInfiniteFetch(createFeed().setQueryParams({ cursor: "2" }), {
|
|
345
|
+
pagination: feedPagination,
|
|
346
|
+
dependencyTracking: false,
|
|
347
|
+
}),
|
|
348
|
+
);
|
|
349
|
+
await waitFor(() => expect(result.current.hasPreviousPage).toBe(true));
|
|
350
|
+
const gate = createDeferred();
|
|
351
|
+
resetCalls();
|
|
352
|
+
mockList("/feed", async () => {
|
|
353
|
+
await gate.promise;
|
|
354
|
+
return { data: pageItems(2), next: null, previous: null };
|
|
355
|
+
});
|
|
356
|
+
|
|
357
|
+
let refetch: Promise<unknown> = Promise.resolve();
|
|
358
|
+
let previous: Promise<unknown> = Promise.resolve();
|
|
359
|
+
act(() => {
|
|
360
|
+
refetch = result.current.refetch();
|
|
361
|
+
previous = result.current.fetchPreviousPage();
|
|
362
|
+
});
|
|
363
|
+
await waitFor(() => expect(calls).toHaveLength(1));
|
|
364
|
+
|
|
365
|
+
gate.resolve();
|
|
366
|
+
await act(async () => {
|
|
367
|
+
await refetch;
|
|
368
|
+
});
|
|
369
|
+
|
|
370
|
+
await expect(previous).resolves.toBeNull();
|
|
371
|
+
expect(calls).toHaveLength(1);
|
|
372
|
+
expect(result.current.hasPreviousPage).toBe(false);
|
|
373
|
+
});
|
|
374
|
+
|
|
375
|
+
it("should run fetches in the order they were asked for", async () => {
|
|
376
|
+
const { result } = await renderPosts();
|
|
377
|
+
resetCalls();
|
|
378
|
+
|
|
379
|
+
await act(async () => {
|
|
380
|
+
await Promise.all([result.current.fetchNextPage(), result.current.fetchPreviousPage()]);
|
|
381
|
+
});
|
|
382
|
+
|
|
383
|
+
expect(calls.map((call) => call.query.page)).toEqual(["2"]);
|
|
384
|
+
expect(result.current.pageParams).toEqual([1, 2]);
|
|
385
|
+
});
|
|
386
|
+
});
|
|
387
|
+
|
|
388
|
+
describe("cancelling", () => {
|
|
389
|
+
it("should keep the list when the previous page is aborted", async () => {
|
|
390
|
+
mockFeed();
|
|
391
|
+
const { result } = renderHook(() =>
|
|
392
|
+
useInfiniteFetch(createFeed().setQueryParams({ cursor: "2" }), {
|
|
393
|
+
pagination: feedPagination,
|
|
394
|
+
dependencyTracking: false,
|
|
395
|
+
}),
|
|
396
|
+
);
|
|
397
|
+
await waitFor(() => expect(result.current.hasPreviousPage).toBe(true));
|
|
398
|
+
const gate = createDeferred();
|
|
399
|
+
mockList("/feed", async () => {
|
|
400
|
+
await gate.promise;
|
|
401
|
+
return { data: pageItems(1), next: "2", previous: null };
|
|
402
|
+
});
|
|
403
|
+
|
|
404
|
+
let previous: Promise<unknown> = Promise.resolve();
|
|
405
|
+
act(() => {
|
|
406
|
+
previous = result.current.fetchPreviousPage();
|
|
407
|
+
});
|
|
408
|
+
expect(result.current.isFetchingPreviousPage).toBe(true);
|
|
409
|
+
|
|
410
|
+
act(() => result.current.abort());
|
|
411
|
+
gate.resolve();
|
|
412
|
+
|
|
413
|
+
await expect(previous).resolves.toBeNull();
|
|
414
|
+
expect(ids(result.current.items)).toEqual([3, 4]);
|
|
415
|
+
expect(result.current.isFetchPreviousPageError).toBe(false);
|
|
416
|
+
});
|
|
417
|
+
|
|
418
|
+
it("should keep the list when every page of a refetch is cancelled from the outside", async () => {
|
|
419
|
+
const { result } = await renderPosts();
|
|
420
|
+
const gate = createDeferred();
|
|
421
|
+
mockList("/posts", async () => {
|
|
422
|
+
await gate.promise;
|
|
423
|
+
return [{ id: 99 }];
|
|
424
|
+
});
|
|
425
|
+
|
|
426
|
+
let refetch: Promise<unknown> = Promise.resolve();
|
|
427
|
+
act(() => {
|
|
428
|
+
refetch = result.current.refetch();
|
|
429
|
+
});
|
|
430
|
+
await waitFor(() => expect(result.current.isRefetching).toBe(true));
|
|
431
|
+
await sleep(10);
|
|
432
|
+
|
|
433
|
+
act(() => {
|
|
434
|
+
createPosts().setQueryParams({ page: 1 }).abort();
|
|
435
|
+
});
|
|
436
|
+
await act(async () => {
|
|
437
|
+
await refetch;
|
|
438
|
+
});
|
|
439
|
+
gate.resolve();
|
|
440
|
+
|
|
441
|
+
expect(ids(result.current.items)).toEqual([1, 2]);
|
|
442
|
+
expect(result.current.error).toBeNull();
|
|
443
|
+
expect(result.current.isRefetching).toBe(false);
|
|
444
|
+
});
|
|
445
|
+
|
|
446
|
+
it("should keep the list when a cursor refetch is aborted", async () => {
|
|
447
|
+
mockFeed();
|
|
448
|
+
const { result } = renderHook(() =>
|
|
449
|
+
useInfiniteFetch(createFeed(), { pagination: feedPagination, dependencyTracking: false }),
|
|
450
|
+
);
|
|
451
|
+
await waitFor(() => expect(result.current.items).toHaveLength(2));
|
|
452
|
+
const gate = createDeferred();
|
|
453
|
+
mockList("/feed", async () => {
|
|
454
|
+
await gate.promise;
|
|
455
|
+
return { data: [{ id: 99 }], next: null };
|
|
456
|
+
});
|
|
457
|
+
|
|
458
|
+
let refetch: Promise<unknown> = Promise.resolve();
|
|
459
|
+
act(() => {
|
|
460
|
+
refetch = result.current.refetch();
|
|
461
|
+
});
|
|
462
|
+
act(() => result.current.abort());
|
|
463
|
+
gate.resolve();
|
|
464
|
+
|
|
465
|
+
await expect(refetch).resolves.toBeNull();
|
|
466
|
+
expect(ids(result.current.items)).toEqual([1, 2]);
|
|
467
|
+
});
|
|
468
|
+
|
|
469
|
+
it("should load the first page again after aborting it", async () => {
|
|
470
|
+
const gate = createDeferred();
|
|
471
|
+
mockList("/posts", async () => {
|
|
472
|
+
await gate.promise;
|
|
473
|
+
return pageItems(1);
|
|
474
|
+
});
|
|
475
|
+
const { result } = renderHook(() => useInfiniteFetch(createPosts(), { pagination, dependencyTracking: false }));
|
|
476
|
+
|
|
477
|
+
act(() => result.current.abort());
|
|
478
|
+
gate.resolve();
|
|
479
|
+
|
|
480
|
+
expect(result.current.loading).toBe(false);
|
|
481
|
+
expect(result.current.isFetching).toBe(false);
|
|
482
|
+
|
|
483
|
+
mockList("/posts", ({ query }) => pageItems(Number(query.page)));
|
|
484
|
+
await act(() => result.current.refetch());
|
|
485
|
+
|
|
486
|
+
expect(ids(result.current.items)).toEqual([1, 2]);
|
|
487
|
+
});
|
|
488
|
+
});
|
|
489
|
+
|
|
490
|
+
describe("failures in a direction", () => {
|
|
491
|
+
it("should report a failed previous page and clear it on the next attempt", async () => {
|
|
492
|
+
mockFeed();
|
|
493
|
+
const { result } = renderHook(() =>
|
|
494
|
+
useInfiniteFetch(createFeed().setQueryParams({ cursor: "2" }), {
|
|
495
|
+
pagination: feedPagination,
|
|
496
|
+
dependencyTracking: false,
|
|
497
|
+
}),
|
|
498
|
+
);
|
|
499
|
+
await waitFor(() => expect(result.current.hasPreviousPage).toBe(true));
|
|
500
|
+
|
|
501
|
+
mockList("/feed", () => failure());
|
|
502
|
+
await act(() => result.current.fetchPreviousPage());
|
|
503
|
+
|
|
504
|
+
expect(result.current.isFetchPreviousPageError).toBe(true);
|
|
505
|
+
expect(result.current.isFetchNextPageError).toBe(false);
|
|
506
|
+
expect(ids(result.current.items)).toEqual([3, 4]);
|
|
507
|
+
|
|
508
|
+
mockFeed();
|
|
509
|
+
await act(() => result.current.fetchPreviousPage());
|
|
510
|
+
|
|
511
|
+
expect(result.current.isFetchPreviousPageError).toBe(false);
|
|
512
|
+
expect(ids(result.current.items)).toEqual([1, 2, 3, 4]);
|
|
513
|
+
});
|
|
514
|
+
|
|
515
|
+
it("should clear direction errors on reset", async () => {
|
|
516
|
+
const { result } = await renderPosts();
|
|
517
|
+
mockList("/posts", () => failure());
|
|
518
|
+
await act(() => result.current.fetchNextPage());
|
|
519
|
+
expect(result.current.isFetchNextPageError).toBe(true);
|
|
520
|
+
|
|
521
|
+
mockList("/posts", ({ query }) => pageItems(Number(query.page)));
|
|
522
|
+
await act(() => result.current.reset());
|
|
523
|
+
|
|
524
|
+
expect(result.current.isFetchNextPageError).toBe(false);
|
|
525
|
+
});
|
|
526
|
+
});
|
|
527
|
+
|
|
528
|
+
describe("response mappers", () => {
|
|
529
|
+
const mapped = () =>
|
|
530
|
+
createPosts().setResponseMapper(((response: any) => ({
|
|
531
|
+
...response,
|
|
532
|
+
data: response.data?.map((post: Post) => ({ ...post, version: 7 })) ?? null,
|
|
533
|
+
})) as any) as unknown as ReturnType<typeof createPosts>;
|
|
534
|
+
|
|
535
|
+
it("should show mapped pages after fetching and after restoring", async () => {
|
|
536
|
+
const first = renderHook(() => useInfiniteFetch(mapped(), { pagination, dependencyTracking: false }));
|
|
537
|
+
await waitFor(() => expect(first.result.current.items).toHaveLength(2));
|
|
538
|
+
expect(first.result.current.items[0].version).toBe(7);
|
|
539
|
+
first.unmount();
|
|
540
|
+
resetCalls();
|
|
541
|
+
|
|
542
|
+
const second = renderHook(() => useInfiniteFetch(mapped(), { pagination, dependencyTracking: false }));
|
|
543
|
+
|
|
544
|
+
expect(second.result.current.items[0].version).toBe(7);
|
|
545
|
+
await sleep(20);
|
|
546
|
+
expect(calls).toHaveLength(0);
|
|
547
|
+
});
|
|
548
|
+
|
|
549
|
+
it("should map cache changes of a loaded page", async () => {
|
|
550
|
+
const { result } = renderHook(() => useInfiniteFetch(mapped(), { pagination, dependencyTracking: false }));
|
|
551
|
+
await waitFor(() => expect(result.current.items).toHaveLength(2));
|
|
552
|
+
|
|
553
|
+
act(() => {
|
|
554
|
+
client.cache.update(createPosts().setQueryParams({ page: 1 }), () => ({ data: [{ id: 50 }] }));
|
|
555
|
+
});
|
|
556
|
+
|
|
557
|
+
expect(result.current.items).toEqual([{ id: 50, version: 7 }]);
|
|
558
|
+
});
|
|
559
|
+
|
|
560
|
+
it("should fetch again when an asynchronous mapper cannot be read from the cache", async () => {
|
|
561
|
+
const asynchronous = () =>
|
|
562
|
+
createPosts().setResponseMapper((async (response: any) => ({
|
|
563
|
+
...response,
|
|
564
|
+
data: response.data?.map((post: Post) => ({ ...post, version: 8 })) ?? null,
|
|
565
|
+
})) as any) as unknown as ReturnType<typeof createPosts>;
|
|
566
|
+
const first = renderHook(() => useInfiniteFetch(asynchronous(), { pagination, dependencyTracking: false }));
|
|
567
|
+
await waitFor(() => expect(first.result.current.items).toHaveLength(2));
|
|
568
|
+
expect(first.result.current.items[0].version).toBe(8);
|
|
569
|
+
first.unmount();
|
|
570
|
+
resetCalls();
|
|
571
|
+
|
|
572
|
+
const second = renderHook(() => useInfiniteFetch(asynchronous(), { pagination, dependencyTracking: false }));
|
|
573
|
+
|
|
574
|
+
expect(second.result.current.loading).toBe(true);
|
|
575
|
+
await waitFor(() => expect(second.result.current.items).toHaveLength(2));
|
|
576
|
+
expect(calls).toHaveLength(1);
|
|
577
|
+
});
|
|
578
|
+
});
|
|
579
|
+
|
|
580
|
+
describe("requests without cache", () => {
|
|
581
|
+
const uncached = () => createPosts().setCache(false);
|
|
582
|
+
|
|
583
|
+
it("should show the responses and fetch them again after remounting", async () => {
|
|
584
|
+
const first = renderHook(() => useInfiniteFetch(uncached(), { pagination, dependencyTracking: false }));
|
|
585
|
+
await waitFor(() => expect(first.result.current.items).toHaveLength(2));
|
|
586
|
+
await act(() => first.result.current.fetchNextPage());
|
|
587
|
+
|
|
588
|
+
expect(ids(first.result.current.items)).toEqual([1, 2, 3, 4]);
|
|
589
|
+
expect(client.cache.keys()).toHaveLength(0);
|
|
590
|
+
first.unmount();
|
|
591
|
+
resetCalls();
|
|
592
|
+
|
|
593
|
+
const second = renderHook(() => useInfiniteFetch(uncached(), { pagination, dependencyTracking: false }));
|
|
594
|
+
|
|
595
|
+
expect(second.result.current.items).toEqual([]);
|
|
596
|
+
await waitFor(() => expect(second.result.current.items).toHaveLength(2));
|
|
597
|
+
expect(calls).toHaveLength(1);
|
|
598
|
+
});
|
|
599
|
+
|
|
600
|
+
it("should not refetch a page it keeps in memory only because the cache is empty", async () => {
|
|
601
|
+
const { result } = renderHook(() => useInfiniteFetch(uncached(), { pagination, dependencyTracking: false }));
|
|
602
|
+
await waitFor(() => expect(result.current.items).toHaveLength(2));
|
|
603
|
+
resetCalls();
|
|
604
|
+
|
|
605
|
+
await sleep(30);
|
|
606
|
+
|
|
607
|
+
expect(calls).toHaveLength(0);
|
|
608
|
+
});
|
|
609
|
+
});
|
|
610
|
+
|
|
611
|
+
describe("cache changing around mounting", () => {
|
|
612
|
+
const response = (data: Post[]) =>
|
|
613
|
+
({
|
|
614
|
+
data,
|
|
615
|
+
error: null,
|
|
616
|
+
status: 200,
|
|
617
|
+
success: true,
|
|
618
|
+
extra: {},
|
|
619
|
+
requestTimestamp: Date.now(),
|
|
620
|
+
responseTimestamp: Date.now(),
|
|
621
|
+
}) as any;
|
|
622
|
+
|
|
623
|
+
it("should keep a rendered page when its cache entry disappears before mounting", () => {
|
|
624
|
+
client.cache.set(createPosts().setQueryParams({ page: 1 }), response(pageItems(1)));
|
|
625
|
+
|
|
626
|
+
const { result } = renderHook(() => {
|
|
627
|
+
useLayoutEffect(() => {
|
|
628
|
+
client.cache.delete(createPosts().setQueryParams({ page: 1 }).cacheKey);
|
|
629
|
+
}, []);
|
|
630
|
+
return useInfiniteFetch(createPosts(), { pagination, disabled: true, dependencyTracking: false });
|
|
631
|
+
});
|
|
632
|
+
|
|
633
|
+
expect(ids(result.current.items)).toEqual([1, 2]);
|
|
634
|
+
});
|
|
635
|
+
|
|
636
|
+
it("should show a value written to a rendered page before mounting", () => {
|
|
637
|
+
client.cache.set(createPosts().setQueryParams({ page: 1 }), response(pageItems(1)));
|
|
638
|
+
|
|
639
|
+
const { result } = renderHook(() => {
|
|
640
|
+
useLayoutEffect(() => {
|
|
641
|
+
client.cache.set(createPosts().setQueryParams({ page: 1 }), response([{ id: 70 }]));
|
|
642
|
+
}, []);
|
|
643
|
+
return useInfiniteFetch(createPosts(), { pagination, disabled: true, dependencyTracking: false });
|
|
644
|
+
});
|
|
645
|
+
|
|
646
|
+
expect(ids(result.current.items)).toEqual([70]);
|
|
647
|
+
});
|
|
648
|
+
|
|
649
|
+
it("should ignore failed cache events of loaded pages", async () => {
|
|
650
|
+
const { result } = await renderPosts();
|
|
651
|
+
|
|
652
|
+
act(() => {
|
|
653
|
+
client.cache.events.emitCacheData({
|
|
654
|
+
...createPosts().setQueryParams({ page: 1 }).read(),
|
|
655
|
+
cacheKey: createPosts().setQueryParams({ page: 1 }).cacheKey,
|
|
656
|
+
scope: null,
|
|
657
|
+
success: false,
|
|
658
|
+
data: [{ id: 5 }],
|
|
659
|
+
} as any);
|
|
660
|
+
});
|
|
661
|
+
|
|
662
|
+
expect(ids(result.current.items)).toEqual([1, 2]);
|
|
663
|
+
});
|
|
664
|
+
|
|
665
|
+
it("should not refetch after unmounting right after an invalidation", async () => {
|
|
666
|
+
const { unmount } = await renderPosts();
|
|
667
|
+
resetCalls();
|
|
668
|
+
|
|
669
|
+
act(() => {
|
|
670
|
+
client.cache.invalidate(createPosts().setQueryParams({ page: 1 }));
|
|
671
|
+
unmount();
|
|
672
|
+
});
|
|
673
|
+
|
|
674
|
+
await sleep(30);
|
|
675
|
+
expect(calls).toHaveLength(0);
|
|
676
|
+
});
|
|
677
|
+
|
|
678
|
+
it("should stop listening to the cache after unmounting", async () => {
|
|
679
|
+
const { result, unmount } = await renderPosts();
|
|
680
|
+
const { items } = result.current;
|
|
681
|
+
unmount();
|
|
682
|
+
|
|
683
|
+
client.cache.update(createPosts().setQueryParams({ page: 1 }), () => ({ data: [{ id: 80 }] }));
|
|
684
|
+
|
|
685
|
+
expect(result.current.items).toBe(items);
|
|
686
|
+
});
|
|
687
|
+
});
|
|
688
|
+
|
|
689
|
+
describe("pagination callbacks that throw", () => {
|
|
690
|
+
const throwingNext = () => ({
|
|
691
|
+
cursor: "cursor",
|
|
692
|
+
items: "data",
|
|
693
|
+
next: ({ data }: { data: Feed }) => {
|
|
694
|
+
if (data.next === "broken") {
|
|
695
|
+
throw new Error("Broken cursor");
|
|
696
|
+
}
|
|
697
|
+
return data.next;
|
|
698
|
+
},
|
|
699
|
+
});
|
|
700
|
+
|
|
701
|
+
it("should report the error and keep the list valid", async () => {
|
|
702
|
+
mockList("/feed", ({ query }) => {
|
|
703
|
+
return query.cursor ? { data: [{ id: 2 }], next: "broken" } : { data: [{ id: 1 }], next: "second" };
|
|
704
|
+
});
|
|
705
|
+
const { result } = renderHook(() =>
|
|
706
|
+
useInfiniteFetch(createFeed(), { pagination: throwingNext() as any, dependencyTracking: false }),
|
|
707
|
+
);
|
|
708
|
+
await waitFor(() => expect(result.current.items).toHaveLength(1));
|
|
709
|
+
|
|
710
|
+
await act(() => result.current.fetchNextPage());
|
|
711
|
+
|
|
712
|
+
expect(result.current.error).toEqual(new Error("Broken cursor"));
|
|
713
|
+
expect(result.current.success).toBe(false);
|
|
714
|
+
expect(ids(result.current.items as Post[])).toEqual([1]);
|
|
715
|
+
expect(result.current.isFetchingNextPage).toBe(false);
|
|
716
|
+
});
|
|
717
|
+
|
|
718
|
+
it("should keep working after the error", async () => {
|
|
719
|
+
mockList("/feed", ({ query }) => {
|
|
720
|
+
return query.cursor ? { data: [{ id: 2 }], next: "broken" } : { data: [{ id: 1 }], next: "second" };
|
|
721
|
+
});
|
|
722
|
+
const { result } = renderHook(() =>
|
|
723
|
+
useInfiniteFetch(createFeed(), { pagination: throwingNext() as any, dependencyTracking: false }),
|
|
724
|
+
);
|
|
725
|
+
await waitFor(() => expect(result.current.items).toHaveLength(1));
|
|
726
|
+
await act(() => result.current.fetchNextPage());
|
|
727
|
+
|
|
728
|
+
mockList("/feed", ({ query }) => {
|
|
729
|
+
return query.cursor ? { data: [{ id: 2 }], next: null } : { data: [{ id: 1 }], next: "second" };
|
|
730
|
+
});
|
|
731
|
+
await act(() => result.current.fetchNextPage());
|
|
732
|
+
|
|
733
|
+
expect(ids(result.current.items as Post[])).toEqual([1, 2]);
|
|
734
|
+
});
|
|
735
|
+
|
|
736
|
+
it("should report the error of a cursor refetch and keep the old pages", async () => {
|
|
737
|
+
mockList("/feed", () => ({ data: [{ id: 1 }], next: null }));
|
|
738
|
+
const { result } = renderHook(() =>
|
|
739
|
+
useInfiniteFetch(createFeed(), { pagination: throwingNext() as any, dependencyTracking: false }),
|
|
740
|
+
);
|
|
741
|
+
await waitFor(() => expect(result.current.items).toHaveLength(1));
|
|
742
|
+
|
|
743
|
+
mockList("/feed", () => ({ data: [{ id: 9 }], next: "broken" }));
|
|
744
|
+
await act(() => result.current.refetch());
|
|
745
|
+
|
|
746
|
+
expect(result.current.error).toEqual(new Error("Broken cursor"));
|
|
747
|
+
expect(ids(result.current.items as Post[])).toEqual([1]);
|
|
748
|
+
expect(result.current.isRefetching).toBe(false);
|
|
749
|
+
});
|
|
750
|
+
|
|
751
|
+
it("should reject a cache update the callbacks cannot read", async () => {
|
|
752
|
+
mockList("/feed", () => ({ data: [{ id: 1 }], next: null }));
|
|
753
|
+
const { result } = renderHook(() =>
|
|
754
|
+
useInfiniteFetch(createFeed(), { pagination: throwingNext() as any, dependencyTracking: false }),
|
|
755
|
+
);
|
|
756
|
+
await waitFor(() => expect(result.current.items).toHaveLength(1));
|
|
757
|
+
|
|
758
|
+
act(() => {
|
|
759
|
+
client.cache.update(createFeed(), () => ({ data: { data: [{ id: 2 }], next: "broken" } }));
|
|
760
|
+
});
|
|
761
|
+
|
|
762
|
+
expect(result.current.error).toEqual(new Error("Broken cursor"));
|
|
763
|
+
expect(ids(result.current.items as Post[])).toEqual([1]);
|
|
764
|
+
});
|
|
765
|
+
});
|
|
766
|
+
|
|
767
|
+
describe("options", () => {
|
|
768
|
+
it("should bounce new lists with the throttle strategy", async () => {
|
|
769
|
+
const { result, rerender } = renderHook(
|
|
770
|
+
({ search }) =>
|
|
771
|
+
useInfiniteFetch(createPosts().setQueryParams({ search }), {
|
|
772
|
+
pagination,
|
|
773
|
+
bounce: true,
|
|
774
|
+
bounceType: "throttle",
|
|
775
|
+
bounceTime: 20,
|
|
776
|
+
dependencyTracking: false,
|
|
777
|
+
}),
|
|
778
|
+
{ initialProps: { search: "a" } },
|
|
779
|
+
);
|
|
780
|
+
await waitFor(() => expect(result.current.items).toHaveLength(2));
|
|
781
|
+
resetCalls();
|
|
782
|
+
|
|
783
|
+
rerender({ search: "b" });
|
|
784
|
+
|
|
785
|
+
await waitFor(() => expect(calls.at(-1)?.query.search).toBe("b"));
|
|
786
|
+
expect(result.current.bounce.reset).toBeFunction();
|
|
787
|
+
});
|
|
788
|
+
|
|
789
|
+
it("should not refresh a blurred tab with refetchBlurred turned off", async () => {
|
|
790
|
+
await renderPosts({ refresh: true, refreshTime: 10, refetchBlurred: false });
|
|
791
|
+
act(() => client.appManager.setFocused(false));
|
|
792
|
+
await sleep(30);
|
|
793
|
+
resetCalls();
|
|
794
|
+
|
|
795
|
+
await sleep(50);
|
|
796
|
+
|
|
797
|
+
expect(calls).toHaveLength(0);
|
|
798
|
+
});
|
|
799
|
+
|
|
800
|
+
it("should refresh a blurred tab by default", async () => {
|
|
801
|
+
await renderPosts({ refresh: true, refreshTime: 10 });
|
|
802
|
+
act(() => client.appManager.setFocused(false));
|
|
803
|
+
resetCalls();
|
|
804
|
+
|
|
805
|
+
await waitFor(() => expect(calls.length).toBeGreaterThan(0));
|
|
806
|
+
});
|
|
807
|
+
|
|
808
|
+
it("should stop refreshing after unmounting", async () => {
|
|
809
|
+
const { unmount } = await renderPosts({ refresh: true, refreshTime: 10 });
|
|
810
|
+
unmount();
|
|
811
|
+
await sleep(30);
|
|
812
|
+
resetCalls();
|
|
813
|
+
|
|
814
|
+
await sleep(50);
|
|
815
|
+
|
|
816
|
+
expect(calls).toHaveLength(0);
|
|
817
|
+
});
|
|
818
|
+
|
|
819
|
+
it("should not refresh while disabled", async () => {
|
|
820
|
+
renderHook(() =>
|
|
821
|
+
useInfiniteFetch(createPosts(), {
|
|
822
|
+
pagination,
|
|
823
|
+
disabled: true,
|
|
824
|
+
refresh: true,
|
|
825
|
+
refreshTime: 10,
|
|
826
|
+
dependencyTracking: false,
|
|
827
|
+
}),
|
|
828
|
+
);
|
|
829
|
+
|
|
830
|
+
await sleep(50);
|
|
831
|
+
|
|
832
|
+
expect(calls).toHaveLength(0);
|
|
833
|
+
});
|
|
834
|
+
|
|
835
|
+
it("should refetch on blur when asked to", async () => {
|
|
836
|
+
await renderPosts({ refetchOnBlur: true });
|
|
837
|
+
resetCalls();
|
|
838
|
+
|
|
839
|
+
act(() => client.appManager.events.emitBlur());
|
|
840
|
+
|
|
841
|
+
await waitFor(() => expect(calls).toHaveLength(1));
|
|
842
|
+
});
|
|
843
|
+
|
|
844
|
+
it("should not refetch on window events while disabled", async () => {
|
|
845
|
+
renderHook(() =>
|
|
846
|
+
useInfiniteFetch(createPosts(), {
|
|
847
|
+
pagination,
|
|
848
|
+
disabled: true,
|
|
849
|
+
refetchOnFocus: true,
|
|
850
|
+
dependencyTracking: false,
|
|
851
|
+
}),
|
|
852
|
+
);
|
|
853
|
+
|
|
854
|
+
act(() => client.appManager.events.emitFocus());
|
|
855
|
+
|
|
856
|
+
await sleep(30);
|
|
857
|
+
expect(calls).toHaveLength(0);
|
|
858
|
+
});
|
|
859
|
+
|
|
860
|
+
it("should return a new selected value without structural sharing", async () => {
|
|
861
|
+
const { result, rerender } = await renderPosts({
|
|
862
|
+
select: ({ items }: { items: Post[] }) => items.map((item) => ({ ...item })),
|
|
863
|
+
structuralSharing: false,
|
|
864
|
+
});
|
|
865
|
+
const { items } = result.current;
|
|
866
|
+
|
|
867
|
+
rerender();
|
|
868
|
+
|
|
869
|
+
expect(result.current.items).not.toBe(items);
|
|
870
|
+
expect(result.current.items).toEqual(items);
|
|
871
|
+
});
|
|
872
|
+
|
|
873
|
+
it("should replace unchanged references without structural sharing", async () => {
|
|
874
|
+
const { result } = await renderPosts({ structuralSharing: false });
|
|
875
|
+
const { items } = result.current;
|
|
876
|
+
|
|
877
|
+
await act(() => result.current.refetch());
|
|
878
|
+
|
|
879
|
+
expect(result.current.items).not.toBe(items);
|
|
880
|
+
expect(result.current.items).toEqual(items);
|
|
881
|
+
});
|
|
882
|
+
|
|
883
|
+
it("should apply a changed uniqueBy", async () => {
|
|
884
|
+
mockList("/posts", () => [
|
|
885
|
+
{ id: 1, version: 1 },
|
|
886
|
+
{ id: 2, version: 1 },
|
|
887
|
+
]);
|
|
888
|
+
const { result, rerender } = renderHook(
|
|
889
|
+
({ uniqueBy }: { uniqueBy: "id" | "version" }) =>
|
|
890
|
+
useInfiniteFetch(createPosts(), { pagination, uniqueBy, dependencyTracking: false }),
|
|
891
|
+
{ initialProps: { uniqueBy: "id" as "id" | "version" } },
|
|
892
|
+
);
|
|
893
|
+
await waitFor(() => expect(result.current.items).toHaveLength(2));
|
|
894
|
+
|
|
895
|
+
rerender({ uniqueBy: "version" });
|
|
896
|
+
|
|
897
|
+
expect(result.current.items).toHaveLength(1);
|
|
898
|
+
});
|
|
899
|
+
|
|
900
|
+
it("should use the callbacks of the latest render", async () => {
|
|
901
|
+
const first = vi.fn();
|
|
902
|
+
const second = vi.fn();
|
|
903
|
+
const { result, rerender } = renderHook(
|
|
904
|
+
({ callback }) => {
|
|
905
|
+
const list = useInfiniteFetch(createPosts(), { pagination, dependencyTracking: false });
|
|
906
|
+
list.onSuccess(callback);
|
|
907
|
+
return list;
|
|
908
|
+
},
|
|
909
|
+
{ initialProps: { callback: first } },
|
|
910
|
+
);
|
|
911
|
+
await waitFor(() => expect(first).toHaveBeenCalledTimes(1));
|
|
912
|
+
|
|
913
|
+
rerender({ callback: second });
|
|
914
|
+
await act(() => result.current.fetchNextPage());
|
|
915
|
+
|
|
916
|
+
expect(first).toHaveBeenCalledTimes(1);
|
|
917
|
+
expect(second).toHaveBeenCalledTimes(1);
|
|
918
|
+
});
|
|
919
|
+
});
|
|
920
|
+
|
|
921
|
+
describe("shared stores", () => {
|
|
922
|
+
it("should keep the list of a hook that stays after another one threw", async () => {
|
|
923
|
+
const consoleError = vi.spyOn(console, "error").mockImplementation(() => null);
|
|
924
|
+
mockList("/posts", () => failure());
|
|
925
|
+
|
|
926
|
+
const Throwing = () => {
|
|
927
|
+
const { items } = useInfiniteFetch(createPosts(), { pagination, throwOnError: true });
|
|
928
|
+
return <div>throwing:{items.length}</div>;
|
|
929
|
+
};
|
|
930
|
+
const Staying = () => {
|
|
931
|
+
const { error, refetch, items } = useInfiniteFetch(createPosts(), { pagination });
|
|
932
|
+
return (
|
|
933
|
+
<button type="button" onClick={() => refetch()}>
|
|
934
|
+
staying:{error ? "failed" : items.length}
|
|
935
|
+
</button>
|
|
936
|
+
);
|
|
937
|
+
};
|
|
938
|
+
|
|
939
|
+
render(
|
|
940
|
+
<>
|
|
941
|
+
<Boundary>
|
|
942
|
+
<Throwing />
|
|
943
|
+
</Boundary>
|
|
944
|
+
<Staying />
|
|
945
|
+
</>,
|
|
946
|
+
);
|
|
947
|
+
|
|
948
|
+
await screen.findByText("boundary");
|
|
949
|
+
await screen.findByText("staying:failed");
|
|
950
|
+
await sleep(5);
|
|
951
|
+
|
|
952
|
+
mockList("/posts", ({ query }) => pageItems(Number(query.page)));
|
|
953
|
+
act(() => screen.getByRole("button").click());
|
|
954
|
+
|
|
955
|
+
await screen.findByText("staying:2");
|
|
956
|
+
consoleError.mockRestore();
|
|
957
|
+
});
|
|
958
|
+
|
|
959
|
+
it("should not fetch twice when a slow first page outlives the unused store check", async () => {
|
|
960
|
+
const gate = createDeferred();
|
|
961
|
+
mockList("/posts", async () => {
|
|
962
|
+
await gate.promise;
|
|
963
|
+
return pageItems(1);
|
|
964
|
+
});
|
|
965
|
+
const List = () => {
|
|
966
|
+
// Without the cache, only the store that sent the request knows its response
|
|
967
|
+
const { items } = useInfiniteFetch(createPosts().setCache(false), { pagination, suspense: true });
|
|
968
|
+
return <div>items:{items.length}</div>;
|
|
969
|
+
};
|
|
970
|
+
|
|
971
|
+
render(
|
|
972
|
+
<Suspense fallback="loading">
|
|
973
|
+
<List />
|
|
974
|
+
</Suspense>,
|
|
975
|
+
);
|
|
976
|
+
await sleep(1200);
|
|
977
|
+
gate.resolve();
|
|
978
|
+
|
|
979
|
+
await screen.findByText("items:2");
|
|
980
|
+
expect(calls).toHaveLength(1);
|
|
981
|
+
});
|
|
982
|
+
|
|
983
|
+
it("should forget a list whose component never mounted", async () => {
|
|
984
|
+
const List = () => {
|
|
985
|
+
const { items } = useInfiniteFetch(createPosts(), { pagination, suspense: true });
|
|
986
|
+
return <div>items:{items.length}</div>;
|
|
987
|
+
};
|
|
988
|
+
|
|
989
|
+
const view = render(
|
|
990
|
+
<Suspense fallback="loading">
|
|
991
|
+
<List />
|
|
992
|
+
</Suspense>,
|
|
993
|
+
);
|
|
994
|
+
view.unmount();
|
|
995
|
+
await waitFor(() => expect(client.cache.keys()).toHaveLength(1));
|
|
996
|
+
await sleep(1100);
|
|
997
|
+
await client.cache.clear();
|
|
998
|
+
resetCalls();
|
|
999
|
+
|
|
1000
|
+
render(
|
|
1001
|
+
<Suspense fallback="loading">
|
|
1002
|
+
<List />
|
|
1003
|
+
</Suspense>,
|
|
1004
|
+
);
|
|
1005
|
+
|
|
1006
|
+
await screen.findByText("items:2");
|
|
1007
|
+
expect(calls).toHaveLength(1);
|
|
1008
|
+
});
|
|
1009
|
+
|
|
1010
|
+
it("should keep lists of different clients apart", async () => {
|
|
1011
|
+
const other = new Client({ url: baseUrl });
|
|
1012
|
+
const request = other.createRequest<{ response: Post[]; queryParams: { page?: number } }>()({
|
|
1013
|
+
endpoint: "/posts",
|
|
1014
|
+
});
|
|
1015
|
+
const { result } = await renderPosts();
|
|
1016
|
+
const second = renderHook(() => useInfiniteFetch(request, { pagination, dependencyTracking: false }));
|
|
1017
|
+
await waitFor(() => expect(second.result.current.items).toHaveLength(2));
|
|
1018
|
+
|
|
1019
|
+
await act(() => result.current.fetchNextPage());
|
|
1020
|
+
|
|
1021
|
+
expect(result.current.pageParams).toEqual([1, 2]);
|
|
1022
|
+
expect(second.result.current.pageParams).toEqual([1]);
|
|
1023
|
+
});
|
|
1024
|
+
|
|
1025
|
+
it("should follow a change of the client", async () => {
|
|
1026
|
+
const other = new Client({ url: baseUrl });
|
|
1027
|
+
const create = (testClient: Client) =>
|
|
1028
|
+
testClient.createRequest<{ response: Post[]; queryParams: { page?: number } }>()({ endpoint: "/posts" });
|
|
1029
|
+
|
|
1030
|
+
const { result, rerender } = renderHook(
|
|
1031
|
+
({ testClient }) => useInfiniteFetch(create(testClient), { pagination, dependencyTracking: false }),
|
|
1032
|
+
{ initialProps: { testClient: client } },
|
|
1033
|
+
);
|
|
1034
|
+
await waitFor(() => expect(result.current.items).toHaveLength(2));
|
|
1035
|
+
resetCalls();
|
|
1036
|
+
|
|
1037
|
+
rerender({ testClient: other });
|
|
1038
|
+
|
|
1039
|
+
await waitFor(() => expect(calls).toHaveLength(1));
|
|
1040
|
+
await waitFor(() => expect(other.cache.keys()).toHaveLength(1));
|
|
1041
|
+
});
|
|
1042
|
+
});
|
|
1043
|
+
});
|