@hyper-fetch/react 9.6.0 → 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 (102) hide show
  1. package/__tests__/features/helpers/use-request-events/use-request-events.async-mapper.spec.ts +243 -0
  2. package/__tests__/features/helpers/use-tracked-state/use-tacked-state.actions.spec.ts +1 -1
  3. package/__tests__/features/helpers/use-tracked-state/use-tracked-state.keys.spec.ts +294 -0
  4. package/__tests__/features/helpers/utils.spec.ts +127 -0
  5. package/__tests__/features/provider/provider.config.spec.tsx +172 -0
  6. package/__tests__/features/use-app-manager/use-app-manager.events.spec.tsx +497 -0
  7. package/__tests__/features/use-cache/use-cache.state.spec.tsx +326 -0
  8. package/__tests__/features/use-emitter/use-emitter.lifecycle.spec.tsx +417 -0
  9. package/__tests__/features/use-fetch/use-fetch.bounce-timers.spec.ts +199 -0
  10. package/__tests__/features/use-fetch/use-fetch.cache-events.spec.ts +212 -0
  11. package/__tests__/features/use-fetch/use-fetch.callbacks.spec.tsx +359 -0
  12. package/__tests__/features/use-fetch/use-fetch.cancel.spec.ts +6 -3
  13. package/__tests__/features/use-fetch/use-fetch.debounce.spec.ts +72 -80
  14. package/__tests__/features/use-fetch/use-fetch.hydration.spec.tsx +126 -0
  15. package/__tests__/features/use-fetch/use-fetch.infinite.spec.ts +146 -0
  16. package/__tests__/features/use-fetch/use-fetch.initial-state.spec.ts +340 -0
  17. package/__tests__/features/use-fetch/use-fetch.keys.spec.tsx +559 -0
  18. package/__tests__/features/use-fetch/use-fetch.lifecycle.spec.ts +348 -0
  19. package/__tests__/features/use-fetch/use-fetch.mounting.spec.tsx +411 -0
  20. package/__tests__/features/use-fetch/use-fetch.pagination.spec.ts +177 -0
  21. package/__tests__/features/use-fetch/use-fetch.refresh-interval.spec.ts +355 -0
  22. package/__tests__/features/use-fetch/use-fetch.refresh.spec.ts +36 -13
  23. package/__tests__/features/use-fetch/use-fetch.response-order.spec.ts +105 -0
  24. package/__tests__/features/use-fetch/use-fetch.retry.spec.ts +235 -0
  25. package/__tests__/features/use-fetch/use-fetch.return-types.spec.ts +186 -0
  26. package/__tests__/features/use-fetch/use-fetch.scope.spec.ts +333 -0
  27. package/__tests__/features/use-fetch/use-fetch.ssr.spec.tsx +195 -0
  28. package/__tests__/features/use-fetch/use-fetch.suspense-edge.spec.tsx +391 -0
  29. package/__tests__/features/use-fetch/use-fetch.throwing-callbacks.spec.tsx +112 -0
  30. package/__tests__/features/use-fetch/use-fetch.tracking.spec.tsx +364 -0
  31. package/__tests__/features/use-fetch/use-fetch.utils.spec.ts +11 -2
  32. package/__tests__/features/use-fetch/use-fetch.window-events.spec.ts +300 -0
  33. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.parity.spec.tsx +1027 -0
  34. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.resubscribe.spec.tsx +267 -0
  35. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.typescript.spec.ts +64 -1
  36. package/__tests__/features/use-is-fetching/use-is-fetching.base.spec.tsx +19 -9
  37. package/__tests__/features/use-is-fetching/use-is-fetching.lifecycle.spec.tsx +301 -0
  38. package/__tests__/features/use-listener/use-listener.lifecycle.spec.tsx +507 -0
  39. package/__tests__/features/use-listener/use-listener.ssr.spec.tsx +89 -0
  40. package/__tests__/features/use-queue/use-queue.controls.spec.tsx +593 -0
  41. package/__tests__/features/use-queue/use-queue.list.spec.tsx +560 -0
  42. package/__tests__/features/use-queue/use-queue.progress.spec.tsx +650 -0
  43. package/__tests__/features/use-submit/use-submit.abort.spec.tsx +270 -0
  44. package/__tests__/features/use-submit/use-submit.actions.spec.tsx +446 -0
  45. package/__tests__/features/use-submit/use-submit.arguments.spec.tsx +732 -0
  46. package/__tests__/features/use-submit/use-submit.bounce.spec.tsx +644 -0
  47. package/__tests__/features/use-submit/use-submit.callbacks.spec.tsx +860 -0
  48. package/__tests__/features/use-submit/use-submit.chaining.spec.tsx +167 -0
  49. package/__tests__/features/use-submit/use-submit.concurrency.spec.ts +2 -1
  50. package/__tests__/features/use-submit/use-submit.debounce.spec.ts +100 -124
  51. package/__tests__/features/use-submit/use-submit.double-submit.spec.tsx +552 -0
  52. package/__tests__/features/use-submit/use-submit.offline.spec.tsx +285 -0
  53. package/__tests__/features/use-submit/use-submit.optimistic-cache.spec.tsx +619 -0
  54. package/__tests__/features/use-submit/use-submit.optimistic-settlement.spec.ts +8 -1
  55. package/__tests__/features/use-submit/use-submit.optimistic.spec.ts +5 -1
  56. package/__tests__/features/use-submit/use-submit.retry.spec.ts +51 -35
  57. package/__tests__/features/use-submit/use-submit.state.spec.tsx +1025 -0
  58. package/__tests__/features/use-submit/use-submit.submit-types.spec.ts +194 -0
  59. package/__tests__/features/use-submit/use-submit.submitting.spec.tsx +180 -0
  60. package/__tests__/features/use-submit/use-submit.unmount.spec.ts +2 -1
  61. package/__tests__/utils/gate.utils.ts +103 -0
  62. package/__tests__/utils/gated-client.utils.ts +158 -0
  63. package/__tests__/utils/helpers.utils.ts +19 -0
  64. package/__tests__/utils/use-queue.utils.ts +8 -4
  65. package/dist/helpers/use-request-events/use-request-events.hooks.d.ts.map +1 -1
  66. package/dist/helpers/use-request-events/use-request-events.types.d.ts +1 -1
  67. package/dist/helpers/use-request-events/use-request-events.types.d.ts.map +1 -1
  68. package/dist/helpers/use-tracked-state/use-tracked-state.hooks.d.ts.map +1 -1
  69. package/dist/helpers/use-tracked-state/use-tracked-state.utils.d.ts +8 -0
  70. package/dist/helpers/use-tracked-state/use-tracked-state.utils.d.ts.map +1 -1
  71. package/dist/hooks/use-cache/use-cache.hooks.d.ts.map +1 -1
  72. package/dist/hooks/use-fetch/use-fetch.hooks.d.ts.map +1 -1
  73. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.hooks.d.ts.map +1 -1
  74. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts +3 -0
  75. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts.map +1 -1
  76. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts +5 -3
  77. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts.map +1 -1
  78. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts +11 -1
  79. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts.map +1 -1
  80. package/dist/hooks/use-listener/use-listener.hooks.d.ts.map +1 -1
  81. package/dist/hooks/use-queue/use-queue.hooks.d.ts.map +1 -1
  82. package/dist/hooks/use-submit/use-submit.hooks.d.ts.map +1 -1
  83. package/dist/index.mjs +633 -347
  84. package/dist/index.mjs.map +1 -1
  85. package/dist/provider/provider.d.ts.map +1 -1
  86. package/package.json +1 -1
  87. package/src/helpers/use-request-events/use-request-events.hooks.ts +147 -32
  88. package/src/helpers/use-request-events/use-request-events.types.ts +1 -1
  89. package/src/helpers/use-tracked-state/use-tracked-state.hooks.ts +148 -101
  90. package/src/helpers/use-tracked-state/use-tracked-state.utils.ts +26 -5
  91. package/src/hooks/use-cache/use-cache.hooks.ts +20 -5
  92. package/src/hooks/use-fetch/use-fetch.hooks.ts +194 -113
  93. package/src/hooks/use-infinite-fetch/use-infinite-fetch.hooks.ts +55 -26
  94. package/src/hooks/use-infinite-fetch/use-infinite-fetch.store.ts +35 -29
  95. package/src/hooks/use-infinite-fetch/use-infinite-fetch.types.ts +5 -3
  96. package/src/hooks/use-infinite-fetch/use-infinite-fetch.utils.ts +25 -1
  97. package/src/hooks/use-listener/use-listener.hooks.ts +2 -1
  98. package/src/hooks/use-queue/use-queue.hooks.ts +85 -60
  99. package/src/hooks/use-submit/use-submit.hooks.ts +163 -53
  100. package/src/provider/provider.tsx +9 -1
  101. package/__tests__/features/use-fetch/use-fetch.pagination.ts +0 -36
  102. package/__tests__/features/use-fetch/use-fetch.retry.ts +0 -38
@@ -0,0 +1,355 @@
1
+ import { act, renderHook } from "@testing-library/react";
2
+ import type { UseFetchOptionsType } from "hooks/use-fetch";
3
+ import { useFetch } from "hooks/use-fetch";
4
+ import { StrictMode } from "react";
5
+
6
+ import { client, createRequest } from "../../utils";
7
+ import { advance, gateRequest, settle } from "../../utils/gate.utils";
8
+
9
+ type Data = { value: number };
10
+ type Options = UseFetchOptionsType<ReturnType<typeof createRequest<Data>>>;
11
+
12
+ const refreshTime = 10_000;
13
+
14
+ describe("useFetch [ Refresh Interval ]", () => {
15
+ let request = createRequest<Data>();
16
+ let calls = gateRequest(request);
17
+
18
+ const renderRefresh = (options?: Options, wrapper?: typeof StrictMode) => {
19
+ return renderHook(
20
+ (props: Options) => {
21
+ const { data, refetch } = useFetch(request, { refresh: true, refreshTime, ...options, ...props } as Options);
22
+ return { data, refetch };
23
+ },
24
+ { initialProps: {}, wrapper },
25
+ );
26
+ };
27
+
28
+ /** Answers every pending call, so the next interval is free to send a request */
29
+ const answerAll = async () => {
30
+ calls.forEach((call, index) => call.succeed({ value: index }));
31
+ await settle();
32
+ };
33
+
34
+ beforeEach(() => {
35
+ vi.useFakeTimers();
36
+ client.clear();
37
+ request = createRequest<Data>();
38
+ calls = gateRequest(request);
39
+ });
40
+
41
+ afterEach(() => {
42
+ vi.useRealTimers();
43
+ });
44
+
45
+ describe("when refresh is enabled", () => {
46
+ it("should not refresh before the refresh time passes", async () => {
47
+ renderRefresh();
48
+ await advance();
49
+ await answerAll();
50
+
51
+ await advance(refreshTime - 1000);
52
+
53
+ expect(calls).toHaveLength(1);
54
+ });
55
+ it("should refresh once the refresh time passes", async () => {
56
+ renderRefresh();
57
+ await advance();
58
+ await answerAll();
59
+
60
+ await advance(refreshTime);
61
+
62
+ expect(calls).toHaveLength(2);
63
+ });
64
+ it("should refresh once per interval", async () => {
65
+ renderRefresh();
66
+ await advance();
67
+ await answerAll();
68
+
69
+ for (let i = 0; i < 4; i += 1) {
70
+ // eslint-disable-next-line no-await-in-loop
71
+ await advance(refreshTime);
72
+ // eslint-disable-next-line no-await-in-loop
73
+ await answerAll();
74
+ }
75
+
76
+ expect(calls).toHaveLength(5);
77
+ });
78
+ it("should update the data with every refresh", async () => {
79
+ const { result } = renderRefresh();
80
+ await advance();
81
+ calls[0].succeed({ value: 1 });
82
+ await settle();
83
+
84
+ await advance(refreshTime);
85
+ calls[1].succeed({ value: 2 });
86
+ await settle();
87
+
88
+ expect(result.current.data).toStrictEqual({ value: 2 });
89
+ });
90
+ it("should not stack requests while the previous one is still running", async () => {
91
+ renderRefresh();
92
+ await advance();
93
+
94
+ await advance(refreshTime * 3);
95
+
96
+ expect(calls).toHaveLength(1);
97
+ });
98
+ it("should keep a single timer running", async () => {
99
+ renderRefresh();
100
+ await advance();
101
+ await answerAll();
102
+ const timers = vi.getTimerCount();
103
+
104
+ await advance(refreshTime);
105
+ await answerAll();
106
+ await advance(refreshTime);
107
+ await answerAll();
108
+
109
+ expect(vi.getTimerCount()).toBe(timers);
110
+ });
111
+ it("should keep a single timer in StrictMode", async () => {
112
+ renderRefresh({}, StrictMode);
113
+ await advance();
114
+ await answerAll();
115
+
116
+ await advance(refreshTime);
117
+
118
+ expect(calls).toHaveLength(2);
119
+ });
120
+ it("should not refresh without the refresh option", async () => {
121
+ renderRefresh({ refresh: false });
122
+ await advance();
123
+ await answerAll();
124
+
125
+ await advance(refreshTime * 3);
126
+
127
+ expect(calls).toHaveLength(1);
128
+ });
129
+ });
130
+
131
+ describe("when options change", () => {
132
+ it("should stop refreshing when refresh gets turned off", async () => {
133
+ const { rerender } = renderRefresh();
134
+ await advance();
135
+ await answerAll();
136
+
137
+ rerender({ refresh: false });
138
+ await advance(refreshTime * 3);
139
+
140
+ expect(calls).toHaveLength(1);
141
+ });
142
+ it("should start refreshing when refresh gets turned on", async () => {
143
+ const { rerender } = renderRefresh({ refresh: false });
144
+ await advance();
145
+ await answerAll();
146
+
147
+ rerender({ refresh: true });
148
+ await advance(refreshTime);
149
+
150
+ expect(calls).toHaveLength(2);
151
+ });
152
+ it("should stop refreshing when the hook gets disabled", async () => {
153
+ const { rerender } = renderRefresh();
154
+ await advance();
155
+ await answerAll();
156
+
157
+ rerender({ disabled: true });
158
+ await advance(refreshTime * 3);
159
+
160
+ expect(calls).toHaveLength(1);
161
+ });
162
+ it("should never refresh the disabled hook", async () => {
163
+ renderRefresh({ disabled: true });
164
+
165
+ await advance(refreshTime * 3);
166
+
167
+ expect(calls).toHaveLength(0);
168
+ });
169
+ it("should use the new refresh time", async () => {
170
+ const { rerender } = renderRefresh();
171
+ await advance();
172
+ await answerAll();
173
+
174
+ rerender({ refreshTime: 1000 });
175
+ await advance(1000);
176
+
177
+ expect(calls).toHaveLength(2);
178
+ });
179
+ it("should restart the countdown when dependencies change", async () => {
180
+ const { rerender } = renderRefresh({ dependencies: [1] });
181
+ await advance();
182
+ await answerAll();
183
+
184
+ await advance(refreshTime - 1000);
185
+ rerender({ dependencies: [2] });
186
+ await advance();
187
+ await answerAll();
188
+ expect(calls).toHaveLength(2);
189
+
190
+ // The old countdown would fire here
191
+ await advance(1000);
192
+ expect(calls).toHaveLength(2);
193
+
194
+ await advance(refreshTime - 1000);
195
+ expect(calls).toHaveLength(3);
196
+ });
197
+ });
198
+
199
+ describe("when refetch is called during the countdown", () => {
200
+ it("should restart the countdown", async () => {
201
+ const { result } = renderRefresh();
202
+ await advance();
203
+ await answerAll();
204
+
205
+ await advance(refreshTime - 1000);
206
+ act(() => {
207
+ result.current.refetch();
208
+ });
209
+ await advance();
210
+ await answerAll();
211
+ expect(calls).toHaveLength(2);
212
+
213
+ await advance(refreshTime - 1000);
214
+ expect(calls).toHaveLength(2);
215
+
216
+ await advance(1000);
217
+ expect(calls).toHaveLength(3);
218
+ });
219
+ });
220
+
221
+ describe("when the window is blurred", () => {
222
+ it("should keep refreshing by default", async () => {
223
+ renderRefresh();
224
+ await advance();
225
+ await answerAll();
226
+
227
+ act(() => {
228
+ client.appManager.setFocused(false);
229
+ });
230
+ await advance(refreshTime);
231
+
232
+ expect(calls).toHaveLength(2);
233
+ });
234
+ it("should not refresh when refetchBlurred is off", async () => {
235
+ renderRefresh({ refetchBlurred: false });
236
+ await advance();
237
+ await answerAll();
238
+
239
+ act(() => {
240
+ client.appManager.setFocused(false);
241
+ });
242
+ await advance(refreshTime * 3);
243
+
244
+ expect(calls).toHaveLength(1);
245
+ });
246
+ it("should refresh again after the window gets focused", async () => {
247
+ renderRefresh({ refetchBlurred: false });
248
+ await advance();
249
+ await answerAll();
250
+
251
+ act(() => {
252
+ client.appManager.setFocused(false);
253
+ });
254
+ await advance(refreshTime * 2);
255
+ act(() => {
256
+ client.appManager.setFocused(true);
257
+ });
258
+ await advance(refreshTime);
259
+
260
+ expect(calls).toHaveLength(2);
261
+ });
262
+ it("should respect refetchBlurred changed after the countdown started", async () => {
263
+ const { rerender } = renderRefresh({ refetchBlurred: true });
264
+ await advance();
265
+ await answerAll();
266
+
267
+ act(() => {
268
+ client.appManager.setFocused(false);
269
+ });
270
+ rerender({ refetchBlurred: false });
271
+ await advance(refreshTime * 2);
272
+
273
+ expect(calls).toHaveLength(1);
274
+ });
275
+ });
276
+
277
+ describe("when the application is offline", () => {
278
+ it("should queue a single request and send it once online", async () => {
279
+ renderRefresh();
280
+ await advance();
281
+ await answerAll();
282
+
283
+ act(() => {
284
+ client.appManager.setOnline(false);
285
+ });
286
+ await advance(refreshTime * 3);
287
+ expect(calls).toHaveLength(1);
288
+
289
+ act(() => {
290
+ client.appManager.setOnline(true);
291
+ });
292
+ await advance();
293
+
294
+ expect(calls).toHaveLength(2);
295
+ });
296
+ });
297
+
298
+ describe("when the hook unmounts", () => {
299
+ it("should stop refreshing", async () => {
300
+ const { unmount } = renderRefresh();
301
+ await advance();
302
+ await answerAll();
303
+
304
+ unmount();
305
+ await advance(refreshTime * 3);
306
+
307
+ expect(calls).toHaveLength(1);
308
+ });
309
+ it("should remove the refresh timer", async () => {
310
+ const { unmount } = renderRefresh({ refresh: false });
311
+ await advance();
312
+ await answerAll();
313
+ const baseline = vi.getTimerCount();
314
+ unmount();
315
+
316
+ const { unmount: unmountRefreshing } = renderRefresh();
317
+ await advance();
318
+ await answerAll();
319
+ expect(vi.getTimerCount()).toBeGreaterThan(baseline);
320
+ unmountRefreshing();
321
+
322
+ expect(vi.getTimerCount()).toBe(baseline);
323
+ });
324
+ it("should stop refreshing after unmounting in StrictMode", async () => {
325
+ const { unmount } = renderRefresh({}, StrictMode);
326
+ await advance();
327
+ await answerAll();
328
+
329
+ unmount();
330
+ await advance(refreshTime * 3);
331
+
332
+ expect(calls).toHaveLength(1);
333
+ });
334
+ });
335
+
336
+ describe("when the request key changes", () => {
337
+ it("should refresh only the current key", async () => {
338
+ const { rerender } = renderHook(
339
+ ({ page }) => useFetch(request.setQueryParams({ page }), { refresh: true, refreshTime }).data,
340
+ { initialProps: { page: 1 } },
341
+ );
342
+ await advance();
343
+ await answerAll();
344
+
345
+ await advance(refreshTime - 1000);
346
+ rerender({ page: 2 });
347
+ await advance();
348
+ await answerAll();
349
+
350
+ await advance(refreshTime);
351
+
352
+ expect(calls.map((call) => call.request.queryParams)).toStrictEqual([{ page: 1 }, { page: 2 }, { page: 2 }]);
353
+ });
354
+ });
355
+ });
@@ -17,11 +17,30 @@ describe("useFetch [ Refreshing ]", () => {
17
17
 
18
18
  let request = createRequest();
19
19
 
20
+ /**
21
+ * Refreshing is decided by elapsed time, so specs asserting that it stops run on a fake clock. On real timers a slow
22
+ * machine lets the next refresh fire before the hook gets disabled. Each poll moves the clock a little, so a response
23
+ * settles before the clock can reach the next refresh, wherever msw registers its delay timers.
24
+ */
25
+ const useFakeClock = () => {
26
+ vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] });
27
+ };
28
+ const advance = (ms: number) => act(() => vi.advanceTimersByTimeAsync(ms));
29
+ const advanceUntil = (assertion: () => void) =>
30
+ vi.waitFor(
31
+ async () => {
32
+ await advance(5);
33
+ assertion();
34
+ },
35
+ { interval: 5 },
36
+ );
37
+
20
38
  beforeAll(() => {
21
39
  startServer();
22
40
  });
23
41
 
24
42
  afterEach(() => {
43
+ vi.useRealTimers();
25
44
  resetMocks();
26
45
  });
27
46
 
@@ -87,6 +106,7 @@ describe("useFetch [ Refreshing ]", () => {
87
106
  // TODO
88
107
  });
89
108
  it("should stop refreshing when value is changing from true to false", async () => {
109
+ useFakeClock();
90
110
  const spy = vi.fn();
91
111
  mockRequest(request);
92
112
  const { result, rerender } = renderUseFetch(request, hookOptions);
@@ -95,10 +115,7 @@ describe("useFetch [ Refreshing ]", () => {
95
115
  result.current.onRequestStart(spy);
96
116
  });
97
117
 
98
- await waitFor(() => {
99
- expect(spy).toHaveBeenCalledTimes(1);
100
- });
101
- await waitFor(() => {
118
+ await advanceUntil(() => {
102
119
  expect(spy).toHaveBeenCalledTimes(2);
103
120
  });
104
121
 
@@ -106,30 +123,33 @@ describe("useFetch [ Refreshing ]", () => {
106
123
  rerender({ refresh: false });
107
124
  });
108
125
 
109
- await waitForRender(hookOptions.refreshTime * 1.5);
126
+ await advance(hookOptions.refreshTime * 5);
110
127
 
111
128
  expect(spy).toHaveBeenCalledTimes(2);
112
129
  });
113
130
  it("should refetch when tab is focused and refetchOnFocus is true", async () => {
114
131
  const spy = vi.fn();
115
132
  mockRequest(request);
116
- // Deduplication would collapse the focus refetch into the still-running initial fetch
117
- const { result } = renderUseFetch(request.setDeduplicate(false), { ...hookOptions });
133
+ // Deduplication would collapse the focus refetch into the still-running initial fetch.
134
+ // Refreshing is off, a timed refresh on a slow machine would add a request the focus did not cause.
135
+ const { result } = renderUseFetch(request.setDeduplicate(false), { ...hookOptions, refresh: false });
118
136
 
119
137
  act(() => {
120
138
  result.current.onRequestStart(spy);
121
139
  });
122
140
 
123
- await waitForRender();
124
- expect(spy).toHaveBeenCalledTimes(1);
141
+ await waitFor(() => {
142
+ expect(spy).toHaveBeenCalledTimes(1);
143
+ });
125
144
 
126
145
  // Simulate tab focus
127
146
  act(() => {
128
147
  client.appManager.setFocused(true);
129
148
  });
130
149
 
131
- await waitForRender();
132
- expect(spy).toHaveBeenCalledTimes(2);
150
+ await waitFor(() => {
151
+ expect(spy).toHaveBeenCalledTimes(2);
152
+ });
133
153
  });
134
154
  it("should not refresh when disabled is true", async () => {
135
155
  const spy = vi.fn();
@@ -146,6 +166,7 @@ describe("useFetch [ Refreshing ]", () => {
146
166
  expect(spy).not.toHaveBeenCalled();
147
167
  });
148
168
  it("should stop refreshing when disabled changes from false to true", async () => {
169
+ useFakeClock();
149
170
  const spy = vi.fn();
150
171
  mockRequest(request);
151
172
  const { result, rerender } = renderUseFetch(request, hookOptions);
@@ -154,22 +175,24 @@ describe("useFetch [ Refreshing ]", () => {
154
175
  result.current.onRequestStart(spy);
155
176
  });
156
177
 
157
- await waitForRender();
178
+ await advance(0);
158
179
  expect(spy).toHaveBeenCalledTimes(1);
159
180
 
160
181
  act(() => {
161
182
  rerender({ disabled: true });
162
183
  });
163
184
 
164
- await waitForRender(hookOptions.refreshTime * 1.5);
185
+ await advance(hookOptions.refreshTime * 5);
165
186
 
166
187
  expect(spy).toHaveBeenCalledTimes(1);
167
188
  });
168
189
  it("should not refetch when tab is focused and refetchOnFocus is false", async () => {
169
190
  const spy = vi.fn();
170
191
  mockRequest(request);
192
+ // Refreshing is off, a timed refresh on a slow machine would add a request the focus did not cause
171
193
  const { result } = renderUseFetch(request, {
172
194
  ...hookOptions,
195
+ refresh: false,
173
196
  refetchOnFocus: false,
174
197
  });
175
198
 
@@ -0,0 +1,105 @@
1
+ import { act, renderHook } from "@testing-library/react";
2
+ import { useFetch } from "hooks/use-fetch";
3
+
4
+ import { client, createRequest } from "../../utils";
5
+ import { advance, gateRequest, settle } from "../../utils/gate.utils";
6
+
7
+ type Data = { value: string };
8
+
9
+ /**
10
+ * A fetch and a refetch of the same request can be in flight together and answer in any order.
11
+ * The hook has to end with the data of the request that was sent last.
12
+ */
13
+ describe("useFetch [ Response order ]", () => {
14
+ let request = createRequest<Data>();
15
+ let calls = gateRequest(request);
16
+
17
+ const renderData = () =>
18
+ renderHook(() => {
19
+ const { data, error, loading, refetch } = useFetch(request);
20
+ return { data, error, loading, refetch };
21
+ });
22
+
23
+ /** Mount (first request) and refetch a moment later (second request) - both stay in flight */
24
+ const startTwoRequests = async () => {
25
+ const view = renderData();
26
+ await advance();
27
+ await advance(100);
28
+ act(() => {
29
+ view.result.current.refetch();
30
+ });
31
+ await advance();
32
+
33
+ return view;
34
+ };
35
+
36
+ beforeEach(() => {
37
+ vi.useFakeTimers();
38
+ client.clear();
39
+ request = createRequest<Data>();
40
+ calls = gateRequest(request);
41
+ });
42
+
43
+ afterEach(() => {
44
+ vi.useRealTimers();
45
+ });
46
+
47
+ describe("when the refetch answers before the first request", () => {
48
+ it("should keep the data of the refetch", async () => {
49
+ const { result } = await startTwoRequests();
50
+
51
+ calls[1].succeed({ value: "new" });
52
+ await settle();
53
+ calls[0].succeed({ value: "old" });
54
+ await settle();
55
+
56
+ expect(result.current.data).toStrictEqual({ value: "new" });
57
+ expect(client.cache.get(request.cacheKey)?.data).toStrictEqual({ value: "new" });
58
+ expect(result.current.loading).toBeFalse();
59
+ });
60
+
61
+ it("should not show the error of the first request", async () => {
62
+ const { result } = await startTwoRequests();
63
+
64
+ calls[1].succeed({ value: "new" });
65
+ await settle();
66
+ calls[0].fail(new Error("Too late"));
67
+ await settle();
68
+
69
+ expect(result.current.data).toStrictEqual({ value: "new" });
70
+ expect(result.current.error).toBeNull();
71
+ expect(result.current.loading).toBeFalse();
72
+ });
73
+
74
+ it("should give the same data to every component using the request", async () => {
75
+ const first = await startTwoRequests();
76
+ const second = renderData();
77
+ await advance();
78
+
79
+ calls[1].succeed({ value: "new" });
80
+ await settle();
81
+ calls[0].succeed({ value: "old" });
82
+ await settle();
83
+
84
+ expect(first.result.current.data).toStrictEqual({ value: "new" });
85
+ expect(second.result.current.data).toStrictEqual({ value: "new" });
86
+ });
87
+ });
88
+
89
+ describe("when the requests answer in the order they were sent", () => {
90
+ it("should end with the data of the refetch", async () => {
91
+ const { result } = await startTwoRequests();
92
+
93
+ calls[0].succeed({ value: "old" });
94
+ await settle();
95
+ expect(result.current.data).toStrictEqual({ value: "old" });
96
+ expect(result.current.loading).toBeTrue();
97
+
98
+ calls[1].succeed({ value: "new" });
99
+ await settle();
100
+
101
+ expect(result.current.data).toStrictEqual({ value: "new" });
102
+ expect(result.current.loading).toBeFalse();
103
+ });
104
+ });
105
+ });