@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,364 @@
|
|
|
1
|
+
import { act, renderHook } from "@testing-library/react";
|
|
2
|
+
import type { UseFetchReturnType } from "hooks/use-fetch";
|
|
3
|
+
import { useFetch } from "hooks/use-fetch";
|
|
4
|
+
import { useEffect } from "react";
|
|
5
|
+
|
|
6
|
+
import { client, createRequest } from "../../utils";
|
|
7
|
+
import { advance, gateRequest, settle } from "../../utils/gate.utils";
|
|
8
|
+
|
|
9
|
+
type User = { id: number; name: string; tags: string[] };
|
|
10
|
+
type Request = ReturnType<typeof createRequest<User>>;
|
|
11
|
+
|
|
12
|
+
const user: User = { id: 1, name: "Maciej", tags: ["a", "b"] };
|
|
13
|
+
|
|
14
|
+
describe("useFetch [ Dependency Tracking ]", () => {
|
|
15
|
+
let request = createRequest<User>();
|
|
16
|
+
let calls = gateRequest(request);
|
|
17
|
+
|
|
18
|
+
/**
|
|
19
|
+
* Renders the hook reading only the picked fields and counts the renders.
|
|
20
|
+
* Requests are answered with gates, so the number of state changes - and renders - is exact by construction.
|
|
21
|
+
*/
|
|
22
|
+
const renderReading = <Picked,>(
|
|
23
|
+
pick: (state: UseFetchReturnType<Request>) => Picked,
|
|
24
|
+
options?: Parameters<typeof useFetch<Request>>[1],
|
|
25
|
+
) => {
|
|
26
|
+
const counter = { renders: 0 };
|
|
27
|
+
const view = renderHook(() => {
|
|
28
|
+
counter.renders += 1;
|
|
29
|
+
const state = useFetch(request, options);
|
|
30
|
+
return { picked: pick(state), refetch: state.refetch, setData: state.setData, setLoading: state.setLoading };
|
|
31
|
+
});
|
|
32
|
+
return { ...view, counter };
|
|
33
|
+
};
|
|
34
|
+
|
|
35
|
+
beforeEach(() => {
|
|
36
|
+
vi.useFakeTimers();
|
|
37
|
+
client.clear();
|
|
38
|
+
request = createRequest<User>();
|
|
39
|
+
calls = gateRequest(request);
|
|
40
|
+
});
|
|
41
|
+
|
|
42
|
+
afterEach(() => {
|
|
43
|
+
vi.useRealTimers();
|
|
44
|
+
});
|
|
45
|
+
|
|
46
|
+
describe("when the component reads only the data", () => {
|
|
47
|
+
it("should render once for mount and once for the response", async () => {
|
|
48
|
+
const { counter, result } = renderReading((state) => state.data);
|
|
49
|
+
await advance();
|
|
50
|
+
calls[0].succeed(user);
|
|
51
|
+
await settle();
|
|
52
|
+
|
|
53
|
+
expect(result.current.picked).toStrictEqual(user);
|
|
54
|
+
expect(counter.renders).toBe(2);
|
|
55
|
+
});
|
|
56
|
+
it("should not rerender when refetch brings the same data", async () => {
|
|
57
|
+
const { counter, result } = renderReading((state) => state.data);
|
|
58
|
+
await advance();
|
|
59
|
+
calls[0].succeed(user);
|
|
60
|
+
await settle();
|
|
61
|
+
|
|
62
|
+
act(() => {
|
|
63
|
+
result.current.refetch();
|
|
64
|
+
});
|
|
65
|
+
await advance();
|
|
66
|
+
calls[1].succeed({ ...user, tags: [...user.tags] });
|
|
67
|
+
await settle();
|
|
68
|
+
|
|
69
|
+
// Loading, timestamps and status changed, but they are not used by the component
|
|
70
|
+
expect(counter.renders).toBe(2);
|
|
71
|
+
});
|
|
72
|
+
it("should not rerender when the refetch fails", async () => {
|
|
73
|
+
const { counter, result } = renderReading((state) => state.data);
|
|
74
|
+
await advance();
|
|
75
|
+
calls[0].succeed(user);
|
|
76
|
+
await settle();
|
|
77
|
+
|
|
78
|
+
act(() => {
|
|
79
|
+
result.current.refetch();
|
|
80
|
+
});
|
|
81
|
+
await advance();
|
|
82
|
+
calls[1].fail();
|
|
83
|
+
await settle();
|
|
84
|
+
|
|
85
|
+
expect(counter.renders).toBe(2);
|
|
86
|
+
expect(result.current.picked).toStrictEqual(user);
|
|
87
|
+
});
|
|
88
|
+
it("should rerender when the data changes", async () => {
|
|
89
|
+
const { counter, result } = renderReading((state) => state.data);
|
|
90
|
+
await advance();
|
|
91
|
+
calls[0].succeed(user);
|
|
92
|
+
await settle();
|
|
93
|
+
|
|
94
|
+
act(() => {
|
|
95
|
+
result.current.refetch();
|
|
96
|
+
});
|
|
97
|
+
await advance();
|
|
98
|
+
calls[1].succeed({ ...user, name: "Changed" });
|
|
99
|
+
await settle();
|
|
100
|
+
|
|
101
|
+
expect(counter.renders).toBe(3);
|
|
102
|
+
expect(result.current.picked?.name).toBe("Changed");
|
|
103
|
+
});
|
|
104
|
+
it("should not rerender on local loading changes", async () => {
|
|
105
|
+
const { counter, result } = renderReading((state) => state.data);
|
|
106
|
+
await advance();
|
|
107
|
+
calls[0].succeed(user);
|
|
108
|
+
await settle();
|
|
109
|
+
|
|
110
|
+
act(() => {
|
|
111
|
+
result.current.setLoading(true);
|
|
112
|
+
});
|
|
113
|
+
|
|
114
|
+
expect(counter.renders).toBe(2);
|
|
115
|
+
});
|
|
116
|
+
});
|
|
117
|
+
|
|
118
|
+
describe("when the component reads only the loading state", () => {
|
|
119
|
+
it("should rerender only when loading changes", async () => {
|
|
120
|
+
const { counter, result } = renderReading((state) => state.loading);
|
|
121
|
+
await advance();
|
|
122
|
+
calls[0].succeed(user);
|
|
123
|
+
await settle();
|
|
124
|
+
expect(counter.renders).toBe(2);
|
|
125
|
+
|
|
126
|
+
act(() => {
|
|
127
|
+
result.current.refetch();
|
|
128
|
+
});
|
|
129
|
+
await advance();
|
|
130
|
+
expect(result.current.picked).toBeTrue();
|
|
131
|
+
expect(counter.renders).toBe(3);
|
|
132
|
+
|
|
133
|
+
calls[1].succeed({ ...user, name: "Changed" });
|
|
134
|
+
await settle();
|
|
135
|
+
expect(result.current.picked).toBeFalse();
|
|
136
|
+
expect(counter.renders).toBe(4);
|
|
137
|
+
});
|
|
138
|
+
it("should not rerender on local data changes", async () => {
|
|
139
|
+
const { counter, result } = renderReading((state) => state.loading);
|
|
140
|
+
await advance();
|
|
141
|
+
calls[0].succeed(user);
|
|
142
|
+
await settle();
|
|
143
|
+
|
|
144
|
+
act(() => {
|
|
145
|
+
result.current.setData({ ...user, name: "Local" });
|
|
146
|
+
});
|
|
147
|
+
|
|
148
|
+
expect(counter.renders).toBe(2);
|
|
149
|
+
});
|
|
150
|
+
});
|
|
151
|
+
|
|
152
|
+
describe("when the component reads only the error", () => {
|
|
153
|
+
it("should not rerender for successful responses", async () => {
|
|
154
|
+
const { counter } = renderReading((state) => state.error);
|
|
155
|
+
await advance();
|
|
156
|
+
calls[0].succeed(user);
|
|
157
|
+
await settle();
|
|
158
|
+
|
|
159
|
+
expect(counter.renders).toBe(1);
|
|
160
|
+
});
|
|
161
|
+
it("should rerender when the error appears", async () => {
|
|
162
|
+
const { counter, result } = renderReading((state) => state.error);
|
|
163
|
+
await advance();
|
|
164
|
+
calls[0].fail(new Error("Failed"));
|
|
165
|
+
await settle();
|
|
166
|
+
|
|
167
|
+
expect(counter.renders).toBe(2);
|
|
168
|
+
expect(result.current.picked?.message).toBe("Failed");
|
|
169
|
+
});
|
|
170
|
+
});
|
|
171
|
+
|
|
172
|
+
describe("when the component reads no state", () => {
|
|
173
|
+
it("should not rerender at all", async () => {
|
|
174
|
+
const { counter, result } = renderReading(() => null);
|
|
175
|
+
await advance();
|
|
176
|
+
calls[0].succeed(user);
|
|
177
|
+
await settle();
|
|
178
|
+
act(() => {
|
|
179
|
+
result.current.refetch();
|
|
180
|
+
});
|
|
181
|
+
await advance();
|
|
182
|
+
calls[1].fail();
|
|
183
|
+
await settle();
|
|
184
|
+
|
|
185
|
+
expect(counter.renders).toBe(1);
|
|
186
|
+
});
|
|
187
|
+
});
|
|
188
|
+
|
|
189
|
+
describe("when dependency tracking is off", () => {
|
|
190
|
+
it("should rerender for the changes of unused fields", async () => {
|
|
191
|
+
const { counter, result } = renderReading((state) => state.data, { dependencyTracking: false });
|
|
192
|
+
await advance();
|
|
193
|
+
calls[0].succeed(user);
|
|
194
|
+
await settle();
|
|
195
|
+
const rendersAfterResponse = counter.renders;
|
|
196
|
+
|
|
197
|
+
act(() => {
|
|
198
|
+
result.current.setLoading(true);
|
|
199
|
+
});
|
|
200
|
+
|
|
201
|
+
expect(counter.renders).toBe(rendersAfterResponse + 1);
|
|
202
|
+
});
|
|
203
|
+
});
|
|
204
|
+
|
|
205
|
+
describe("when the data comes back unchanged", () => {
|
|
206
|
+
it("should keep the references of the data and its nested parts", async () => {
|
|
207
|
+
const { result } = renderReading((state) => state.data);
|
|
208
|
+
await advance();
|
|
209
|
+
calls[0].succeed(user);
|
|
210
|
+
await settle();
|
|
211
|
+
const first = result.current.picked;
|
|
212
|
+
|
|
213
|
+
act(() => {
|
|
214
|
+
result.current.refetch();
|
|
215
|
+
});
|
|
216
|
+
await advance();
|
|
217
|
+
calls[1].succeed({ ...user, name: "Changed", tags: [...user.tags] });
|
|
218
|
+
await settle();
|
|
219
|
+
|
|
220
|
+
expect(result.current.picked).not.toBe(first);
|
|
221
|
+
expect(result.current.picked?.tags).toBe(first?.tags);
|
|
222
|
+
});
|
|
223
|
+
it("should not rerun the effects depending on the data", async () => {
|
|
224
|
+
const effect = vi.fn();
|
|
225
|
+
const { result } = renderHook(() => {
|
|
226
|
+
const { data, loading, refetch } = useFetch(request);
|
|
227
|
+
useEffect(() => {
|
|
228
|
+
effect(data);
|
|
229
|
+
}, [data]);
|
|
230
|
+
return { loading, refetch };
|
|
231
|
+
});
|
|
232
|
+
await advance();
|
|
233
|
+
calls[0].succeed(user);
|
|
234
|
+
await settle();
|
|
235
|
+
expect(effect).toHaveBeenCalledTimes(2);
|
|
236
|
+
|
|
237
|
+
act(() => {
|
|
238
|
+
result.current.refetch();
|
|
239
|
+
});
|
|
240
|
+
await advance();
|
|
241
|
+
calls[1].succeed({ ...user });
|
|
242
|
+
await settle();
|
|
243
|
+
|
|
244
|
+
expect(result.current.loading).toBeFalse();
|
|
245
|
+
expect(effect).toHaveBeenCalledTimes(2);
|
|
246
|
+
});
|
|
247
|
+
});
|
|
248
|
+
|
|
249
|
+
describe("when the returned functions are used as dependencies", () => {
|
|
250
|
+
const functionNames = [
|
|
251
|
+
"refetch",
|
|
252
|
+
"abort",
|
|
253
|
+
"setData",
|
|
254
|
+
"setError",
|
|
255
|
+
"setLoading",
|
|
256
|
+
"setStatus",
|
|
257
|
+
"setSuccess",
|
|
258
|
+
"setExtra",
|
|
259
|
+
"setRetries",
|
|
260
|
+
"setResponseTimestamp",
|
|
261
|
+
"setRequestTimestamp",
|
|
262
|
+
"clearState",
|
|
263
|
+
"onSuccess",
|
|
264
|
+
"onError",
|
|
265
|
+
"onAbort",
|
|
266
|
+
"onOfflineError",
|
|
267
|
+
"onFinished",
|
|
268
|
+
"onRequestStart",
|
|
269
|
+
"onResponseStart",
|
|
270
|
+
"onDownloadProgress",
|
|
271
|
+
"onUploadProgress",
|
|
272
|
+
] as const;
|
|
273
|
+
|
|
274
|
+
it.each(functionNames)("should keep the identity of %s between renders", async (name) => {
|
|
275
|
+
const identities = new Set<unknown>();
|
|
276
|
+
const { rerender } = renderHook(() => {
|
|
277
|
+
const state = useFetch(request);
|
|
278
|
+
identities.add(state[name]);
|
|
279
|
+
return state.data;
|
|
280
|
+
});
|
|
281
|
+
await advance();
|
|
282
|
+
calls[0].succeed(user);
|
|
283
|
+
await settle();
|
|
284
|
+
rerender();
|
|
285
|
+
|
|
286
|
+
expect(identities.size).toBe(1);
|
|
287
|
+
});
|
|
288
|
+
it("should not loop when refetch is called from an effect depending on it", async () => {
|
|
289
|
+
renderHook(() => {
|
|
290
|
+
const { data, loading, refetch } = useFetch(request, { disabled: false });
|
|
291
|
+
useEffect(() => {
|
|
292
|
+
refetch();
|
|
293
|
+
}, [refetch]);
|
|
294
|
+
return { data, loading };
|
|
295
|
+
});
|
|
296
|
+
await advance();
|
|
297
|
+
calls.forEach((call) => call.succeed(user));
|
|
298
|
+
await settle();
|
|
299
|
+
await advance(1000);
|
|
300
|
+
|
|
301
|
+
// Initial request and the single effect call
|
|
302
|
+
expect(calls).toHaveLength(2);
|
|
303
|
+
});
|
|
304
|
+
it("should refetch the current request with the stable refetch function", async () => {
|
|
305
|
+
const { result, rerender } = renderHook(
|
|
306
|
+
({ page }) => {
|
|
307
|
+
const { data, refetch } = useFetch(request.setQueryParams({ page }));
|
|
308
|
+
return { data, refetch };
|
|
309
|
+
},
|
|
310
|
+
{ initialProps: { page: 1 } },
|
|
311
|
+
);
|
|
312
|
+
const initialRefetch = result.current.refetch;
|
|
313
|
+
await advance();
|
|
314
|
+
rerender({ page: 2 });
|
|
315
|
+
await advance();
|
|
316
|
+
calls.forEach((call) => call.succeed(user));
|
|
317
|
+
await settle();
|
|
318
|
+
|
|
319
|
+
act(() => {
|
|
320
|
+
initialRefetch();
|
|
321
|
+
});
|
|
322
|
+
await advance();
|
|
323
|
+
|
|
324
|
+
expect(calls).toHaveLength(3);
|
|
325
|
+
expect(calls[2].request.queryParams).toStrictEqual({ page: 2 });
|
|
326
|
+
});
|
|
327
|
+
});
|
|
328
|
+
|
|
329
|
+
describe("when local state setters get function updaters", () => {
|
|
330
|
+
it("should pass falsy previous data to the updater", async () => {
|
|
331
|
+
const numberRequest = createRequest<number>();
|
|
332
|
+
gateRequest(numberRequest);
|
|
333
|
+
const updater = vi.fn((previous: number | null) => (previous ?? -1) + 1);
|
|
334
|
+
const { result } = renderHook(() => {
|
|
335
|
+
const { data, setData } = useFetch(numberRequest, { disabled: true });
|
|
336
|
+
return { data, setData };
|
|
337
|
+
});
|
|
338
|
+
|
|
339
|
+
act(() => {
|
|
340
|
+
result.current.setData(0);
|
|
341
|
+
});
|
|
342
|
+
act(() => {
|
|
343
|
+
result.current.setData(updater);
|
|
344
|
+
});
|
|
345
|
+
|
|
346
|
+
expect(updater).toHaveBeenCalledWith(0);
|
|
347
|
+
expect(result.current.data).toBe(1);
|
|
348
|
+
});
|
|
349
|
+
it("should call the updater once", async () => {
|
|
350
|
+
const updater = vi.fn((previous: number | null) => (previous ?? 0) + 1);
|
|
351
|
+
const { result } = renderHook(() => {
|
|
352
|
+
const { retries, setRetries } = useFetch(request, { disabled: true });
|
|
353
|
+
return { retries, setRetries };
|
|
354
|
+
});
|
|
355
|
+
|
|
356
|
+
act(() => {
|
|
357
|
+
result.current.setRetries(updater);
|
|
358
|
+
});
|
|
359
|
+
|
|
360
|
+
expect(updater).toHaveBeenCalledOnce();
|
|
361
|
+
expect(result.current.retries).toBe(1);
|
|
362
|
+
});
|
|
363
|
+
});
|
|
364
|
+
});
|
|
@@ -2,13 +2,22 @@ import { getRefreshTime } from "hooks/use-fetch";
|
|
|
2
2
|
|
|
3
3
|
describe("useFetch [ Utils ]", () => {
|
|
4
4
|
const refreshTime = 1000;
|
|
5
|
+
|
|
6
|
+
// getRefreshTime reads Date.now(), so freeze it to make the elapsed time exact
|
|
7
|
+
beforeEach(() => {
|
|
8
|
+
vi.useFakeTimers({ toFake: ["Date"] });
|
|
9
|
+
});
|
|
10
|
+
|
|
11
|
+
afterEach(() => {
|
|
12
|
+
vi.useRealTimers();
|
|
13
|
+
});
|
|
14
|
+
|
|
5
15
|
describe("given using getRefreshTime util", () => {
|
|
6
16
|
describe("when state is available", () => {
|
|
7
17
|
it("should give the reduced refresh time based on timestamp", async () => {
|
|
8
18
|
const timestamp = new Date(Date.now() - 500);
|
|
9
19
|
const time = getRefreshTime(refreshTime, timestamp);
|
|
10
|
-
expect(time).
|
|
11
|
-
expect(time).toBeGreaterThanOrEqual(490);
|
|
20
|
+
expect(time).toBe(500);
|
|
12
21
|
});
|
|
13
22
|
it("should give refreshTime on old timestamp", async () => {
|
|
14
23
|
const timestamp = new Date(Date.now() - refreshTime);
|
|
@@ -0,0 +1,300 @@
|
|
|
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
|
+
describe("useFetch [ Window Events ]", () => {
|
|
13
|
+
let request = createRequest<Data>();
|
|
14
|
+
let calls = gateRequest(request);
|
|
15
|
+
|
|
16
|
+
const renderEvents = (options?: Options, wrapper?: typeof StrictMode) => {
|
|
17
|
+
return renderHook(
|
|
18
|
+
(props: Options) => {
|
|
19
|
+
const { data, loading } = useFetch(request, { ...options, ...props } as Options);
|
|
20
|
+
return { data, loading };
|
|
21
|
+
},
|
|
22
|
+
{ initialProps: {}, wrapper },
|
|
23
|
+
);
|
|
24
|
+
};
|
|
25
|
+
|
|
26
|
+
const finishInitialRequest = async () => {
|
|
27
|
+
await advance();
|
|
28
|
+
calls[0].succeed({ value: 0 });
|
|
29
|
+
await settle();
|
|
30
|
+
};
|
|
31
|
+
|
|
32
|
+
const focus = () => act(() => client.appManager.setFocused(true));
|
|
33
|
+
const blur = () => act(() => client.appManager.setFocused(false));
|
|
34
|
+
const goOnline = () => act(() => client.appManager.setOnline(true));
|
|
35
|
+
const goOffline = () => act(() => client.appManager.setOnline(false));
|
|
36
|
+
|
|
37
|
+
beforeEach(() => {
|
|
38
|
+
vi.useFakeTimers();
|
|
39
|
+
client.clear();
|
|
40
|
+
request = createRequest<Data>();
|
|
41
|
+
calls = gateRequest(request);
|
|
42
|
+
});
|
|
43
|
+
|
|
44
|
+
afterEach(() => {
|
|
45
|
+
vi.useRealTimers();
|
|
46
|
+
});
|
|
47
|
+
|
|
48
|
+
describe("when the window gets focused", () => {
|
|
49
|
+
it("should not refetch by default", async () => {
|
|
50
|
+
renderEvents();
|
|
51
|
+
await finishInitialRequest();
|
|
52
|
+
|
|
53
|
+
focus();
|
|
54
|
+
await advance();
|
|
55
|
+
|
|
56
|
+
expect(calls).toHaveLength(1);
|
|
57
|
+
});
|
|
58
|
+
it("should refetch with refetchOnFocus", async () => {
|
|
59
|
+
const { result } = renderEvents({ refetchOnFocus: true });
|
|
60
|
+
await finishInitialRequest();
|
|
61
|
+
|
|
62
|
+
focus();
|
|
63
|
+
await advance();
|
|
64
|
+
|
|
65
|
+
expect(calls).toHaveLength(2);
|
|
66
|
+
expect(result.current.loading).toBeTrue();
|
|
67
|
+
expect(result.current.data).toStrictEqual({ value: 0 });
|
|
68
|
+
});
|
|
69
|
+
it("should refetch once per focus event", async () => {
|
|
70
|
+
renderEvents({ refetchOnFocus: true });
|
|
71
|
+
await finishInitialRequest();
|
|
72
|
+
|
|
73
|
+
focus();
|
|
74
|
+
await advance();
|
|
75
|
+
calls[1].succeed({ value: 1 });
|
|
76
|
+
await settle();
|
|
77
|
+
focus();
|
|
78
|
+
await advance();
|
|
79
|
+
|
|
80
|
+
expect(calls).toHaveLength(3);
|
|
81
|
+
});
|
|
82
|
+
it("should join the running request instead of sending another one", async () => {
|
|
83
|
+
renderEvents({ refetchOnFocus: true });
|
|
84
|
+
await advance();
|
|
85
|
+
|
|
86
|
+
focus();
|
|
87
|
+
focus();
|
|
88
|
+
await advance();
|
|
89
|
+
|
|
90
|
+
expect(calls).toHaveLength(1);
|
|
91
|
+
});
|
|
92
|
+
it("should refetch once in StrictMode", async () => {
|
|
93
|
+
renderEvents({ refetchOnFocus: true }, StrictMode);
|
|
94
|
+
await finishInitialRequest();
|
|
95
|
+
|
|
96
|
+
focus();
|
|
97
|
+
await advance();
|
|
98
|
+
|
|
99
|
+
expect(calls).toHaveLength(2);
|
|
100
|
+
});
|
|
101
|
+
it("should not refetch when disabled", async () => {
|
|
102
|
+
renderEvents({ refetchOnFocus: true, disabled: true });
|
|
103
|
+
await advance();
|
|
104
|
+
|
|
105
|
+
focus();
|
|
106
|
+
await advance();
|
|
107
|
+
|
|
108
|
+
expect(calls).toHaveLength(0);
|
|
109
|
+
});
|
|
110
|
+
it("should start refetching once refetchOnFocus gets turned on", async () => {
|
|
111
|
+
const { rerender } = renderEvents({ refetchOnFocus: false });
|
|
112
|
+
await finishInitialRequest();
|
|
113
|
+
|
|
114
|
+
rerender({ refetchOnFocus: true });
|
|
115
|
+
focus();
|
|
116
|
+
await advance();
|
|
117
|
+
|
|
118
|
+
expect(calls).toHaveLength(2);
|
|
119
|
+
});
|
|
120
|
+
it("should stop refetching once refetchOnFocus gets turned off", async () => {
|
|
121
|
+
const { rerender } = renderEvents({ refetchOnFocus: true });
|
|
122
|
+
await finishInitialRequest();
|
|
123
|
+
|
|
124
|
+
rerender({ refetchOnFocus: false });
|
|
125
|
+
focus();
|
|
126
|
+
await advance();
|
|
127
|
+
|
|
128
|
+
expect(calls).toHaveLength(1);
|
|
129
|
+
});
|
|
130
|
+
it("should stop refetching once the hook gets disabled", async () => {
|
|
131
|
+
const { rerender } = renderEvents({ refetchOnFocus: true });
|
|
132
|
+
await finishInitialRequest();
|
|
133
|
+
|
|
134
|
+
rerender({ disabled: true });
|
|
135
|
+
focus();
|
|
136
|
+
await advance();
|
|
137
|
+
|
|
138
|
+
expect(calls).toHaveLength(1);
|
|
139
|
+
});
|
|
140
|
+
it("should refetch the current request after the key change", async () => {
|
|
141
|
+
const { rerender } = renderHook(
|
|
142
|
+
({ page }) => useFetch(request.setQueryParams({ page }), { refetchOnFocus: true }).data,
|
|
143
|
+
{ initialProps: { page: 1 } },
|
|
144
|
+
);
|
|
145
|
+
await advance();
|
|
146
|
+
rerender({ page: 2 });
|
|
147
|
+
await advance();
|
|
148
|
+
calls.forEach((call) => call.succeed({ value: 0 }));
|
|
149
|
+
await settle();
|
|
150
|
+
|
|
151
|
+
focus();
|
|
152
|
+
await advance();
|
|
153
|
+
|
|
154
|
+
expect(calls).toHaveLength(3);
|
|
155
|
+
expect(calls[2].request.queryParams).toStrictEqual({ page: 2 });
|
|
156
|
+
});
|
|
157
|
+
it("should not refetch after unmount", async () => {
|
|
158
|
+
const { unmount } = renderEvents({ refetchOnFocus: true });
|
|
159
|
+
await finishInitialRequest();
|
|
160
|
+
|
|
161
|
+
unmount();
|
|
162
|
+
focus();
|
|
163
|
+
await advance();
|
|
164
|
+
|
|
165
|
+
expect(calls).toHaveLength(1);
|
|
166
|
+
});
|
|
167
|
+
it("should restart the refresh countdown", async () => {
|
|
168
|
+
renderEvents({ refetchOnFocus: true, refresh: true, refreshTime: 10_000 });
|
|
169
|
+
await finishInitialRequest();
|
|
170
|
+
|
|
171
|
+
await advance(9000);
|
|
172
|
+
focus();
|
|
173
|
+
await advance();
|
|
174
|
+
calls[1].succeed({ value: 1 });
|
|
175
|
+
await settle();
|
|
176
|
+
|
|
177
|
+
await advance(9000);
|
|
178
|
+
expect(calls).toHaveLength(2);
|
|
179
|
+
|
|
180
|
+
await advance(1000);
|
|
181
|
+
expect(calls).toHaveLength(3);
|
|
182
|
+
});
|
|
183
|
+
});
|
|
184
|
+
|
|
185
|
+
describe("when the window gets blurred", () => {
|
|
186
|
+
it("should not refetch by default", async () => {
|
|
187
|
+
renderEvents();
|
|
188
|
+
await finishInitialRequest();
|
|
189
|
+
|
|
190
|
+
blur();
|
|
191
|
+
await advance();
|
|
192
|
+
|
|
193
|
+
expect(calls).toHaveLength(1);
|
|
194
|
+
});
|
|
195
|
+
it("should refetch with refetchOnBlur", async () => {
|
|
196
|
+
renderEvents({ refetchOnBlur: true });
|
|
197
|
+
await finishInitialRequest();
|
|
198
|
+
|
|
199
|
+
blur();
|
|
200
|
+
await advance();
|
|
201
|
+
|
|
202
|
+
expect(calls).toHaveLength(2);
|
|
203
|
+
});
|
|
204
|
+
it("should not refetch on focus with only refetchOnBlur", async () => {
|
|
205
|
+
renderEvents({ refetchOnBlur: true });
|
|
206
|
+
await finishInitialRequest();
|
|
207
|
+
|
|
208
|
+
focus();
|
|
209
|
+
await advance();
|
|
210
|
+
|
|
211
|
+
expect(calls).toHaveLength(1);
|
|
212
|
+
});
|
|
213
|
+
it("should start refetching once refetchOnBlur gets turned on", async () => {
|
|
214
|
+
const { rerender } = renderEvents();
|
|
215
|
+
await finishInitialRequest();
|
|
216
|
+
|
|
217
|
+
rerender({ refetchOnBlur: true });
|
|
218
|
+
blur();
|
|
219
|
+
await advance();
|
|
220
|
+
|
|
221
|
+
expect(calls).toHaveLength(2);
|
|
222
|
+
});
|
|
223
|
+
it("should not refetch when disabled", async () => {
|
|
224
|
+
renderEvents({ refetchOnBlur: true, disabled: true });
|
|
225
|
+
await advance();
|
|
226
|
+
|
|
227
|
+
blur();
|
|
228
|
+
await advance();
|
|
229
|
+
|
|
230
|
+
expect(calls).toHaveLength(0);
|
|
231
|
+
});
|
|
232
|
+
});
|
|
233
|
+
|
|
234
|
+
describe("when the connection is restored", () => {
|
|
235
|
+
it("should not refetch by default", async () => {
|
|
236
|
+
renderEvents();
|
|
237
|
+
await finishInitialRequest();
|
|
238
|
+
|
|
239
|
+
goOffline();
|
|
240
|
+
goOnline();
|
|
241
|
+
await advance();
|
|
242
|
+
|
|
243
|
+
expect(calls).toHaveLength(1);
|
|
244
|
+
});
|
|
245
|
+
it("should refetch with refetchOnReconnect", async () => {
|
|
246
|
+
renderEvents({ refetchOnReconnect: true });
|
|
247
|
+
await finishInitialRequest();
|
|
248
|
+
|
|
249
|
+
goOffline();
|
|
250
|
+
goOnline();
|
|
251
|
+
await advance();
|
|
252
|
+
|
|
253
|
+
expect(calls).toHaveLength(2);
|
|
254
|
+
});
|
|
255
|
+
it("should not refetch when going offline", async () => {
|
|
256
|
+
renderEvents({ refetchOnReconnect: true });
|
|
257
|
+
await finishInitialRequest();
|
|
258
|
+
|
|
259
|
+
goOffline();
|
|
260
|
+
await advance();
|
|
261
|
+
|
|
262
|
+
expect(calls).toHaveLength(1);
|
|
263
|
+
});
|
|
264
|
+
it("should start refetching once refetchOnReconnect gets turned on", async () => {
|
|
265
|
+
const { rerender } = renderEvents();
|
|
266
|
+
await finishInitialRequest();
|
|
267
|
+
|
|
268
|
+
rerender({ refetchOnReconnect: true });
|
|
269
|
+
goOffline();
|
|
270
|
+
goOnline();
|
|
271
|
+
await advance();
|
|
272
|
+
|
|
273
|
+
expect(calls).toHaveLength(2);
|
|
274
|
+
});
|
|
275
|
+
it("should not refetch when disabled", async () => {
|
|
276
|
+
renderEvents({ refetchOnReconnect: true, disabled: true });
|
|
277
|
+
await advance();
|
|
278
|
+
|
|
279
|
+
goOffline();
|
|
280
|
+
goOnline();
|
|
281
|
+
await advance();
|
|
282
|
+
|
|
283
|
+
expect(calls).toHaveLength(0);
|
|
284
|
+
});
|
|
285
|
+
it("should send the request mounted offline once online", async () => {
|
|
286
|
+
goOffline();
|
|
287
|
+
const { result } = renderEvents();
|
|
288
|
+
await advance();
|
|
289
|
+
expect(calls).toHaveLength(0);
|
|
290
|
+
|
|
291
|
+
goOnline();
|
|
292
|
+
await advance();
|
|
293
|
+
calls[0].succeed({ value: 1 });
|
|
294
|
+
await settle();
|
|
295
|
+
|
|
296
|
+
expect(calls).toHaveLength(1);
|
|
297
|
+
expect(result.current.data).toStrictEqual({ value: 1 });
|
|
298
|
+
});
|
|
299
|
+
});
|
|
300
|
+
});
|