@hyper-fetch/react 9.6.0 → 9.6.1
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/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.refresh.spec.ts +36 -13
- package/__tests__/features/use-fetch/use-fetch.utils.spec.ts +11 -2
- package/__tests__/features/use-is-fetching/use-is-fetching.base.spec.tsx +19 -9
- 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.optimistic-settlement.spec.ts +2 -1
- package/__tests__/features/use-submit/use-submit.retry.spec.ts +51 -35
- package/__tests__/features/use-submit/use-submit.unmount.spec.ts +2 -1
- 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/index.mjs +3 -1
- package/dist/index.mjs.map +1 -1
- package/package.json +1 -1
- package/src/helpers/use-request-events/use-request-events.hooks.ts +6 -4
|
@@ -0,0 +1,243 @@
|
|
|
1
|
+
import type { OptimisticRollbackArgs, RequestInstance } from "@hyper-fetch/core";
|
|
2
|
+
import { Client } from "@hyper-fetch/core";
|
|
3
|
+
import { createHttpMockingServer } from "@hyper-fetch/testing";
|
|
4
|
+
import { act, renderHook, waitFor } from "@testing-library/react";
|
|
5
|
+
import { useFetch } from "hooks/use-fetch";
|
|
6
|
+
import { useSubmit } from "hooks/use-submit";
|
|
7
|
+
import { StrictMode } from "react";
|
|
8
|
+
|
|
9
|
+
const { resetMocks, startServer, stopServer, mockRequest } = createHttpMockingServer();
|
|
10
|
+
|
|
11
|
+
type Data = { ok: boolean; mapped?: boolean };
|
|
12
|
+
|
|
13
|
+
/**
|
|
14
|
+
* Async response mapper which resolves only once the test releases it
|
|
15
|
+
*/
|
|
16
|
+
const createGatedMapper = () => {
|
|
17
|
+
let release: () => void = () => undefined;
|
|
18
|
+
const gate = new Promise<void>((resolve) => {
|
|
19
|
+
release = resolve;
|
|
20
|
+
});
|
|
21
|
+
const calls = vi.fn();
|
|
22
|
+
|
|
23
|
+
// Mapping keeps the response type, so the request and its mocks stay typed with `Data`
|
|
24
|
+
const mapper = async <Response extends { data: Data | null }>(response: Response): Promise<Response> => {
|
|
25
|
+
calls();
|
|
26
|
+
await gate;
|
|
27
|
+
const data: Data | null = response.data ? { ...response.data, mapped: true } : null;
|
|
28
|
+
return { ...response, data };
|
|
29
|
+
};
|
|
30
|
+
|
|
31
|
+
return { mapper, calls, release };
|
|
32
|
+
};
|
|
33
|
+
|
|
34
|
+
/**
|
|
35
|
+
* The hook delivers callbacks in a promise continuation of the mapper - after a macrotask all of them have run
|
|
36
|
+
*/
|
|
37
|
+
const flushPromises = () =>
|
|
38
|
+
new Promise<void>((resolve) => {
|
|
39
|
+
setTimeout(resolve, 0);
|
|
40
|
+
});
|
|
41
|
+
|
|
42
|
+
const createSetup = () => {
|
|
43
|
+
const client = new Client({ url: "shared-base-url" });
|
|
44
|
+
const list = client.createRequest<{ response: string[] }>()({ endpoint: "/list" });
|
|
45
|
+
const rollback = vi.fn((_args: OptimisticRollbackArgs<RequestInstance>) => undefined);
|
|
46
|
+
const invalidate = vi.spyOn(client.cache, "invalidate");
|
|
47
|
+
const gated = createGatedMapper();
|
|
48
|
+
|
|
49
|
+
const fetchRequest = client
|
|
50
|
+
.createRequest<{ response: Data }>()({ endpoint: "/fetch" })
|
|
51
|
+
.setResponseMapper(gated.mapper);
|
|
52
|
+
const submitRequest = client
|
|
53
|
+
.createRequest<{ response: Data }>()({ endpoint: "/submit", method: "POST" })
|
|
54
|
+
.setOptimistic(() => ({ rollback, invalidate: [list] }))
|
|
55
|
+
.setResponseMapper(gated.mapper);
|
|
56
|
+
|
|
57
|
+
return { client, list, rollback, invalidate, fetchRequest, submitRequest, ...gated };
|
|
58
|
+
};
|
|
59
|
+
|
|
60
|
+
const modes = [
|
|
61
|
+
{ mode: "default", wrapper: undefined },
|
|
62
|
+
{ mode: "StrictMode", wrapper: StrictMode },
|
|
63
|
+
];
|
|
64
|
+
|
|
65
|
+
describe("useRequestEvents [ Async response mapper ]", () => {
|
|
66
|
+
beforeAll(() => {
|
|
67
|
+
startServer();
|
|
68
|
+
});
|
|
69
|
+
|
|
70
|
+
afterEach(() => {
|
|
71
|
+
resetMocks();
|
|
72
|
+
});
|
|
73
|
+
|
|
74
|
+
afterAll(() => {
|
|
75
|
+
stopServer();
|
|
76
|
+
});
|
|
77
|
+
|
|
78
|
+
describe.each(modes)("when rendered in $mode", ({ wrapper }) => {
|
|
79
|
+
const renderSubmit = (request: ReturnType<typeof createSetup>["submitRequest"]) => {
|
|
80
|
+
const callbacks = { onSuccess: vi.fn(), onError: vi.fn(), onFinished: vi.fn() };
|
|
81
|
+
const view = renderHook(() => useSubmit(request), { wrapper });
|
|
82
|
+
|
|
83
|
+
act(() => {
|
|
84
|
+
view.result.current.onSubmitSuccess(callbacks.onSuccess);
|
|
85
|
+
view.result.current.onSubmitError(callbacks.onError);
|
|
86
|
+
view.result.current.onSubmitFinished(callbacks.onFinished);
|
|
87
|
+
});
|
|
88
|
+
|
|
89
|
+
return { ...view, callbacks };
|
|
90
|
+
};
|
|
91
|
+
|
|
92
|
+
const renderFetch = (request: ReturnType<typeof createSetup>["fetchRequest"]) => {
|
|
93
|
+
const callbacks = { onSuccess: vi.fn(), onError: vi.fn(), onFinished: vi.fn() };
|
|
94
|
+
const view = renderHook(() => useFetch(request), { wrapper });
|
|
95
|
+
|
|
96
|
+
act(() => {
|
|
97
|
+
view.result.current.onSuccess(callbacks.onSuccess);
|
|
98
|
+
view.result.current.onError(callbacks.onError);
|
|
99
|
+
view.result.current.onFinished(callbacks.onFinished);
|
|
100
|
+
});
|
|
101
|
+
|
|
102
|
+
return { ...view, callbacks };
|
|
103
|
+
};
|
|
104
|
+
|
|
105
|
+
describe("when useSubmit unmounts while the mapper is pending", () => {
|
|
106
|
+
it("should fire no callback and invalidate once after success", async () => {
|
|
107
|
+
const setup = createSetup();
|
|
108
|
+
mockRequest(setup.submitRequest, { data: { ok: true } });
|
|
109
|
+
const { result, unmount, callbacks } = renderSubmit(setup.submitRequest);
|
|
110
|
+
let pending: ReturnType<typeof result.current.submit> | undefined;
|
|
111
|
+
|
|
112
|
+
act(() => {
|
|
113
|
+
pending = result.current.submit();
|
|
114
|
+
});
|
|
115
|
+
await waitFor(() => {
|
|
116
|
+
expect(setup.calls).toHaveBeenCalled();
|
|
117
|
+
});
|
|
118
|
+
unmount();
|
|
119
|
+
setup.release();
|
|
120
|
+
const response = await pending;
|
|
121
|
+
await flushPromises();
|
|
122
|
+
|
|
123
|
+
expect(response?.data).toStrictEqual({ ok: true, mapped: true });
|
|
124
|
+
expect(callbacks.onSuccess).not.toHaveBeenCalled();
|
|
125
|
+
expect(callbacks.onError).not.toHaveBeenCalled();
|
|
126
|
+
expect(callbacks.onFinished).not.toHaveBeenCalled();
|
|
127
|
+
expect(setup.invalidate).toHaveBeenCalledTimes(1);
|
|
128
|
+
expect(setup.invalidate).toHaveBeenCalledWith(setup.list);
|
|
129
|
+
expect(setup.rollback).not.toHaveBeenCalled();
|
|
130
|
+
});
|
|
131
|
+
|
|
132
|
+
it("should fire no callback and roll back once after error", async () => {
|
|
133
|
+
const setup = createSetup();
|
|
134
|
+
mockRequest(setup.submitRequest, { status: 400 });
|
|
135
|
+
const { result, unmount, callbacks } = renderSubmit(setup.submitRequest);
|
|
136
|
+
let pending: ReturnType<typeof result.current.submit> | undefined;
|
|
137
|
+
|
|
138
|
+
act(() => {
|
|
139
|
+
pending = result.current.submit();
|
|
140
|
+
});
|
|
141
|
+
await waitFor(() => {
|
|
142
|
+
expect(setup.calls).toHaveBeenCalled();
|
|
143
|
+
});
|
|
144
|
+
unmount();
|
|
145
|
+
setup.release();
|
|
146
|
+
const response = await pending;
|
|
147
|
+
await flushPromises();
|
|
148
|
+
|
|
149
|
+
expect(response?.status).toBe(400);
|
|
150
|
+
expect(callbacks.onSuccess).not.toHaveBeenCalled();
|
|
151
|
+
expect(callbacks.onError).not.toHaveBeenCalled();
|
|
152
|
+
expect(callbacks.onFinished).not.toHaveBeenCalled();
|
|
153
|
+
expect(setup.rollback).toHaveBeenCalledTimes(1);
|
|
154
|
+
expect(setup.rollback.mock.calls[0][0].reason).toBe("error");
|
|
155
|
+
expect(setup.invalidate).not.toHaveBeenCalled();
|
|
156
|
+
});
|
|
157
|
+
});
|
|
158
|
+
|
|
159
|
+
describe("when useSubmit stays mounted", () => {
|
|
160
|
+
it("should fire callbacks once with the mapped response", async () => {
|
|
161
|
+
const setup = createSetup();
|
|
162
|
+
mockRequest(setup.submitRequest, { data: { ok: true } });
|
|
163
|
+
const { result, callbacks } = renderSubmit(setup.submitRequest);
|
|
164
|
+
let pending: ReturnType<typeof result.current.submit> | undefined;
|
|
165
|
+
|
|
166
|
+
act(() => {
|
|
167
|
+
pending = result.current.submit();
|
|
168
|
+
});
|
|
169
|
+
await waitFor(() => {
|
|
170
|
+
expect(setup.calls).toHaveBeenCalled();
|
|
171
|
+
});
|
|
172
|
+
setup.release();
|
|
173
|
+
await act(async () => {
|
|
174
|
+
await pending;
|
|
175
|
+
});
|
|
176
|
+
|
|
177
|
+
await waitFor(() => {
|
|
178
|
+
expect(callbacks.onSuccess).toHaveBeenCalledTimes(1);
|
|
179
|
+
});
|
|
180
|
+
expect(callbacks.onSuccess.mock.calls[0][0].response.data).toStrictEqual({ ok: true, mapped: true });
|
|
181
|
+
expect(callbacks.onFinished).toHaveBeenCalledTimes(1);
|
|
182
|
+
expect(callbacks.onError).not.toHaveBeenCalled();
|
|
183
|
+
expect(setup.invalidate).toHaveBeenCalledTimes(1);
|
|
184
|
+
});
|
|
185
|
+
});
|
|
186
|
+
|
|
187
|
+
describe("when useFetch unmounts while the mapper is pending", () => {
|
|
188
|
+
it("should fire no callback after success", async () => {
|
|
189
|
+
const setup = createSetup();
|
|
190
|
+
mockRequest(setup.fetchRequest, { data: { ok: true } });
|
|
191
|
+
const { unmount, callbacks } = renderFetch(setup.fetchRequest);
|
|
192
|
+
|
|
193
|
+
await waitFor(() => {
|
|
194
|
+
expect(setup.calls).toHaveBeenCalled();
|
|
195
|
+
});
|
|
196
|
+
unmount();
|
|
197
|
+
setup.release();
|
|
198
|
+
await flushPromises();
|
|
199
|
+
|
|
200
|
+
expect(callbacks.onSuccess).not.toHaveBeenCalled();
|
|
201
|
+
expect(callbacks.onError).not.toHaveBeenCalled();
|
|
202
|
+
expect(callbacks.onFinished).not.toHaveBeenCalled();
|
|
203
|
+
});
|
|
204
|
+
|
|
205
|
+
it("should fire no callback after error", async () => {
|
|
206
|
+
const setup = createSetup();
|
|
207
|
+
mockRequest(setup.fetchRequest, { status: 400 });
|
|
208
|
+
const { unmount, callbacks } = renderFetch(setup.fetchRequest);
|
|
209
|
+
|
|
210
|
+
await waitFor(() => {
|
|
211
|
+
expect(setup.calls).toHaveBeenCalled();
|
|
212
|
+
});
|
|
213
|
+
unmount();
|
|
214
|
+
setup.release();
|
|
215
|
+
await flushPromises();
|
|
216
|
+
|
|
217
|
+
expect(callbacks.onSuccess).not.toHaveBeenCalled();
|
|
218
|
+
expect(callbacks.onError).not.toHaveBeenCalled();
|
|
219
|
+
expect(callbacks.onFinished).not.toHaveBeenCalled();
|
|
220
|
+
});
|
|
221
|
+
});
|
|
222
|
+
|
|
223
|
+
describe("when useFetch stays mounted", () => {
|
|
224
|
+
it("should fire callbacks once with the mapped response", async () => {
|
|
225
|
+
const setup = createSetup();
|
|
226
|
+
mockRequest(setup.fetchRequest, { data: { ok: true } });
|
|
227
|
+
const { callbacks } = renderFetch(setup.fetchRequest);
|
|
228
|
+
|
|
229
|
+
await waitFor(() => {
|
|
230
|
+
expect(setup.calls).toHaveBeenCalled();
|
|
231
|
+
});
|
|
232
|
+
setup.release();
|
|
233
|
+
|
|
234
|
+
await waitFor(() => {
|
|
235
|
+
expect(callbacks.onSuccess).toHaveBeenCalledTimes(1);
|
|
236
|
+
});
|
|
237
|
+
expect(callbacks.onSuccess.mock.calls[0][0].response.data).toStrictEqual({ ok: true, mapped: true });
|
|
238
|
+
expect(callbacks.onFinished).toHaveBeenCalledTimes(1);
|
|
239
|
+
expect(callbacks.onError).not.toHaveBeenCalled();
|
|
240
|
+
});
|
|
241
|
+
});
|
|
242
|
+
});
|
|
243
|
+
});
|
|
@@ -29,9 +29,12 @@ describe("useFetch [ Cancel ]", () => {
|
|
|
29
29
|
});
|
|
30
30
|
|
|
31
31
|
describe("given request is cancelable", () => {
|
|
32
|
+
// The mock must outlive every render and sleep before the abort, otherwise the response wins the race under load
|
|
33
|
+
const inFlightDelay = 1000;
|
|
34
|
+
|
|
32
35
|
describe("when aborting request", () => {
|
|
33
36
|
it("should allow to cancel the ongoing request", async () => {
|
|
34
|
-
mockRequest(request, { delay:
|
|
37
|
+
mockRequest(request, { delay: inFlightDelay });
|
|
35
38
|
const response = renderUseFetch(request);
|
|
36
39
|
|
|
37
40
|
await waitForRender();
|
|
@@ -44,7 +47,7 @@ describe("useFetch [ Cancel ]", () => {
|
|
|
44
47
|
});
|
|
45
48
|
|
|
46
49
|
it("should allow to cancel deduplicated request", async () => {
|
|
47
|
-
mockRequest(request, { delay:
|
|
50
|
+
mockRequest(request, { delay: inFlightDelay });
|
|
48
51
|
const response = renderUseFetch(request);
|
|
49
52
|
await waitForRender();
|
|
50
53
|
const dedupeResponse = renderUseFetch(request);
|
|
@@ -60,7 +63,7 @@ describe("useFetch [ Cancel ]", () => {
|
|
|
60
63
|
it("should cancel previous requests when dependencies change", async () => {
|
|
61
64
|
const spy = vi.fn();
|
|
62
65
|
|
|
63
|
-
mockRequest(request, { delay:
|
|
66
|
+
mockRequest(request, { delay: inFlightDelay });
|
|
64
67
|
const response = renderUseFetch(request, { dependencies: [{}] });
|
|
65
68
|
await waitForRender(1);
|
|
66
69
|
|
|
@@ -1,19 +1,28 @@
|
|
|
1
1
|
import { createHttpMockingServer } from "@hyper-fetch/testing";
|
|
2
|
-
import {
|
|
2
|
+
import { act } from "@testing-library/react";
|
|
3
3
|
|
|
4
|
-
import { client, createRequest, renderUseFetch
|
|
4
|
+
import { client, createRequest, renderUseFetch } from "../../utils";
|
|
5
5
|
|
|
6
6
|
const { resetMocks, startServer, stopServer, mockRequest } = createHttpMockingServer();
|
|
7
7
|
|
|
8
|
+
/**
|
|
9
|
+
* Bouncing is decided by elapsed time, so these specs run on a fake clock. With real timers a stall between two
|
|
10
|
+
* triggers moves them into separate bounce windows and the request count changes.
|
|
11
|
+
*/
|
|
8
12
|
describe("useFetch [ Bounce ]", () => {
|
|
9
13
|
const hookDebounceOptions = { bounce: true, bounceType: "debounce", bounceTime: 50 } as const;
|
|
10
|
-
const hookThrottleOptions = { bounce: true, bounceType: "throttle", bounceTime: 50 } as const;
|
|
14
|
+
const hookThrottleOptions = { bounce: true, bounceType: "throttle", bounceTime: 50, bounceTimeout: 100 } as const;
|
|
15
|
+
const mockDelay = 5;
|
|
11
16
|
let request = createRequest();
|
|
17
|
+
|
|
18
|
+
const advance = (ms: number) => act(() => vi.advanceTimersByTimeAsync(ms));
|
|
19
|
+
|
|
12
20
|
beforeAll(() => {
|
|
13
21
|
startServer();
|
|
14
22
|
});
|
|
15
23
|
|
|
16
24
|
afterEach(() => {
|
|
25
|
+
vi.useRealTimers();
|
|
17
26
|
resetMocks();
|
|
18
27
|
});
|
|
19
28
|
|
|
@@ -25,8 +34,27 @@ describe("useFetch [ Bounce ]", () => {
|
|
|
25
34
|
vi.resetModules();
|
|
26
35
|
request = createRequest();
|
|
27
36
|
client.clear();
|
|
37
|
+
vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout", "Date"] });
|
|
28
38
|
});
|
|
29
39
|
|
|
40
|
+
const renderWithDependencies = (options: typeof hookDebounceOptions | typeof hookThrottleOptions) => {
|
|
41
|
+
const spy = vi.fn();
|
|
42
|
+
mockRequest(request, { delay: mockDelay });
|
|
43
|
+
const response = renderUseFetch(request, { ...options, dependencies: [{ test: 10 }] });
|
|
44
|
+
|
|
45
|
+
act(() => {
|
|
46
|
+
response.result.current.onRequestStart(spy);
|
|
47
|
+
});
|
|
48
|
+
|
|
49
|
+
const trigger = () => {
|
|
50
|
+
act(() => {
|
|
51
|
+
response.rerender({ dependencies: [{ test: Math.random() }] });
|
|
52
|
+
});
|
|
53
|
+
};
|
|
54
|
+
|
|
55
|
+
return { spy, trigger };
|
|
56
|
+
};
|
|
57
|
+
|
|
30
58
|
describe("given debounce is active", () => {
|
|
31
59
|
describe("when request is about to change", () => {
|
|
32
60
|
it("should not debounce initial request", async () => {
|
|
@@ -38,53 +66,36 @@ describe("useFetch [ Bounce ]", () => {
|
|
|
38
66
|
response.result.current.onRequestStart(spy);
|
|
39
67
|
});
|
|
40
68
|
|
|
41
|
-
await
|
|
69
|
+
await advance(0);
|
|
42
70
|
expect(spy).toHaveBeenCalledTimes(1);
|
|
43
71
|
});
|
|
44
|
-
it("should debounce multiple request triggers by
|
|
45
|
-
const spy =
|
|
46
|
-
mockRequest(request, { delay: 0 });
|
|
47
|
-
const response = renderUseFetch(request, { ...hookDebounceOptions, dependencies: [{ test: 10 }] });
|
|
48
|
-
|
|
49
|
-
act(() => {
|
|
50
|
-
response.result.current.onRequestStart(spy);
|
|
51
|
-
});
|
|
52
|
-
|
|
53
|
-
const rerender = () => {
|
|
54
|
-
response.rerender({ dependencies: [{ test: Math.random() }] });
|
|
55
|
-
};
|
|
56
|
-
|
|
57
|
-
await waitForRender();
|
|
72
|
+
it("should debounce multiple request triggers by bounceTime", async () => {
|
|
73
|
+
const { spy, trigger } = renderWithDependencies(hookDebounceOptions);
|
|
58
74
|
|
|
75
|
+
await advance(0);
|
|
59
76
|
expect(spy).toHaveBeenCalledTimes(1);
|
|
77
|
+
await advance(mockDelay);
|
|
60
78
|
|
|
61
|
-
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
await
|
|
65
|
-
|
|
66
|
-
act(() => {
|
|
67
|
-
rerender();
|
|
68
|
-
});
|
|
69
|
-
await waitForRender();
|
|
79
|
+
trigger();
|
|
80
|
+
await advance(10);
|
|
81
|
+
trigger();
|
|
82
|
+
await advance(hookDebounceOptions.bounceTime - 1);
|
|
83
|
+
expect(spy).toHaveBeenCalledTimes(1);
|
|
70
84
|
|
|
71
|
-
await
|
|
72
|
-
|
|
73
|
-
});
|
|
85
|
+
await advance(1);
|
|
86
|
+
expect(spy).toHaveBeenCalledTimes(2);
|
|
74
87
|
|
|
75
|
-
|
|
76
|
-
|
|
77
|
-
|
|
78
|
-
await
|
|
88
|
+
trigger();
|
|
89
|
+
await advance(10);
|
|
90
|
+
trigger();
|
|
91
|
+
await advance(hookDebounceOptions.bounceTime - 1);
|
|
92
|
+
expect(spy).toHaveBeenCalledTimes(2);
|
|
79
93
|
|
|
80
|
-
|
|
81
|
-
|
|
82
|
-
});
|
|
83
|
-
await waitForRender();
|
|
94
|
+
await advance(1);
|
|
95
|
+
expect(spy).toHaveBeenCalledTimes(3);
|
|
84
96
|
|
|
85
|
-
await
|
|
86
|
-
|
|
87
|
-
});
|
|
97
|
+
await advance(1000);
|
|
98
|
+
expect(spy).toHaveBeenCalledTimes(3);
|
|
88
99
|
});
|
|
89
100
|
});
|
|
90
101
|
|
|
@@ -99,53 +110,34 @@ describe("useFetch [ Bounce ]", () => {
|
|
|
99
110
|
response.result.current.onRequestStart(spy);
|
|
100
111
|
});
|
|
101
112
|
|
|
102
|
-
await
|
|
113
|
+
await advance(0);
|
|
103
114
|
expect(spy).toHaveBeenCalledTimes(1);
|
|
104
115
|
});
|
|
105
|
-
it("should throttle multiple request triggers by
|
|
106
|
-
const spy =
|
|
107
|
-
mockRequest(request, { delay: 0 });
|
|
108
|
-
const response = renderUseFetch(request, { ...hookThrottleOptions, dependencies: [{ test: 10 }] });
|
|
109
|
-
|
|
110
|
-
act(() => {
|
|
111
|
-
response.result.current.onRequestStart(spy);
|
|
112
|
-
});
|
|
113
|
-
|
|
114
|
-
const rerender = () => {
|
|
115
|
-
response.rerender({ dependencies: [{ test: Math.random() }] });
|
|
116
|
-
};
|
|
117
|
-
|
|
118
|
-
await waitForRender();
|
|
116
|
+
it("should throttle multiple request triggers by bounceTime", async () => {
|
|
117
|
+
const { spy, trigger } = renderWithDependencies(hookThrottleOptions);
|
|
119
118
|
|
|
119
|
+
await advance(0);
|
|
120
120
|
expect(spy).toHaveBeenCalledTimes(1);
|
|
121
|
+
await advance(mockDelay);
|
|
121
122
|
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
|
|
127
|
-
act(() => {
|
|
128
|
-
rerender();
|
|
129
|
-
});
|
|
130
|
-
await waitForRender();
|
|
131
|
-
|
|
132
|
-
await waitFor(() => {
|
|
133
|
-
expect(spy).toHaveBeenCalledTimes(2);
|
|
134
|
-
});
|
|
123
|
+
// Nothing was throttled yet, so the first change fetches right away
|
|
124
|
+
trigger();
|
|
125
|
+
await advance(0);
|
|
126
|
+
expect(spy).toHaveBeenCalledTimes(2);
|
|
135
127
|
|
|
136
|
-
|
|
137
|
-
|
|
138
|
-
|
|
139
|
-
await
|
|
128
|
+
// Changes inside the interval are held back and only the last one is sent after the timeout
|
|
129
|
+
await advance(10);
|
|
130
|
+
trigger();
|
|
131
|
+
await advance(10);
|
|
132
|
+
trigger();
|
|
133
|
+
await advance(hookThrottleOptions.bounceTimeout - 1);
|
|
134
|
+
expect(spy).toHaveBeenCalledTimes(2);
|
|
140
135
|
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
});
|
|
144
|
-
await waitForRender();
|
|
136
|
+
await advance(1);
|
|
137
|
+
expect(spy).toHaveBeenCalledTimes(3);
|
|
145
138
|
|
|
146
|
-
await
|
|
147
|
-
|
|
148
|
-
});
|
|
139
|
+
await advance(1000);
|
|
140
|
+
expect(spy).toHaveBeenCalledTimes(3);
|
|
149
141
|
});
|
|
150
142
|
});
|
|
151
143
|
});
|
|
@@ -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
|
|
|
@@ -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);
|
|
@@ -12,6 +12,7 @@ describe("useIsFetching [ Base ]", () => {
|
|
|
12
12
|
});
|
|
13
13
|
|
|
14
14
|
afterEach(() => {
|
|
15
|
+
vi.useRealTimers();
|
|
15
16
|
resetMocks();
|
|
16
17
|
});
|
|
17
18
|
|
|
@@ -25,10 +26,13 @@ describe("useIsFetching [ Base ]", () => {
|
|
|
25
26
|
});
|
|
26
27
|
|
|
27
28
|
it("should count the running fetch requests", async () => {
|
|
29
|
+
// The mock delays run on a fake clock, so each request settles only when the test moves time past it.
|
|
30
|
+
// On real timers a stall can settle both requests before the single running one is ever observed.
|
|
31
|
+
vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] });
|
|
28
32
|
const usersRequest = createRequest({ endpoint: "/users" });
|
|
29
33
|
const postsRequest = createRequest({ endpoint: "/posts" });
|
|
30
34
|
mockRequest(usersRequest, { delay: 30 });
|
|
31
|
-
mockRequest(postsRequest, { delay:
|
|
35
|
+
mockRequest(postsRequest, { delay: 1000 });
|
|
32
36
|
|
|
33
37
|
const { result } = renderHook(() => useIsFetching(client));
|
|
34
38
|
expect(result.current).toBe(0);
|
|
@@ -37,14 +41,20 @@ describe("useIsFetching [ Base ]", () => {
|
|
|
37
41
|
client.fetchDispatcher.add(usersRequest);
|
|
38
42
|
client.fetchDispatcher.add(postsRequest);
|
|
39
43
|
});
|
|
40
|
-
|
|
41
|
-
|
|
42
|
-
|
|
43
|
-
|
|
44
|
-
await waitFor(
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
|
|
44
|
+
expect(result.current).toBe(2);
|
|
45
|
+
|
|
46
|
+
// Small clock steps per real-timer poll: the users response gets real ticks to settle long before
|
|
47
|
+
// the clock can reach the posts delay, wherever msw registers its delay timers
|
|
48
|
+
await vi.waitFor(
|
|
49
|
+
async () => {
|
|
50
|
+
await act(() => vi.advanceTimersByTimeAsync(5));
|
|
51
|
+
expect(result.current).toBe(1);
|
|
52
|
+
},
|
|
53
|
+
{ interval: 5 },
|
|
54
|
+
);
|
|
55
|
+
|
|
56
|
+
await act(() => vi.advanceTimersByTimeAsync(1000));
|
|
57
|
+
await vi.waitFor(() => {
|
|
48
58
|
expect(result.current).toBe(0);
|
|
49
59
|
});
|
|
50
60
|
});
|