@hyper-fetch/react 9.6.1 → 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 (91) hide show
  1. package/__tests__/features/helpers/use-tracked-state/use-tacked-state.actions.spec.ts +1 -1
  2. package/__tests__/features/helpers/use-tracked-state/use-tracked-state.keys.spec.ts +294 -0
  3. package/__tests__/features/helpers/utils.spec.ts +127 -0
  4. package/__tests__/features/provider/provider.config.spec.tsx +172 -0
  5. package/__tests__/features/use-app-manager/use-app-manager.events.spec.tsx +497 -0
  6. package/__tests__/features/use-cache/use-cache.state.spec.tsx +326 -0
  7. package/__tests__/features/use-emitter/use-emitter.lifecycle.spec.tsx +417 -0
  8. package/__tests__/features/use-fetch/use-fetch.bounce-timers.spec.ts +199 -0
  9. package/__tests__/features/use-fetch/use-fetch.cache-events.spec.ts +212 -0
  10. package/__tests__/features/use-fetch/use-fetch.callbacks.spec.tsx +359 -0
  11. package/__tests__/features/use-fetch/use-fetch.hydration.spec.tsx +126 -0
  12. package/__tests__/features/use-fetch/use-fetch.infinite.spec.ts +146 -0
  13. package/__tests__/features/use-fetch/use-fetch.initial-state.spec.ts +340 -0
  14. package/__tests__/features/use-fetch/use-fetch.keys.spec.tsx +559 -0
  15. package/__tests__/features/use-fetch/use-fetch.lifecycle.spec.ts +348 -0
  16. package/__tests__/features/use-fetch/use-fetch.mounting.spec.tsx +411 -0
  17. package/__tests__/features/use-fetch/use-fetch.pagination.spec.ts +177 -0
  18. package/__tests__/features/use-fetch/use-fetch.refresh-interval.spec.ts +355 -0
  19. package/__tests__/features/use-fetch/use-fetch.response-order.spec.ts +105 -0
  20. package/__tests__/features/use-fetch/use-fetch.retry.spec.ts +235 -0
  21. package/__tests__/features/use-fetch/use-fetch.return-types.spec.ts +186 -0
  22. package/__tests__/features/use-fetch/use-fetch.scope.spec.ts +333 -0
  23. package/__tests__/features/use-fetch/use-fetch.ssr.spec.tsx +195 -0
  24. package/__tests__/features/use-fetch/use-fetch.suspense-edge.spec.tsx +391 -0
  25. package/__tests__/features/use-fetch/use-fetch.throwing-callbacks.spec.tsx +112 -0
  26. package/__tests__/features/use-fetch/use-fetch.tracking.spec.tsx +364 -0
  27. package/__tests__/features/use-fetch/use-fetch.window-events.spec.ts +300 -0
  28. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.parity.spec.tsx +1027 -0
  29. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.resubscribe.spec.tsx +267 -0
  30. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.typescript.spec.ts +64 -1
  31. package/__tests__/features/use-is-fetching/use-is-fetching.lifecycle.spec.tsx +301 -0
  32. package/__tests__/features/use-listener/use-listener.lifecycle.spec.tsx +507 -0
  33. package/__tests__/features/use-listener/use-listener.ssr.spec.tsx +89 -0
  34. package/__tests__/features/use-queue/use-queue.controls.spec.tsx +593 -0
  35. package/__tests__/features/use-queue/use-queue.list.spec.tsx +560 -0
  36. package/__tests__/features/use-queue/use-queue.progress.spec.tsx +650 -0
  37. package/__tests__/features/use-submit/use-submit.abort.spec.tsx +270 -0
  38. package/__tests__/features/use-submit/use-submit.actions.spec.tsx +446 -0
  39. package/__tests__/features/use-submit/use-submit.arguments.spec.tsx +732 -0
  40. package/__tests__/features/use-submit/use-submit.bounce.spec.tsx +644 -0
  41. package/__tests__/features/use-submit/use-submit.callbacks.spec.tsx +860 -0
  42. package/__tests__/features/use-submit/use-submit.chaining.spec.tsx +167 -0
  43. package/__tests__/features/use-submit/use-submit.double-submit.spec.tsx +552 -0
  44. package/__tests__/features/use-submit/use-submit.offline.spec.tsx +285 -0
  45. package/__tests__/features/use-submit/use-submit.optimistic-cache.spec.tsx +619 -0
  46. package/__tests__/features/use-submit/use-submit.optimistic-settlement.spec.ts +6 -0
  47. package/__tests__/features/use-submit/use-submit.optimistic.spec.ts +5 -1
  48. package/__tests__/features/use-submit/use-submit.state.spec.tsx +1025 -0
  49. package/__tests__/features/use-submit/use-submit.submit-types.spec.ts +194 -0
  50. package/__tests__/features/use-submit/use-submit.submitting.spec.tsx +180 -0
  51. package/__tests__/utils/gate.utils.ts +103 -0
  52. package/__tests__/utils/gated-client.utils.ts +158 -0
  53. package/__tests__/utils/helpers.utils.ts +19 -0
  54. package/dist/helpers/use-request-events/use-request-events.hooks.d.ts.map +1 -1
  55. package/dist/helpers/use-request-events/use-request-events.types.d.ts +1 -1
  56. package/dist/helpers/use-request-events/use-request-events.types.d.ts.map +1 -1
  57. package/dist/helpers/use-tracked-state/use-tracked-state.hooks.d.ts.map +1 -1
  58. package/dist/helpers/use-tracked-state/use-tracked-state.utils.d.ts +8 -0
  59. package/dist/helpers/use-tracked-state/use-tracked-state.utils.d.ts.map +1 -1
  60. package/dist/hooks/use-cache/use-cache.hooks.d.ts.map +1 -1
  61. package/dist/hooks/use-fetch/use-fetch.hooks.d.ts.map +1 -1
  62. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.hooks.d.ts.map +1 -1
  63. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts +3 -0
  64. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts.map +1 -1
  65. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts +5 -3
  66. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts.map +1 -1
  67. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts +11 -1
  68. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts.map +1 -1
  69. package/dist/hooks/use-listener/use-listener.hooks.d.ts.map +1 -1
  70. package/dist/hooks/use-queue/use-queue.hooks.d.ts.map +1 -1
  71. package/dist/hooks/use-submit/use-submit.hooks.d.ts.map +1 -1
  72. package/dist/index.mjs +630 -346
  73. package/dist/index.mjs.map +1 -1
  74. package/dist/provider/provider.d.ts.map +1 -1
  75. package/package.json +1 -1
  76. package/src/helpers/use-request-events/use-request-events.hooks.ts +141 -28
  77. package/src/helpers/use-request-events/use-request-events.types.ts +1 -1
  78. package/src/helpers/use-tracked-state/use-tracked-state.hooks.ts +148 -101
  79. package/src/helpers/use-tracked-state/use-tracked-state.utils.ts +26 -5
  80. package/src/hooks/use-cache/use-cache.hooks.ts +20 -5
  81. package/src/hooks/use-fetch/use-fetch.hooks.ts +194 -113
  82. package/src/hooks/use-infinite-fetch/use-infinite-fetch.hooks.ts +55 -26
  83. package/src/hooks/use-infinite-fetch/use-infinite-fetch.store.ts +35 -29
  84. package/src/hooks/use-infinite-fetch/use-infinite-fetch.types.ts +5 -3
  85. package/src/hooks/use-infinite-fetch/use-infinite-fetch.utils.ts +25 -1
  86. package/src/hooks/use-listener/use-listener.hooks.ts +2 -1
  87. package/src/hooks/use-queue/use-queue.hooks.ts +85 -60
  88. package/src/hooks/use-submit/use-submit.hooks.ts +163 -53
  89. package/src/provider/provider.tsx +9 -1
  90. package/__tests__/features/use-fetch/use-fetch.pagination.ts +0 -36
  91. package/__tests__/features/use-fetch/use-fetch.retry.ts +0 -38
@@ -0,0 +1,650 @@
1
+ import type { RequestInstance } from "@hyper-fetch/core";
2
+ import { act, renderHook, waitFor } from "@testing-library/react";
3
+ import type { QueueRequest, UseQueueReturnType } from "hooks/use-queue";
4
+ import { useQueue } from "hooks/use-queue";
5
+ import { expectTypeOf } from "vitest";
6
+
7
+ import { createGatedClient } from "../../utils/gated-client.utils";
8
+
9
+ const setup = (options?: { queued?: boolean; retry?: number; retryTime?: number; offline?: boolean }) => {
10
+ const gated = createGatedClient();
11
+ const request = gated.client.createRequest<{ response: { id: number }; payload: { name: string } }>()({
12
+ endpoint: "/items",
13
+ method: "POST",
14
+ queued: options?.queued ?? true,
15
+ retry: options?.retry ?? 0,
16
+ retryTime: options?.retryTime ?? 0,
17
+ offline: options?.offline ?? true,
18
+ });
19
+ const dispatcher = gated.client.submitDispatcher;
20
+ /** Adds the request to the dispatcher and returns its id */
21
+ const add = (req: RequestInstance = request) => {
22
+ let requestId = "";
23
+ act(() => {
24
+ requestId = dispatcher.add(req);
25
+ });
26
+ return requestId;
27
+ };
28
+ return { ...gated, request, dispatcher, add };
29
+ };
30
+
31
+ const getIds = (requests: QueueRequest<RequestInstance>[]) => requests.map((item) => item.requestId);
32
+
33
+ /** Run the pending timers and promise callbacks - for the tests using fake timers */
34
+ const advance = async (time = 0) => {
35
+ await act(async () => {
36
+ await vi.advanceTimersByTimeAsync(time);
37
+ });
38
+ };
39
+
40
+ describe("useQueue [ Progress ]", () => {
41
+ describe("when a request reports upload progress", () => {
42
+ it("should start with an empty progress", async () => {
43
+ const { request, add, dispatcher } = setup();
44
+ dispatcher.stop(request.queryKey);
45
+ const { result } = renderHook(() => useQueue(request));
46
+
47
+ add();
48
+
49
+ const emptyProgress = { progress: 0, timeLeft: 0, sizeLeft: 0, total: 0, loaded: 0, startTimestamp: 0 };
50
+ expect(result.current.requests[0].uploading).toStrictEqual(emptyProgress);
51
+ expect(result.current.requests[0].downloading).toStrictEqual(emptyProgress);
52
+ });
53
+ it("should update the progress of that request", async () => {
54
+ const { request, add, waitForCall } = setup();
55
+ const { result } = renderHook(() => useQueue(request));
56
+ add();
57
+ const call = await waitForCall(0);
58
+
59
+ act(() => {
60
+ call.upload(40, 100);
61
+ });
62
+
63
+ expect(result.current.requests[0].uploading.loaded).toBe(40);
64
+ expect(result.current.requests[0].uploading.total).toBe(100);
65
+ expect(result.current.requests[0].uploading.progress).toBe(40);
66
+ expect(result.current.requests[0].uploading.sizeLeft).toBe(60);
67
+ });
68
+ it("should follow the progress up to the end", async () => {
69
+ const { request, add, waitForCall } = setup();
70
+ const { result } = renderHook(() => useQueue(request));
71
+ add();
72
+ const call = await waitForCall(0);
73
+ const seen: number[] = [];
74
+
75
+ [10, 55, 100].forEach((loaded) => {
76
+ act(() => {
77
+ call.upload(loaded, 100);
78
+ });
79
+ seen.push(result.current.requests[0].uploading.progress);
80
+ });
81
+
82
+ expect(seen).toStrictEqual([10, 55, 100]);
83
+ });
84
+ it("should not touch the progress of the waiting requests", async () => {
85
+ const { request, add, waitForCall } = setup();
86
+ const { result } = renderHook(() => useQueue(request));
87
+ add();
88
+ add();
89
+ const call = await waitForCall(0);
90
+
91
+ act(() => {
92
+ call.upload(40, 100);
93
+ });
94
+
95
+ expect(result.current.requests[1].uploading.loaded).toBe(0);
96
+ expect(result.current.requests[1].downloading.loaded).toBe(0);
97
+ });
98
+ it("should track two running requests separately", async () => {
99
+ const { request, add, waitForCalls } = setup({ queued: false });
100
+ const { result } = renderHook(() => useQueue(request));
101
+ add();
102
+ add();
103
+ const calls = await waitForCalls(2);
104
+
105
+ act(() => {
106
+ calls[0].upload(10, 100);
107
+ calls[1].upload(70, 100);
108
+ });
109
+
110
+ expect(result.current.requests.map((item) => item.uploading.loaded)).toStrictEqual([10, 70]);
111
+ });
112
+ it("should keep the progress when another request joins the queue", async () => {
113
+ const { request, add, waitForCall } = setup();
114
+ const { result } = renderHook(() => useQueue(request));
115
+ add();
116
+ const call = await waitForCall(0);
117
+ act(() => {
118
+ call.upload(40, 100);
119
+ });
120
+
121
+ add();
122
+
123
+ expect(result.current.requests[0].uploading.loaded).toBe(40);
124
+ });
125
+ it("should keep the progress when the queue status changes", async () => {
126
+ const { request, add, waitForCall } = setup();
127
+ const { result } = renderHook(() => useQueue(request));
128
+ add();
129
+ const call = await waitForCall(0);
130
+ act(() => {
131
+ call.upload(40, 100);
132
+ });
133
+
134
+ act(() => {
135
+ result.current.pause();
136
+ });
137
+
138
+ expect(result.current.requests[0].uploading.loaded).toBe(40);
139
+ });
140
+ it("should ignore the progress of an unknown request", async () => {
141
+ const { request, add, waitForCall, client } = setup();
142
+ const { result } = renderHook(() => useQueue(request));
143
+ add();
144
+ await waitForCall(0);
145
+ const before = result.current.requests;
146
+
147
+ act(() => {
148
+ client.requestManager.events.emitUploadProgress({
149
+ progress: 50,
150
+ timeLeft: 1,
151
+ sizeLeft: 5,
152
+ total: 10,
153
+ loaded: 5,
154
+ startTimestamp: 1,
155
+ requestId: "unknown",
156
+ request,
157
+ });
158
+ });
159
+
160
+ expect(result.current.requests[0]).toBe(before[0]);
161
+ });
162
+ });
163
+
164
+ describe("when a request reports download progress", () => {
165
+ it("should update the progress of that request", async () => {
166
+ const { request, add, waitForCall } = setup();
167
+ const { result } = renderHook(() => useQueue(request));
168
+ add();
169
+ const call = await waitForCall(0);
170
+
171
+ act(() => {
172
+ call.download(25, 50);
173
+ });
174
+
175
+ expect(result.current.requests[0].downloading.loaded).toBe(25);
176
+ expect(result.current.requests[0].downloading.total).toBe(50);
177
+ expect(result.current.requests[0].downloading.progress).toBe(50);
178
+ });
179
+ it("should keep the upload and download progress apart", async () => {
180
+ const { request, add, waitForCall } = setup();
181
+ const { result } = renderHook(() => useQueue(request));
182
+ add();
183
+ const call = await waitForCall(0);
184
+
185
+ act(() => {
186
+ call.upload(100, 100);
187
+ call.download(10, 200);
188
+ });
189
+
190
+ expect(result.current.requests[0].uploading.loaded).toBe(100);
191
+ expect(result.current.requests[0].downloading.loaded).toBe(10);
192
+ });
193
+ it("should show the same progress in two hooks", async () => {
194
+ const { request, add, waitForCall } = setup();
195
+ const first = renderHook(() => useQueue(request));
196
+ const second = renderHook(() => useQueue(request));
197
+ add();
198
+ const call = await waitForCall(0);
199
+
200
+ act(() => {
201
+ call.download(25, 50);
202
+ });
203
+
204
+ expect(first.result.current.requests[0].downloading.loaded).toBe(25);
205
+ expect(second.result.current.requests[0].downloading.loaded).toBe(25);
206
+ });
207
+ });
208
+ });
209
+
210
+ describe("useQueue [ Finished requests ]", () => {
211
+ afterEach(() => {
212
+ vi.useRealTimers();
213
+ });
214
+
215
+ describe("given keepFinishedRequests is off", () => {
216
+ it("should drop a request as soon as it succeeds", async () => {
217
+ const { request, add, waitForCall } = setup();
218
+ const { result } = renderHook(() => useQueue(request));
219
+ add();
220
+ const call = await waitForCall(0);
221
+
222
+ act(() => {
223
+ call.succeed();
224
+ });
225
+
226
+ await waitFor(() => {
227
+ expect(result.current.requests).toStrictEqual([]);
228
+ });
229
+ });
230
+ it("should drop a request as soon as it fails for good", async () => {
231
+ const { request, add, waitForCall } = setup();
232
+ const { result } = renderHook(() => useQueue(request));
233
+ add();
234
+ const call = await waitForCall(0);
235
+
236
+ act(() => {
237
+ call.fail();
238
+ });
239
+
240
+ await waitFor(() => {
241
+ expect(result.current.requests).toStrictEqual([]);
242
+ });
243
+ });
244
+ it("should keep a request that waits for its retry", async () => {
245
+ vi.useFakeTimers();
246
+ const { request, add, calls } = setup({ retry: 1, retryTime: 5000 });
247
+ const { result } = renderHook(() => useQueue(request));
248
+ const requestId = add();
249
+ await advance();
250
+
251
+ calls[0].fail();
252
+ await advance();
253
+
254
+ expect(getIds(result.current.requests)).toStrictEqual([requestId]);
255
+ expect(result.current.requests[0].failed).toBeFalse();
256
+ });
257
+ });
258
+
259
+ describe("given keepFinishedRequests is on", () => {
260
+ it("should keep a successful request and mark it as success", async () => {
261
+ const { request, add, waitForCall, dispatcher } = setup();
262
+ const { result } = renderHook(() => useQueue(request, { keepFinishedRequests: true }));
263
+ const requestId = add();
264
+ const call = await waitForCall(0);
265
+
266
+ act(() => {
267
+ call.succeed();
268
+ });
269
+
270
+ await waitFor(() => {
271
+ expect(dispatcher.getQueue(request.queryKey).requests).toHaveLength(0);
272
+ });
273
+ expect(getIds(result.current.requests)).toStrictEqual([requestId]);
274
+ expect(result.current.requests[0].success).toBeTrue();
275
+ expect(result.current.requests[0].failed).toBeFalse();
276
+ expect(result.current.requests[0].removed).toBeFalse();
277
+ });
278
+ it("should keep a failed request and mark it as failed", async () => {
279
+ const { request, add, waitForCall, dispatcher } = setup();
280
+ const { result } = renderHook(() => useQueue(request, { keepFinishedRequests: true }));
281
+ const requestId = add();
282
+ const call = await waitForCall(0);
283
+
284
+ act(() => {
285
+ call.fail();
286
+ });
287
+
288
+ await waitFor(() => {
289
+ expect(dispatcher.getQueue(request.queryKey).requests).toHaveLength(0);
290
+ });
291
+ expect(getIds(result.current.requests)).toStrictEqual([requestId]);
292
+ expect(result.current.requests[0].failed).toBeTrue();
293
+ expect(result.current.requests[0].success).toBeFalse();
294
+ });
295
+ it("should keep the finished requests in front of the waiting ones", async () => {
296
+ const { request, add, waitForCall } = setup();
297
+ const { result } = renderHook(() => useQueue(request, { keepFinishedRequests: true }));
298
+ const ids = [add(), add(), add()];
299
+ const call = await waitForCall(0);
300
+
301
+ act(() => {
302
+ call.succeed();
303
+ });
304
+ await waitForCall(1);
305
+
306
+ await waitFor(() => {
307
+ expect(result.current.requests[0].success).toBeTrue();
308
+ });
309
+ expect(getIds(result.current.requests)).toStrictEqual(ids);
310
+ expect(result.current.requests.map((item) => item.success)).toStrictEqual([true, false, false]);
311
+ });
312
+ it("should add new requests after the finished ones", async () => {
313
+ const { request, add, waitForCall, dispatcher } = setup();
314
+ const { result } = renderHook(() => useQueue(request, { keepFinishedRequests: true }));
315
+ const first = add();
316
+ const call = await waitForCall(0);
317
+ act(() => {
318
+ call.succeed();
319
+ });
320
+ await waitFor(() => {
321
+ expect(dispatcher.getQueue(request.queryKey).requests).toHaveLength(0);
322
+ });
323
+
324
+ const second = add();
325
+ const third = add();
326
+
327
+ expect(getIds(result.current.requests)).toStrictEqual([first, second, third]);
328
+ });
329
+ it("should keep the whole history of a drained queue", async () => {
330
+ const { request, add, waitForCall, dispatcher } = setup();
331
+ const { result } = renderHook(() => useQueue(request, { keepFinishedRequests: true }));
332
+ const ids = [add(), add(), add()];
333
+
334
+ for (let index = 0; index < ids.length; index += 1) {
335
+ // eslint-disable-next-line no-await-in-loop
336
+ const call = await waitForCall(index);
337
+ act(() => {
338
+ if (index === 1) {
339
+ call.fail();
340
+ } else {
341
+ call.succeed();
342
+ }
343
+ });
344
+ }
345
+ await waitFor(() => {
346
+ expect(dispatcher.getQueue(request.queryKey).requests).toHaveLength(0);
347
+ });
348
+
349
+ expect(getIds(result.current.requests)).toStrictEqual(ids);
350
+ expect(result.current.requests.map((item) => item.success)).toStrictEqual([true, false, true]);
351
+ expect(result.current.requests.map((item) => item.failed)).toStrictEqual([false, true, false]);
352
+ });
353
+ it("should keep the last progress of a finished request", async () => {
354
+ const { request, add, waitForCall } = setup();
355
+ const { result } = renderHook(() => useQueue(request, { keepFinishedRequests: true }));
356
+ add();
357
+ const call = await waitForCall(0);
358
+
359
+ act(() => {
360
+ call.upload(100, 100);
361
+ call.succeed();
362
+ });
363
+
364
+ await waitFor(() => {
365
+ expect(result.current.requests[0].success).toBeTrue();
366
+ });
367
+ expect(result.current.requests[0].uploading.loaded).toBe(100);
368
+ });
369
+ it("should not change the progress of a finished request", async () => {
370
+ const { request, add, waitForCall, client } = setup();
371
+ const { result } = renderHook(() => useQueue(request, { keepFinishedRequests: true }));
372
+ const requestId = add();
373
+ const call = await waitForCall(0);
374
+ act(() => {
375
+ call.upload(100, 100);
376
+ call.succeed();
377
+ });
378
+ await waitFor(() => {
379
+ expect(result.current.requests[0].success).toBeTrue();
380
+ });
381
+
382
+ act(() => {
383
+ client.requestManager.events.emitUploadProgress({
384
+ progress: 1,
385
+ timeLeft: 1,
386
+ sizeLeft: 99,
387
+ total: 100,
388
+ loaded: 1,
389
+ startTimestamp: 1,
390
+ requestId,
391
+ request,
392
+ });
393
+ });
394
+
395
+ expect(result.current.requests[0].uploading.loaded).toBe(100);
396
+ });
397
+ it("should mark a deleted waiting request as removed", async () => {
398
+ const { request, add, waitForCall } = setup();
399
+ const { result } = renderHook(() => useQueue(request, { keepFinishedRequests: true }));
400
+ const ids = [add(), add()];
401
+ await waitForCall(0);
402
+
403
+ act(() => {
404
+ result.current.requests[1].deleteRequest();
405
+ });
406
+
407
+ expect(getIds(result.current.requests)).toStrictEqual(ids);
408
+ expect(result.current.requests[1].removed).toBeTrue();
409
+ expect(result.current.requests[0].removed).toBeFalse();
410
+ });
411
+ it("should mark a deleted running request as canceled and removed", async () => {
412
+ const { request, add, waitForCall } = setup();
413
+ const { result } = renderHook(() => useQueue(request, { keepFinishedRequests: true }));
414
+ add();
415
+ await waitForCall(0);
416
+
417
+ act(() => {
418
+ result.current.requests[0].deleteRequest();
419
+ });
420
+
421
+ expect(result.current.requests[0].removed).toBeTrue();
422
+ expect(result.current.requests[0].canceled).toBeTrue();
423
+ expect(result.current.requests[0].failed).toBeFalse();
424
+ });
425
+ it("should not mark a successful request as removed", async () => {
426
+ const { request, add, waitForCall, dispatcher } = setup();
427
+ const { result } = renderHook(() => useQueue(request, { keepFinishedRequests: true }));
428
+ add();
429
+ const call = await waitForCall(0);
430
+
431
+ act(() => {
432
+ call.succeed();
433
+ });
434
+ await waitFor(() => {
435
+ expect(dispatcher.getQueue(request.queryKey).requests).toHaveLength(0);
436
+ });
437
+
438
+ expect(result.current.requests[0].success).toBeTrue();
439
+ expect(result.current.requests[0].removed).toBeFalse();
440
+ });
441
+ it("should start a new history when the request changes", async () => {
442
+ const { request, client, add, waitForCall, dispatcher } = setup();
443
+ const otherRequest = client.createRequest()({ endpoint: "/other", method: "POST", queued: true });
444
+ const { result, rerender } = renderHook(
445
+ ({ current }: { current: RequestInstance }) => useQueue(current, { keepFinishedRequests: true }),
446
+ { initialProps: { current: request as RequestInstance } },
447
+ );
448
+ add();
449
+ const call = await waitForCall(0);
450
+ act(() => {
451
+ call.succeed();
452
+ });
453
+ await waitFor(() => {
454
+ expect(dispatcher.getQueue(request.queryKey).requests).toHaveLength(0);
455
+ });
456
+ expect(result.current.requests).toHaveLength(1);
457
+
458
+ rerender({ current: otherRequest });
459
+
460
+ expect(result.current.requests).toStrictEqual([]);
461
+ });
462
+ });
463
+
464
+ describe("given the request can be retried", () => {
465
+ it("should not mark the request as failed while it waits for the retry", async () => {
466
+ vi.useFakeTimers();
467
+ const { request, add, calls } = setup({ retry: 2, retryTime: 5000 });
468
+ const { result } = renderHook(() => useQueue(request, { keepFinishedRequests: true }));
469
+ add();
470
+ await advance();
471
+
472
+ calls[0].fail();
473
+ await advance();
474
+
475
+ expect(result.current.requests[0].failed).toBeFalse();
476
+ expect(result.current.requests[0].success).toBeFalse();
477
+ });
478
+ it("should mark the request as success when the retry succeeds", async () => {
479
+ vi.useFakeTimers();
480
+ const { request, add, calls } = setup({ retry: 1, retryTime: 5000 });
481
+ const { result } = renderHook(() => useQueue(request, { keepFinishedRequests: true }));
482
+ add();
483
+ await advance();
484
+ calls[0].fail();
485
+ await advance(5000);
486
+ expect(calls).toHaveLength(2);
487
+
488
+ calls[1].succeed();
489
+ await advance();
490
+
491
+ expect(result.current.requests[0].success).toBeTrue();
492
+ expect(result.current.requests[0].failed).toBeFalse();
493
+ });
494
+ it("should mark the request as failed only after the last retry", async () => {
495
+ vi.useFakeTimers();
496
+ const { request, add, calls } = setup({ retry: 2, retryTime: 5000 });
497
+ const { result } = renderHook(() => useQueue(request, { keepFinishedRequests: true }));
498
+ add();
499
+ await advance();
500
+ const failedAfterAttempt: boolean[] = [];
501
+
502
+ for (let attempt = 0; attempt < 3; attempt += 1) {
503
+ calls[attempt].fail();
504
+ // eslint-disable-next-line no-await-in-loop
505
+ await advance();
506
+ failedAfterAttempt.push(!!result.current.requests[0].failed);
507
+ // eslint-disable-next-line no-await-in-loop
508
+ await advance(5000);
509
+ }
510
+
511
+ expect(calls).toHaveLength(3);
512
+ expect(failedAfterAttempt).toStrictEqual([false, false, true]);
513
+ });
514
+ it("should keep tracking the progress of the retry", async () => {
515
+ vi.useFakeTimers();
516
+ const { request, add, calls } = setup({ retry: 1, retryTime: 5000 });
517
+ const { result } = renderHook(() => useQueue(request, { keepFinishedRequests: true }));
518
+ add();
519
+ await advance();
520
+ calls[0].upload(100, 100);
521
+ calls[0].fail();
522
+ await advance(5000);
523
+
524
+ act(() => {
525
+ calls[1].upload(30, 100);
526
+ });
527
+
528
+ expect(result.current.requests[0].uploading.loaded).toBe(30);
529
+ });
530
+ it("should keep the next request waiting during the retries", async () => {
531
+ vi.useFakeTimers();
532
+ const { request, add, calls } = setup({ retry: 1, retryTime: 5000 });
533
+ const { result } = renderHook(() => useQueue(request));
534
+ const ids = [add(), add()];
535
+ await advance();
536
+
537
+ calls[0].fail();
538
+ await advance();
539
+
540
+ expect(getIds(result.current.requests)).toStrictEqual(ids);
541
+ });
542
+ });
543
+
544
+ describe("given the application goes offline", () => {
545
+ it("should keep an offline request in the list without marking it as failed", async () => {
546
+ const { request, add, waitForCall, client, dispatcher } = setup();
547
+ const { result } = renderHook(() => useQueue(request, { keepFinishedRequests: true }));
548
+ const requestId = add();
549
+ const call = await waitForCall(0);
550
+
551
+ act(() => {
552
+ client.appManager.setOnline(false);
553
+ call.fail();
554
+ });
555
+ await waitFor(() => {
556
+ expect(dispatcher.hasRunningRequests(request.queryKey)).toBeFalse();
557
+ });
558
+
559
+ expect(getIds(result.current.requests)).toStrictEqual([requestId]);
560
+ expect(result.current.requests[0].failed).toBeFalse();
561
+ });
562
+ it("should send the request again when the connection is back", async () => {
563
+ const { request, add, waitForCall, client, dispatcher } = setup();
564
+ const { result } = renderHook(() => useQueue(request, { keepFinishedRequests: true }));
565
+ const requestId = add();
566
+ const call = await waitForCall(0);
567
+ act(() => {
568
+ client.appManager.setOnline(false);
569
+ call.fail();
570
+ });
571
+ await waitFor(() => {
572
+ expect(dispatcher.hasRunningRequests(request.queryKey)).toBeFalse();
573
+ });
574
+
575
+ act(() => {
576
+ client.appManager.setOnline(true);
577
+ });
578
+ const retried = await waitForCall(1);
579
+ expect(retried.requestId).toBe(requestId);
580
+ act(() => {
581
+ retried.succeed();
582
+ });
583
+
584
+ await waitFor(() => {
585
+ expect(result.current.requests[0].success).toBeTrue();
586
+ });
587
+ expect(result.current.requests[0].failed).toBeFalse();
588
+ });
589
+ it("should mark a request that does not wait for the network as failed", async () => {
590
+ const { request, add, waitForCall, client } = setup({ offline: false });
591
+ const { result } = renderHook(() => useQueue(request, { keepFinishedRequests: true }));
592
+ add();
593
+ const call = await waitForCall(0);
594
+
595
+ act(() => {
596
+ client.appManager.setOnline(false);
597
+ call.fail();
598
+ });
599
+
600
+ await waitFor(() => {
601
+ expect(result.current.requests[0].failed).toBeTrue();
602
+ });
603
+ });
604
+ it("should keep the requests queued while offline in the list", async () => {
605
+ const { request, add, client, calls } = setup();
606
+ const { result } = renderHook(() => useQueue(request));
607
+ act(() => {
608
+ client.appManager.setOnline(false);
609
+ });
610
+
611
+ const ids = [add(), add()];
612
+
613
+ expect(getIds(result.current.requests)).toStrictEqual(ids);
614
+ expect(calls).toHaveLength(0);
615
+ });
616
+ });
617
+ });
618
+
619
+ describe("useQueue [ Types ]", () => {
620
+ const { client } = createGatedClient();
621
+ const upload = client.createRequest<{ response: { url: string }; payload: { file: string } }>()({
622
+ endpoint: "/files/:folderId",
623
+ method: "POST",
624
+ });
625
+ type Result = UseQueueReturnType<typeof upload>;
626
+
627
+ it("should type the returned queue state", () => {
628
+ expectTypeOf<Result["stopped"]>().toEqualTypeOf<boolean>();
629
+ expectTypeOf<Result["requests"]>().toEqualTypeOf<QueueRequest<typeof upload>[]>();
630
+ expectTypeOf<Result["stop"]>().toEqualTypeOf<() => void>();
631
+ expectTypeOf<Result["pause"]>().toEqualTypeOf<() => void>();
632
+ expectTypeOf<Result["start"]>().toEqualTypeOf<() => void>();
633
+ });
634
+ it("should type the request of every item", () => {
635
+ expectTypeOf<Result["requests"][number]["request"]>().toEqualTypeOf<typeof upload>();
636
+ expectTypeOf<Result["requests"][number]["requestId"]>().toEqualTypeOf<string>();
637
+ });
638
+ it("should type the progress and the actions of every item", () => {
639
+ expectTypeOf<Result["requests"][number]["uploading"]["progress"]>().toEqualTypeOf<number>();
640
+ expectTypeOf<Result["requests"][number]["downloading"]["loaded"]>().toEqualTypeOf<number>();
641
+ expectTypeOf<Result["requests"][number]["stopRequest"]>().toEqualTypeOf<() => void>();
642
+ expectTypeOf<Result["requests"][number]["startRequest"]>().toEqualTypeOf<() => void>();
643
+ expectTypeOf<Result["requests"][number]["deleteRequest"]>().toEqualTypeOf<() => void>();
644
+ });
645
+ it("should accept only the known options", () => {
646
+ expectTypeOf(useQueue<typeof upload>)
647
+ .parameter(1)
648
+ .toEqualTypeOf<{ dispatcherType?: "auto" | "fetch" | "submit"; keepFinishedRequests?: boolean } | undefined>();
649
+ });
650
+ });