@hyper-fetch/react 9.6.1 → 9.6.2

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 (91) hide show
  1. package/__tests__/features/helpers/use-tracked-state/use-tacked-state.actions.spec.ts +1 -1
  2. package/__tests__/features/helpers/use-tracked-state/use-tracked-state.keys.spec.ts +294 -0
  3. package/__tests__/features/helpers/utils.spec.ts +127 -0
  4. package/__tests__/features/provider/provider.config.spec.tsx +172 -0
  5. package/__tests__/features/use-app-manager/use-app-manager.events.spec.tsx +497 -0
  6. package/__tests__/features/use-cache/use-cache.state.spec.tsx +326 -0
  7. package/__tests__/features/use-emitter/use-emitter.lifecycle.spec.tsx +417 -0
  8. package/__tests__/features/use-fetch/use-fetch.bounce-timers.spec.ts +199 -0
  9. package/__tests__/features/use-fetch/use-fetch.cache-events.spec.ts +212 -0
  10. package/__tests__/features/use-fetch/use-fetch.callbacks.spec.tsx +359 -0
  11. package/__tests__/features/use-fetch/use-fetch.hydration.spec.tsx +126 -0
  12. package/__tests__/features/use-fetch/use-fetch.infinite.spec.ts +146 -0
  13. package/__tests__/features/use-fetch/use-fetch.initial-state.spec.ts +340 -0
  14. package/__tests__/features/use-fetch/use-fetch.keys.spec.tsx +559 -0
  15. package/__tests__/features/use-fetch/use-fetch.lifecycle.spec.ts +348 -0
  16. package/__tests__/features/use-fetch/use-fetch.mounting.spec.tsx +411 -0
  17. package/__tests__/features/use-fetch/use-fetch.pagination.spec.ts +177 -0
  18. package/__tests__/features/use-fetch/use-fetch.refresh-interval.spec.ts +355 -0
  19. package/__tests__/features/use-fetch/use-fetch.response-order.spec.ts +105 -0
  20. package/__tests__/features/use-fetch/use-fetch.retry.spec.ts +235 -0
  21. package/__tests__/features/use-fetch/use-fetch.return-types.spec.ts +186 -0
  22. package/__tests__/features/use-fetch/use-fetch.scope.spec.ts +333 -0
  23. package/__tests__/features/use-fetch/use-fetch.ssr.spec.tsx +195 -0
  24. package/__tests__/features/use-fetch/use-fetch.suspense-edge.spec.tsx +391 -0
  25. package/__tests__/features/use-fetch/use-fetch.throwing-callbacks.spec.tsx +112 -0
  26. package/__tests__/features/use-fetch/use-fetch.tracking.spec.tsx +364 -0
  27. package/__tests__/features/use-fetch/use-fetch.window-events.spec.ts +300 -0
  28. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.parity.spec.tsx +1027 -0
  29. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.resubscribe.spec.tsx +267 -0
  30. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.typescript.spec.ts +64 -1
  31. package/__tests__/features/use-is-fetching/use-is-fetching.lifecycle.spec.tsx +301 -0
  32. package/__tests__/features/use-listener/use-listener.lifecycle.spec.tsx +507 -0
  33. package/__tests__/features/use-listener/use-listener.ssr.spec.tsx +89 -0
  34. package/__tests__/features/use-queue/use-queue.controls.spec.tsx +593 -0
  35. package/__tests__/features/use-queue/use-queue.list.spec.tsx +560 -0
  36. package/__tests__/features/use-queue/use-queue.progress.spec.tsx +650 -0
  37. package/__tests__/features/use-submit/use-submit.abort.spec.tsx +270 -0
  38. package/__tests__/features/use-submit/use-submit.actions.spec.tsx +446 -0
  39. package/__tests__/features/use-submit/use-submit.arguments.spec.tsx +732 -0
  40. package/__tests__/features/use-submit/use-submit.bounce.spec.tsx +644 -0
  41. package/__tests__/features/use-submit/use-submit.callbacks.spec.tsx +860 -0
  42. package/__tests__/features/use-submit/use-submit.chaining.spec.tsx +167 -0
  43. package/__tests__/features/use-submit/use-submit.double-submit.spec.tsx +552 -0
  44. package/__tests__/features/use-submit/use-submit.offline.spec.tsx +285 -0
  45. package/__tests__/features/use-submit/use-submit.optimistic-cache.spec.tsx +619 -0
  46. package/__tests__/features/use-submit/use-submit.optimistic-settlement.spec.ts +6 -0
  47. package/__tests__/features/use-submit/use-submit.optimistic.spec.ts +5 -1
  48. package/__tests__/features/use-submit/use-submit.state.spec.tsx +1025 -0
  49. package/__tests__/features/use-submit/use-submit.submit-types.spec.ts +194 -0
  50. package/__tests__/features/use-submit/use-submit.submitting.spec.tsx +180 -0
  51. package/__tests__/utils/gate.utils.ts +103 -0
  52. package/__tests__/utils/gated-client.utils.ts +158 -0
  53. package/__tests__/utils/helpers.utils.ts +19 -0
  54. package/dist/helpers/use-request-events/use-request-events.hooks.d.ts.map +1 -1
  55. package/dist/helpers/use-request-events/use-request-events.types.d.ts +1 -1
  56. package/dist/helpers/use-request-events/use-request-events.types.d.ts.map +1 -1
  57. package/dist/helpers/use-tracked-state/use-tracked-state.hooks.d.ts.map +1 -1
  58. package/dist/helpers/use-tracked-state/use-tracked-state.utils.d.ts +8 -0
  59. package/dist/helpers/use-tracked-state/use-tracked-state.utils.d.ts.map +1 -1
  60. package/dist/hooks/use-cache/use-cache.hooks.d.ts.map +1 -1
  61. package/dist/hooks/use-fetch/use-fetch.hooks.d.ts.map +1 -1
  62. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.hooks.d.ts.map +1 -1
  63. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts +3 -0
  64. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts.map +1 -1
  65. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts +5 -3
  66. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts.map +1 -1
  67. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts +11 -1
  68. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts.map +1 -1
  69. package/dist/hooks/use-listener/use-listener.hooks.d.ts.map +1 -1
  70. package/dist/hooks/use-queue/use-queue.hooks.d.ts.map +1 -1
  71. package/dist/hooks/use-submit/use-submit.hooks.d.ts.map +1 -1
  72. package/dist/index.mjs +630 -346
  73. package/dist/index.mjs.map +1 -1
  74. package/dist/provider/provider.d.ts.map +1 -1
  75. package/package.json +1 -1
  76. package/src/helpers/use-request-events/use-request-events.hooks.ts +141 -28
  77. package/src/helpers/use-request-events/use-request-events.types.ts +1 -1
  78. package/src/helpers/use-tracked-state/use-tracked-state.hooks.ts +148 -101
  79. package/src/helpers/use-tracked-state/use-tracked-state.utils.ts +26 -5
  80. package/src/hooks/use-cache/use-cache.hooks.ts +20 -5
  81. package/src/hooks/use-fetch/use-fetch.hooks.ts +194 -113
  82. package/src/hooks/use-infinite-fetch/use-infinite-fetch.hooks.ts +55 -26
  83. package/src/hooks/use-infinite-fetch/use-infinite-fetch.store.ts +35 -29
  84. package/src/hooks/use-infinite-fetch/use-infinite-fetch.types.ts +5 -3
  85. package/src/hooks/use-infinite-fetch/use-infinite-fetch.utils.ts +25 -1
  86. package/src/hooks/use-listener/use-listener.hooks.ts +2 -1
  87. package/src/hooks/use-queue/use-queue.hooks.ts +85 -60
  88. package/src/hooks/use-submit/use-submit.hooks.ts +163 -53
  89. package/src/provider/provider.tsx +9 -1
  90. package/__tests__/features/use-fetch/use-fetch.pagination.ts +0 -36
  91. package/__tests__/features/use-fetch/use-fetch.retry.ts +0 -38
@@ -0,0 +1,411 @@
1
+ import type { RequestInstance } from "@hyper-fetch/core";
2
+ import { act, render, renderHook, screen } from "@testing-library/react";
3
+ import { useFetch } from "hooks/use-fetch";
4
+ import { Activity, StrictMode } from "react";
5
+
6
+ import { client, createRequest } from "../../utils";
7
+ import { advance, countListeners, gateRequest, setCacheResponse, settle } from "../../utils/gate.utils";
8
+
9
+ type User = { id: number };
10
+
11
+ const View = ({ request, name }: { request: RequestInstance; name: string }) => {
12
+ const { data, loading, error } = useFetch(request);
13
+ return <div data-testid={name}>{JSON.stringify({ data, loading, error: error?.message ?? null })}</div>;
14
+ };
15
+
16
+ const read = (name: string) => JSON.parse(screen.getByTestId(name).textContent || "{}");
17
+
18
+ describe("useFetch [ Mounting ]", () => {
19
+ let request = createRequest<User, any, "/users/:id">({ endpoint: "/users/:id" });
20
+ let calls = gateRequest(request);
21
+
22
+ beforeEach(() => {
23
+ vi.useFakeTimers();
24
+ client.clear();
25
+ request = createRequest<User, any, "/users/:id">({ endpoint: "/users/:id" });
26
+ calls = gateRequest(request);
27
+ });
28
+
29
+ afterEach(() => {
30
+ vi.restoreAllMocks();
31
+ vi.useRealTimers();
32
+ });
33
+
34
+ describe("when rendered in StrictMode", () => {
35
+ it("should send one request on mount", async () => {
36
+ render(<View request={request.setParams({ id: 1 })} name="user" />, { wrapper: StrictMode });
37
+ await advance();
38
+
39
+ expect(calls).toHaveLength(1);
40
+ });
41
+ it("should receive the response", async () => {
42
+ render(<View request={request.setParams({ id: 1 })} name="user" />, { wrapper: StrictMode });
43
+ await advance();
44
+ calls[0].succeed({ id: 1 });
45
+ await settle();
46
+
47
+ expect(read("user")).toStrictEqual({ data: { id: 1 }, loading: false, error: null });
48
+ });
49
+ it("should send one request per key change", async () => {
50
+ const view = render(<View request={request.setParams({ id: 1 })} name="user" />, { wrapper: StrictMode });
51
+ await advance();
52
+ view.rerender(<View request={request.setParams({ id: 2 })} name="user" />);
53
+ await advance();
54
+ view.rerender(<View request={request.setParams({ id: 3 })} name="user" />);
55
+ await advance();
56
+
57
+ expect(calls.map((call) => call.request.endpoint)).toStrictEqual(["/users/1", "/users/2", "/users/3"]);
58
+ });
59
+ it("should send one request per refetch", async () => {
60
+ const { result } = renderHook(
61
+ () => {
62
+ const { data, refetch } = useFetch(request.setParams({ id: 1 }));
63
+ return { data, refetch };
64
+ },
65
+ { wrapper: StrictMode },
66
+ );
67
+ await advance();
68
+ calls[0].succeed({ id: 1 });
69
+ await settle();
70
+
71
+ act(() => {
72
+ result.current.refetch();
73
+ });
74
+ await advance();
75
+
76
+ expect(calls).toHaveLength(2);
77
+ });
78
+ it("should not send any request for fresh cache without revalidation", async () => {
79
+ setCacheResponse(request.setParams({ id: 1 }), { id: 1 });
80
+ const { result } = renderHook(() => useFetch(request.setParams({ id: 1 }), { revalidate: false }).data, {
81
+ wrapper: StrictMode,
82
+ });
83
+ await advance();
84
+
85
+ expect(calls).toHaveLength(0);
86
+ expect(result.current).toStrictEqual({ id: 1 });
87
+ });
88
+ it("should leave no listeners after unmount", async () => {
89
+ const baseline = countListeners(client);
90
+ const { unmount } = render(<View request={request.setParams({ id: 1 })} name="user" />, {
91
+ wrapper: StrictMode,
92
+ });
93
+ await advance();
94
+ calls[0].succeed({ id: 1 });
95
+ await settle();
96
+
97
+ unmount();
98
+
99
+ expect(countListeners(client)).toStrictEqual(baseline);
100
+ });
101
+ });
102
+
103
+ describe("when rendered inside of Activity", () => {
104
+ const App = ({ id, hidden }: { id: number; hidden: boolean }) => (
105
+ <Activity mode={hidden ? "hidden" : "visible"}>
106
+ <View request={request.setParams({ id })} name="user" />
107
+ </Activity>
108
+ );
109
+
110
+ it("should fetch the key changed while hidden once it is revealed", async () => {
111
+ const view = render(<App id={1} hidden={false} />);
112
+ await advance();
113
+ calls[0].succeed({ id: 1 });
114
+ await settle();
115
+
116
+ view.rerender(<App id={1} hidden />);
117
+ view.rerender(<App id={2} hidden />);
118
+ await advance();
119
+ view.rerender(<App id={2} hidden={false} />);
120
+ await advance();
121
+
122
+ expect(calls.map((call) => call.request.endpoint)).toStrictEqual(["/users/1", "/users/2"]);
123
+
124
+ calls[1].succeed({ id: 2 });
125
+ await settle();
126
+
127
+ expect(read("user")).toStrictEqual({ data: { id: 2 }, loading: false, error: null });
128
+ });
129
+ it("should not fetch again when revealed without changes", async () => {
130
+ const view = render(<App id={1} hidden={false} />);
131
+ await advance();
132
+ calls[0].succeed({ id: 1 });
133
+ await settle();
134
+
135
+ view.rerender(<App id={1} hidden />);
136
+ view.rerender(<App id={1} hidden={false} />);
137
+ await advance();
138
+
139
+ expect(calls).toHaveLength(1);
140
+ expect(read("user").data).toStrictEqual({ id: 1 });
141
+ });
142
+ it("should receive cache updates after it is revealed", async () => {
143
+ const view = render(<App id={1} hidden={false} />);
144
+ await advance();
145
+ calls[0].succeed({ id: 1 });
146
+ await settle();
147
+
148
+ view.rerender(<App id={1} hidden />);
149
+ view.rerender(<App id={1} hidden={false} />);
150
+ act(() => {
151
+ setCacheResponse(request.setParams({ id: 1 }), { id: 100 });
152
+ });
153
+
154
+ expect(read("user").data).toStrictEqual({ id: 100 });
155
+ });
156
+ });
157
+
158
+ describe("when the hook unmounts during the request", () => {
159
+ it("should not report any React warning", async () => {
160
+ const consoleError = vi.spyOn(console, "error").mockImplementation(() => null);
161
+ const { unmount } = render(<View request={request.setParams({ id: 1 })} name="user" />);
162
+ await advance();
163
+
164
+ unmount();
165
+ calls[0].succeed({ id: 1 });
166
+ await settle();
167
+
168
+ expect(consoleError).not.toHaveBeenCalled();
169
+ });
170
+ it("should let the request finish and save the response in the cache", async () => {
171
+ const { unmount } = render(<View request={request.setParams({ id: 1 })} name="user" />);
172
+ await advance();
173
+
174
+ unmount();
175
+ expect(client.fetchDispatcher.getAllRunningRequests()).toHaveLength(1);
176
+ calls[0].succeed({ id: 1 });
177
+ await settle();
178
+
179
+ expect(client.cache.get(request.setParams({ id: 1 }).cacheKey)?.data).toStrictEqual({ id: 1 });
180
+ expect(client.fetchDispatcher.getAllRunningRequests()).toHaveLength(0);
181
+ });
182
+ it("should use the response of the finished request on the next mount", async () => {
183
+ const first = render(<View request={request.setParams({ id: 1 })} name="user" />);
184
+ await advance();
185
+ first.unmount();
186
+ calls[0].succeed({ id: 1 });
187
+ await settle();
188
+
189
+ const { result } = renderHook(() => useFetch(request.setParams({ id: 1 }), { revalidate: false }).data);
190
+ await advance();
191
+
192
+ expect(result.current).toStrictEqual({ id: 1 });
193
+ expect(calls).toHaveLength(1);
194
+ });
195
+ it("should join the request left by the unmounted hook", async () => {
196
+ const first = render(<View request={request.setParams({ id: 1 })} name="user" />);
197
+ await advance();
198
+ first.unmount();
199
+
200
+ render(<View request={request.setParams({ id: 1 })} name="user" />);
201
+ await advance();
202
+ expect(calls).toHaveLength(1);
203
+
204
+ calls[0].succeed({ id: 1 });
205
+ await settle();
206
+
207
+ expect(read("user")).toStrictEqual({ data: { id: 1 }, loading: false, error: null });
208
+ });
209
+ });
210
+
211
+ describe("when hooks mount and unmount", () => {
212
+ it("should bring the listeners count back to the baseline", async () => {
213
+ const baseline = countListeners(client);
214
+ const { unmount } = render(<View request={request.setParams({ id: 1 })} name="user" />);
215
+ await advance();
216
+ expect(countListeners(client)).not.toStrictEqual(baseline);
217
+
218
+ unmount();
219
+
220
+ expect(countListeners(client)).toStrictEqual(baseline);
221
+ });
222
+ it("should not accumulate listeners over many mounts", async () => {
223
+ const baseline = countListeners(client);
224
+
225
+ for (let i = 0; i < 20; i += 1) {
226
+ const { unmount } = render(<View request={request.setParams({ id: i })} name="user" />);
227
+ unmount();
228
+ }
229
+
230
+ expect(countListeners(client)).toStrictEqual(baseline);
231
+ });
232
+ it("should not accumulate listeners over many key changes", async () => {
233
+ const view = render(<View request={request.setParams({ id: 0 })} name="user" />);
234
+ const mounted = countListeners(client);
235
+
236
+ for (let i = 1; i < 20; i += 1) {
237
+ view.rerender(<View request={request.setParams({ id: i })} name="user" />);
238
+ }
239
+
240
+ expect(countListeners(client)).toStrictEqual(mounted);
241
+ });
242
+ it("should not accumulate listeners over many rerenders", async () => {
243
+ const view = render(<View request={request.setParams({ id: 1 })} name="user" />);
244
+ const mounted = countListeners(client);
245
+
246
+ for (let i = 0; i < 20; i += 1) {
247
+ view.rerender(<View request={request.setParams({ id: 1 })} name="user" />);
248
+ }
249
+
250
+ expect(countListeners(client)).toStrictEqual(mounted);
251
+ });
252
+ it("should leave no timers besides the cache garbage collector", async () => {
253
+ const { unmount } = renderHook(() =>
254
+ useFetch(request.setParams({ id: 1 }), {
255
+ refresh: true,
256
+ refreshTime: 1000,
257
+ bounce: true,
258
+ bounceTime: 500,
259
+ dependencies: [1],
260
+ }),
261
+ );
262
+ await advance();
263
+ calls[0].succeed({ id: 1 });
264
+ await settle();
265
+
266
+ unmount();
267
+ client.cache.clear();
268
+
269
+ expect(vi.getTimerCount()).toBe(0);
270
+ });
271
+ });
272
+
273
+ describe("when many components use the same request", () => {
274
+ const sameRequest = () => request.setParams({ id: 1 });
275
+
276
+ it("should send one request and update all of them", async () => {
277
+ render(
278
+ <>
279
+ <View request={sameRequest()} name="first" />
280
+ <View request={sameRequest()} name="second" />
281
+ <View request={sameRequest()} name="third" />
282
+ </>,
283
+ );
284
+ await advance();
285
+ expect(calls).toHaveLength(1);
286
+
287
+ calls[0].succeed({ id: 1 });
288
+ await settle();
289
+
290
+ ["first", "second", "third"].forEach((name) => {
291
+ expect(read(name)).toStrictEqual({ data: { id: 1 }, loading: false, error: null });
292
+ });
293
+ });
294
+ it("should show the loading state in all of them", async () => {
295
+ render(
296
+ <>
297
+ <View request={sameRequest()} name="first" />
298
+ <View request={sameRequest()} name="second" />
299
+ </>,
300
+ );
301
+ await advance();
302
+
303
+ expect(read("first").loading).toBeTrue();
304
+ expect(read("second").loading).toBeTrue();
305
+ });
306
+ it("should show the error in all of them", async () => {
307
+ render(
308
+ <>
309
+ <View request={sameRequest()} name="first" />
310
+ <View request={sameRequest()} name="second" />
311
+ </>,
312
+ );
313
+ await advance();
314
+ calls[0].fail(new Error("Failed"));
315
+ await settle();
316
+
317
+ expect(read("first").error).toBe("Failed");
318
+ expect(read("second").error).toBe("Failed");
319
+ });
320
+ it("should keep the request running when one of them unmounts", async () => {
321
+ const first = render(<View request={sameRequest()} name="first" />);
322
+ render(<View request={sameRequest()} name="second" />);
323
+ await advance();
324
+
325
+ first.unmount();
326
+ calls[0].succeed({ id: 1 });
327
+ await settle();
328
+
329
+ expect(calls).toHaveLength(1);
330
+ expect(read("second")).toStrictEqual({ data: { id: 1 }, loading: false, error: null });
331
+ });
332
+ it("should give the cached data to the component mounted later", async () => {
333
+ render(<View request={sameRequest()} name="first" />);
334
+ await advance();
335
+ calls[0].succeed({ id: 1 });
336
+ await settle();
337
+
338
+ const { result } = renderHook(() => useFetch(sameRequest(), { revalidate: false }).data);
339
+
340
+ expect(result.current).toStrictEqual({ id: 1 });
341
+ expect(calls).toHaveLength(1);
342
+ });
343
+ it("should update all of them when one refetches", async () => {
344
+ render(<View request={sameRequest()} name="first" />);
345
+ const { result } = renderHook(() => {
346
+ const { data, refetch } = useFetch(sameRequest());
347
+ return { data, refetch };
348
+ });
349
+ await advance();
350
+ calls[0].succeed({ id: 1 });
351
+ await settle();
352
+
353
+ act(() => {
354
+ result.current.refetch();
355
+ });
356
+ await advance();
357
+ expect(read("first").loading).toBeTrue();
358
+
359
+ calls[1].succeed({ id: 2 });
360
+ await settle();
361
+
362
+ expect(read("first").data).toStrictEqual({ id: 2 });
363
+ expect(result.current.data).toStrictEqual({ id: 2 });
364
+ });
365
+ it("should keep the data set locally in one of them out of the others", async () => {
366
+ render(<View request={sameRequest()} name="first" />);
367
+ const { result } = renderHook(() => {
368
+ const { data, setData } = useFetch(sameRequest());
369
+ return { data, setData };
370
+ });
371
+ await advance();
372
+ calls[0].succeed({ id: 1 });
373
+ await settle();
374
+
375
+ act(() => {
376
+ result.current.setData({ id: 50 });
377
+ });
378
+
379
+ expect(result.current.data).toStrictEqual({ id: 50 });
380
+ expect(read("first").data).toStrictEqual({ id: 1 });
381
+ expect(client.cache.get(sameRequest().cacheKey)?.data).toStrictEqual({ id: 1 });
382
+ });
383
+ });
384
+
385
+ describe("when one component uses two requests", () => {
386
+ it("should keep their states independent", async () => {
387
+ const { result } = renderHook(() => {
388
+ const first = useFetch(request.setParams({ id: 1 }));
389
+ const second = useFetch(request.setParams({ id: 2 }));
390
+ return {
391
+ first: { data: first.data, loading: first.loading, error: first.error?.message ?? null },
392
+ second: { data: second.data, loading: second.loading, error: second.error?.message ?? null },
393
+ };
394
+ });
395
+ await advance();
396
+ expect(calls).toHaveLength(2);
397
+
398
+ calls[1].fail(new Error("Second failed"));
399
+ await settle();
400
+
401
+ expect(result.current.first).toStrictEqual({ data: null, loading: true, error: null });
402
+ expect(result.current.second).toStrictEqual({ data: null, loading: false, error: "Second failed" });
403
+
404
+ calls[0].succeed({ id: 1 });
405
+ await settle();
406
+
407
+ expect(result.current.first).toStrictEqual({ data: { id: 1 }, loading: false, error: null });
408
+ expect(result.current.second).toStrictEqual({ data: null, loading: false, error: "Second failed" });
409
+ });
410
+ });
411
+ });
@@ -0,0 +1,177 @@
1
+ import { renderHook } from "@testing-library/react";
2
+ import type { UseFetchOptionsType } from "hooks/use-fetch";
3
+ import { useFetch } from "hooks/use-fetch";
4
+
5
+ import { client, createRequest } from "../../utils";
6
+ import { advance, gateRequest, setCacheResponse, settle } from "../../utils/gate.utils";
7
+
8
+ type Page = { page: number; items: string[] };
9
+
10
+ const pageData = (page: number): Page => ({ page, items: [`item-${page}-a`, `item-${page}-b`] });
11
+
12
+ describe("useFetch [ Pagination ]", () => {
13
+ let request = createRequest<Page, any, "/posts">({ endpoint: "/posts" });
14
+ let calls = gateRequest(request);
15
+
16
+ const callFor = (page: number) => {
17
+ const call = calls.findLast((item) => item.request.queryParams?.page === page);
18
+ if (!call) {
19
+ throw new Error(`Request for page ${page} was not sent`);
20
+ }
21
+ return call;
22
+ };
23
+
24
+ const renderPage = (options?: UseFetchOptionsType<ReturnType<(typeof request)["setQueryParams"]>>) => {
25
+ const renders: { page: number; data: Page | null; loading: boolean }[] = [];
26
+ const view = renderHook(
27
+ ({ page }) => {
28
+ const { data, loading } = useFetch(request.setQueryParams({ page }), options);
29
+ renders.push({ page, data, loading });
30
+ return { data, loading };
31
+ },
32
+ { initialProps: { page: 1 } },
33
+ );
34
+ return { ...view, renders };
35
+ };
36
+
37
+ beforeEach(() => {
38
+ vi.useFakeTimers();
39
+ client.clear();
40
+ request = createRequest<Page, any, "/posts">({ endpoint: "/posts" });
41
+ calls = gateRequest(request);
42
+ });
43
+
44
+ afterEach(() => {
45
+ vi.useRealTimers();
46
+ });
47
+
48
+ describe("when request query params are changed", () => {
49
+ it("should allow to see previous results until new page is loaded", async () => {
50
+ const { rerender, result } = renderPage();
51
+ await advance();
52
+ callFor(1).succeed(pageData(1));
53
+ await settle();
54
+
55
+ rerender({ page: 2 });
56
+ await advance();
57
+
58
+ expect(result.current).toStrictEqual({ data: pageData(1), loading: true });
59
+
60
+ callFor(2).succeed(pageData(2));
61
+ await settle();
62
+
63
+ expect(result.current).toStrictEqual({ data: pageData(2), loading: false });
64
+ });
65
+ it("should never render an empty page between the pages", async () => {
66
+ const { rerender, renders } = renderPage();
67
+ await advance();
68
+ callFor(1).succeed(pageData(1));
69
+ await settle();
70
+
71
+ for (const page of [2, 3]) {
72
+ rerender({ page });
73
+ // eslint-disable-next-line no-await-in-loop
74
+ await advance();
75
+ callFor(page).succeed(pageData(page));
76
+ // eslint-disable-next-line no-await-in-loop
77
+ await settle();
78
+ }
79
+
80
+ expect(renders.slice(1).every((render) => render.data !== null)).toBeTrue();
81
+ });
82
+ it("should not override previous results by initialData", async () => {
83
+ const initialResponse = { data: { page: 0, items: ["initial"] } };
84
+ const { rerender, result } = renderPage({ initialResponse });
85
+ expect(result.current.data).toStrictEqual(initialResponse.data);
86
+ await advance();
87
+ callFor(1).succeed(pageData(1));
88
+ await settle();
89
+
90
+ rerender({ page: 2 });
91
+ await advance();
92
+
93
+ expect(result.current.data).toStrictEqual(pageData(1));
94
+
95
+ callFor(2).succeed(pageData(2));
96
+ await settle();
97
+
98
+ expect(result.current.data).toStrictEqual(pageData(2));
99
+ });
100
+ it("should cache pages on change", async () => {
101
+ const { rerender } = renderPage();
102
+ await advance();
103
+ callFor(1).succeed(pageData(1));
104
+ await settle();
105
+ rerender({ page: 2 });
106
+ await advance();
107
+ callFor(2).succeed(pageData(2));
108
+ await settle();
109
+
110
+ expect(client.cache.get(request.setQueryParams({ page: 1 }).cacheKey)?.data).toStrictEqual(pageData(1));
111
+ expect(client.cache.get(request.setQueryParams({ page: 2 }).cacheKey)?.data).toStrictEqual(pageData(2));
112
+ });
113
+ it("should show the cached page right away when going back", async () => {
114
+ const { rerender, renders } = renderPage({ revalidate: false });
115
+ await advance();
116
+ callFor(1).succeed(pageData(1));
117
+ await settle();
118
+ rerender({ page: 2 });
119
+ await advance();
120
+ callFor(2).succeed(pageData(2));
121
+ await settle();
122
+
123
+ rerender({ page: 1 });
124
+ await advance();
125
+
126
+ expect(renders.findLast((render) => render.page === 1)).toStrictEqual({
127
+ page: 1,
128
+ data: pageData(1),
129
+ loading: false,
130
+ });
131
+ expect(calls).toHaveLength(2);
132
+ });
133
+ it("should replace the previous page with the error state when the new page fails", async () => {
134
+ const { rerender } = renderPage();
135
+ const errors = renderHook(
136
+ ({ page }) => {
137
+ const { data, error } = useFetch(request.setQueryParams({ page }));
138
+ return { data, error: error?.message ?? null };
139
+ },
140
+ { initialProps: { page: 1 } },
141
+ );
142
+ await advance();
143
+ callFor(1).succeed(pageData(1));
144
+ await settle();
145
+
146
+ rerender({ page: 2 });
147
+ errors.rerender({ page: 2 });
148
+ await advance();
149
+ callFor(2).fail(new Error("Page failed"));
150
+ await settle();
151
+
152
+ expect(errors.result.current).toStrictEqual({ data: null, error: "Page failed" });
153
+ });
154
+ it('should clear the previous page in the "clean" mode', async () => {
155
+ const { rerender, result } = renderPage({ keepPreviousData: "clean" });
156
+ await advance();
157
+ callFor(1).succeed(pageData(1));
158
+ await settle();
159
+
160
+ rerender({ page: 2 });
161
+
162
+ expect(result.current).toStrictEqual({ data: null, loading: true });
163
+ });
164
+ it("should use the page prefetched before the change", async () => {
165
+ setCacheResponse(request.setQueryParams({ page: 2 }), pageData(2));
166
+ const { rerender, result } = renderPage({ revalidate: false });
167
+ await advance();
168
+ callFor(1).succeed(pageData(1));
169
+ await settle();
170
+
171
+ rerender({ page: 2 });
172
+
173
+ expect(result.current).toStrictEqual({ data: pageData(2), loading: false });
174
+ expect(calls).toHaveLength(1);
175
+ });
176
+ });
177
+ });