@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.
Files changed (102) hide show
  1. package/__tests__/features/helpers/use-request-events/use-request-events.async-mapper.spec.ts +243 -0
  2. package/__tests__/features/helpers/use-tracked-state/use-tacked-state.actions.spec.ts +1 -1
  3. package/__tests__/features/helpers/use-tracked-state/use-tracked-state.keys.spec.ts +294 -0
  4. package/__tests__/features/helpers/utils.spec.ts +127 -0
  5. package/__tests__/features/provider/provider.config.spec.tsx +172 -0
  6. package/__tests__/features/use-app-manager/use-app-manager.events.spec.tsx +497 -0
  7. package/__tests__/features/use-cache/use-cache.state.spec.tsx +326 -0
  8. package/__tests__/features/use-emitter/use-emitter.lifecycle.spec.tsx +417 -0
  9. package/__tests__/features/use-fetch/use-fetch.bounce-timers.spec.ts +199 -0
  10. package/__tests__/features/use-fetch/use-fetch.cache-events.spec.ts +212 -0
  11. package/__tests__/features/use-fetch/use-fetch.callbacks.spec.tsx +359 -0
  12. package/__tests__/features/use-fetch/use-fetch.cancel.spec.ts +6 -3
  13. package/__tests__/features/use-fetch/use-fetch.debounce.spec.ts +72 -80
  14. package/__tests__/features/use-fetch/use-fetch.hydration.spec.tsx +126 -0
  15. package/__tests__/features/use-fetch/use-fetch.infinite.spec.ts +146 -0
  16. package/__tests__/features/use-fetch/use-fetch.initial-state.spec.ts +340 -0
  17. package/__tests__/features/use-fetch/use-fetch.keys.spec.tsx +559 -0
  18. package/__tests__/features/use-fetch/use-fetch.lifecycle.spec.ts +348 -0
  19. package/__tests__/features/use-fetch/use-fetch.mounting.spec.tsx +411 -0
  20. package/__tests__/features/use-fetch/use-fetch.pagination.spec.ts +177 -0
  21. package/__tests__/features/use-fetch/use-fetch.refresh-interval.spec.ts +355 -0
  22. package/__tests__/features/use-fetch/use-fetch.refresh.spec.ts +36 -13
  23. package/__tests__/features/use-fetch/use-fetch.response-order.spec.ts +105 -0
  24. package/__tests__/features/use-fetch/use-fetch.retry.spec.ts +235 -0
  25. package/__tests__/features/use-fetch/use-fetch.return-types.spec.ts +186 -0
  26. package/__tests__/features/use-fetch/use-fetch.scope.spec.ts +333 -0
  27. package/__tests__/features/use-fetch/use-fetch.ssr.spec.tsx +195 -0
  28. package/__tests__/features/use-fetch/use-fetch.suspense-edge.spec.tsx +391 -0
  29. package/__tests__/features/use-fetch/use-fetch.throwing-callbacks.spec.tsx +112 -0
  30. package/__tests__/features/use-fetch/use-fetch.tracking.spec.tsx +364 -0
  31. package/__tests__/features/use-fetch/use-fetch.utils.spec.ts +11 -2
  32. package/__tests__/features/use-fetch/use-fetch.window-events.spec.ts +300 -0
  33. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.parity.spec.tsx +1027 -0
  34. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.resubscribe.spec.tsx +267 -0
  35. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.typescript.spec.ts +64 -1
  36. package/__tests__/features/use-is-fetching/use-is-fetching.base.spec.tsx +19 -9
  37. package/__tests__/features/use-is-fetching/use-is-fetching.lifecycle.spec.tsx +301 -0
  38. package/__tests__/features/use-listener/use-listener.lifecycle.spec.tsx +507 -0
  39. package/__tests__/features/use-listener/use-listener.ssr.spec.tsx +89 -0
  40. package/__tests__/features/use-queue/use-queue.controls.spec.tsx +593 -0
  41. package/__tests__/features/use-queue/use-queue.list.spec.tsx +560 -0
  42. package/__tests__/features/use-queue/use-queue.progress.spec.tsx +650 -0
  43. package/__tests__/features/use-submit/use-submit.abort.spec.tsx +270 -0
  44. package/__tests__/features/use-submit/use-submit.actions.spec.tsx +446 -0
  45. package/__tests__/features/use-submit/use-submit.arguments.spec.tsx +732 -0
  46. package/__tests__/features/use-submit/use-submit.bounce.spec.tsx +644 -0
  47. package/__tests__/features/use-submit/use-submit.callbacks.spec.tsx +860 -0
  48. package/__tests__/features/use-submit/use-submit.chaining.spec.tsx +167 -0
  49. package/__tests__/features/use-submit/use-submit.concurrency.spec.ts +2 -1
  50. package/__tests__/features/use-submit/use-submit.debounce.spec.ts +100 -124
  51. package/__tests__/features/use-submit/use-submit.double-submit.spec.tsx +552 -0
  52. package/__tests__/features/use-submit/use-submit.offline.spec.tsx +285 -0
  53. package/__tests__/features/use-submit/use-submit.optimistic-cache.spec.tsx +619 -0
  54. package/__tests__/features/use-submit/use-submit.optimistic-settlement.spec.ts +8 -1
  55. package/__tests__/features/use-submit/use-submit.optimistic.spec.ts +5 -1
  56. package/__tests__/features/use-submit/use-submit.retry.spec.ts +51 -35
  57. package/__tests__/features/use-submit/use-submit.state.spec.tsx +1025 -0
  58. package/__tests__/features/use-submit/use-submit.submit-types.spec.ts +194 -0
  59. package/__tests__/features/use-submit/use-submit.submitting.spec.tsx +180 -0
  60. package/__tests__/features/use-submit/use-submit.unmount.spec.ts +2 -1
  61. package/__tests__/utils/gate.utils.ts +103 -0
  62. package/__tests__/utils/gated-client.utils.ts +158 -0
  63. package/__tests__/utils/helpers.utils.ts +19 -0
  64. package/__tests__/utils/use-queue.utils.ts +8 -4
  65. package/dist/helpers/use-request-events/use-request-events.hooks.d.ts.map +1 -1
  66. package/dist/helpers/use-request-events/use-request-events.types.d.ts +1 -1
  67. package/dist/helpers/use-request-events/use-request-events.types.d.ts.map +1 -1
  68. package/dist/helpers/use-tracked-state/use-tracked-state.hooks.d.ts.map +1 -1
  69. package/dist/helpers/use-tracked-state/use-tracked-state.utils.d.ts +8 -0
  70. package/dist/helpers/use-tracked-state/use-tracked-state.utils.d.ts.map +1 -1
  71. package/dist/hooks/use-cache/use-cache.hooks.d.ts.map +1 -1
  72. package/dist/hooks/use-fetch/use-fetch.hooks.d.ts.map +1 -1
  73. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.hooks.d.ts.map +1 -1
  74. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts +3 -0
  75. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts.map +1 -1
  76. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts +5 -3
  77. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts.map +1 -1
  78. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts +11 -1
  79. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts.map +1 -1
  80. package/dist/hooks/use-listener/use-listener.hooks.d.ts.map +1 -1
  81. package/dist/hooks/use-queue/use-queue.hooks.d.ts.map +1 -1
  82. package/dist/hooks/use-submit/use-submit.hooks.d.ts.map +1 -1
  83. package/dist/index.mjs +633 -347
  84. package/dist/index.mjs.map +1 -1
  85. package/dist/provider/provider.d.ts.map +1 -1
  86. package/package.json +1 -1
  87. package/src/helpers/use-request-events/use-request-events.hooks.ts +147 -32
  88. package/src/helpers/use-request-events/use-request-events.types.ts +1 -1
  89. package/src/helpers/use-tracked-state/use-tracked-state.hooks.ts +148 -101
  90. package/src/helpers/use-tracked-state/use-tracked-state.utils.ts +26 -5
  91. package/src/hooks/use-cache/use-cache.hooks.ts +20 -5
  92. package/src/hooks/use-fetch/use-fetch.hooks.ts +194 -113
  93. package/src/hooks/use-infinite-fetch/use-infinite-fetch.hooks.ts +55 -26
  94. package/src/hooks/use-infinite-fetch/use-infinite-fetch.store.ts +35 -29
  95. package/src/hooks/use-infinite-fetch/use-infinite-fetch.types.ts +5 -3
  96. package/src/hooks/use-infinite-fetch/use-infinite-fetch.utils.ts +25 -1
  97. package/src/hooks/use-listener/use-listener.hooks.ts +2 -1
  98. package/src/hooks/use-queue/use-queue.hooks.ts +85 -60
  99. package/src/hooks/use-submit/use-submit.hooks.ts +163 -53
  100. package/src/provider/provider.tsx +9 -1
  101. package/__tests__/features/use-fetch/use-fetch.pagination.ts +0 -36
  102. package/__tests__/features/use-fetch/use-fetch.retry.ts +0 -38
@@ -0,0 +1,391 @@
1
+ import type { RequestInstance } from "@hyper-fetch/core";
2
+ import { Client } from "@hyper-fetch/core";
3
+ import { act, render, screen } from "@testing-library/react";
4
+ import { useFetch } from "hooks/use-fetch";
5
+ import type { ReactNode } from "react";
6
+ import { Component, StrictMode, Suspense } from "react";
7
+
8
+ import { client, createRequest } from "../../utils";
9
+ import { advance, gateRequest, setCacheResponse, settle } from "../../utils/gate.utils";
10
+
11
+ class ErrorBoundary extends Component<{ children: ReactNode }, { error: Error | null }> {
12
+ constructor(props: { children: ReactNode }) {
13
+ super(props);
14
+ this.state = { error: null };
15
+ }
16
+
17
+ static getDerivedStateFromError(error: Error) {
18
+ return { error };
19
+ }
20
+
21
+ handleReset = () => {
22
+ // oxlint-disable-next-line react/no-set-state -- error boundaries have to be class components
23
+ this.setState({ error: null });
24
+ };
25
+
26
+ render() {
27
+ const { error } = this.state;
28
+ if (error) {
29
+ return (
30
+ <button type="button" data-testid="boundary" onClick={this.handleReset}>
31
+ {error.message}
32
+ </button>
33
+ );
34
+ }
35
+ return this.props.children;
36
+ }
37
+ }
38
+
39
+ const Page = ({
40
+ request,
41
+ name = "page",
42
+ throwOnError = false,
43
+ }: {
44
+ request: RequestInstance;
45
+ name?: string;
46
+ throwOnError?: boolean;
47
+ }) => {
48
+ const { data, error, loading, success } = useFetch(request, { suspense: true, throwOnError });
49
+ return <div data-testid={name}>{JSON.stringify({ data, error: error?.message ?? null, loading, success })}</div>;
50
+ };
51
+
52
+ const Fallback = ({ name = "fallback" }: { name?: string }) => <div data-testid={name}>loading</div>;
53
+
54
+ const read = (name = "page") => JSON.parse(screen.getByTestId(name).textContent || "{}");
55
+
56
+ describe("useFetch [ Suspense Edge Cases ]", () => {
57
+ let request = createRequest<{ value: number } | null>();
58
+ let calls = gateRequest(request);
59
+
60
+ beforeEach(() => {
61
+ vi.useFakeTimers();
62
+ client.clear();
63
+ request = createRequest<{ value: number } | null>();
64
+ calls = gateRequest(request);
65
+ vi.spyOn(console, "error").mockImplementation(() => null);
66
+ });
67
+
68
+ afterEach(() => {
69
+ vi.restoreAllMocks();
70
+ vi.useRealTimers();
71
+ });
72
+
73
+ describe("when the request resolves", () => {
74
+ it("should send a single request for the suspended component", async () => {
75
+ render(
76
+ <Suspense fallback={<Fallback />}>
77
+ <Page request={request} />
78
+ </Suspense>,
79
+ );
80
+ await advance();
81
+ calls[0].succeed({ value: 1 });
82
+ await settle();
83
+ await advance(5000);
84
+
85
+ expect(read().data).toStrictEqual({ value: 1 });
86
+ expect(calls).toHaveLength(1);
87
+ });
88
+ it("should not be in the loading state after resolving", async () => {
89
+ render(
90
+ <Suspense fallback={<Fallback />}>
91
+ <Page request={request} />
92
+ </Suspense>,
93
+ );
94
+ await advance();
95
+ calls[0].succeed({ value: 1 });
96
+ await settle();
97
+
98
+ expect(read()).toStrictEqual({ data: { value: 1 }, error: null, loading: false, success: true });
99
+ });
100
+ it("should send a single request for many components using the same request", async () => {
101
+ render(
102
+ <Suspense fallback={<Fallback />}>
103
+ <Page request={request} name="first" />
104
+ <Page request={request} name="second" />
105
+ <Page request={request} name="third" />
106
+ </Suspense>,
107
+ );
108
+ await advance();
109
+ calls[0].succeed({ value: 1 });
110
+ await settle();
111
+ await advance(5000);
112
+
113
+ expect(read("first").data).toStrictEqual({ value: 1 });
114
+ expect(read("second").data).toStrictEqual({ value: 1 });
115
+ expect(read("third").data).toStrictEqual({ value: 1 });
116
+ expect(calls).toHaveLength(1);
117
+ });
118
+ it("should send a single request in StrictMode", async () => {
119
+ render(
120
+ <StrictMode>
121
+ <Suspense fallback={<Fallback />}>
122
+ <Page request={request} />
123
+ </Suspense>
124
+ </StrictMode>,
125
+ );
126
+ await advance();
127
+ calls[0].succeed({ value: 1 });
128
+ await settle();
129
+ await advance(5000);
130
+
131
+ expect(read().data).toStrictEqual({ value: 1 });
132
+ expect(calls).toHaveLength(1);
133
+ });
134
+ it("should finish suspending when the response has no data", async () => {
135
+ render(
136
+ <Suspense fallback={<Fallback />}>
137
+ <Page request={request} />
138
+ </Suspense>,
139
+ );
140
+ await advance();
141
+ calls[0].succeed(null, 204);
142
+ await settle();
143
+ await settle();
144
+
145
+ expect(read()).toStrictEqual({ data: null, error: null, loading: false, success: true });
146
+ expect(calls).toHaveLength(1);
147
+ });
148
+ it("should render the error response once and not request again", async () => {
149
+ render(
150
+ <Suspense fallback={<Fallback />}>
151
+ <Page request={request} />
152
+ </Suspense>,
153
+ );
154
+ await advance();
155
+ calls[0].fail(new Error("Failed"));
156
+ await settle();
157
+ await advance(5000);
158
+
159
+ expect(read()).toStrictEqual({ data: null, error: "Failed", loading: false, success: false });
160
+ expect(calls).toHaveLength(1);
161
+ });
162
+ });
163
+
164
+ describe("when the cache has data", () => {
165
+ it("should revalidate cached data that was not fetched by the suspended component", async () => {
166
+ setCacheResponse(request, { value: 1 });
167
+ await advance(5000);
168
+
169
+ render(
170
+ <Suspense fallback={<Fallback />}>
171
+ <Page request={request} />
172
+ </Suspense>,
173
+ );
174
+ await advance();
175
+
176
+ expect(screen.queryByTestId("fallback")).toBeNull();
177
+ expect(read().data).toStrictEqual({ value: 1 });
178
+ expect(calls).toHaveLength(1);
179
+ });
180
+ });
181
+
182
+ describe("when the suspended component is gone before the response", () => {
183
+ it("should not reuse the outdated response on the next mount", async () => {
184
+ const view = render(
185
+ <Suspense fallback={<Fallback />}>
186
+ <Page request={request} />
187
+ </Suspense>,
188
+ );
189
+ await advance();
190
+ view.unmount();
191
+ calls[0].fail(new Error("Old failure"));
192
+ await settle();
193
+
194
+ // User comes back after a while
195
+ await advance(60_000);
196
+ render(
197
+ <Suspense fallback={<Fallback />}>
198
+ <Page request={request} />
199
+ </Suspense>,
200
+ );
201
+ await advance();
202
+
203
+ expect(screen.getByTestId("fallback")).toBeInTheDocument();
204
+ expect(calls).toHaveLength(2);
205
+
206
+ calls[1].succeed({ value: 2 });
207
+ await settle();
208
+
209
+ expect(read()).toStrictEqual({ data: { value: 2 }, error: null, loading: false, success: true });
210
+ });
211
+ });
212
+
213
+ describe("when two clients use the same endpoint", () => {
214
+ const createClients = () => {
215
+ const clientA = new Client({ url: "http://a.test" });
216
+ const clientB = new Client({ url: "http://b.test" });
217
+ const requestA = clientA.createRequest<{ response: string }>()({ endpoint: "/same" });
218
+ const requestB = clientB.createRequest<{ response: string }>()({ endpoint: "/same" });
219
+ return { requestA, requestB, callsA: gateRequest(requestA), callsB: gateRequest(requestB) };
220
+ };
221
+
222
+ it("should not give the response of one client to the other", async () => {
223
+ const { requestA, requestB, callsA, callsB } = createClients();
224
+ const viewA = render(
225
+ <Suspense fallback={<Fallback name="fallback-a" />}>
226
+ <Page request={requestA} name="a" />
227
+ </Suspense>,
228
+ );
229
+ await advance();
230
+ render(
231
+ <Suspense fallback={<Fallback name="fallback-b" />}>
232
+ <Page request={requestB} name="b" />
233
+ </Suspense>,
234
+ );
235
+ await advance();
236
+
237
+ viewA.unmount();
238
+ callsA[0].succeed("data-a");
239
+ await settle();
240
+
241
+ expect(screen.queryByTestId("b")).toBeNull();
242
+ expect(screen.getByTestId("fallback-b")).toBeInTheDocument();
243
+
244
+ callsB[0].succeed("data-b");
245
+ await settle();
246
+
247
+ expect(read("b").data).toBe("data-b");
248
+ });
249
+ it("should resolve each client with its own response", async () => {
250
+ const { requestA, requestB, callsA, callsB } = createClients();
251
+ render(
252
+ <>
253
+ <Suspense fallback={<Fallback name="fallback-a" />}>
254
+ <Page request={requestA} name="a" />
255
+ </Suspense>
256
+ <Suspense fallback={<Fallback name="fallback-b" />}>
257
+ <Page request={requestB} name="b" />
258
+ </Suspense>
259
+ </>,
260
+ );
261
+ await advance();
262
+
263
+ callsB[0].succeed("data-b");
264
+ await settle();
265
+ expect(read("b").data).toBe("data-b");
266
+ expect(screen.getByTestId("fallback-a")).toBeInTheDocument();
267
+
268
+ callsA[0].succeed("data-a");
269
+ await settle();
270
+ expect(read("a").data).toBe("data-a");
271
+ });
272
+ });
273
+
274
+ describe("when two scopes use the same request", () => {
275
+ it("should resolve each scope with its own response", async () => {
276
+ const scopedA = request.setScope("a");
277
+ const scopedB = request.setScope("b");
278
+ render(
279
+ <>
280
+ <Suspense fallback={<Fallback name="fallback-a" />}>
281
+ <Page request={scopedA} name="a" />
282
+ </Suspense>
283
+ <Suspense fallback={<Fallback name="fallback-b" />}>
284
+ <Page request={scopedB} name="b" />
285
+ </Suspense>
286
+ </>,
287
+ );
288
+ await advance();
289
+ expect(calls).toHaveLength(2);
290
+
291
+ calls.find((call) => call.request.scope === "b")?.succeed({ value: 2 });
292
+ await settle();
293
+
294
+ expect(read("b").data).toStrictEqual({ value: 2 });
295
+ expect(screen.getByTestId("fallback-a")).toBeInTheDocument();
296
+
297
+ calls.find((call) => call.request.scope === "a")?.succeed({ value: 1 });
298
+ await settle();
299
+
300
+ expect(read("a").data).toStrictEqual({ value: 1 });
301
+ });
302
+ });
303
+
304
+ describe("when the key changes", () => {
305
+ it("should suspend again without rendering the previous resource", async () => {
306
+ const userRequest = createRequest<{ id: number }, any, "/users/:id">({ endpoint: "/users/:id" });
307
+ const userCalls = gateRequest(userRequest);
308
+ const rendered: { id: number; dataId: number | undefined }[] = [];
309
+ const User = ({ id }: { id: number }) => {
310
+ const { data } = useFetch(userRequest.setParams({ id }), { suspense: true });
311
+ rendered.push({ id, dataId: data?.id });
312
+ return <div data-testid="user">{data?.id}</div>;
313
+ };
314
+ const view = render(
315
+ <Suspense fallback={<Fallback />}>
316
+ <User id={1} />
317
+ </Suspense>,
318
+ );
319
+ await advance();
320
+ userCalls[0].succeed({ id: 1 });
321
+ await settle();
322
+ expect(screen.getByTestId("user").textContent).toBe("1");
323
+
324
+ view.rerender(
325
+ <Suspense fallback={<Fallback />}>
326
+ <User id={2} />
327
+ </Suspense>,
328
+ );
329
+ await advance();
330
+ expect(screen.getByTestId("fallback")).toBeInTheDocument();
331
+
332
+ userCalls[1].succeed({ id: 2 });
333
+ await settle();
334
+
335
+ expect(screen.getByTestId("user").textContent).toBe("2");
336
+ expect(rendered.filter((item) => item.id !== item.dataId)).toStrictEqual([]);
337
+ });
338
+ });
339
+
340
+ describe("when combined with the error boundary", () => {
341
+ it("should throw the error, and fetch again after the boundary reset", async () => {
342
+ render(
343
+ <ErrorBoundary>
344
+ <Suspense fallback={<Fallback />}>
345
+ <Page request={request} throwOnError />
346
+ </Suspense>
347
+ </ErrorBoundary>,
348
+ );
349
+ await advance();
350
+ calls[0].fail(new Error("Failed"));
351
+ await settle();
352
+
353
+ expect(screen.getByTestId("boundary").textContent).toBe("Failed");
354
+ expect(calls).toHaveLength(1);
355
+
356
+ act(() => {
357
+ screen.getByTestId("boundary").click();
358
+ });
359
+ await advance();
360
+
361
+ expect(screen.getByTestId("fallback")).toBeInTheDocument();
362
+ expect(calls).toHaveLength(2);
363
+
364
+ calls[1].succeed({ value: 1 });
365
+ await settle();
366
+
367
+ expect(read()).toStrictEqual({ data: { value: 1 }, error: null, loading: false, success: true });
368
+ });
369
+ it("should throw again when the request fails again after the reset", async () => {
370
+ render(
371
+ <ErrorBoundary>
372
+ <Suspense fallback={<Fallback />}>
373
+ <Page request={request} throwOnError />
374
+ </Suspense>
375
+ </ErrorBoundary>,
376
+ );
377
+ await advance();
378
+ calls[0].fail(new Error("First"));
379
+ await settle();
380
+
381
+ act(() => {
382
+ screen.getByTestId("boundary").click();
383
+ });
384
+ await advance();
385
+ calls[1].fail(new Error("Second"));
386
+ await settle();
387
+
388
+ expect(screen.getByTestId("boundary").textContent).toBe("Second");
389
+ });
390
+ });
391
+ });
@@ -0,0 +1,112 @@
1
+ import { act, renderHook, waitFor } from "@testing-library/react";
2
+ import { useFetch } from "hooks/use-fetch";
3
+
4
+ import { createGatedClient } from "../../utils/gated-client.utils";
5
+ import { collectThrownErrors } from "../../utils/helpers.utils";
6
+
7
+ type User = { id: number };
8
+
9
+ /**
10
+ * Callbacks of a hook run inside of the request lifecycle, next to the listeners of other hooks. A throwing one
11
+ * can't keep the response from the other hooks - its error is thrown outside of the lifecycle instead.
12
+ */
13
+ describe("useFetch [ Throwing callbacks ]", () => {
14
+ const failure = new Error("Callback failed");
15
+ const fail = () => {
16
+ throw failure;
17
+ };
18
+
19
+ const setup = () => {
20
+ const gated = createGatedClient();
21
+ const request = gated.client.createRequest<{ response: User }>()({ endpoint: "/users/1" });
22
+ return { ...gated, request };
23
+ };
24
+
25
+ it.each(["onSuccess", "onFinished", "onRequestStart", "onResponseStart"] as const)(
26
+ "should still give the data to the other hooks when %s of one of them throws",
27
+ async (name) => {
28
+ const thrown = collectThrownErrors();
29
+ const { request, waitForCall } = setup();
30
+ const onSuccess = vi.fn();
31
+ const failing = renderHook(() => {
32
+ const state = useFetch(request, { dependencyTracking: false });
33
+ state[name](fail);
34
+ return state;
35
+ });
36
+ const other = renderHook(() => {
37
+ const state = useFetch(request, { dependencyTracking: false });
38
+ state.onSuccess(onSuccess);
39
+ return state;
40
+ });
41
+ const call = await waitForCall(0);
42
+
43
+ act(() => {
44
+ call.succeed({ id: 1 });
45
+ });
46
+
47
+ await waitFor(() => {
48
+ expect(other.result.current.data).toStrictEqual({ id: 1 });
49
+ });
50
+ expect(failing.result.current.data).toStrictEqual({ id: 1 });
51
+ expect(other.result.current.loading).toBeFalse();
52
+ expect(onSuccess).toHaveBeenCalledTimes(1);
53
+ await waitFor(() => {
54
+ expect(thrown).toStrictEqual([failure]);
55
+ });
56
+ },
57
+ );
58
+
59
+ it("should still call the error callback of the other hooks when onError of one of them throws", async () => {
60
+ const thrown = collectThrownErrors();
61
+ const { request, waitForCall } = setup();
62
+ const onError = vi.fn();
63
+ renderHook(() => useFetch(request, { dependencyTracking: false }).onError(fail));
64
+ const other = renderHook(() => {
65
+ const state = useFetch(request, { dependencyTracking: false });
66
+ state.onError(onError);
67
+ return state;
68
+ });
69
+ const call = await waitForCall(0);
70
+
71
+ act(() => {
72
+ call.fail({ message: "Nope" }, 400);
73
+ });
74
+
75
+ await waitFor(() => {
76
+ expect(onError).toHaveBeenCalledTimes(1);
77
+ });
78
+ expect(other.result.current.error).toStrictEqual({ message: "Nope" });
79
+ await waitFor(() => {
80
+ expect(thrown).toStrictEqual([failure]);
81
+ });
82
+ });
83
+
84
+ it("should fetch again after a callback threw", async () => {
85
+ collectThrownErrors();
86
+ const { request, waitForCall } = setup();
87
+ const { result } = renderHook(() => {
88
+ const state = useFetch(request, { dependencyTracking: false });
89
+ state.onSuccess(fail);
90
+ return state;
91
+ });
92
+ const first = await waitForCall(0);
93
+ act(() => {
94
+ first.succeed({ id: 1 });
95
+ });
96
+ await waitFor(() => {
97
+ expect(result.current.loading).toBeFalse();
98
+ });
99
+
100
+ act(() => {
101
+ result.current.refetch();
102
+ });
103
+ const second = await waitForCall(1);
104
+ act(() => {
105
+ second.succeed({ id: 2 });
106
+ });
107
+
108
+ await waitFor(() => {
109
+ expect(result.current.data).toStrictEqual({ id: 2 });
110
+ });
111
+ });
112
+ });