@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.
- package/__tests__/features/helpers/use-tracked-state/use-tacked-state.actions.spec.ts +1 -1
- package/__tests__/features/helpers/use-tracked-state/use-tracked-state.keys.spec.ts +294 -0
- package/__tests__/features/helpers/utils.spec.ts +127 -0
- package/__tests__/features/provider/provider.config.spec.tsx +172 -0
- package/__tests__/features/use-app-manager/use-app-manager.events.spec.tsx +497 -0
- package/__tests__/features/use-cache/use-cache.state.spec.tsx +326 -0
- package/__tests__/features/use-emitter/use-emitter.lifecycle.spec.tsx +417 -0
- package/__tests__/features/use-fetch/use-fetch.bounce-timers.spec.ts +199 -0
- package/__tests__/features/use-fetch/use-fetch.cache-events.spec.ts +212 -0
- package/__tests__/features/use-fetch/use-fetch.callbacks.spec.tsx +359 -0
- package/__tests__/features/use-fetch/use-fetch.hydration.spec.tsx +126 -0
- package/__tests__/features/use-fetch/use-fetch.infinite.spec.ts +146 -0
- package/__tests__/features/use-fetch/use-fetch.initial-state.spec.ts +340 -0
- package/__tests__/features/use-fetch/use-fetch.keys.spec.tsx +559 -0
- package/__tests__/features/use-fetch/use-fetch.lifecycle.spec.ts +348 -0
- package/__tests__/features/use-fetch/use-fetch.mounting.spec.tsx +411 -0
- package/__tests__/features/use-fetch/use-fetch.pagination.spec.ts +177 -0
- package/__tests__/features/use-fetch/use-fetch.refresh-interval.spec.ts +355 -0
- package/__tests__/features/use-fetch/use-fetch.response-order.spec.ts +105 -0
- package/__tests__/features/use-fetch/use-fetch.retry.spec.ts +235 -0
- package/__tests__/features/use-fetch/use-fetch.return-types.spec.ts +186 -0
- package/__tests__/features/use-fetch/use-fetch.scope.spec.ts +333 -0
- package/__tests__/features/use-fetch/use-fetch.ssr.spec.tsx +195 -0
- package/__tests__/features/use-fetch/use-fetch.suspense-edge.spec.tsx +391 -0
- package/__tests__/features/use-fetch/use-fetch.throwing-callbacks.spec.tsx +112 -0
- package/__tests__/features/use-fetch/use-fetch.tracking.spec.tsx +364 -0
- package/__tests__/features/use-fetch/use-fetch.window-events.spec.ts +300 -0
- package/__tests__/features/use-infinite-fetch/use-infinite-fetch.parity.spec.tsx +1027 -0
- package/__tests__/features/use-infinite-fetch/use-infinite-fetch.resubscribe.spec.tsx +267 -0
- package/__tests__/features/use-infinite-fetch/use-infinite-fetch.typescript.spec.ts +64 -1
- package/__tests__/features/use-is-fetching/use-is-fetching.lifecycle.spec.tsx +301 -0
- package/__tests__/features/use-listener/use-listener.lifecycle.spec.tsx +507 -0
- package/__tests__/features/use-listener/use-listener.ssr.spec.tsx +89 -0
- package/__tests__/features/use-queue/use-queue.controls.spec.tsx +593 -0
- package/__tests__/features/use-queue/use-queue.list.spec.tsx +560 -0
- package/__tests__/features/use-queue/use-queue.progress.spec.tsx +650 -0
- package/__tests__/features/use-submit/use-submit.abort.spec.tsx +270 -0
- package/__tests__/features/use-submit/use-submit.actions.spec.tsx +446 -0
- package/__tests__/features/use-submit/use-submit.arguments.spec.tsx +732 -0
- package/__tests__/features/use-submit/use-submit.bounce.spec.tsx +644 -0
- package/__tests__/features/use-submit/use-submit.callbacks.spec.tsx +860 -0
- package/__tests__/features/use-submit/use-submit.chaining.spec.tsx +167 -0
- package/__tests__/features/use-submit/use-submit.double-submit.spec.tsx +552 -0
- package/__tests__/features/use-submit/use-submit.offline.spec.tsx +285 -0
- package/__tests__/features/use-submit/use-submit.optimistic-cache.spec.tsx +619 -0
- package/__tests__/features/use-submit/use-submit.optimistic-settlement.spec.ts +6 -0
- package/__tests__/features/use-submit/use-submit.optimistic.spec.ts +5 -1
- package/__tests__/features/use-submit/use-submit.state.spec.tsx +1025 -0
- package/__tests__/features/use-submit/use-submit.submit-types.spec.ts +194 -0
- package/__tests__/features/use-submit/use-submit.submitting.spec.tsx +180 -0
- package/__tests__/utils/gate.utils.ts +103 -0
- package/__tests__/utils/gated-client.utils.ts +158 -0
- package/__tests__/utils/helpers.utils.ts +19 -0
- package/dist/helpers/use-request-events/use-request-events.hooks.d.ts.map +1 -1
- package/dist/helpers/use-request-events/use-request-events.types.d.ts +1 -1
- package/dist/helpers/use-request-events/use-request-events.types.d.ts.map +1 -1
- package/dist/helpers/use-tracked-state/use-tracked-state.hooks.d.ts.map +1 -1
- package/dist/helpers/use-tracked-state/use-tracked-state.utils.d.ts +8 -0
- package/dist/helpers/use-tracked-state/use-tracked-state.utils.d.ts.map +1 -1
- package/dist/hooks/use-cache/use-cache.hooks.d.ts.map +1 -1
- package/dist/hooks/use-fetch/use-fetch.hooks.d.ts.map +1 -1
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.hooks.d.ts.map +1 -1
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts +3 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts.map +1 -1
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts +5 -3
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts.map +1 -1
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts +11 -1
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts.map +1 -1
- package/dist/hooks/use-listener/use-listener.hooks.d.ts.map +1 -1
- package/dist/hooks/use-queue/use-queue.hooks.d.ts.map +1 -1
- package/dist/hooks/use-submit/use-submit.hooks.d.ts.map +1 -1
- package/dist/index.mjs +630 -346
- package/dist/index.mjs.map +1 -1
- package/dist/provider/provider.d.ts.map +1 -1
- package/package.json +1 -1
- package/src/helpers/use-request-events/use-request-events.hooks.ts +141 -28
- package/src/helpers/use-request-events/use-request-events.types.ts +1 -1
- package/src/helpers/use-tracked-state/use-tracked-state.hooks.ts +148 -101
- package/src/helpers/use-tracked-state/use-tracked-state.utils.ts +26 -5
- package/src/hooks/use-cache/use-cache.hooks.ts +20 -5
- package/src/hooks/use-fetch/use-fetch.hooks.ts +194 -113
- package/src/hooks/use-infinite-fetch/use-infinite-fetch.hooks.ts +55 -26
- package/src/hooks/use-infinite-fetch/use-infinite-fetch.store.ts +35 -29
- package/src/hooks/use-infinite-fetch/use-infinite-fetch.types.ts +5 -3
- package/src/hooks/use-infinite-fetch/use-infinite-fetch.utils.ts +25 -1
- package/src/hooks/use-listener/use-listener.hooks.ts +2 -1
- package/src/hooks/use-queue/use-queue.hooks.ts +85 -60
- package/src/hooks/use-submit/use-submit.hooks.ts +163 -53
- package/src/provider/provider.tsx +9 -1
- package/__tests__/features/use-fetch/use-fetch.pagination.ts +0 -36
- 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
|
+
});
|
|
@@ -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
|
+
});
|
|
@@ -0,0 +1,235 @@
|
|
|
1
|
+
import { act, renderHook } from "@testing-library/react";
|
|
2
|
+
import { useFetch } from "hooks/use-fetch";
|
|
3
|
+
import { useIsFetching } from "hooks/use-is-fetching";
|
|
4
|
+
|
|
5
|
+
import { client, createRequest } from "../../utils";
|
|
6
|
+
import { advance, gateRequest, settle } from "../../utils/gate.utils";
|
|
7
|
+
|
|
8
|
+
type Data = { value: number };
|
|
9
|
+
|
|
10
|
+
const retryTime = 5000;
|
|
11
|
+
|
|
12
|
+
describe("useFetch [ Retry ]", () => {
|
|
13
|
+
let calls = gateRequest(createRequest<Data>());
|
|
14
|
+
|
|
15
|
+
const renderRetry = (retry: number) => {
|
|
16
|
+
const request = createRequest<Data>({ retry, retryTime });
|
|
17
|
+
calls = gateRequest(request);
|
|
18
|
+
const spies = { onError: vi.fn(), onSuccess: vi.fn(), onFinished: vi.fn() };
|
|
19
|
+
const view = renderHook(() => {
|
|
20
|
+
const state = useFetch(request);
|
|
21
|
+
state.onError(spies.onError);
|
|
22
|
+
state.onSuccess(spies.onSuccess);
|
|
23
|
+
state.onFinished(spies.onFinished);
|
|
24
|
+
const fetching = useIsFetching(client);
|
|
25
|
+
return {
|
|
26
|
+
data: state.data,
|
|
27
|
+
error: state.error?.message ?? null,
|
|
28
|
+
loading: state.loading,
|
|
29
|
+
retries: state.retries,
|
|
30
|
+
fetching,
|
|
31
|
+
};
|
|
32
|
+
});
|
|
33
|
+
return { ...view, spies, request };
|
|
34
|
+
};
|
|
35
|
+
|
|
36
|
+
const failAttempt = async (index: number) => {
|
|
37
|
+
calls[index].fail(new Error(`Attempt ${index + 1} failed`));
|
|
38
|
+
await settle();
|
|
39
|
+
};
|
|
40
|
+
|
|
41
|
+
beforeEach(() => {
|
|
42
|
+
vi.useFakeTimers();
|
|
43
|
+
client.clear();
|
|
44
|
+
});
|
|
45
|
+
|
|
46
|
+
afterEach(() => {
|
|
47
|
+
vi.useRealTimers();
|
|
48
|
+
});
|
|
49
|
+
|
|
50
|
+
describe("when request retry attribute is set to false", () => {
|
|
51
|
+
it("should not retry request on failure", async () => {
|
|
52
|
+
const { result } = renderRetry(0);
|
|
53
|
+
await advance();
|
|
54
|
+
await failAttempt(0);
|
|
55
|
+
await advance(retryTime * 3);
|
|
56
|
+
|
|
57
|
+
expect(calls).toHaveLength(1);
|
|
58
|
+
expect(result.current).toStrictEqual({
|
|
59
|
+
data: null,
|
|
60
|
+
error: "Attempt 1 failed",
|
|
61
|
+
loading: false,
|
|
62
|
+
retries: 0,
|
|
63
|
+
fetching: 0,
|
|
64
|
+
});
|
|
65
|
+
});
|
|
66
|
+
it("should call the error callback once", async () => {
|
|
67
|
+
const { spies } = renderRetry(0);
|
|
68
|
+
await advance();
|
|
69
|
+
await failAttempt(0);
|
|
70
|
+
await advance(retryTime * 3);
|
|
71
|
+
|
|
72
|
+
expect(spies.onError).toHaveBeenCalledOnce();
|
|
73
|
+
expect(spies.onError.mock.calls[0][0].details.willRetry).toBeFalse();
|
|
74
|
+
});
|
|
75
|
+
});
|
|
76
|
+
|
|
77
|
+
describe("when request retry attribute is set to true", () => {
|
|
78
|
+
it("should retry request once", async () => {
|
|
79
|
+
renderRetry(1);
|
|
80
|
+
await advance();
|
|
81
|
+
await failAttempt(0);
|
|
82
|
+
await advance(retryTime);
|
|
83
|
+
await failAttempt(1);
|
|
84
|
+
await advance(retryTime * 3);
|
|
85
|
+
|
|
86
|
+
expect(calls).toHaveLength(2);
|
|
87
|
+
});
|
|
88
|
+
it("should retry request twice", async () => {
|
|
89
|
+
renderRetry(2);
|
|
90
|
+
await advance();
|
|
91
|
+
await failAttempt(0);
|
|
92
|
+
await advance(retryTime);
|
|
93
|
+
await failAttempt(1);
|
|
94
|
+
await advance(retryTime);
|
|
95
|
+
await failAttempt(2);
|
|
96
|
+
await advance(retryTime * 3);
|
|
97
|
+
|
|
98
|
+
expect(calls).toHaveLength(3);
|
|
99
|
+
});
|
|
100
|
+
it("should trigger retries with the config interval", async () => {
|
|
101
|
+
renderRetry(1);
|
|
102
|
+
await advance();
|
|
103
|
+
await failAttempt(0);
|
|
104
|
+
|
|
105
|
+
await advance(retryTime - 1000);
|
|
106
|
+
expect(calls).toHaveLength(1);
|
|
107
|
+
|
|
108
|
+
await advance(1000);
|
|
109
|
+
expect(calls).toHaveLength(2);
|
|
110
|
+
});
|
|
111
|
+
it("should stop retrying after the successful attempt", async () => {
|
|
112
|
+
const { result } = renderRetry(3);
|
|
113
|
+
await advance();
|
|
114
|
+
await failAttempt(0);
|
|
115
|
+
await advance(retryTime);
|
|
116
|
+
calls[1].succeed({ value: 1 });
|
|
117
|
+
await settle();
|
|
118
|
+
await advance(retryTime * 3);
|
|
119
|
+
|
|
120
|
+
expect(calls).toHaveLength(2);
|
|
121
|
+
expect(result.current).toStrictEqual({
|
|
122
|
+
data: { value: 1 },
|
|
123
|
+
error: null,
|
|
124
|
+
loading: false,
|
|
125
|
+
retries: 1,
|
|
126
|
+
fetching: 0,
|
|
127
|
+
});
|
|
128
|
+
});
|
|
129
|
+
it("should expose the number of the used retries", async () => {
|
|
130
|
+
const { result } = renderRetry(2);
|
|
131
|
+
await advance();
|
|
132
|
+
expect(result.current.retries).toBe(0);
|
|
133
|
+
|
|
134
|
+
await failAttempt(0);
|
|
135
|
+
await advance(retryTime);
|
|
136
|
+
await failAttempt(1);
|
|
137
|
+
expect(result.current.retries).toBe(1);
|
|
138
|
+
|
|
139
|
+
await advance(retryTime);
|
|
140
|
+
await failAttempt(2);
|
|
141
|
+
expect(result.current.retries).toBe(2);
|
|
142
|
+
});
|
|
143
|
+
it("should be loading during every attempt", async () => {
|
|
144
|
+
const { result } = renderRetry(1);
|
|
145
|
+
await advance();
|
|
146
|
+
expect(result.current.loading).toBeTrue();
|
|
147
|
+
expect(result.current.fetching).toBe(1);
|
|
148
|
+
|
|
149
|
+
await failAttempt(0);
|
|
150
|
+
await advance(retryTime);
|
|
151
|
+
|
|
152
|
+
expect(result.current.loading).toBeTrue();
|
|
153
|
+
expect(result.current.fetching).toBe(1);
|
|
154
|
+
});
|
|
155
|
+
it("should end with the last error", async () => {
|
|
156
|
+
const { result } = renderRetry(1);
|
|
157
|
+
await advance();
|
|
158
|
+
await failAttempt(0);
|
|
159
|
+
await advance(retryTime);
|
|
160
|
+
await failAttempt(1);
|
|
161
|
+
|
|
162
|
+
expect(result.current).toStrictEqual({
|
|
163
|
+
data: null,
|
|
164
|
+
error: "Attempt 2 failed",
|
|
165
|
+
loading: false,
|
|
166
|
+
retries: 1,
|
|
167
|
+
fetching: 0,
|
|
168
|
+
});
|
|
169
|
+
});
|
|
170
|
+
it("should call the callbacks for every attempt", async () => {
|
|
171
|
+
const { spies } = renderRetry(2);
|
|
172
|
+
await advance();
|
|
173
|
+
await failAttempt(0);
|
|
174
|
+
await advance(retryTime);
|
|
175
|
+
await failAttempt(1);
|
|
176
|
+
await advance(retryTime);
|
|
177
|
+
calls[2].succeed({ value: 1 });
|
|
178
|
+
await settle();
|
|
179
|
+
|
|
180
|
+
expect(spies.onError).toHaveBeenCalledTimes(2);
|
|
181
|
+
expect(spies.onError.mock.calls.map(([params]) => params.details.willRetry)).toStrictEqual([true, true]);
|
|
182
|
+
expect(spies.onSuccess).toHaveBeenCalledOnce();
|
|
183
|
+
expect(spies.onFinished).toHaveBeenCalledTimes(3);
|
|
184
|
+
});
|
|
185
|
+
it("should mark only the last failed attempt as final", async () => {
|
|
186
|
+
const { spies } = renderRetry(1);
|
|
187
|
+
await advance();
|
|
188
|
+
await failAttempt(0);
|
|
189
|
+
await advance(retryTime);
|
|
190
|
+
await failAttempt(1);
|
|
191
|
+
|
|
192
|
+
expect(spies.onError.mock.calls.map(([params]) => params.details.willRetry)).toStrictEqual([true, false]);
|
|
193
|
+
});
|
|
194
|
+
it("should start the retries from scratch on refetch", async () => {
|
|
195
|
+
const request = createRequest<Data>({ retry: 1, retryTime });
|
|
196
|
+
calls = gateRequest(request);
|
|
197
|
+
const { result } = renderHook(() => {
|
|
198
|
+
const { retries, refetch } = useFetch(request);
|
|
199
|
+
return { retries, refetch };
|
|
200
|
+
});
|
|
201
|
+
await advance();
|
|
202
|
+
await failAttempt(0);
|
|
203
|
+
await advance(retryTime);
|
|
204
|
+
await failAttempt(1);
|
|
205
|
+
|
|
206
|
+
act(() => {
|
|
207
|
+
result.current.refetch();
|
|
208
|
+
});
|
|
209
|
+
await advance();
|
|
210
|
+
calls[2].succeed({ value: 1 });
|
|
211
|
+
await settle();
|
|
212
|
+
|
|
213
|
+
expect(result.current.retries).toBe(0);
|
|
214
|
+
});
|
|
215
|
+
it("should not retry the request removed with abort", async () => {
|
|
216
|
+
const request = createRequest<Data>({ retry: 3, retryTime });
|
|
217
|
+
calls = gateRequest(request);
|
|
218
|
+
const { result } = renderHook(() => {
|
|
219
|
+
const { error, abort } = useFetch(request);
|
|
220
|
+
return { error, abort };
|
|
221
|
+
});
|
|
222
|
+
await advance();
|
|
223
|
+
await failAttempt(0);
|
|
224
|
+
await advance(retryTime);
|
|
225
|
+
expect(calls).toHaveLength(2);
|
|
226
|
+
|
|
227
|
+
act(() => {
|
|
228
|
+
result.current.abort();
|
|
229
|
+
});
|
|
230
|
+
await advance(retryTime * 3);
|
|
231
|
+
|
|
232
|
+
expect(calls).toHaveLength(2);
|
|
233
|
+
});
|
|
234
|
+
});
|
|
235
|
+
});
|