@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.
- package/__tests__/features/helpers/use-request-events/use-request-events.async-mapper.spec.ts +243 -0
- 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.cancel.spec.ts +6 -3
- package/__tests__/features/use-fetch/use-fetch.debounce.spec.ts +72 -80
- 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.refresh.spec.ts +36 -13
- 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.utils.spec.ts +11 -2
- 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.base.spec.tsx +19 -9
- 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.concurrency.spec.ts +2 -1
- package/__tests__/features/use-submit/use-submit.debounce.spec.ts +100 -124
- 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 +8 -1
- package/__tests__/features/use-submit/use-submit.optimistic.spec.ts +5 -1
- package/__tests__/features/use-submit/use-submit.retry.spec.ts +51 -35
- 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__/features/use-submit/use-submit.unmount.spec.ts +2 -1
- 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/__tests__/utils/use-queue.utils.ts +8 -4
- 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 +633 -347
- 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 +147 -32
- 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
|
+
});
|
|
@@ -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
|
|
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
|
|
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
|
-
|
|
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
|
|
124
|
-
|
|
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
|
|
132
|
-
|
|
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
|
|
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
|
|
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
|
+
});
|