@hyper-fetch/react 9.5.2 → 9.6.1

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.
Files changed (58) hide show
  1. package/__tests__/features/helpers/use-request-events/use-request-events.async-mapper.spec.ts +243 -0
  2. package/__tests__/features/use-fetch/use-fetch.cancel.spec.ts +6 -3
  3. package/__tests__/features/use-fetch/use-fetch.debounce.spec.ts +72 -80
  4. package/__tests__/features/use-fetch/use-fetch.refresh.spec.ts +36 -13
  5. package/__tests__/features/use-fetch/use-fetch.utils.spec.ts +11 -2
  6. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.base.spec.tsx +745 -0
  7. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.boundaries.spec.tsx +362 -0
  8. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.edge.spec.tsx +1043 -0
  9. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.matrix.spec.tsx +441 -0
  10. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.random.spec.tsx +121 -0
  11. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.refetch.spec.tsx +567 -0
  12. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.start-over.spec.tsx +353 -0
  13. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.typescript.spec.ts +128 -0
  14. package/__tests__/features/use-is-fetching/use-is-fetching.base.spec.tsx +19 -9
  15. package/__tests__/features/use-submit/use-submit.concurrency.spec.ts +2 -1
  16. package/__tests__/features/use-submit/use-submit.debounce.spec.ts +100 -124
  17. package/__tests__/features/use-submit/use-submit.optimistic-settlement.spec.ts +2 -1
  18. package/__tests__/features/use-submit/use-submit.retry.spec.ts +51 -35
  19. package/__tests__/features/use-submit/use-submit.unmount.spec.ts +311 -0
  20. package/__tests__/utils/use-infinite-fetch.modes.ts +131 -0
  21. package/__tests__/utils/use-infinite-fetch.utils.ts +90 -0
  22. package/__tests__/utils/use-queue.utils.ts +8 -4
  23. package/dist/helpers/use-request-events/use-request-events.hooks.d.ts.map +1 -1
  24. package/dist/hooks/use-infinite-fetch/index.d.ts +4 -0
  25. package/dist/hooks/use-infinite-fetch/index.d.ts.map +1 -0
  26. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.constants.d.ts +22 -0
  27. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.constants.d.ts.map +1 -0
  28. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.hooks.d.ts +21 -0
  29. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.hooks.d.ts.map +1 -0
  30. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.requests.d.ts +19 -0
  31. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.requests.d.ts.map +1 -0
  32. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts +119 -0
  33. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts.map +1 -0
  34. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.types.d.ts +48 -0
  35. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.types.d.ts.map +1 -0
  36. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts +172 -0
  37. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts.map +1 -0
  38. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts +15 -0
  39. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts.map +1 -0
  40. package/dist/index.d.ts +1 -0
  41. package/dist/index.d.ts.map +1 -1
  42. package/dist/index.mjs +917 -3
  43. package/dist/index.mjs.map +1 -1
  44. package/dist/provider/provider.types.d.ts +2 -0
  45. package/dist/provider/provider.types.d.ts.map +1 -1
  46. package/package.json +1 -1
  47. package/src/helpers/use-request-events/use-request-events.hooks.ts +17 -5
  48. package/src/hooks/use-infinite-fetch/index.ts +3 -0
  49. package/src/hooks/use-infinite-fetch/use-infinite-fetch.constants.ts +25 -0
  50. package/src/hooks/use-infinite-fetch/use-infinite-fetch.hooks.ts +389 -0
  51. package/src/hooks/use-infinite-fetch/use-infinite-fetch.requests.ts +98 -0
  52. package/src/hooks/use-infinite-fetch/use-infinite-fetch.store.ts +780 -0
  53. package/src/hooks/use-infinite-fetch/use-infinite-fetch.store.types.ts +49 -0
  54. package/src/hooks/use-infinite-fetch/use-infinite-fetch.types.ts +195 -0
  55. package/src/hooks/use-infinite-fetch/use-infinite-fetch.utils.ts +44 -0
  56. package/src/index.ts +1 -0
  57. package/src/provider/provider.types.ts +3 -0
  58. package/__tests__/features/use-fetch/use-fetch.infinite.ts +0 -39
@@ -0,0 +1,441 @@
1
+ import { Client, fetchInfinite, getPageRequest } from "@hyper-fetch/core";
2
+ import { act, renderHook, waitFor } from "@testing-library/react";
3
+ import { useInfiniteFetch } from "hooks/use-infinite-fetch";
4
+ import { Hydrate } from "hydrate";
5
+ import React, { StrictMode } from "react";
6
+
7
+ import type { ListBackend } from "../../utils/use-infinite-fetch.modes";
8
+ import { createListBackend, pagingModes } from "../../utils/use-infinite-fetch.modes";
9
+ import { baseUrl, createDeferred, createListServer, settleRequests, sleep } from "../../utils/use-infinite-fetch.utils";
10
+
11
+ const server = createListServer();
12
+ const { startServer, stopServer, resetMocks, calls, resetCalls } = server;
13
+
14
+ const ids = (items: any[]) => items.map((item) => item.id);
15
+ const versions = (items: any[]) => items.map((item) => item.version);
16
+
17
+ describe.each(pagingModes)("useInfiniteFetch [ Matrix ] $name", (mode) => {
18
+ let client: Client;
19
+ let backend: ListBackend;
20
+
21
+ const options = { pagination: mode.pagination, dependencyTracking: false };
22
+ const starts = () => calls.map(mode.startOf);
23
+
24
+ const renderList = async (request = mode.create(client), extra: Record<string, unknown> = {}) => {
25
+ const view = renderHook(() => useInfiniteFetch(request, { ...options, ...extra }) as any);
26
+ await waitFor(() => expect(view.result.current.loading).toBe(false));
27
+ return view;
28
+ };
29
+
30
+ const loadAll = async (view: Awaited<ReturnType<typeof renderList>>) => {
31
+ while (view.result.current.hasNextPage) {
32
+ // Every page depends on the one before it
33
+ // eslint-disable-next-line no-await-in-loop
34
+ await act(() => view.result.current.fetchNextPage());
35
+ }
36
+ };
37
+
38
+ beforeAll(() => startServer());
39
+ afterAll(() => stopServer());
40
+
41
+ beforeEach(() => {
42
+ client = new Client({ url: baseUrl });
43
+ backend = createListBackend();
44
+ resetCalls();
45
+ mode.mock(server, backend);
46
+ });
47
+
48
+ afterEach(async () => {
49
+ await settleRequests(client);
50
+ resetMocks();
51
+ });
52
+
53
+ describe("loading", () => {
54
+ it("should load every page once and in order", async () => {
55
+ const view = await renderList();
56
+
57
+ await loadAll(view);
58
+
59
+ expect(ids(view.result.current.items)).toEqual([1, 2, 3, 4, 5, 6]);
60
+ expect(starts()).toEqual([0, 2, 4]);
61
+ expect(view.result.current.pages).toHaveLength(3);
62
+ expect(view.result.current.total).toBe(6);
63
+ expect(view.result.current.hasNextPage).toBe(false);
64
+ expect(view.result.current.isFetching).toBe(false);
65
+ });
66
+
67
+ it("should store every page under its own key", async () => {
68
+ const view = await renderList();
69
+
70
+ await loadAll(view);
71
+
72
+ expect(client.cache.keys()).toHaveLength(3);
73
+ });
74
+
75
+ it("should not request anything past the end", async () => {
76
+ const view = await renderList();
77
+ await loadAll(view);
78
+ resetCalls();
79
+
80
+ await expect(view.result.current.fetchNextPage()).resolves.toBeNull();
81
+
82
+ expect(calls).toHaveLength(0);
83
+ });
84
+
85
+ it("should share one request between repeated calls", async () => {
86
+ const view = await renderList();
87
+ resetCalls();
88
+
89
+ await act(async () => {
90
+ await Promise.all([1, 2, 3, 4, 5].map(() => view.result.current.fetchNextPage()));
91
+ });
92
+
93
+ expect(starts()).toEqual([2]);
94
+ expect(view.result.current.pages).toHaveLength(2);
95
+ });
96
+
97
+ it("should handle an empty list", async () => {
98
+ backend.total = 0;
99
+
100
+ const view = await renderList();
101
+
102
+ expect(view.result.current.items).toEqual([]);
103
+ expect(view.result.current.hasNextPage).toBe(false);
104
+ expect(view.result.current.error).toBeNull();
105
+ });
106
+
107
+ it("should handle a list of one page", async () => {
108
+ backend.total = 2;
109
+
110
+ const view = await renderList();
111
+
112
+ expect(view.result.current.hasNextPage).toBe(false);
113
+ expect(calls).toHaveLength(1);
114
+ });
115
+
116
+ it("should handle a shorter last page", async () => {
117
+ backend.total = 5;
118
+ const view = await renderList();
119
+
120
+ await loadAll(view);
121
+
122
+ expect(ids(view.result.current.items)).toEqual([1, 2, 3, 4, 5]);
123
+ expect(calls).toHaveLength(3);
124
+ });
125
+
126
+ it("should send one request in StrictMode", async () => {
127
+ const view = renderHook(() => useInfiniteFetch(mode.create(client), options) as any, { wrapper: StrictMode });
128
+
129
+ await waitFor(() => expect(view.result.current.items).toHaveLength(2));
130
+
131
+ expect(calls).toHaveLength(1);
132
+ });
133
+
134
+ it("should wait for the list to be enabled", async () => {
135
+ const view = renderHook(
136
+ ({ disabled }) => useInfiniteFetch(mode.create(client), { ...options, disabled }) as any,
137
+ { initialProps: { disabled: true } },
138
+ );
139
+ await sleep(20);
140
+ expect(calls).toHaveLength(0);
141
+
142
+ view.rerender({ disabled: false });
143
+
144
+ await waitFor(() => expect(view.result.current.items).toHaveLength(2));
145
+ });
146
+
147
+ it("should transform the list with select", async () => {
148
+ const view = await renderList(undefined, {
149
+ select: ({ items, pages }: { items: unknown[]; pages: unknown[] }) => `${items.length}/${pages.length}`,
150
+ });
151
+
152
+ await act(() => view.result.current.fetchNextPage());
153
+
154
+ expect(view.result.current.items).toBe("4/2");
155
+ });
156
+ });
157
+
158
+ describe("directions", () => {
159
+ it("should reach both ends from the middle", async () => {
160
+ const view = await renderList(mode.at(client, 2));
161
+ expect(ids(view.result.current.items)).toEqual([3, 4]);
162
+ expect(view.result.current.hasPreviousPage).toBe(true);
163
+ expect(view.result.current.hasNextPage).toBe(true);
164
+
165
+ await act(() => view.result.current.fetchPreviousPage());
166
+ expect(ids(view.result.current.items)).toEqual([1, 2, 3, 4]);
167
+ expect(view.result.current.hasPreviousPage).toBe(false);
168
+
169
+ await act(() => view.result.current.fetchNextPage());
170
+ expect(ids(view.result.current.items)).toEqual([1, 2, 3, 4, 5, 6]);
171
+ expect(view.result.current.hasNextPage).toBe(false);
172
+ });
173
+
174
+ it("should move a window of pages in both directions", async () => {
175
+ const view = await renderList(undefined, { maxPages: 2 });
176
+
177
+ await loadAll(view);
178
+ expect(ids(view.result.current.items)).toEqual([3, 4, 5, 6]);
179
+ expect(view.result.current.hasPreviousPage).toBe(true);
180
+
181
+ await act(() => view.result.current.fetchPreviousPage());
182
+ expect(ids(view.result.current.items)).toEqual([1, 2, 3, 4]);
183
+ expect(view.result.current.hasNextPage).toBe(true);
184
+
185
+ await act(() => view.result.current.fetchNextPage());
186
+ expect(ids(view.result.current.items)).toEqual([3, 4, 5, 6]);
187
+ });
188
+ });
189
+
190
+ describe("refetching", () => {
191
+ it("should replace every page with fresh data", async () => {
192
+ const view = await renderList();
193
+ await loadAll(view);
194
+ backend.version = 2;
195
+ resetCalls();
196
+
197
+ await act(() => view.result.current.refetch());
198
+
199
+ expect(versions(view.result.current.items)).toEqual([2, 2, 2, 2, 2, 2]);
200
+ expect([...starts()].toSorted()).toEqual([0, 2, 4]);
201
+ });
202
+
203
+ it("should show the old pages until the fresh ones arrive", async () => {
204
+ const view = await renderList();
205
+ backend.version = 2;
206
+ backend.gate = createDeferred();
207
+
208
+ let pending: Promise<unknown> = Promise.resolve();
209
+ act(() => {
210
+ pending = view.result.current.refetch();
211
+ });
212
+
213
+ expect(view.result.current.isRefetching).toBe(true);
214
+ expect(versions(view.result.current.items)).toEqual([1, 1]);
215
+
216
+ backend.gate.resolve();
217
+ await act(async () => {
218
+ await pending;
219
+ });
220
+
221
+ expect(versions(view.result.current.items)).toEqual([2, 2]);
222
+ });
223
+
224
+ it("should keep every item when a page fails to refetch", async () => {
225
+ const view = await renderList();
226
+ await loadAll(view);
227
+ backend.failing.add(2);
228
+
229
+ await act(() => view.result.current.refetch());
230
+
231
+ expect(ids(view.result.current.items)).toEqual([1, 2, 3, 4, 5, 6]);
232
+ expect(view.result.current.error).toBeTruthy();
233
+ });
234
+
235
+ it("should refetch the list when one of the pages is invalidated", async () => {
236
+ const view = await renderList();
237
+ await loadAll(view);
238
+ backend.version = 2;
239
+
240
+ const [, param] = view.result.current.pageParams;
241
+ act(() => {
242
+ client.cache.invalidate(getPageRequest(mode.create(client), mode.pagination, param));
243
+ });
244
+
245
+ await waitFor(() => expect(versions(view.result.current.items)).toEqual([2, 2, 2, 2, 2, 2]));
246
+ });
247
+
248
+ it("should refetch when the dependencies change", async () => {
249
+ const view = renderHook(
250
+ ({ value }) => useInfiniteFetch(mode.create(client), { ...options, dependencies: [value] }) as any,
251
+ { initialProps: { value: 1 } },
252
+ );
253
+ await waitFor(() => expect(view.result.current.items).toHaveLength(2));
254
+ backend.version = 2;
255
+
256
+ view.rerender({ value: 2 });
257
+
258
+ await waitFor(() => expect(versions(view.result.current.items)).toEqual([2, 2]));
259
+ });
260
+
261
+ it("should update one page in place when its cache changes", async () => {
262
+ const request = mode.create(client);
263
+ const view = await renderList(request);
264
+ await loadAll(view);
265
+ const [first] = view.result.current.items;
266
+ resetCalls();
267
+
268
+ const param = view.result.current.pageParams.at(-1);
269
+ act(() => {
270
+ client.cache.update(getPageRequest(request, mode.pagination, param), (previous: any) => ({
271
+ data: { ...previous.data, items: [{ id: 100 }, { id: 101 }] },
272
+ }));
273
+ });
274
+
275
+ expect(ids(view.result.current.items)).toEqual([1, 2, 3, 4, 100, 101]);
276
+ expect(view.result.current.items[0]).toBe(first);
277
+ expect(calls).toHaveLength(0);
278
+ });
279
+ });
280
+
281
+ describe("restoring", () => {
282
+ it("should restore every loaded page after remounting", async () => {
283
+ const first = await renderList();
284
+ await loadAll(first);
285
+ first.unmount();
286
+ resetCalls();
287
+
288
+ const view = renderHook(() => useInfiniteFetch(mode.create(client), options) as any);
289
+
290
+ expect(ids(view.result.current.items)).toEqual([1, 2, 3, 4, 5, 6]);
291
+ expect(view.result.current.loading).toBe(false);
292
+ await sleep(20);
293
+ expect(calls).toHaveLength(0);
294
+ });
295
+
296
+ it("should keep a page that arrived after unmounting", async () => {
297
+ const first = await renderList();
298
+ backend.gate = createDeferred();
299
+ act(() => {
300
+ first.result.current.fetchNextPage();
301
+ });
302
+ await waitFor(() => expect(calls).toHaveLength(2));
303
+
304
+ first.unmount();
305
+ backend.gate.resolve();
306
+ await waitFor(() => expect(client.cache.keys()).toHaveLength(2));
307
+
308
+ const view = renderHook(() => useInfiniteFetch(mode.create(client), options) as any);
309
+
310
+ expect(ids(view.result.current.items)).toEqual([1, 2, 3, 4]);
311
+ });
312
+
313
+ it("should render prefetched pages and continue after them", async () => {
314
+ const { dehydrated } = await fetchInfinite(mode.create(client), { pagination: mode.pagination, pages: 2 });
315
+ resetCalls();
316
+
317
+ const view = renderHook(() => useInfiniteFetch(mode.create(client), options) as any, {
318
+ wrapper: ({ children }: { children: React.ReactNode }) => (
319
+ <Hydrate client={client} data={dehydrated}>
320
+ {children}
321
+ </Hydrate>
322
+ ),
323
+ });
324
+
325
+ expect(ids(view.result.current.items)).toEqual([1, 2, 3, 4]);
326
+ await sleep(20);
327
+ expect(calls).toHaveLength(0);
328
+
329
+ await act(() => view.result.current.fetchNextPage());
330
+
331
+ expect(ids(view.result.current.items)).toEqual([1, 2, 3, 4, 5, 6]);
332
+ expect(starts()).toEqual([4]);
333
+ });
334
+ });
335
+
336
+ describe("recovering", () => {
337
+ it("should drop to the first page on reset", async () => {
338
+ const view = await renderList();
339
+ await loadAll(view);
340
+ resetCalls();
341
+
342
+ await act(() => view.result.current.reset());
343
+
344
+ expect(ids(view.result.current.items)).toEqual([1, 2]);
345
+ expect(starts()).toEqual([0]);
346
+ expect(view.result.current.hasNextPage).toBe(true);
347
+ });
348
+
349
+ it("should continue after an aborted page", async () => {
350
+ const view = await renderList();
351
+ backend.gate = createDeferred();
352
+
353
+ let pending: Promise<unknown> = Promise.resolve();
354
+ act(() => {
355
+ pending = view.result.current.fetchNextPage();
356
+ });
357
+ act(() => view.result.current.abort());
358
+ backend.gate.resolve();
359
+ backend.gate = null;
360
+
361
+ await expect(pending).resolves.toBeNull();
362
+ expect(ids(view.result.current.items)).toEqual([1, 2]);
363
+
364
+ await act(() => view.result.current.fetchNextPage());
365
+
366
+ expect(ids(view.result.current.items)).toEqual([1, 2, 3, 4]);
367
+ });
368
+
369
+ it("should retry a failed page", async () => {
370
+ const view = await renderList();
371
+ backend.failing.add(2);
372
+
373
+ await act(() => view.result.current.fetchNextPage());
374
+ expect(view.result.current.isFetchNextPageError).toBe(true);
375
+ expect(ids(view.result.current.items)).toEqual([1, 2]);
376
+
377
+ backend.failing.clear();
378
+ await act(() => view.result.current.fetchNextPage());
379
+
380
+ expect(view.result.current.isFetchNextPageError).toBe(false);
381
+ expect(view.result.current.error).toBeNull();
382
+ expect(ids(view.result.current.items)).toEqual([1, 2, 3, 4]);
383
+ });
384
+
385
+ it("should recover from a failed first page", async () => {
386
+ backend.failing.add(0);
387
+ const view = await renderList();
388
+ expect(view.result.current.error).toBeTruthy();
389
+
390
+ backend.failing.clear();
391
+ await act(() => view.result.current.refetch());
392
+
393
+ expect(view.result.current.error).toBeNull();
394
+ expect(ids(view.result.current.items)).toEqual([1, 2]);
395
+ });
396
+ });
397
+
398
+ describe("sharing", () => {
399
+ it("should keep hooks of one list in sync", async () => {
400
+ const view = renderHook(() => ({
401
+ first: useInfiniteFetch(mode.create(client), options) as any,
402
+ second: useInfiniteFetch(mode.create(client), options) as any,
403
+ }));
404
+ await waitFor(() => expect(view.result.current.second.items).toHaveLength(2));
405
+
406
+ await act(() => view.result.current.first.fetchNextPage());
407
+
408
+ expect(ids(view.result.current.second.items)).toEqual([1, 2, 3, 4]);
409
+ expect(calls).toHaveLength(2);
410
+ });
411
+
412
+ it("should keep scopes apart", async () => {
413
+ const view = renderHook(() => ({
414
+ a: useInfiniteFetch(mode.create(client).setScope("a"), options) as any,
415
+ b: useInfiniteFetch(mode.create(client).setScope("b"), options) as any,
416
+ }));
417
+ await waitFor(() => expect(view.result.current.a.items).toHaveLength(2));
418
+ await waitFor(() => expect(view.result.current.b.items).toHaveLength(2));
419
+
420
+ await act(() => view.result.current.a.fetchNextPage());
421
+
422
+ expect(view.result.current.a.pages).toHaveLength(2);
423
+ expect(view.result.current.b.pages).toHaveLength(1);
424
+ expect(calls).toHaveLength(3);
425
+ });
426
+
427
+ it("should start over when the scope changes", async () => {
428
+ const view = renderHook(({ scope }) => useInfiniteFetch(mode.create(client).setScope(scope), options) as any, {
429
+ initialProps: { scope: "a" },
430
+ });
431
+ await waitFor(() => expect(view.result.current.items).toHaveLength(2));
432
+ await act(() => view.result.current.fetchNextPage());
433
+
434
+ view.rerender({ scope: "b" });
435
+
436
+ await waitFor(() => expect(view.result.current.pages).toHaveLength(1));
437
+ await waitFor(() => expect(view.result.current.isPreviousData).toBe(false));
438
+ expect(ids(view.result.current.items)).toEqual([1, 2]);
439
+ });
440
+ });
441
+ });
@@ -0,0 +1,121 @@
1
+ import { Client, getPageRequest } from "@hyper-fetch/core";
2
+ import { act, renderHook, waitFor } from "@testing-library/react";
3
+ import { useInfiniteFetch } from "hooks/use-infinite-fetch";
4
+
5
+ import type { ListBackend } from "../../utils/use-infinite-fetch.modes";
6
+ import { createListBackend, pagingModes } from "../../utils/use-infinite-fetch.modes";
7
+ import { baseUrl, createListServer, settleRequests, sleep } from "../../utils/use-infinite-fetch.utils";
8
+
9
+ const server = createListServer();
10
+ const { startServer, stopServer, resetMocks, resetCalls } = server;
11
+
12
+ const seeds = [1, 7, 42, 1234, 99_991];
13
+ const steps = 30;
14
+
15
+ // Failing seeds can be replayed: the same seed always produces the same actions
16
+ const createRandom = (seed: number) => {
17
+ let value = seed;
18
+ return () => {
19
+ value = (value * 16_807) % 2_147_483_647;
20
+ return value / 2_147_483_647;
21
+ };
22
+ };
23
+
24
+ describe.each(pagingModes)("useInfiniteFetch [ Random ] $name", (mode) => {
25
+ let client: Client;
26
+ let backend: ListBackend;
27
+
28
+ const options = { pagination: mode.pagination, dependencyTracking: false };
29
+ const mount = () => renderHook(() => useInfiniteFetch(mode.create(client), options) as any);
30
+
31
+ beforeAll(() => startServer());
32
+ afterAll(() => stopServer());
33
+
34
+ beforeEach(() => {
35
+ client = new Client({ url: baseUrl });
36
+ backend = createListBackend();
37
+ backend.total = 12;
38
+ resetCalls();
39
+ mode.mock(server, backend);
40
+ });
41
+
42
+ afterEach(async () => {
43
+ await settleRequests(client);
44
+ resetMocks();
45
+ });
46
+
47
+ it.each(seeds)("should end up matching the server for seed %s", async (seed) => {
48
+ const random = createRandom(seed);
49
+ const pick = (size: number) => Math.floor(random() * size);
50
+ const pending: Promise<unknown>[] = [];
51
+ let view = mount();
52
+
53
+ const actions: VoidFunction[] = [
54
+ () => pending.push(view.result.current.fetchNextPage()),
55
+ () => pending.push(view.result.current.fetchNextPage()),
56
+ () => pending.push(view.result.current.fetchPreviousPage()),
57
+ () => pending.push(view.result.current.refetch()),
58
+ () => pending.push(view.result.current.reset()),
59
+ () => view.result.current.abort(),
60
+ () => {
61
+ backend.version += 1;
62
+ },
63
+ () => {
64
+ backend.failing.add(pick(6) * 2);
65
+ },
66
+ () => backend.failing.clear(),
67
+ () => {
68
+ const { pageParams } = view.result.current;
69
+ if (pageParams.length > 0) {
70
+ const param = pageParams[pick(pageParams.length)];
71
+ client.cache.invalidate(getPageRequest(mode.create(client), mode.pagination, param));
72
+ }
73
+ },
74
+ () => {
75
+ view.unmount();
76
+ view = mount();
77
+ },
78
+ ];
79
+
80
+ for (let step = 0; step < steps; step += 1) {
81
+ const count = 1 + pick(3);
82
+ for (let index = 0; index < count; index += 1) {
83
+ // Nothing is awaited in between, so the actions overlap each other
84
+ act(() => actions[pick(actions.length)]());
85
+ }
86
+ // Some actions overlap the responses of the previous ones, some wait for them
87
+ // eslint-disable-next-line no-await-in-loop, @typescript-eslint/no-loop-func
88
+ await act(async () => {
89
+ await sleep(pick(12));
90
+ });
91
+ }
92
+
93
+ backend.failing.clear();
94
+ await act(async () => {
95
+ await Promise.all(pending);
96
+ });
97
+ await act(() => view.result.current.refetch());
98
+ await waitFor(() => expect(view.result.current.isFetching).toBe(false));
99
+
100
+ const { items, pageParams, error, hasNextPage, hasPreviousPage } = view.result.current;
101
+ const ids: number[] = items.map((item: { id: number }) => item.id);
102
+
103
+ expect(error).toBeNull();
104
+ expect(ids.length).toBeGreaterThan(0);
105
+ // Whole pages, in order, without gaps or repeated items
106
+ expect((ids[0] - 1) % 2).toBe(0);
107
+ expect(ids.length % 2).toBe(0);
108
+ ids.forEach((id, index) => {
109
+ expect(id).toBe(ids[0] + index);
110
+ });
111
+ expect(new Set(pageParams.map(String)).size).toBe(pageParams.length);
112
+ // Everything on screen comes from the latest state of the server
113
+ items.forEach((item: { version: number }) => {
114
+ expect(item.version).toBe(backend.version);
115
+ });
116
+ expect(hasNextPage).toBe((ids.at(-1) as number) < backend.total);
117
+ expect(hasPreviousPage).toBe(ids[0] > 1);
118
+ // Nothing is left behind
119
+ expect(client.fetchDispatcher.getAllRunningRequests()).toHaveLength(0);
120
+ });
121
+ });