@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,559 @@
1
+ import { act, 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 User = { id: number };
9
+ type Render = { id: number; data: User | null; loading: boolean; error: string | null };
10
+
11
+ describe("useFetch [ Request Keys ]", () => {
12
+ let userRequest = createRequest<User, any, "/users/:id">({ endpoint: "/users/:id" });
13
+ let calls = gateRequest(userRequest);
14
+
15
+ /**
16
+ * Renders useFetch for the user of the given id and records every render with the id it was rendered for
17
+ */
18
+ const renderUser = (
19
+ initialId: number,
20
+ options?: UseFetchOptionsType<ReturnType<(typeof userRequest)["setParams"]>>,
21
+ ) => {
22
+ const renders: Render[] = [];
23
+ const view = renderHook(
24
+ ({ id, ...rest }: { id: number } & UseFetchOptionsType<ReturnType<(typeof userRequest)["setParams"]>>) => {
25
+ const state = useFetch(userRequest.setParams({ id }), { ...options, ...rest } as typeof options);
26
+ renders.push({
27
+ id,
28
+ data: state.data as User | null,
29
+ loading: state.loading,
30
+ error: state.error?.message ?? null,
31
+ });
32
+ return state;
33
+ },
34
+ {
35
+ initialProps: { id: initialId } as { id: number } & UseFetchOptionsType<
36
+ ReturnType<(typeof userRequest)["setParams"]>
37
+ >,
38
+ },
39
+ );
40
+ return { ...view, renders };
41
+ };
42
+
43
+ const callFor = (id: number) => {
44
+ const call = calls.find((item) => item.request.endpoint === `/users/${id}`);
45
+ if (!call) {
46
+ throw new Error(`Request for user ${id} was not sent`);
47
+ }
48
+ return call;
49
+ };
50
+
51
+ beforeEach(() => {
52
+ vi.useFakeTimers();
53
+ client.clear();
54
+ userRequest = createRequest<User, any, "/users/:id">({ endpoint: "/users/:id" });
55
+ calls = gateRequest(userRequest);
56
+ });
57
+
58
+ afterEach(() => {
59
+ vi.useRealTimers();
60
+ });
61
+
62
+ describe("when params change to another resource", () => {
63
+ it("should never render the data of the previous resource", async () => {
64
+ const { rerender, renders } = renderUser(1);
65
+ await advance();
66
+ callFor(1).succeed({ id: 1 });
67
+ await settle();
68
+
69
+ rerender({ id: 2 });
70
+ await advance();
71
+ callFor(2).succeed({ id: 2 });
72
+ await settle();
73
+
74
+ const mismatched = renders.filter((render) => render.data !== null && render.data.id !== render.id);
75
+ expect(mismatched).toStrictEqual([]);
76
+ });
77
+ it("should be in the loading state on the first render with the new key", async () => {
78
+ const { rerender, renders } = renderUser(1);
79
+ await advance();
80
+ callFor(1).succeed({ id: 1 });
81
+ await settle();
82
+
83
+ rerender({ id: 2 });
84
+
85
+ const firstRenderOfNewKey = renders.find((render) => render.id === 2);
86
+ expect(firstRenderOfNewKey).toStrictEqual({ id: 2, data: null, loading: true, error: null });
87
+ });
88
+ it("should not show the error of the previous resource", async () => {
89
+ const { rerender, renders } = renderUser(1);
90
+ await advance();
91
+ callFor(1).fail(new Error("User 1 failed"));
92
+ await settle();
93
+
94
+ rerender({ id: 2 });
95
+ await advance();
96
+
97
+ const rendersOfNewKey = renders.filter((render) => render.id === 2);
98
+ expect(rendersOfNewKey.every((render) => render.error === null)).toBeTrue();
99
+ });
100
+ it("should send one request per resource", async () => {
101
+ const { rerender } = renderUser(1);
102
+ await advance();
103
+ rerender({ id: 2 });
104
+ await advance();
105
+ rerender({ id: 3 });
106
+ await advance();
107
+
108
+ expect(calls.map((call) => call.request.endpoint)).toStrictEqual(["/users/1", "/users/2", "/users/3"]);
109
+ });
110
+ it("should show cached data of the new key on the first render with it", async () => {
111
+ setCacheResponse(userRequest.setParams({ id: 2 }), { id: 2 });
112
+ const { rerender, renders } = renderUser(1);
113
+ await advance();
114
+
115
+ rerender({ id: 2 });
116
+
117
+ const firstRenderOfNewKey = renders.find((render) => render.id === 2);
118
+ expect(firstRenderOfNewKey?.data).toStrictEqual({ id: 2 });
119
+ });
120
+ it("should not refetch fresh cached data of the new key when revalidate is off", async () => {
121
+ setCacheResponse(userRequest.setParams({ id: 2 }), { id: 2 });
122
+ const { rerender, result } = renderUser(1, { revalidate: false });
123
+ await advance();
124
+
125
+ rerender({ id: 2 });
126
+ await advance();
127
+
128
+ expect(calls.map((call) => call.request.endpoint)).toStrictEqual(["/users/1"]);
129
+ expect(result.current.loading).toBeFalse();
130
+ });
131
+ it("should refetch cached data of the new key by default", async () => {
132
+ setCacheResponse(userRequest.setParams({ id: 2 }), { id: 2 });
133
+ const { rerender } = renderUser(1);
134
+ await advance();
135
+
136
+ rerender({ id: 2 });
137
+ await advance();
138
+
139
+ expect(calls.map((call) => call.request.endpoint)).toStrictEqual(["/users/1", "/users/2"]);
140
+ });
141
+ it("should reuse the data reference when coming back to the cached key", async () => {
142
+ const { rerender, result } = renderUser(1, { revalidate: false });
143
+ await advance();
144
+ callFor(1).succeed({ id: 1 });
145
+ await settle();
146
+ const firstUser = result.current.data;
147
+
148
+ rerender({ id: 2 });
149
+ await advance();
150
+ callFor(2).succeed({ id: 2 });
151
+ await settle();
152
+ rerender({ id: 1 });
153
+
154
+ expect(result.current.data).toBe(firstUser);
155
+ expect(calls).toHaveLength(2);
156
+ });
157
+ });
158
+
159
+ describe("when responses arrive out of order", () => {
160
+ it("should ignore the late response of the previous key", async () => {
161
+ const { rerender, result } = renderUser(1);
162
+ await advance();
163
+ rerender({ id: 2 });
164
+ await advance();
165
+
166
+ callFor(2).succeed({ id: 2 });
167
+ await settle();
168
+ callFor(1).succeed({ id: 1 });
169
+ await settle();
170
+
171
+ expect(result.current.data).toStrictEqual({ id: 2 });
172
+ expect(result.current.loading).toBeFalse();
173
+ });
174
+ it("should still cache the late response under its own key", async () => {
175
+ const { rerender } = renderUser(1);
176
+ await advance();
177
+ rerender({ id: 2 });
178
+ await advance();
179
+
180
+ callFor(2).succeed({ id: 2 });
181
+ await settle();
182
+ callFor(1).succeed({ id: 1 });
183
+ await settle();
184
+
185
+ expect(client.cache.get(userRequest.setParams({ id: 1 }).cacheKey)?.data).toStrictEqual({ id: 1 });
186
+ expect(client.cache.get(userRequest.setParams({ id: 2 }).cacheKey)?.data).toStrictEqual({ id: 2 });
187
+ });
188
+ it("should ignore the late error of the previous key", async () => {
189
+ const { rerender, result } = renderUser(1);
190
+ await advance();
191
+ rerender({ id: 2 });
192
+ await advance();
193
+
194
+ callFor(2).succeed({ id: 2 });
195
+ await settle();
196
+ callFor(1).fail(new Error("Late error"));
197
+ await settle();
198
+
199
+ expect(result.current.error).toBeNull();
200
+ expect(result.current.data).toStrictEqual({ id: 2 });
201
+ });
202
+ it("should stay in loading state when only the previous key responds", async () => {
203
+ const { rerender, result } = renderUser(1);
204
+ await advance();
205
+ rerender({ id: 2 });
206
+ await advance();
207
+
208
+ callFor(1).succeed({ id: 1 });
209
+ await settle();
210
+
211
+ expect(result.current.data).toBeNull();
212
+ expect(result.current.loading).toBeTrue();
213
+ });
214
+ });
215
+
216
+ describe("when keys are switched rapidly", () => {
217
+ it("should end up with the data of the last key", async () => {
218
+ const { rerender, result } = renderUser(1);
219
+ [2, 3, 4, 5].forEach((id) => rerender({ id }));
220
+ await advance();
221
+
222
+ // Answer in reversed order - the last key answers first
223
+ [5, 4, 3, 2, 1].forEach((id) => callFor(id).succeed({ id }));
224
+ await settle();
225
+
226
+ expect(result.current.data).toStrictEqual({ id: 5 });
227
+ expect(result.current.loading).toBeFalse();
228
+ });
229
+ it("should never render data of a key other than the current one", async () => {
230
+ const { rerender, renders } = renderUser(1);
231
+ await advance();
232
+ callFor(1).succeed({ id: 1 });
233
+ await settle();
234
+
235
+ for (const id of [2, 3, 4]) {
236
+ rerender({ id });
237
+ // eslint-disable-next-line no-await-in-loop
238
+ await advance();
239
+ callFor(id).succeed({ id });
240
+ // eslint-disable-next-line no-await-in-loop
241
+ await settle();
242
+ }
243
+
244
+ const mismatched = renders.filter((render) => render.data !== null && render.data.id !== render.id);
245
+ expect(mismatched).toStrictEqual([]);
246
+ });
247
+ it("should show cached data when toggling between two cached keys", async () => {
248
+ const { rerender, result } = renderUser(1, { revalidate: false });
249
+ await advance();
250
+ callFor(1).succeed({ id: 1 });
251
+ await settle();
252
+ rerender({ id: 2 });
253
+ await advance();
254
+ callFor(2).succeed({ id: 2 });
255
+ await settle();
256
+
257
+ for (const id of [1, 2, 1, 2]) {
258
+ rerender({ id });
259
+ expect(result.current.data).toStrictEqual({ id });
260
+ }
261
+ expect(calls).toHaveLength(2);
262
+ });
263
+ });
264
+
265
+ describe("when the request is recreated without changes", () => {
266
+ it("should not refetch when rerendered with an equal request instance", async () => {
267
+ const { rerender } = renderUser(1);
268
+ await advance();
269
+ callFor(1).succeed({ id: 1 });
270
+ await settle();
271
+
272
+ rerender({ id: 1 });
273
+ rerender({ id: 1 });
274
+ await advance();
275
+
276
+ expect(calls).toHaveLength(1);
277
+ });
278
+ it("should keep the data when rerendered with an equal request instance", async () => {
279
+ const { rerender, result } = renderUser(1);
280
+ await advance();
281
+ callFor(1).succeed({ id: 1 });
282
+ await settle();
283
+ const { data } = result.current;
284
+
285
+ rerender({ id: 1 });
286
+
287
+ expect(result.current.data).toBe(data);
288
+ });
289
+ });
290
+
291
+ describe("when query params change", () => {
292
+ const listRequest = () => createRequest<{ page: number }, any, "/users">({ endpoint: "/users" });
293
+
294
+ it("should give every query its own cache key", async () => {
295
+ const request = listRequest();
296
+
297
+ const keys = [1, 2, 3].map((page) => request.setQueryParams({ page }).cacheKey);
298
+
299
+ expect(new Set(keys).size).toBe(3);
300
+ });
301
+ it("should keep the previous data when the query params contain underscores", async () => {
302
+ const request = listRequest();
303
+ const listCalls = gateRequest(request);
304
+ const renders: { page: number; data: { page: number } | null }[] = [];
305
+ const { rerender } = renderHook(
306
+ ({ page }) => {
307
+ const { data } = useFetch(request.setQueryParams({ page, sort_by: "created_at", per_page: 10 }));
308
+ renders.push({ page, data });
309
+ return data;
310
+ },
311
+ { initialProps: { page: 1 } },
312
+ );
313
+ await advance();
314
+ listCalls[0].succeed({ page: 1 });
315
+ await settle();
316
+
317
+ rerender({ page: 2 });
318
+ await advance();
319
+
320
+ // "auto" mode keeps the data of the same resource - only its query changed
321
+ expect(renders.filter((render) => render.page === 2).map((render) => render.data)).toStrictEqual(
322
+ renders.filter((render) => render.page === 2).map(() => ({ page: 1 })),
323
+ );
324
+
325
+ listCalls[1].succeed({ page: 2 });
326
+ await settle();
327
+
328
+ expect(renders.at(-1)).toStrictEqual({ page: 2, data: { page: 2 } });
329
+ });
330
+ it("should keep the previous data when the query params are a string with underscores", async () => {
331
+ const request = listRequest();
332
+ const listCalls = gateRequest(request);
333
+ const { rerender, result } = renderHook(
334
+ ({ search }) => {
335
+ const { data } = useFetch(request.setQueryParams(`?search=${search}` as any));
336
+ return { data };
337
+ },
338
+ { initialProps: { search: "john_doe" } },
339
+ );
340
+ await advance();
341
+ listCalls[0].succeed({ page: 1 });
342
+ await settle();
343
+
344
+ rerender({ search: "jane_doe" });
345
+
346
+ expect(result.current.data).toStrictEqual({ page: 1 });
347
+ });
348
+ it("should clear the data when the endpoint contains underscores and the resource changes", async () => {
349
+ const request = createRequest<User, any, "/user_profiles/:id">({ endpoint: "/user_profiles/:id" });
350
+ const profileCalls = gateRequest(request);
351
+ const { rerender, result } = renderHook(
352
+ ({ id }) => {
353
+ const { data } = useFetch(request.setParams({ id }).setQueryParams({ include_details: true }));
354
+ return { data };
355
+ },
356
+ { initialProps: { id: 1 } },
357
+ );
358
+ await advance();
359
+ profileCalls[0].succeed({ id: 1 });
360
+ await settle();
361
+
362
+ rerender({ id: 2 });
363
+
364
+ expect(result.current.data).toBeNull();
365
+ });
366
+ it("should send a request for the new query", async () => {
367
+ const request = listRequest();
368
+ const listCalls = gateRequest(request);
369
+ const { rerender } = renderHook(({ page }) => useFetch(request.setQueryParams({ page })).data, {
370
+ initialProps: { page: 1 },
371
+ });
372
+ await advance();
373
+ rerender({ page: 2 });
374
+ await advance();
375
+
376
+ expect(listCalls.map((call) => call.request.queryParams)).toStrictEqual([{ page: 1 }, { page: 2 }]);
377
+ });
378
+ });
379
+
380
+ describe("when the payload changes", () => {
381
+ it("should refetch and keep the data of the same cache key", async () => {
382
+ const request = createRequest<{ total: number }, { filter: string }>({ method: "QUERY" as any });
383
+ const queryCalls = gateRequest(request);
384
+ const { rerender, result } = renderHook(
385
+ ({ filter }) => {
386
+ const { data, loading } = useFetch(request.setPayload({ filter }));
387
+ return { data, loading };
388
+ },
389
+ { initialProps: { filter: "a" } },
390
+ );
391
+ await advance();
392
+ queryCalls[0].succeed({ total: 1 });
393
+ await settle();
394
+
395
+ rerender({ filter: "b" });
396
+ await advance();
397
+
398
+ expect(queryCalls).toHaveLength(2);
399
+ expect(queryCalls[1].request.payload).toStrictEqual({ filter: "b" });
400
+ expect(result.current.data).toStrictEqual({ total: 1 });
401
+ expect(result.current.loading).toBeTrue();
402
+ });
403
+ });
404
+
405
+ describe("when dependencies change", () => {
406
+ it("should refetch", async () => {
407
+ const { rerender } = renderUser(1, { dependencies: ["a"] });
408
+ await advance();
409
+ callFor(1).succeed({ id: 1 });
410
+ await settle();
411
+
412
+ rerender({ id: 1, dependencies: ["b"] });
413
+ await advance();
414
+
415
+ expect(calls).toHaveLength(2);
416
+ });
417
+ it("should not refetch when dependencies stay the same", async () => {
418
+ const { rerender } = renderUser(1, { dependencies: ["a", 1] });
419
+ await advance();
420
+ callFor(1).succeed({ id: 1 });
421
+ await settle();
422
+
423
+ rerender({ id: 1, dependencies: ["a", 1] });
424
+ await advance();
425
+
426
+ expect(calls).toHaveLength(1);
427
+ });
428
+ it("should compare dependencies by identity", async () => {
429
+ const dependency = { value: 1 };
430
+ const { rerender } = renderUser(1, { dependencies: [dependency] });
431
+ await advance();
432
+ callFor(1).succeed({ id: 1 });
433
+ await settle();
434
+
435
+ rerender({ id: 1, dependencies: [dependency] });
436
+ await advance();
437
+ expect(calls).toHaveLength(1);
438
+
439
+ rerender({ id: 1, dependencies: [{ value: 1 }] });
440
+ await advance();
441
+ expect(calls).toHaveLength(2);
442
+ });
443
+ it("should not refetch fresh data when revalidate is off", async () => {
444
+ const { rerender } = renderUser(1, { dependencies: ["a"], revalidate: false });
445
+ await advance();
446
+ callFor(1).succeed({ id: 1 });
447
+ await settle();
448
+
449
+ rerender({ id: 1, dependencies: ["b"], revalidate: false });
450
+ await advance();
451
+
452
+ expect(calls).toHaveLength(1);
453
+ });
454
+ });
455
+
456
+ describe("when disabled changes", () => {
457
+ it("should fetch once enabled", async () => {
458
+ const { rerender, result } = renderUser(1, { disabled: true });
459
+ await advance();
460
+ expect(calls).toHaveLength(0);
461
+
462
+ rerender({ id: 1, disabled: false });
463
+ await advance();
464
+ expect(calls).toHaveLength(1);
465
+
466
+ callFor(1).succeed({ id: 1 });
467
+ await settle();
468
+ expect(result.current.data).toStrictEqual({ id: 1 });
469
+ });
470
+ it("should keep the data once disabled", async () => {
471
+ const { rerender, result } = renderUser(1);
472
+ await advance();
473
+ callFor(1).succeed({ id: 1 });
474
+ await settle();
475
+
476
+ rerender({ id: 1, disabled: true });
477
+ await advance();
478
+
479
+ expect(result.current.data).toStrictEqual({ id: 1 });
480
+ expect(result.current.loading).toBeFalse();
481
+ expect(calls).toHaveLength(1);
482
+ });
483
+ it("should not fetch the new key when it is switched together with disabling", async () => {
484
+ const { rerender } = renderUser(1);
485
+ await advance();
486
+ callFor(1).succeed({ id: 1 });
487
+ await settle();
488
+
489
+ rerender({ id: 2, disabled: true });
490
+ await advance();
491
+
492
+ expect(calls).toHaveLength(1);
493
+ });
494
+ it("should not be in the loading state for the disabled new key", async () => {
495
+ const { rerender, result } = renderUser(1);
496
+ await advance();
497
+ callFor(1).succeed({ id: 1 });
498
+ await settle();
499
+
500
+ rerender({ id: 2, disabled: true });
501
+
502
+ expect(result.current.data).toBeNull();
503
+ expect(result.current.loading).toBeFalse();
504
+ });
505
+ it("should fetch the dependent request once its param is known", async () => {
506
+ const { rerender, result } = renderHook(
507
+ ({ id }: { id: number | null }) => {
508
+ const { data, loading } = useFetch(userRequest.setParams({ id: id ?? 0 }), { disabled: id === null });
509
+ return { data, loading };
510
+ },
511
+ { initialProps: { id: null as number | null } },
512
+ );
513
+ await advance();
514
+ expect(calls).toHaveLength(0);
515
+ expect(result.current.loading).toBeFalse();
516
+
517
+ rerender({ id: 7 });
518
+ await advance();
519
+ callFor(7).succeed({ id: 7 });
520
+ await settle();
521
+
522
+ expect(calls).toHaveLength(1);
523
+ expect(result.current.data).toStrictEqual({ id: 7 });
524
+ });
525
+ it("should refetch after enabling a request that failed before", async () => {
526
+ const { rerender, result } = renderUser(1);
527
+ await advance();
528
+ callFor(1).fail(new Error("Failed"));
529
+ await settle();
530
+
531
+ rerender({ id: 1, disabled: true });
532
+ rerender({ id: 1, disabled: false });
533
+ await advance();
534
+ calls[1].succeed({ id: 1 });
535
+ await settle();
536
+
537
+ expect(result.current.error).toBeNull();
538
+ expect(result.current.data).toStrictEqual({ id: 1 });
539
+ });
540
+ });
541
+
542
+ describe("when the key changes after a local update", () => {
543
+ it("should drop the data set with setData", async () => {
544
+ const { rerender, result } = renderUser(1);
545
+ await advance();
546
+ callFor(1).succeed({ id: 1 });
547
+ await settle();
548
+
549
+ act(() => {
550
+ result.current.setData({ id: 100 });
551
+ });
552
+ expect(result.current.data).toStrictEqual({ id: 100 });
553
+
554
+ rerender({ id: 2 });
555
+
556
+ expect(result.current.data).toBeNull();
557
+ });
558
+ });
559
+ });