@hyper-fetch/react 9.5.2 → 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.
Files changed (58) hide show
  1. package/__tests__/features/helpers/use-request-events/use-request-events.async-mapper.spec.ts +243 -0
  2. package/__tests__/features/use-fetch/use-fetch.cancel.spec.ts +6 -3
  3. package/__tests__/features/use-fetch/use-fetch.debounce.spec.ts +72 -80
  4. package/__tests__/features/use-fetch/use-fetch.refresh.spec.ts +36 -13
  5. package/__tests__/features/use-fetch/use-fetch.utils.spec.ts +11 -2
  6. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.base.spec.tsx +745 -0
  7. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.boundaries.spec.tsx +362 -0
  8. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.edge.spec.tsx +1043 -0
  9. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.matrix.spec.tsx +441 -0
  10. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.random.spec.tsx +121 -0
  11. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.refetch.spec.tsx +567 -0
  12. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.start-over.spec.tsx +353 -0
  13. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.typescript.spec.ts +128 -0
  14. package/__tests__/features/use-is-fetching/use-is-fetching.base.spec.tsx +19 -9
  15. package/__tests__/features/use-submit/use-submit.concurrency.spec.ts +2 -1
  16. package/__tests__/features/use-submit/use-submit.debounce.spec.ts +100 -124
  17. package/__tests__/features/use-submit/use-submit.optimistic-settlement.spec.ts +2 -1
  18. package/__tests__/features/use-submit/use-submit.retry.spec.ts +51 -35
  19. package/__tests__/features/use-submit/use-submit.unmount.spec.ts +311 -0
  20. package/__tests__/utils/use-infinite-fetch.modes.ts +131 -0
  21. package/__tests__/utils/use-infinite-fetch.utils.ts +90 -0
  22. package/__tests__/utils/use-queue.utils.ts +8 -4
  23. package/dist/helpers/use-request-events/use-request-events.hooks.d.ts.map +1 -1
  24. package/dist/hooks/use-infinite-fetch/index.d.ts +4 -0
  25. package/dist/hooks/use-infinite-fetch/index.d.ts.map +1 -0
  26. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.constants.d.ts +22 -0
  27. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.constants.d.ts.map +1 -0
  28. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.hooks.d.ts +21 -0
  29. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.hooks.d.ts.map +1 -0
  30. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.requests.d.ts +19 -0
  31. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.requests.d.ts.map +1 -0
  32. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts +119 -0
  33. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts.map +1 -0
  34. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.types.d.ts +48 -0
  35. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.types.d.ts.map +1 -0
  36. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts +172 -0
  37. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts.map +1 -0
  38. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts +15 -0
  39. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts.map +1 -0
  40. package/dist/index.d.ts +1 -0
  41. package/dist/index.d.ts.map +1 -1
  42. package/dist/index.mjs +917 -3
  43. package/dist/index.mjs.map +1 -1
  44. package/dist/provider/provider.types.d.ts +2 -0
  45. package/dist/provider/provider.types.d.ts.map +1 -1
  46. package/package.json +1 -1
  47. package/src/helpers/use-request-events/use-request-events.hooks.ts +17 -5
  48. package/src/hooks/use-infinite-fetch/index.ts +3 -0
  49. package/src/hooks/use-infinite-fetch/use-infinite-fetch.constants.ts +25 -0
  50. package/src/hooks/use-infinite-fetch/use-infinite-fetch.hooks.ts +389 -0
  51. package/src/hooks/use-infinite-fetch/use-infinite-fetch.requests.ts +98 -0
  52. package/src/hooks/use-infinite-fetch/use-infinite-fetch.store.ts +780 -0
  53. package/src/hooks/use-infinite-fetch/use-infinite-fetch.store.types.ts +49 -0
  54. package/src/hooks/use-infinite-fetch/use-infinite-fetch.types.ts +195 -0
  55. package/src/hooks/use-infinite-fetch/use-infinite-fetch.utils.ts +44 -0
  56. package/src/index.ts +1 -0
  57. package/src/provider/provider.types.ts +3 -0
  58. package/__tests__/features/use-fetch/use-fetch.infinite.ts +0 -39
@@ -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: 40 });
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: 100 });
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: 50 });
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 { waitFor, act } from "@testing-library/react";
2
+ import { act } from "@testing-library/react";
3
3
 
4
- import { client, createRequest, renderUseFetch, waitForRender } from "../../utils";
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 waitForRender(0);
69
+ await advance(0);
42
70
  expect(spy).toHaveBeenCalledTimes(1);
43
71
  });
44
- it("should debounce multiple request triggers by 100ms", async () => {
45
- const spy = vi.fn();
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
- act(() => {
62
- rerender();
63
- });
64
- await waitForRender();
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 waitFor(() => {
72
- expect(spy).toHaveBeenCalledTimes(2);
73
- });
85
+ await advance(1);
86
+ expect(spy).toHaveBeenCalledTimes(2);
74
87
 
75
- act(() => {
76
- rerender();
77
- });
78
- await waitForRender();
88
+ trigger();
89
+ await advance(10);
90
+ trigger();
91
+ await advance(hookDebounceOptions.bounceTime - 1);
92
+ expect(spy).toHaveBeenCalledTimes(2);
79
93
 
80
- act(() => {
81
- rerender();
82
- });
83
- await waitForRender();
94
+ await advance(1);
95
+ expect(spy).toHaveBeenCalledTimes(3);
84
96
 
85
- await waitFor(() => {
86
- expect(spy).toHaveBeenCalledTimes(3);
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 waitForRender(0);
113
+ await advance(0);
103
114
  expect(spy).toHaveBeenCalledTimes(1);
104
115
  });
105
- it("should throttle multiple request triggers by 100ms", async () => {
106
- const spy = vi.fn();
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
- act(() => {
123
- rerender();
124
- });
125
- await waitForRender();
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
- act(() => {
137
- rerender();
138
- });
139
- await waitForRender();
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
- act(() => {
142
- rerender();
143
- });
144
- await waitForRender();
136
+ await advance(1);
137
+ expect(spy).toHaveBeenCalledTimes(3);
145
138
 
146
- await waitFor(() => {
147
- expect(spy).toHaveBeenCalledTimes(3);
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 waitFor(() => {
99
- expect(spy).toHaveBeenCalledTimes(1);
100
- });
101
- await waitFor(() => {
118
+ await advanceUntil(() => {
102
119
  expect(spy).toHaveBeenCalledTimes(2);
103
120
  });
104
121
 
@@ -106,30 +123,33 @@ describe("useFetch [ Refreshing ]", () => {
106
123
  rerender({ refresh: false });
107
124
  });
108
125
 
109
- await waitForRender(hookOptions.refreshTime * 1.5);
126
+ await advance(hookOptions.refreshTime * 5);
110
127
 
111
128
  expect(spy).toHaveBeenCalledTimes(2);
112
129
  });
113
130
  it("should refetch when tab is focused and refetchOnFocus is true", async () => {
114
131
  const spy = vi.fn();
115
132
  mockRequest(request);
116
- // Deduplication would collapse the focus refetch into the still-running initial fetch
117
- const { result } = renderUseFetch(request.setDeduplicate(false), { ...hookOptions });
133
+ // Deduplication would collapse the focus refetch into the still-running initial fetch.
134
+ // Refreshing is off, a timed refresh on a slow machine would add a request the focus did not cause.
135
+ const { result } = renderUseFetch(request.setDeduplicate(false), { ...hookOptions, refresh: false });
118
136
 
119
137
  act(() => {
120
138
  result.current.onRequestStart(spy);
121
139
  });
122
140
 
123
- await waitForRender();
124
- expect(spy).toHaveBeenCalledTimes(1);
141
+ await waitFor(() => {
142
+ expect(spy).toHaveBeenCalledTimes(1);
143
+ });
125
144
 
126
145
  // Simulate tab focus
127
146
  act(() => {
128
147
  client.appManager.setFocused(true);
129
148
  });
130
149
 
131
- await waitForRender();
132
- expect(spy).toHaveBeenCalledTimes(2);
150
+ await waitFor(() => {
151
+ expect(spy).toHaveBeenCalledTimes(2);
152
+ });
133
153
  });
134
154
  it("should not refresh when disabled is true", async () => {
135
155
  const spy = vi.fn();
@@ -146,6 +166,7 @@ describe("useFetch [ Refreshing ]", () => {
146
166
  expect(spy).not.toHaveBeenCalled();
147
167
  });
148
168
  it("should stop refreshing when disabled changes from false to true", async () => {
169
+ useFakeClock();
149
170
  const spy = vi.fn();
150
171
  mockRequest(request);
151
172
  const { result, rerender } = renderUseFetch(request, hookOptions);
@@ -154,22 +175,24 @@ describe("useFetch [ Refreshing ]", () => {
154
175
  result.current.onRequestStart(spy);
155
176
  });
156
177
 
157
- await waitForRender();
178
+ await advance(0);
158
179
  expect(spy).toHaveBeenCalledTimes(1);
159
180
 
160
181
  act(() => {
161
182
  rerender({ disabled: true });
162
183
  });
163
184
 
164
- await waitForRender(hookOptions.refreshTime * 1.5);
185
+ await advance(hookOptions.refreshTime * 5);
165
186
 
166
187
  expect(spy).toHaveBeenCalledTimes(1);
167
188
  });
168
189
  it("should not refetch when tab is focused and refetchOnFocus is false", async () => {
169
190
  const spy = vi.fn();
170
191
  mockRequest(request);
192
+ // Refreshing is off, a timed refresh on a slow machine would add a request the focus did not cause
171
193
  const { result } = renderUseFetch(request, {
172
194
  ...hookOptions,
195
+ refresh: false,
173
196
  refetchOnFocus: false,
174
197
  });
175
198
 
@@ -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).toBeLessThanOrEqual(500);
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);