@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,1025 @@
1
+ import type { RequestInstance } from "@hyper-fetch/core";
2
+ import { getErrorMessage } from "@hyper-fetch/core";
3
+ import { act, fireEvent, render, renderHook, screen, waitFor } from "@testing-library/react";
4
+ import { useSubmit } from "hooks/use-submit";
5
+ import { StrictMode, useEffect } from "react";
6
+
7
+ import { createGatedClient } from "../../utils/gated-client.utils";
8
+
9
+ type User = { id: number; name: string };
10
+
11
+ const setup = (options?: { retry?: number; retryTime?: number; endpoint?: string }) => {
12
+ const gated = createGatedClient();
13
+ const request = gated.client.createRequest<{ response: User; payload: { name: string } }>()({
14
+ endpoint: options?.endpoint ?? "/users",
15
+ method: "POST",
16
+ retry: options?.retry ?? 0,
17
+ retryTime: options?.retryTime ?? 0,
18
+ });
19
+ return { ...gated, request };
20
+ };
21
+
22
+ /** The tests read the state outside of the render, so the hook has to rerender on every change */
23
+ const useUntrackedSubmit = <T extends RequestInstance>(request: T) => useSubmit(request, { dependencyTracking: false });
24
+
25
+ /** Run the pending timers and promise callbacks - for the tests using fake timers */
26
+ const advance = async (time = 0) => {
27
+ await act(async () => {
28
+ await vi.advanceTimersByTimeAsync(time);
29
+ });
30
+ };
31
+
32
+ describe("useSubmit [ State ]", () => {
33
+ afterEach(() => {
34
+ vi.useRealTimers();
35
+ });
36
+
37
+ describe("given the hook is idle", () => {
38
+ it("should start with an empty state", () => {
39
+ const { request } = setup();
40
+ const { result } = renderHook(() => useUntrackedSubmit(request));
41
+
42
+ expect(result.current.data).toBeNull();
43
+ expect(result.current.error).toBeNull();
44
+ expect(result.current.status).toBeNull();
45
+ expect(result.current.success).toBeFalse();
46
+ expect(result.current.submitting).toBeFalse();
47
+ expect(result.current.retries).toBe(0);
48
+ expect(result.current.requestTimestamp).toBeNull();
49
+ expect(result.current.responseTimestamp).toBeNull();
50
+ expect(result.current.extra).toStrictEqual(request.client.adapter.defaultExtra);
51
+ });
52
+ it("should not send any request on mount", async () => {
53
+ vi.useFakeTimers();
54
+ const { request, calls } = setup();
55
+ renderHook(() => useUntrackedSubmit(request));
56
+
57
+ await advance(1000);
58
+
59
+ expect(calls).toHaveLength(0);
60
+ });
61
+ it("should not send any request on rerender", async () => {
62
+ vi.useFakeTimers();
63
+ const { request, calls } = setup();
64
+ const { rerender } = renderHook(() => useUntrackedSubmit(request));
65
+
66
+ rerender();
67
+ rerender();
68
+ await advance(1000);
69
+
70
+ expect(calls).toHaveLength(0);
71
+ });
72
+ it("should not be in the bounce state", () => {
73
+ const { request } = setup();
74
+ const { result } = renderHook(() => useUntrackedSubmit(request));
75
+
76
+ expect(result.current.bounce.active).toBeFalse();
77
+ });
78
+ });
79
+
80
+ describe("when the submit succeeds", () => {
81
+ it("should be submitting while the request is in flight", async () => {
82
+ const { request, waitForCall } = setup();
83
+ const { result } = renderHook(() => useUntrackedSubmit(request));
84
+
85
+ act(() => {
86
+ result.current.submit({ payload: { name: "Maciej" } });
87
+ });
88
+ await waitForCall(0);
89
+
90
+ expect(result.current.submitting).toBeTrue();
91
+ expect(result.current.data).toBeNull();
92
+ expect(result.current.error).toBeNull();
93
+ });
94
+ it("should turn on submitting right when submit is called", () => {
95
+ const { request } = setup();
96
+ const { result } = renderHook(() => useUntrackedSubmit(request));
97
+
98
+ act(() => {
99
+ result.current.submit({ payload: { name: "Maciej" } });
100
+ });
101
+
102
+ expect(result.current.submitting).toBeTrue();
103
+ });
104
+ it("should expose the response", async () => {
105
+ const { request, waitForCall } = setup();
106
+ const { result } = renderHook(() => useUntrackedSubmit(request));
107
+ act(() => {
108
+ result.current.submit({ payload: { name: "Maciej" } });
109
+ });
110
+ const call = await waitForCall(0);
111
+
112
+ act(() => {
113
+ call.succeed({ id: 1, name: "Maciej" }, 201);
114
+ });
115
+
116
+ await waitFor(() => {
117
+ expect(result.current.data).toStrictEqual({ id: 1, name: "Maciej" });
118
+ });
119
+ expect(result.current.submitting).toBeFalse();
120
+ expect(result.current.success).toBeTrue();
121
+ expect(result.current.status).toBe(201);
122
+ expect(result.current.error).toBeNull();
123
+ expect(result.current.retries).toBe(0);
124
+ expect(result.current.extra).toStrictEqual({ headers: { "content-type": "application/json" } });
125
+ expect(result.current.requestTimestamp).toBeDate();
126
+ expect(result.current.responseTimestamp).toBeDate();
127
+ });
128
+ it("should keep the previous data while the next submit is in flight", async () => {
129
+ const { request, waitForCall } = setup();
130
+ const { result } = renderHook(() => useUntrackedSubmit(request));
131
+ act(() => {
132
+ result.current.submit({ payload: { name: "First" } });
133
+ });
134
+ const firstCall = await waitForCall(0);
135
+ act(() => {
136
+ firstCall.succeed({ id: 1, name: "First" });
137
+ });
138
+ await waitFor(() => {
139
+ expect(result.current.submitting).toBeFalse();
140
+ });
141
+
142
+ act(() => {
143
+ result.current.submit({ payload: { name: "Second" } });
144
+ });
145
+ await waitForCall(1);
146
+
147
+ expect(result.current.submitting).toBeTrue();
148
+ expect(result.current.data).toStrictEqual({ id: 1, name: "First" });
149
+ });
150
+ it("should replace the data with the response of the next submit", async () => {
151
+ const { request, waitForCall } = setup();
152
+ const { result } = renderHook(() => useUntrackedSubmit(request));
153
+
154
+ for (let index = 0; index < 3; index += 1) {
155
+ act(() => {
156
+ result.current.submit({ payload: { name: `User ${index}` } });
157
+ });
158
+ // eslint-disable-next-line no-await-in-loop
159
+ const call = await waitForCall(index);
160
+ act(() => {
161
+ call.succeed({ id: index, name: `User ${index}` });
162
+ });
163
+ // eslint-disable-next-line no-await-in-loop
164
+ await waitFor(() => {
165
+ expect(result.current.data).toStrictEqual({ id: index, name: `User ${index}` });
166
+ });
167
+ expect(result.current.submitting).toBeFalse();
168
+ }
169
+ });
170
+ it("should go through idle, submitting and success exactly once", async () => {
171
+ const { request, waitForCall } = setup();
172
+ const renders: string[] = [];
173
+ const { result } = renderHook(() => {
174
+ const view = useSubmit(request);
175
+ const snapshot = `${view.submitting}:${view.success}:${view.data?.id ?? null}`;
176
+ if (renders.at(-1) !== snapshot) {
177
+ renders.push(snapshot);
178
+ }
179
+ return view;
180
+ });
181
+
182
+ act(() => {
183
+ result.current.submit({ payload: { name: "Maciej" } });
184
+ });
185
+ const call = await waitForCall(0);
186
+ act(() => {
187
+ call.succeed({ id: 1, name: "Maciej" });
188
+ });
189
+ await waitFor(() => {
190
+ expect(result.current.success).toBeTrue();
191
+ });
192
+
193
+ expect(renders).toStrictEqual(["false:false:null", "true:false:null", "false:true:1"]);
194
+ });
195
+ });
196
+
197
+ describe("when the submit fails", () => {
198
+ it("should expose the error", async () => {
199
+ const { request, waitForCall } = setup();
200
+ const { result } = renderHook(() => useUntrackedSubmit(request));
201
+ act(() => {
202
+ result.current.submit({ payload: { name: "Maciej" } });
203
+ });
204
+ const call = await waitForCall(0);
205
+
206
+ act(() => {
207
+ call.fail({ message: "Name is taken" }, 409);
208
+ });
209
+
210
+ await waitFor(() => {
211
+ expect(result.current.error).toStrictEqual({ message: "Name is taken" });
212
+ });
213
+ expect(result.current.submitting).toBeFalse();
214
+ expect(result.current.success).toBeFalse();
215
+ expect(result.current.status).toBe(409);
216
+ expect(result.current.data).toBeNull();
217
+ expect(result.current.requestTimestamp).toBeDate();
218
+ expect(result.current.responseTimestamp).toBeDate();
219
+ });
220
+ it("should clear the error after a later successful submit", async () => {
221
+ const { request, waitForCall } = setup();
222
+ const { result } = renderHook(() => useUntrackedSubmit(request));
223
+ act(() => {
224
+ result.current.submit({ payload: { name: "Maciej" } });
225
+ });
226
+ const failedCall = await waitForCall(0);
227
+ act(() => {
228
+ failedCall.fail({ message: "Name is taken" }, 409);
229
+ });
230
+ await waitFor(() => {
231
+ expect(result.current.error).not.toBeNull();
232
+ });
233
+
234
+ act(() => {
235
+ result.current.submit({ payload: { name: "Kacper" } });
236
+ });
237
+ const call = await waitForCall(1);
238
+ act(() => {
239
+ call.succeed({ id: 2, name: "Kacper" });
240
+ });
241
+
242
+ await waitFor(() => {
243
+ expect(result.current.data).toStrictEqual({ id: 2, name: "Kacper" });
244
+ });
245
+ expect(result.current.error).toBeNull();
246
+ expect(result.current.success).toBeTrue();
247
+ expect(result.current.status).toBe(200);
248
+ });
249
+ it("should keep the error while the next submit is in flight", async () => {
250
+ const { request, waitForCall } = setup();
251
+ const { result } = renderHook(() => useUntrackedSubmit(request));
252
+ act(() => {
253
+ result.current.submit({ payload: { name: "Maciej" } });
254
+ });
255
+ const failedCall = await waitForCall(0);
256
+ act(() => {
257
+ failedCall.fail({ message: "Name is taken" }, 409);
258
+ });
259
+ await waitFor(() => {
260
+ expect(result.current.error).not.toBeNull();
261
+ });
262
+
263
+ act(() => {
264
+ result.current.submit({ payload: { name: "Kacper" } });
265
+ });
266
+ await waitForCall(1);
267
+
268
+ expect(result.current.submitting).toBeTrue();
269
+ expect(result.current.error).toStrictEqual({ message: "Name is taken" });
270
+ });
271
+ it("should keep the data of the previous successful submit", async () => {
272
+ const { request, waitForCall } = setup();
273
+ const { result } = renderHook(() => useUntrackedSubmit(request));
274
+ act(() => {
275
+ result.current.submit({ payload: { name: "Maciej" } });
276
+ });
277
+ const call = await waitForCall(0);
278
+ act(() => {
279
+ call.succeed({ id: 1, name: "Maciej" });
280
+ });
281
+ await waitFor(() => {
282
+ expect(result.current.success).toBeTrue();
283
+ });
284
+
285
+ act(() => {
286
+ result.current.submit({ payload: { name: "Kacper" } });
287
+ });
288
+ const failedCall = await waitForCall(1);
289
+ act(() => {
290
+ failedCall.fail({ message: "Server error" }, 500);
291
+ });
292
+
293
+ await waitFor(() => {
294
+ expect(result.current.error).toStrictEqual({ message: "Server error" });
295
+ });
296
+ expect(result.current.data).toStrictEqual({ id: 1, name: "Maciej" });
297
+ expect(result.current.success).toBeFalse();
298
+ });
299
+ });
300
+
301
+ describe("when the submit is retried", () => {
302
+ it("should not retry a request without the retry option", async () => {
303
+ vi.useFakeTimers();
304
+ const { request, calls } = setup();
305
+ const { result } = renderHook(() => useUntrackedSubmit(request));
306
+ act(() => {
307
+ result.current.submit({ payload: { name: "Maciej" } });
308
+ });
309
+ await advance();
310
+
311
+ calls[0].fail();
312
+ await advance(10_000);
313
+
314
+ expect(calls).toHaveLength(1);
315
+ expect(result.current.submitting).toBeFalse();
316
+ });
317
+ it("should send the request again after the retry time", async () => {
318
+ vi.useFakeTimers();
319
+ const { request, calls } = setup({ retry: 1, retryTime: 5000 });
320
+ const { result } = renderHook(() => useUntrackedSubmit(request));
321
+ act(() => {
322
+ result.current.submit({ payload: { name: "Maciej" } });
323
+ });
324
+ await advance();
325
+ calls[0].fail();
326
+
327
+ await advance(4999);
328
+ expect(calls).toHaveLength(1);
329
+
330
+ await advance(1);
331
+ expect(calls).toHaveLength(2);
332
+ expect(calls[1].requestId).toBe(calls[0].requestId);
333
+ });
334
+ it("should end with the success state when the retry succeeds", async () => {
335
+ vi.useFakeTimers();
336
+ const { request, calls } = setup({ retry: 1, retryTime: 5000 });
337
+ const { result } = renderHook(() => useUntrackedSubmit(request));
338
+ act(() => {
339
+ result.current.submit({ payload: { name: "Maciej" } });
340
+ });
341
+ await advance();
342
+ calls[0].fail({ message: "Temporary" }, 503);
343
+ await advance(5000);
344
+
345
+ calls[1].succeed({ id: 1, name: "Maciej" });
346
+ await advance();
347
+
348
+ expect(result.current.data).toStrictEqual({ id: 1, name: "Maciej" });
349
+ expect(result.current.error).toBeNull();
350
+ expect(result.current.success).toBeTrue();
351
+ expect(result.current.submitting).toBeFalse();
352
+ expect(result.current.retries).toBe(1);
353
+ });
354
+ it("should be submitting again while the retry is in flight", async () => {
355
+ vi.useFakeTimers();
356
+ const { request, calls } = setup({ retry: 1, retryTime: 5000 });
357
+ const { result } = renderHook(() => useUntrackedSubmit(request));
358
+ act(() => {
359
+ result.current.submit({ payload: { name: "Maciej" } });
360
+ });
361
+ await advance();
362
+ calls[0].fail({ message: "Temporary" }, 503);
363
+ await advance(5000);
364
+
365
+ expect(result.current.submitting).toBeTrue();
366
+ });
367
+ it("should end with the error state when every attempt fails", async () => {
368
+ vi.useFakeTimers();
369
+ const { request, calls } = setup({ retry: 2, retryTime: 5000 });
370
+ const { result } = renderHook(() => useUntrackedSubmit(request));
371
+ act(() => {
372
+ result.current.submit({ payload: { name: "Maciej" } });
373
+ });
374
+ await advance();
375
+
376
+ for (let attempt = 0; attempt < 3; attempt += 1) {
377
+ calls[attempt].fail({ message: `Attempt ${attempt}` }, 500);
378
+ // eslint-disable-next-line no-await-in-loop
379
+ await advance(5000);
380
+ }
381
+
382
+ expect(calls).toHaveLength(3);
383
+ expect(result.current.error).toStrictEqual({ message: "Attempt 2" });
384
+ expect(result.current.submitting).toBeFalse();
385
+ expect(result.current.retries).toBe(2);
386
+ expect(result.current.success).toBeFalse();
387
+ });
388
+ it("should stop retrying once an attempt succeeds", async () => {
389
+ vi.useFakeTimers();
390
+ const { request, calls } = setup({ retry: 5, retryTime: 5000 });
391
+ const { result } = renderHook(() => useUntrackedSubmit(request));
392
+ act(() => {
393
+ result.current.submit({ payload: { name: "Maciej" } });
394
+ });
395
+ await advance();
396
+ calls[0].fail();
397
+ await advance(5000);
398
+ calls[1].succeed({ id: 1, name: "Maciej" });
399
+
400
+ await advance(60_000);
401
+
402
+ expect(calls).toHaveLength(2);
403
+ expect(result.current.success).toBeTrue();
404
+ });
405
+ it("should not retry when retryOnError rejects the response", async () => {
406
+ vi.useFakeTimers();
407
+ const { request, calls } = setup({ retry: 3, retryTime: 5000 });
408
+ const pickyRequest = request.setRetryOnError((response) => response.status !== 422);
409
+ const { result } = renderHook(() => useUntrackedSubmit(pickyRequest));
410
+ act(() => {
411
+ result.current.submit({ payload: { name: "Maciej" } });
412
+ });
413
+ await advance();
414
+
415
+ calls[0].fail({ message: "Invalid" }, 422);
416
+ await advance(60_000);
417
+
418
+ expect(calls).toHaveLength(1);
419
+ expect(result.current.error).toStrictEqual({ message: "Invalid" });
420
+ expect(result.current.submitting).toBeFalse();
421
+ });
422
+ });
423
+
424
+ describe("when the submit is aborted", () => {
425
+ it("should cancel the request in flight", async () => {
426
+ const { request, waitForCall } = setup();
427
+ const { result } = renderHook(() => useUntrackedSubmit(request));
428
+ act(() => {
429
+ result.current.submit({ payload: { name: "Maciej" } });
430
+ });
431
+ const call = await waitForCall(0);
432
+
433
+ act(() => {
434
+ result.current.abort();
435
+ });
436
+
437
+ expect(call.aborted).toBeTrue();
438
+ });
439
+ it("should stop submitting and expose the abort error", async () => {
440
+ const { request, waitForCall } = setup();
441
+ const { result } = renderHook(() => useUntrackedSubmit(request));
442
+ act(() => {
443
+ result.current.submit({ payload: { name: "Maciej" } });
444
+ });
445
+ await waitForCall(0);
446
+
447
+ act(() => {
448
+ result.current.abort();
449
+ });
450
+
451
+ await waitFor(() => {
452
+ expect(result.current.error).toStrictEqual(getErrorMessage("abort"));
453
+ });
454
+ expect(result.current.submitting).toBeFalse();
455
+ expect(result.current.success).toBeFalse();
456
+ expect(result.current.data).toBeNull();
457
+ });
458
+ it("should cancel every request of the hook that is in flight", async () => {
459
+ const { request, waitForCalls } = setup();
460
+ const { result } = renderHook(() => useUntrackedSubmit(request));
461
+ act(() => {
462
+ result.current.submit({ payload: { name: "First" } });
463
+ result.current.submit({ payload: { name: "Second" } });
464
+ });
465
+ const calls = await waitForCalls(2);
466
+
467
+ act(() => {
468
+ result.current.abort();
469
+ });
470
+
471
+ expect(calls.map((call) => call.aborted)).toStrictEqual([true, true]);
472
+ await waitFor(() => {
473
+ expect(result.current.submitting).toBeFalse();
474
+ });
475
+ });
476
+ it("should cancel a request sent with dynamic params", async () => {
477
+ const { client, waitForCall } = setup();
478
+ const request = client.createRequest<{ response: User }>()({ endpoint: "/users/:userId", method: "DELETE" });
479
+ const { result } = renderHook(() => useUntrackedSubmit(request));
480
+ act(() => {
481
+ result.current.submit({ params: { userId: 1 } });
482
+ });
483
+ const call = await waitForCall(0);
484
+
485
+ act(() => {
486
+ result.current.abort();
487
+ });
488
+
489
+ expect(call.aborted).toBeTrue();
490
+ });
491
+ it("should not touch the requests of other hooks", async () => {
492
+ const { request, client, waitForCalls } = setup();
493
+ const otherRequest = client.createRequest<{ response: User }>()({ endpoint: "/teams", method: "POST" });
494
+ const view = renderHook(() => useUntrackedSubmit(request));
495
+ const other = renderHook(() => useUntrackedSubmit(otherRequest));
496
+ act(() => {
497
+ view.result.current.submit({ payload: { name: "Maciej" } });
498
+ other.result.current.submit();
499
+ });
500
+ const calls = await waitForCalls(2);
501
+
502
+ act(() => {
503
+ view.result.current.abort();
504
+ });
505
+
506
+ expect(calls[0].aborted).toBeTrue();
507
+ expect(calls[1].aborted).toBeFalse();
508
+ expect(other.result.current.submitting).toBeTrue();
509
+ });
510
+ it("should do nothing when there is no request in flight", () => {
511
+ const { request } = setup();
512
+ const { result } = renderHook(() => useUntrackedSubmit(request));
513
+
514
+ act(() => {
515
+ result.current.abort();
516
+ });
517
+
518
+ expect(result.current.submitting).toBeFalse();
519
+ expect(result.current.error).toBeNull();
520
+ });
521
+ it("should allow to submit again after the abort", async () => {
522
+ const { request, waitForCall } = setup();
523
+ const { result } = renderHook(() => useUntrackedSubmit(request));
524
+ act(() => {
525
+ result.current.submit({ payload: { name: "Maciej" } });
526
+ });
527
+ await waitForCall(0);
528
+ act(() => {
529
+ result.current.abort();
530
+ });
531
+ await waitFor(() => {
532
+ expect(result.current.submitting).toBeFalse();
533
+ });
534
+
535
+ act(() => {
536
+ result.current.submit({ payload: { name: "Maciej" } });
537
+ });
538
+ const call = await waitForCall(1);
539
+ act(() => {
540
+ call.succeed({ id: 1, name: "Maciej" });
541
+ });
542
+
543
+ await waitFor(() => {
544
+ expect(result.current.data).toStrictEqual({ id: 1, name: "Maciej" });
545
+ });
546
+ expect(result.current.error).toBeNull();
547
+ expect(result.current.success).toBeTrue();
548
+ });
549
+ });
550
+
551
+ describe("when the hook unmounts during the submit", () => {
552
+ it("should let the request finish", async () => {
553
+ const { request, waitForCall } = setup();
554
+ const { result, unmount } = renderHook(() => useUntrackedSubmit(request));
555
+ act(() => {
556
+ result.current.submit({ payload: { name: "Maciej" } });
557
+ });
558
+ const call = await waitForCall(0);
559
+
560
+ unmount();
561
+
562
+ expect(call.aborted).toBeFalse();
563
+ expect(call.settled).toBeFalse();
564
+ });
565
+ it("should not update the state or warn after the unmount", async () => {
566
+ const errorSpy = vi.spyOn(console, "error").mockImplementation(() => null);
567
+ const { request, waitForCall, client } = setup();
568
+ const { result, unmount } = renderHook(() => useUntrackedSubmit(request));
569
+ let promise: Promise<unknown> = Promise.resolve();
570
+ act(() => {
571
+ promise = result.current.submit({ payload: { name: "Maciej" } });
572
+ });
573
+ const call = await waitForCall(0);
574
+
575
+ unmount();
576
+ call.succeed({ id: 1, name: "Maciej" });
577
+ await promise;
578
+ await waitFor(() => {
579
+ expect(client.submitDispatcher.getAllRunningRequests()).toHaveLength(0);
580
+ });
581
+
582
+ expect(result.current.data).toBeNull();
583
+ expect(errorSpy).not.toHaveBeenCalled();
584
+ errorSpy.mockRestore();
585
+ });
586
+ it("should show the response to a hook mounted afterwards", async () => {
587
+ const { request, waitForCall } = setup();
588
+ const first = renderHook(() => useUntrackedSubmit(request));
589
+ let promise: Promise<unknown> = Promise.resolve();
590
+ act(() => {
591
+ promise = first.result.current.submit({ payload: { name: "Maciej" } });
592
+ });
593
+ const call = await waitForCall(0);
594
+ first.unmount();
595
+ call.succeed({ id: 1, name: "Maciej" });
596
+ await promise;
597
+
598
+ const second = renderHook(() => useUntrackedSubmit(request));
599
+
600
+ await waitFor(() => {
601
+ expect(second.result.current.data).toStrictEqual({ id: 1, name: "Maciej" });
602
+ });
603
+ expect(second.result.current.submitting).toBeFalse();
604
+ });
605
+ it("should start in the submitting state when mounted during a request in flight", async () => {
606
+ const { request, waitForCall } = setup();
607
+ const first = renderHook(() => useUntrackedSubmit(request));
608
+ act(() => {
609
+ first.result.current.submit({ payload: { name: "Maciej" } });
610
+ });
611
+ await waitForCall(0);
612
+ first.unmount();
613
+
614
+ const second = renderHook(() => useUntrackedSubmit(request));
615
+
616
+ expect(second.result.current.submitting).toBeTrue();
617
+ });
618
+ it("should remove its listeners", async () => {
619
+ const { request, client, waitForCall } = setup();
620
+ const countListeners = () =>
621
+ client.requestManager.emitter
622
+ .eventNames()
623
+ .reduce((sum, name) => sum + client.requestManager.emitter.listenerCount(name), 0) +
624
+ client.cache.emitter.eventNames().reduce((sum, name) => sum + client.cache.emitter.listenerCount(name), 0);
625
+ const baseline = countListeners();
626
+ const { result, unmount } = renderHook(() => useUntrackedSubmit(request));
627
+ let promise: Promise<unknown> = Promise.resolve();
628
+ act(() => {
629
+ promise = result.current.submit({ payload: { name: "Maciej" } });
630
+ });
631
+ const call = await waitForCall(0);
632
+
633
+ unmount();
634
+ call.succeed({ id: 1, name: "Maciej" });
635
+ await promise;
636
+
637
+ expect(countListeners()).toBe(baseline);
638
+ });
639
+ });
640
+
641
+ describe("when the hook is rendered in StrictMode", () => {
642
+ it("should start with an empty state", () => {
643
+ const { request } = setup();
644
+ const { result } = renderHook(() => useUntrackedSubmit(request), { wrapper: StrictMode });
645
+
646
+ expect(result.current.submitting).toBeFalse();
647
+ expect(result.current.data).toBeNull();
648
+ });
649
+ it("should send a single request for a single submit", async () => {
650
+ const { request, waitForCall, calls } = setup();
651
+ const { result } = renderHook(() => useUntrackedSubmit(request), { wrapper: StrictMode });
652
+
653
+ act(() => {
654
+ result.current.submit({ payload: { name: "Maciej" } });
655
+ });
656
+ const call = await waitForCall(0);
657
+ act(() => {
658
+ call.succeed({ id: 1, name: "Maciej" });
659
+ });
660
+ await waitFor(() => {
661
+ expect(result.current.success).toBeTrue();
662
+ });
663
+
664
+ expect(calls).toHaveLength(1);
665
+ });
666
+ it("should follow the state of the request after the double mount", async () => {
667
+ const { request, waitForCall } = setup();
668
+ const { result } = renderHook(() => useUntrackedSubmit(request), { wrapper: StrictMode });
669
+
670
+ act(() => {
671
+ result.current.submit({ payload: { name: "Maciej" } });
672
+ });
673
+ const call = await waitForCall(0);
674
+ expect(result.current.submitting).toBeTrue();
675
+ act(() => {
676
+ call.succeed({ id: 1, name: "Maciej" });
677
+ });
678
+
679
+ await waitFor(() => {
680
+ expect(result.current.data).toStrictEqual({ id: 1, name: "Maciej" });
681
+ });
682
+ expect(result.current.submitting).toBeFalse();
683
+ });
684
+ it("should expose the error", async () => {
685
+ const { request, waitForCall } = setup();
686
+ const { result } = renderHook(() => useUntrackedSubmit(request), { wrapper: StrictMode });
687
+
688
+ act(() => {
689
+ result.current.submit({ payload: { name: "Maciej" } });
690
+ });
691
+ const call = await waitForCall(0);
692
+ act(() => {
693
+ call.fail({ message: "Nope" }, 400);
694
+ });
695
+
696
+ await waitFor(() => {
697
+ expect(result.current.error).toStrictEqual({ message: "Nope" });
698
+ });
699
+ expect(result.current.submitting).toBeFalse();
700
+ });
701
+ it("should settle the state of a submit made in a mount effect", async () => {
702
+ const { request, waitForCalls } = setup();
703
+ function Page() {
704
+ const { submit, data, submitting } = useSubmit(request);
705
+ useEffect(() => {
706
+ submit({ payload: { name: "Maciej" } });
707
+ }, [submit]);
708
+ return (
709
+ <div data-testid="state">
710
+ {String(submitting)}:{data?.name ?? "none"}
711
+ </div>
712
+ );
713
+ }
714
+
715
+ render(
716
+ <StrictMode>
717
+ <Page />
718
+ </StrictMode>,
719
+ );
720
+ // StrictMode runs the effect twice, so the request is sent twice
721
+ const calls = await waitForCalls(2);
722
+ expect(screen.getByTestId("state").textContent).toBe("true:none");
723
+ act(() => {
724
+ calls.forEach((call) => call.succeed({ id: 1, name: "Maciej" }));
725
+ });
726
+
727
+ await waitFor(() => {
728
+ expect(screen.getByTestId("state").textContent).toBe("false:Maciej");
729
+ });
730
+ });
731
+ });
732
+
733
+ describe("when submit is called from a component", () => {
734
+ it("should submit from an event handler", async () => {
735
+ const { request, waitForCall } = setup();
736
+ function Page() {
737
+ const { submit, data, submitting } = useSubmit(request);
738
+ return (
739
+ <button type="button" disabled={submitting} onClick={() => submit({ payload: { name: "Maciej" } })}>
740
+ {data ? `Created ${data.name}` : "Create"}
741
+ </button>
742
+ );
743
+ }
744
+ render(<Page />);
745
+
746
+ fireEvent.click(screen.getByRole("button"));
747
+ const call = await waitForCall(0);
748
+ expect(screen.getByRole("button")).toBeDisabled();
749
+ act(() => {
750
+ call.succeed({ id: 1, name: "Maciej" });
751
+ });
752
+
753
+ await waitFor(() => {
754
+ expect(screen.getByRole("button").textContent).toBe("Created Maciej");
755
+ });
756
+ expect(screen.getByRole("button")).toBeEnabled();
757
+ });
758
+ it("should submit once from a mount effect", async () => {
759
+ const { request, waitForCall, calls } = setup();
760
+ function Page() {
761
+ const { submit, data } = useSubmit(request);
762
+ useEffect(() => {
763
+ submit({ payload: { name: "Maciej" } });
764
+ }, [submit]);
765
+ return <div data-testid="state">{data?.name ?? "none"}</div>;
766
+ }
767
+ render(<Page />);
768
+
769
+ const call = await waitForCall(0);
770
+ act(() => {
771
+ call.succeed({ id: 1, name: "Maciej" });
772
+ });
773
+
774
+ await waitFor(() => {
775
+ expect(screen.getByTestId("state").textContent).toBe("Maciej");
776
+ });
777
+ expect(calls).toHaveLength(1);
778
+ });
779
+ it("should keep the submit function stable between renders", async () => {
780
+ const { request, waitForCall } = setup();
781
+ const { result, rerender } = renderHook(() => useUntrackedSubmit(request));
782
+ const initialSubmit = result.current.submit;
783
+
784
+ rerender();
785
+ act(() => {
786
+ result.current.submit({ payload: { name: "Maciej" } });
787
+ });
788
+ const call = await waitForCall(0);
789
+ act(() => {
790
+ call.succeed({ id: 1, name: "Maciej" });
791
+ });
792
+ await waitFor(() => {
793
+ expect(result.current.success).toBeTrue();
794
+ });
795
+
796
+ expect(result.current.submit).toBe(initialSubmit);
797
+ });
798
+ it("should keep the refetch function stable between renders", () => {
799
+ const { request } = setup();
800
+ const { result, rerender } = renderHook(() => useUntrackedSubmit(request));
801
+ const initialRefetch = result.current.refetch;
802
+
803
+ rerender();
804
+
805
+ expect(result.current.refetch).toBe(initialRefetch);
806
+ });
807
+ it("should send the request from the latest render with a submit function taken earlier", async () => {
808
+ const { client, waitForCall } = setup();
809
+ const request = client.createRequest<{ response: User }>()({ endpoint: "/users/:userId", method: "DELETE" });
810
+ const { result, rerender } = renderHook(
811
+ ({ userId }: { userId: number }) => useUntrackedSubmit(request.setParams({ userId })),
812
+ {
813
+ initialProps: { userId: 1 },
814
+ },
815
+ );
816
+ const initialSubmit = result.current.submit;
817
+
818
+ rerender({ userId: 2 });
819
+ act(() => {
820
+ initialSubmit();
821
+ });
822
+
823
+ const call = await waitForCall(0);
824
+ expect(call.request.endpoint).toBe("/users/2");
825
+ });
826
+ });
827
+
828
+ describe("when the request passed to the hook changes", () => {
829
+ const setupUsers = () => {
830
+ const gated = createGatedClient();
831
+ const request = gated.client.createRequest<{ response: User }>()({ endpoint: "/users/:userId", method: "PATCH" });
832
+ return { ...gated, request };
833
+ };
834
+
835
+ it("should start with an empty state for the new request", async () => {
836
+ const { request, waitForCall } = setupUsers();
837
+ const { result, rerender } = renderHook(
838
+ ({ userId }: { userId: number }) => useUntrackedSubmit(request.setParams({ userId })),
839
+ {
840
+ initialProps: { userId: 1 },
841
+ },
842
+ );
843
+ act(() => {
844
+ result.current.submit();
845
+ });
846
+ const call = await waitForCall(0);
847
+ act(() => {
848
+ call.succeed({ id: 1, name: "Maciej" });
849
+ });
850
+ await waitFor(() => {
851
+ expect(result.current.data).toStrictEqual({ id: 1, name: "Maciej" });
852
+ });
853
+
854
+ rerender({ userId: 2 });
855
+
856
+ expect(result.current.data).toBeNull();
857
+ expect(result.current.success).toBeFalse();
858
+ expect(result.current.submitting).toBeFalse();
859
+ });
860
+ it("should not show the response of the previous request", async () => {
861
+ const { request, waitForCall, client } = setupUsers();
862
+ const { result, rerender } = renderHook(
863
+ ({ userId }: { userId: number }) => useUntrackedSubmit(request.setParams({ userId })),
864
+ {
865
+ initialProps: { userId: 1 },
866
+ },
867
+ );
868
+ let promise: Promise<unknown> = Promise.resolve();
869
+ act(() => {
870
+ promise = result.current.submit();
871
+ });
872
+ const call = await waitForCall(0);
873
+
874
+ rerender({ userId: 2 });
875
+ await act(async () => {
876
+ call.succeed({ id: 1, name: "Maciej" });
877
+ await promise;
878
+ });
879
+ await waitFor(() => {
880
+ expect(client.submitDispatcher.getAllRunningRequests()).toHaveLength(0);
881
+ });
882
+
883
+ expect(result.current.data).toBeNull();
884
+ expect(result.current.success).toBeFalse();
885
+ });
886
+ it("should follow the submits of the new request made by another hook", async () => {
887
+ const { request, waitForCall } = setupUsers();
888
+ const view = renderHook(({ userId }: { userId: number }) => useUntrackedSubmit(request.setParams({ userId })), {
889
+ initialProps: { userId: 1 },
890
+ });
891
+ const other = renderHook(() => useUntrackedSubmit(request.setParams({ userId: 2 })));
892
+
893
+ view.rerender({ userId: 2 });
894
+ act(() => {
895
+ other.result.current.submit();
896
+ });
897
+ const call = await waitForCall(0);
898
+ expect(view.result.current.submitting).toBeTrue();
899
+ act(() => {
900
+ call.succeed({ id: 2, name: "Kacper" });
901
+ });
902
+
903
+ await waitFor(() => {
904
+ expect(view.result.current.data).toStrictEqual({ id: 2, name: "Kacper" });
905
+ });
906
+ expect(view.result.current.submitting).toBeFalse();
907
+ });
908
+ it("should show the data cached for the new request", async () => {
909
+ const { request, waitForCall } = setupUsers();
910
+ const other = renderHook(() => useUntrackedSubmit(request.setParams({ userId: 2 })));
911
+ act(() => {
912
+ other.result.current.submit();
913
+ });
914
+ const call = await waitForCall(0);
915
+ act(() => {
916
+ call.succeed({ id: 2, name: "Kacper" });
917
+ });
918
+ await waitFor(() => {
919
+ expect(other.result.current.success).toBeTrue();
920
+ });
921
+ const view = renderHook(({ userId }: { userId: number }) => useUntrackedSubmit(request.setParams({ userId })), {
922
+ initialProps: { userId: 1 },
923
+ });
924
+
925
+ view.rerender({ userId: 2 });
926
+
927
+ await waitFor(() => {
928
+ expect(view.result.current.data).toStrictEqual({ id: 2, name: "Kacper" });
929
+ });
930
+ });
931
+ });
932
+
933
+ describe("when two hooks use the same request", () => {
934
+ it("should share the submitting state", async () => {
935
+ const { request, waitForCall } = setup();
936
+ const first = renderHook(() => useUntrackedSubmit(request));
937
+ const second = renderHook(() => useUntrackedSubmit(request));
938
+
939
+ act(() => {
940
+ first.result.current.submit({ payload: { name: "Maciej" } });
941
+ });
942
+ await waitForCall(0);
943
+
944
+ expect(first.result.current.submitting).toBeTrue();
945
+ expect(second.result.current.submitting).toBeTrue();
946
+ });
947
+ it("should share the response", async () => {
948
+ const { request, waitForCall } = setup();
949
+ const first = renderHook(() => useUntrackedSubmit(request));
950
+ const second = renderHook(() => useUntrackedSubmit(request));
951
+ act(() => {
952
+ first.result.current.submit({ payload: { name: "Maciej" } });
953
+ });
954
+ const call = await waitForCall(0);
955
+
956
+ act(() => {
957
+ call.succeed({ id: 1, name: "Maciej" });
958
+ });
959
+
960
+ await waitFor(() => {
961
+ expect(second.result.current.data).toStrictEqual({ id: 1, name: "Maciej" });
962
+ });
963
+ expect(first.result.current.data).toStrictEqual({ id: 1, name: "Maciej" });
964
+ expect(second.result.current.submitting).toBeFalse();
965
+ });
966
+ it("should share the error", async () => {
967
+ const { request, waitForCall } = setup();
968
+ const first = renderHook(() => useUntrackedSubmit(request));
969
+ const second = renderHook(() => useUntrackedSubmit(request));
970
+ act(() => {
971
+ first.result.current.submit({ payload: { name: "Maciej" } });
972
+ });
973
+ const call = await waitForCall(0);
974
+
975
+ act(() => {
976
+ call.fail({ message: "Nope" }, 400);
977
+ });
978
+
979
+ await waitFor(() => {
980
+ expect(second.result.current.error).toStrictEqual({ message: "Nope" });
981
+ });
982
+ expect(first.result.current.error).toStrictEqual({ message: "Nope" });
983
+ });
984
+ it("should keep the hooks of different requests apart", async () => {
985
+ const { request, client, waitForCall } = setup();
986
+ const otherRequest = client.createRequest<{ response: User }>()({ endpoint: "/teams", method: "POST" });
987
+ const first = renderHook(() => useUntrackedSubmit(request));
988
+ const second = renderHook(() => useUntrackedSubmit(otherRequest));
989
+ act(() => {
990
+ first.result.current.submit({ payload: { name: "Maciej" } });
991
+ });
992
+ const call = await waitForCall(0);
993
+ expect(second.result.current.submitting).toBeFalse();
994
+
995
+ act(() => {
996
+ call.succeed({ id: 1, name: "Maciej" });
997
+ });
998
+ await waitFor(() => {
999
+ expect(first.result.current.success).toBeTrue();
1000
+ });
1001
+
1002
+ expect(second.result.current.data).toBeNull();
1003
+ expect(second.result.current.success).toBeFalse();
1004
+ });
1005
+ it("should keep the hooks of different clients apart", async () => {
1006
+ const one = setup();
1007
+ const two = setup();
1008
+ const first = renderHook(() => useUntrackedSubmit(one.request));
1009
+ const second = renderHook(() => useUntrackedSubmit(two.request));
1010
+ act(() => {
1011
+ first.result.current.submit({ payload: { name: "Maciej" } });
1012
+ });
1013
+ const call = await one.waitForCall(0);
1014
+ act(() => {
1015
+ call.succeed({ id: 1, name: "Maciej" });
1016
+ });
1017
+ await waitFor(() => {
1018
+ expect(first.result.current.success).toBeTrue();
1019
+ });
1020
+
1021
+ expect(second.result.current.data).toBeNull();
1022
+ expect(two.calls).toHaveLength(0);
1023
+ });
1024
+ });
1025
+ });