@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,212 @@
1
+ import { act, renderHook } from "@testing-library/react";
2
+ import { useFetch } from "hooks/use-fetch";
3
+
4
+ import { client, createRequest } from "../../utils";
5
+ import { advance, gateRequest, setCacheResponse, settle } from "../../utils/gate.utils";
6
+
7
+ type User = { id: number; name: string };
8
+
9
+ const user: User = { id: 1, name: "Maciej" };
10
+
11
+ describe("useFetch [ Cache Events ]", () => {
12
+ let request = createRequest<User>();
13
+ let calls = gateRequest(request);
14
+
15
+ const renderLoaded = async (options?: Parameters<typeof useFetch<typeof request>>[1]) => {
16
+ const view = renderHook(() => {
17
+ const { data, loading, error, success } = useFetch(request, options);
18
+ return { data, loading, error, success };
19
+ });
20
+ await advance();
21
+ if (calls.length > 0) {
22
+ calls[0].succeed(user);
23
+ await settle();
24
+ }
25
+ return view;
26
+ };
27
+
28
+ beforeEach(() => {
29
+ vi.useFakeTimers();
30
+ client.clear();
31
+ request = createRequest<User>();
32
+ calls = gateRequest(request);
33
+ });
34
+
35
+ afterEach(() => {
36
+ vi.useRealTimers();
37
+ });
38
+
39
+ describe("when the cache is changed from outside", () => {
40
+ it("should show the data saved in the cache", async () => {
41
+ const { result } = await renderLoaded();
42
+
43
+ act(() => {
44
+ setCacheResponse(request, { id: 1, name: "External" });
45
+ });
46
+
47
+ expect(result.current.data).toStrictEqual({ id: 1, name: "External" });
48
+ expect(calls).toHaveLength(1);
49
+ });
50
+ it("should show the data updated with cache.update", async () => {
51
+ const { result } = await renderLoaded();
52
+
53
+ act(() => {
54
+ client.cache.update(request, (previous) => ({ data: { ...(previous?.data as User), name: "Patched" } }));
55
+ });
56
+
57
+ expect(result.current.data).toStrictEqual({ id: 1, name: "Patched" });
58
+ });
59
+ it("should show the data saved for the disabled hook", async () => {
60
+ const { result } = await renderLoaded({ disabled: true });
61
+
62
+ act(() => {
63
+ setCacheResponse(request, user);
64
+ });
65
+
66
+ expect(result.current.data).toStrictEqual(user);
67
+ expect(result.current.success).toBeTrue();
68
+ expect(calls).toHaveLength(0);
69
+ });
70
+ it("should show the response of the request sent outside of the hook", async () => {
71
+ const { result } = await renderLoaded();
72
+
73
+ act(() => {
74
+ client.fetchDispatcher.add(request);
75
+ });
76
+ await advance();
77
+ expect(result.current.loading).toBeTrue();
78
+
79
+ calls[1].succeed({ id: 1, name: "From outside" });
80
+ await settle();
81
+
82
+ expect(result.current.data).toStrictEqual({ id: 1, name: "From outside" });
83
+ expect(result.current.loading).toBeFalse();
84
+ });
85
+ it("should ignore the changes of other cache keys", async () => {
86
+ const { result } = await renderLoaded();
87
+
88
+ act(() => {
89
+ setCacheResponse(request.setQueryParams({ page: 2 }), { id: 2, name: "Other" });
90
+ });
91
+
92
+ expect(result.current.data).toStrictEqual(user);
93
+ });
94
+ });
95
+
96
+ describe("when the cache is invalidated", () => {
97
+ it.each([
98
+ ["request", () => client.cache.invalidate(request)],
99
+ ["cache key", () => client.cache.invalidate(request.cacheKey)],
100
+ ["RegExp", () => client.cache.invalidate(/shared-endpoint/)],
101
+ ["list of keys", () => client.cache.invalidate([request.cacheKey, "other"])],
102
+ ["no arguments", () => client.cache.invalidate()],
103
+ ])("should refetch after the invalidation by %s", async (_, invalidate) => {
104
+ const { result } = await renderLoaded();
105
+
106
+ act(() => {
107
+ invalidate();
108
+ });
109
+ await advance();
110
+
111
+ expect(calls).toHaveLength(2);
112
+ expect(result.current.loading).toBeTrue();
113
+ expect(result.current.data).toStrictEqual(user);
114
+ });
115
+ it("should not refetch after the invalidation of another key", async () => {
116
+ await renderLoaded();
117
+
118
+ act(() => {
119
+ client.cache.invalidate("another-key");
120
+ client.cache.invalidate(/nothing-matches/);
121
+ });
122
+ await advance();
123
+
124
+ expect(calls).toHaveLength(1);
125
+ });
126
+ it("should not refetch the disabled hook", async () => {
127
+ setCacheResponse(request, user);
128
+ await renderLoaded({ disabled: true });
129
+
130
+ act(() => {
131
+ client.cache.invalidate(request);
132
+ });
133
+ await advance();
134
+
135
+ expect(calls).toHaveLength(0);
136
+ });
137
+ it("should send one request for many hooks of the invalidated key", async () => {
138
+ await renderLoaded();
139
+ renderHook(() => useFetch(request, { revalidate: false }).data);
140
+ renderHook(() => useFetch(request, { revalidate: false }).data);
141
+
142
+ act(() => {
143
+ client.cache.invalidate(request);
144
+ });
145
+ await advance();
146
+
147
+ expect(calls).toHaveLength(2);
148
+ });
149
+ it("should not refetch after unmount", async () => {
150
+ const { unmount } = await renderLoaded();
151
+
152
+ unmount();
153
+ act(() => {
154
+ client.cache.invalidate(request);
155
+ });
156
+ await advance();
157
+
158
+ expect(calls).toHaveLength(1);
159
+ });
160
+ it("should refetch on the next mount after the invalidation without mounted hooks", async () => {
161
+ const { unmount } = await renderLoaded({ revalidate: false });
162
+ unmount();
163
+
164
+ act(() => {
165
+ client.cache.invalidate(request);
166
+ });
167
+ renderHook(() => useFetch(request, { revalidate: false }).data);
168
+ await advance();
169
+
170
+ expect(calls).toHaveLength(2);
171
+ });
172
+ });
173
+
174
+ describe("when the cache entry is deleted", () => {
175
+ it("should keep the data visible and refetch it", async () => {
176
+ const { result } = await renderLoaded();
177
+
178
+ act(() => {
179
+ client.cache.delete(request.cacheKey);
180
+ });
181
+ await advance();
182
+
183
+ expect(result.current.data).toStrictEqual(user);
184
+ expect(result.current.loading).toBeTrue();
185
+ expect(calls).toHaveLength(2);
186
+ });
187
+ it("should not refetch the disabled hook", async () => {
188
+ setCacheResponse(request, user);
189
+ const { result } = await renderLoaded({ disabled: true });
190
+
191
+ act(() => {
192
+ client.cache.delete(request.cacheKey);
193
+ });
194
+ await advance();
195
+
196
+ expect(calls).toHaveLength(0);
197
+ expect(result.current.data).toStrictEqual(user);
198
+ });
199
+ });
200
+
201
+ describe("when the cache is disabled for the request", () => {
202
+ it("should show the response without saving it", async () => {
203
+ request = createRequest<User>({ cache: false });
204
+ calls = gateRequest(request);
205
+
206
+ const { result } = await renderLoaded();
207
+
208
+ expect(result.current.data).toStrictEqual(user);
209
+ expect(client.cache.get(request.cacheKey)).toBeUndefined();
210
+ });
211
+ });
212
+ });
@@ -0,0 +1,359 @@
1
+ import { act, renderHook } from "@testing-library/react";
2
+ import { useFetch } from "hooks/use-fetch";
3
+ import { useState } from "react";
4
+
5
+ import { client, createRequest } from "../../utils";
6
+ import { advance, gateRequest, settle } from "../../utils/gate.utils";
7
+
8
+ type User = { id: number };
9
+
10
+ describe("useFetch [ Callbacks ]", () => {
11
+ let request = createRequest<User, any, "/users/:id">({ endpoint: "/users/:id" });
12
+ let calls = gateRequest(request);
13
+
14
+ beforeEach(() => {
15
+ vi.useFakeTimers();
16
+ client.clear();
17
+ request = createRequest<User, any, "/users/:id">({ endpoint: "/users/:id" });
18
+ calls = gateRequest(request);
19
+ });
20
+
21
+ afterEach(() => {
22
+ vi.useRealTimers();
23
+ });
24
+
25
+ const renderCallbacks = (id = 1) => {
26
+ const spies = {
27
+ onSuccess: vi.fn(),
28
+ onError: vi.fn(),
29
+ onFinished: vi.fn(),
30
+ onAbort: vi.fn(),
31
+ onRequestStart: vi.fn(),
32
+ onResponseStart: vi.fn(),
33
+ };
34
+ const view = renderHook(
35
+ (props: { id: number }) => {
36
+ const state = useFetch(request.setParams({ id: props.id }));
37
+ state.onSuccess(spies.onSuccess);
38
+ state.onError(spies.onError);
39
+ state.onFinished(spies.onFinished);
40
+ state.onAbort(spies.onAbort);
41
+ state.onRequestStart(spies.onRequestStart);
42
+ state.onResponseStart(spies.onResponseStart);
43
+ return { data: state.data, refetch: state.refetch, abort: state.abort };
44
+ },
45
+ { initialProps: { id } },
46
+ );
47
+ return { ...view, spies };
48
+ };
49
+
50
+ describe("when the request succeeds", () => {
51
+ it("should call onSuccess and onFinished once", async () => {
52
+ const { spies } = renderCallbacks();
53
+ await advance();
54
+ calls[0].succeed({ id: 1 });
55
+ await settle();
56
+
57
+ expect(spies.onSuccess).toHaveBeenCalledOnce();
58
+ expect(spies.onFinished).toHaveBeenCalledOnce();
59
+ expect(spies.onError).not.toHaveBeenCalled();
60
+ expect(spies.onAbort).not.toHaveBeenCalled();
61
+ });
62
+ it("should pass the response, details and request to onSuccess", async () => {
63
+ const { spies } = renderCallbacks();
64
+ await advance();
65
+ calls[0].succeed({ id: 1 });
66
+ await settle();
67
+
68
+ const [params] = spies.onSuccess.mock.calls[0];
69
+ expect(params.response.data).toStrictEqual({ id: 1 });
70
+ expect(params.response.success).toBeTrue();
71
+ expect(params.response.status).toBe(200);
72
+ expect(params.details.retries).toBe(0);
73
+ expect(params.details.isCanceled).toBeFalse();
74
+ expect(params.request.endpoint).toBe("/users/1");
75
+ expect(params.requestId).toBe(calls[0].requestId);
76
+ });
77
+ it("should call the start callbacks once per request", async () => {
78
+ const { spies } = renderCallbacks();
79
+ await advance();
80
+ calls[0].succeed({ id: 1 });
81
+ await settle();
82
+
83
+ expect(spies.onRequestStart).toHaveBeenCalledOnce();
84
+ expect(spies.onResponseStart).toHaveBeenCalledOnce();
85
+ });
86
+ it("should call the callbacks once per every refetch", async () => {
87
+ const { spies, result } = renderCallbacks();
88
+ await advance();
89
+ calls[0].succeed({ id: 1 });
90
+ await settle();
91
+
92
+ act(() => {
93
+ result.current.refetch();
94
+ });
95
+ await advance();
96
+ calls[1].succeed({ id: 1 });
97
+ await settle();
98
+
99
+ expect(spies.onSuccess).toHaveBeenCalledTimes(2);
100
+ expect(spies.onFinished).toHaveBeenCalledTimes(2);
101
+ });
102
+ it("should call the callback even when the data did not change", async () => {
103
+ const { spies, result } = renderCallbacks();
104
+ await advance();
105
+ calls[0].succeed({ id: 1 });
106
+ await settle();
107
+
108
+ act(() => {
109
+ result.current.refetch();
110
+ });
111
+ await advance();
112
+ calls[1].succeed({ id: 1 });
113
+ await settle();
114
+
115
+ expect(spies.onSuccess.mock.calls[1][0].response.data).toStrictEqual({ id: 1 });
116
+ });
117
+ });
118
+
119
+ describe("when the request fails", () => {
120
+ it("should call onError and onFinished once", async () => {
121
+ const { spies } = renderCallbacks();
122
+ await advance();
123
+ calls[0].fail(new Error("Failed"), 500);
124
+ await settle();
125
+
126
+ expect(spies.onError).toHaveBeenCalledOnce();
127
+ expect(spies.onFinished).toHaveBeenCalledOnce();
128
+ expect(spies.onSuccess).not.toHaveBeenCalled();
129
+ });
130
+ it("should pass the error response to onError", async () => {
131
+ const { spies } = renderCallbacks();
132
+ await advance();
133
+ calls[0].fail(new Error("Failed"), 500);
134
+ await settle();
135
+
136
+ const [params] = spies.onError.mock.calls[0];
137
+ expect(params.response.error.message).toBe("Failed");
138
+ expect(params.response.status).toBe(500);
139
+ expect(params.response.success).toBeFalse();
140
+ expect(params.response.data).toBeNull();
141
+ });
142
+ it("should call onSuccess after the failed request is refetched", async () => {
143
+ const { spies, result } = renderCallbacks();
144
+ await advance();
145
+ calls[0].fail();
146
+ await settle();
147
+
148
+ act(() => {
149
+ result.current.refetch();
150
+ });
151
+ await advance();
152
+ calls[1].succeed({ id: 1 });
153
+ await settle();
154
+
155
+ expect(spies.onError).toHaveBeenCalledOnce();
156
+ expect(spies.onSuccess).toHaveBeenCalledOnce();
157
+ expect(spies.onFinished).toHaveBeenCalledTimes(2);
158
+ });
159
+ });
160
+
161
+ describe("when the callback changes between renders", () => {
162
+ it("should call the callback from the latest render", async () => {
163
+ const seen: number[] = [];
164
+ const { result } = renderHook(() => {
165
+ const [count, setCount] = useState(0);
166
+ const state = useFetch(request.setParams({ id: 1 }));
167
+ state.onSuccess(() => {
168
+ seen.push(count);
169
+ });
170
+ return { data: state.data, setCount };
171
+ });
172
+ await advance();
173
+
174
+ act(() => {
175
+ result.current.setCount(5);
176
+ });
177
+ calls[0].succeed({ id: 1 });
178
+ await settle();
179
+
180
+ expect(seen).toStrictEqual([5]);
181
+ });
182
+ it("should allow to update the state from the callback", async () => {
183
+ const { result } = renderHook(() => {
184
+ const [message, setMessage] = useState("idle");
185
+ const state = useFetch(request.setParams({ id: 1 }));
186
+ state.onSuccess(({ response }) => setMessage(`user ${response.data.id}`));
187
+ state.onError(({ response }) => setMessage(response.error.message));
188
+ return { message, refetch: state.refetch };
189
+ });
190
+ await advance();
191
+ calls[0].succeed({ id: 1 });
192
+ await settle();
193
+ expect(result.current.message).toBe("user 1");
194
+
195
+ act(() => {
196
+ result.current.refetch();
197
+ });
198
+ await advance();
199
+ calls[1].fail(new Error("Failed"));
200
+ await settle();
201
+ expect(result.current.message).toBe("Failed");
202
+ });
203
+ it("should not fail when no callbacks are registered", async () => {
204
+ const { result } = renderHook(() => useFetch(request.setParams({ id: 1 })).data);
205
+ await advance();
206
+ calls[0].succeed({ id: 1 });
207
+ await settle();
208
+
209
+ expect(result.current).toStrictEqual({ id: 1 });
210
+ });
211
+ });
212
+
213
+ describe("when the key changes", () => {
214
+ it("should not call the callbacks for the response of the previous key", async () => {
215
+ const { spies, rerender } = renderCallbacks(1);
216
+ await advance();
217
+ rerender({ id: 2 });
218
+ await advance();
219
+
220
+ calls[0].succeed({ id: 1 });
221
+ await settle();
222
+
223
+ expect(spies.onSuccess).not.toHaveBeenCalled();
224
+ expect(spies.onFinished).not.toHaveBeenCalled();
225
+ });
226
+ it("should call the callbacks for the response of the current key", async () => {
227
+ const { spies, rerender } = renderCallbacks(1);
228
+ await advance();
229
+ rerender({ id: 2 });
230
+ await advance();
231
+
232
+ calls[1].succeed({ id: 2 });
233
+ await settle();
234
+
235
+ expect(spies.onSuccess).toHaveBeenCalledOnce();
236
+ expect(spies.onSuccess.mock.calls[0][0].response.data).toStrictEqual({ id: 2 });
237
+ });
238
+ });
239
+
240
+ describe("when the hook unmounts", () => {
241
+ it("should not call the callbacks of the request finished after the unmount", async () => {
242
+ const { spies, unmount } = renderCallbacks();
243
+ await advance();
244
+
245
+ unmount();
246
+ calls[0].succeed({ id: 1 });
247
+ await settle();
248
+
249
+ expect(spies.onSuccess).not.toHaveBeenCalled();
250
+ expect(spies.onFinished).not.toHaveBeenCalled();
251
+ expect(spies.onResponseStart).not.toHaveBeenCalled();
252
+ });
253
+ it("should not call onError after the unmount", async () => {
254
+ const { spies, unmount } = renderCallbacks();
255
+ await advance();
256
+
257
+ unmount();
258
+ calls[0].fail();
259
+ await settle();
260
+
261
+ expect(spies.onError).not.toHaveBeenCalled();
262
+ });
263
+ });
264
+
265
+ describe("when many hooks use the same request", () => {
266
+ it("should call the callbacks of every hook once", async () => {
267
+ const first = renderCallbacks();
268
+ const second = renderCallbacks();
269
+ await advance();
270
+ expect(calls).toHaveLength(1);
271
+
272
+ calls[0].succeed({ id: 1 });
273
+ await settle();
274
+
275
+ expect(first.spies.onSuccess).toHaveBeenCalledOnce();
276
+ expect(second.spies.onSuccess).toHaveBeenCalledOnce();
277
+ });
278
+ it("should call the callbacks for the request sent outside of the hook", async () => {
279
+ const { spies } = renderCallbacks();
280
+ await advance();
281
+ calls[0].succeed({ id: 1 });
282
+ await settle();
283
+
284
+ act(() => {
285
+ client.fetchDispatcher.add(request.setParams({ id: 1 }));
286
+ });
287
+ await advance();
288
+ calls[1].succeed({ id: 1 });
289
+ await settle();
290
+
291
+ expect(spies.onSuccess).toHaveBeenCalledTimes(2);
292
+ });
293
+ });
294
+
295
+ describe("when the request uses a response mapper", () => {
296
+ it("should pass the mapped response to the callbacks", async () => {
297
+ const mapped = createRequest<User>().setResponseMapper(
298
+ (response) => ({ ...response, data: { id: 100 } }) as typeof response,
299
+ );
300
+ const mappedCalls = gateRequest(mapped);
301
+ const onSuccess = vi.fn();
302
+ const { result } = renderHook(() => {
303
+ const state = useFetch(mapped);
304
+ state.onSuccess(({ response }) => onSuccess(response.data));
305
+ return { data: state.data };
306
+ });
307
+ await advance();
308
+ mappedCalls[0].succeed({ id: 1 });
309
+ await settle();
310
+
311
+ expect(result.current.data).toStrictEqual({ id: 100 });
312
+ expect(onSuccess).toHaveBeenCalledWith({ id: 100 });
313
+ });
314
+ it("should pass the asynchronously mapped response to the callbacks", async () => {
315
+ const mapped = createRequest<User>().setResponseMapper(
316
+ async (response) => ({ ...response, data: { id: 100 } }) as typeof response,
317
+ );
318
+ const mappedCalls = gateRequest(mapped);
319
+ const onSuccess = vi.fn();
320
+ renderHook(() => {
321
+ const state = useFetch(mapped);
322
+ state.onSuccess(({ response }) => onSuccess(response.data));
323
+ return { data: state.data };
324
+ });
325
+ await advance();
326
+ mappedCalls[0].succeed({ id: 1 });
327
+ await settle();
328
+
329
+ expect(onSuccess).toHaveBeenCalledWith({ id: 100 });
330
+ });
331
+ it("should call onError when the mapper turns the response into a failure", async () => {
332
+ const mapped = createRequest<User>().setResponseMapper(
333
+ (response) =>
334
+ ({
335
+ ...response,
336
+ data: null,
337
+ error: new Error("Mapped failure"),
338
+ success: false,
339
+ }) as typeof response,
340
+ );
341
+ const mappedCalls = gateRequest(mapped);
342
+ const onSuccess = vi.fn();
343
+ const onError = vi.fn();
344
+ const { result } = renderHook(() => {
345
+ const state = useFetch(mapped);
346
+ state.onSuccess(onSuccess);
347
+ state.onError(({ response }) => onError(response.error?.message));
348
+ return { error: state.error };
349
+ });
350
+ await advance();
351
+ mappedCalls[0].succeed({ id: 1 });
352
+ await settle();
353
+
354
+ expect(result.current.error?.message).toBe("Mapped failure");
355
+ expect(onError).toHaveBeenCalledWith("Mapped failure");
356
+ expect(onSuccess).not.toHaveBeenCalled();
357
+ });
358
+ });
359
+ });
@@ -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