@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,593 @@
1
+ import type { RequestInstance } from "@hyper-fetch/core";
2
+ import { act, renderHook, waitFor } from "@testing-library/react";
3
+ import type { QueueRequest } from "hooks/use-queue";
4
+ import { useQueue } from "hooks/use-queue";
5
+
6
+ import { createGatedClient } from "../../utils/gated-client.utils";
7
+
8
+ const setup = (options?: { queued?: boolean; retry?: number; retryTime?: number; offline?: boolean }) => {
9
+ const gated = createGatedClient();
10
+ const request = gated.client.createRequest<{ response: { id: number }; payload: { name: string } }>()({
11
+ endpoint: "/items",
12
+ method: "POST",
13
+ queued: options?.queued ?? true,
14
+ retry: options?.retry ?? 0,
15
+ retryTime: options?.retryTime ?? 0,
16
+ offline: options?.offline ?? true,
17
+ });
18
+ const dispatcher = gated.client.submitDispatcher;
19
+ /** Adds the request to the dispatcher and returns its id */
20
+ const add = (req: RequestInstance = request) => {
21
+ let requestId = "";
22
+ act(() => {
23
+ requestId = dispatcher.add(req);
24
+ });
25
+ return requestId;
26
+ };
27
+ const getQueueIds = () => dispatcher.getQueue(request.queryKey).requests.map((item) => item.requestId);
28
+ return { ...gated, request, dispatcher, add, getQueueIds };
29
+ };
30
+
31
+ const getIds = (requests: QueueRequest<RequestInstance>[]) => requests.map((item) => item.requestId);
32
+
33
+ const countListeners = (emitter: {
34
+ eventNames: () => (string | symbol)[];
35
+ listenerCount: (name: string | symbol) => number;
36
+ }) => emitter.eventNames().reduce((sum, name) => sum + emitter.listenerCount(name), 0);
37
+
38
+ describe("useQueue [ Controls ]", () => {
39
+ describe("when the queue gets stopped", () => {
40
+ it("should report the stopped status", () => {
41
+ const { request } = setup();
42
+ const { result } = renderHook(() => useQueue(request));
43
+
44
+ act(() => {
45
+ result.current.stop();
46
+ });
47
+
48
+ expect(result.current.stopped).toBeTrue();
49
+ });
50
+ it("should cancel the running request and keep it in the list", async () => {
51
+ const { request, add, waitForCall } = setup();
52
+ const { result } = renderHook(() => useQueue(request));
53
+ const requestId = add();
54
+ const call = await waitForCall(0);
55
+
56
+ act(() => {
57
+ result.current.stop();
58
+ });
59
+
60
+ expect(call.aborted).toBeTrue();
61
+ await waitFor(() => {
62
+ expect(result.current.requests[0].canceled).toBeTrue();
63
+ });
64
+ expect(getIds(result.current.requests)).toStrictEqual([requestId]);
65
+ });
66
+ it("should not mark the canceled request as failed", async () => {
67
+ const { request, add, waitForCall, dispatcher } = setup();
68
+ const { result } = renderHook(() => useQueue(request));
69
+ add();
70
+ await waitForCall(0);
71
+
72
+ act(() => {
73
+ result.current.stop();
74
+ });
75
+ // The canceled response went through the dispatcher
76
+ await waitFor(() => {
77
+ expect(dispatcher.getQueue(request.queryKey).requests[0].resolved).toBeTrue();
78
+ });
79
+
80
+ expect(result.current.requests[0].failed).toBeFalse();
81
+ expect(result.current.requests[0].success).toBeFalse();
82
+ });
83
+ it("should not send the waiting requests", async () => {
84
+ const { request, add, waitForCall, calls, getQueueIds } = setup();
85
+ const { result } = renderHook(() => useQueue(request));
86
+ const ids = [add(), add(), add()];
87
+ await waitForCall(0);
88
+
89
+ act(() => {
90
+ result.current.stop();
91
+ });
92
+ await waitFor(() => {
93
+ expect(result.current.requests[0].canceled).toBeTrue();
94
+ });
95
+
96
+ expect(calls).toHaveLength(1);
97
+ expect(getQueueIds()).toStrictEqual(ids);
98
+ expect(getIds(result.current.requests)).toStrictEqual(ids);
99
+ });
100
+ it("should keep new requests waiting while the queue is stopped", async () => {
101
+ const { request, add, calls } = setup();
102
+ const { result } = renderHook(() => useQueue(request));
103
+
104
+ act(() => {
105
+ result.current.stop();
106
+ });
107
+ const ids = [add(), add()];
108
+
109
+ expect(getIds(result.current.requests)).toStrictEqual(ids);
110
+ expect(result.current.stopped).toBeTrue();
111
+ expect(calls).toHaveLength(0);
112
+ });
113
+ it("should follow a stop made directly on the dispatcher", () => {
114
+ const { request, dispatcher } = setup();
115
+ const { result } = renderHook(() => useQueue(request));
116
+
117
+ act(() => {
118
+ dispatcher.stop(request.queryKey);
119
+ });
120
+
121
+ expect(result.current.stopped).toBeTrue();
122
+ });
123
+ });
124
+
125
+ describe("when the stopped queue gets started", () => {
126
+ it("should report the running status", () => {
127
+ const { request } = setup();
128
+ const { result } = renderHook(() => useQueue(request));
129
+
130
+ act(() => {
131
+ result.current.stop();
132
+ });
133
+ act(() => {
134
+ result.current.start();
135
+ });
136
+
137
+ expect(result.current.stopped).toBeFalse();
138
+ });
139
+ it("should send the canceled request again", async () => {
140
+ const { request, add, waitForCall } = setup();
141
+ const { result } = renderHook(() => useQueue(request));
142
+ const requestId = add();
143
+ await waitForCall(0);
144
+ act(() => {
145
+ result.current.stop();
146
+ });
147
+ await waitFor(() => {
148
+ expect(result.current.requests[0].canceled).toBeTrue();
149
+ });
150
+
151
+ act(() => {
152
+ result.current.start();
153
+ });
154
+
155
+ const secondCall = await waitForCall(1);
156
+ expect(secondCall.requestId).toBe(requestId);
157
+ });
158
+ it("should clear the canceled flag once the request runs again", async () => {
159
+ const { request, add, waitForCall } = setup();
160
+ const { result } = renderHook(() => useQueue(request));
161
+ add();
162
+ await waitForCall(0);
163
+ act(() => {
164
+ result.current.stop();
165
+ });
166
+ await waitFor(() => {
167
+ expect(result.current.requests[0].canceled).toBeTrue();
168
+ });
169
+
170
+ act(() => {
171
+ result.current.start();
172
+ });
173
+ await waitForCall(1);
174
+
175
+ await waitFor(() => {
176
+ expect(result.current.requests[0].canceled).toBeFalse();
177
+ });
178
+ });
179
+ it("should finish the restarted request and continue with the queue", async () => {
180
+ const { request, add, waitForCall } = setup();
181
+ const { result } = renderHook(() => useQueue(request));
182
+ add();
183
+ const second = add();
184
+ await waitForCall(0);
185
+ act(() => {
186
+ result.current.stop();
187
+ });
188
+ await waitFor(() => {
189
+ expect(result.current.requests[0].canceled).toBeTrue();
190
+ });
191
+ act(() => {
192
+ result.current.start();
193
+ });
194
+
195
+ const restarted = await waitForCall(1);
196
+ act(() => {
197
+ restarted.succeed();
198
+ });
199
+
200
+ const next = await waitForCall(2);
201
+ expect(next.requestId).toBe(second);
202
+ await waitFor(() => {
203
+ expect(getIds(result.current.requests)).toStrictEqual([second]);
204
+ });
205
+ });
206
+ it("should send the requests queued while it was stopped", async () => {
207
+ const { request, add, waitForCall } = setup();
208
+ const { result } = renderHook(() => useQueue(request));
209
+ act(() => {
210
+ result.current.stop();
211
+ });
212
+ const first = add();
213
+ add();
214
+
215
+ act(() => {
216
+ result.current.start();
217
+ });
218
+
219
+ const call = await waitForCall(0);
220
+ expect(call.requestId).toBe(first);
221
+ });
222
+ });
223
+
224
+ describe("when the queue gets paused", () => {
225
+ it("should report the stopped status", () => {
226
+ const { request } = setup();
227
+ const { result } = renderHook(() => useQueue(request));
228
+
229
+ act(() => {
230
+ result.current.pause();
231
+ });
232
+
233
+ expect(result.current.stopped).toBeTrue();
234
+ });
235
+ it("should let the running request finish", async () => {
236
+ const { request, add, waitForCall } = setup();
237
+ const { result } = renderHook(() => useQueue(request));
238
+ add();
239
+ const second = add();
240
+ const call = await waitForCall(0);
241
+
242
+ act(() => {
243
+ result.current.pause();
244
+ });
245
+ expect(call.aborted).toBeFalse();
246
+
247
+ act(() => {
248
+ call.succeed();
249
+ });
250
+
251
+ await waitFor(() => {
252
+ expect(getIds(result.current.requests)).toStrictEqual([second]);
253
+ });
254
+ });
255
+ it("should not send the next request until the queue is started", async () => {
256
+ const { request, add, waitForCall, calls } = setup();
257
+ const { result } = renderHook(() => useQueue(request));
258
+ add();
259
+ const second = add();
260
+ const call = await waitForCall(0);
261
+ act(() => {
262
+ result.current.pause();
263
+ });
264
+ act(() => {
265
+ call.succeed();
266
+ });
267
+ await waitFor(() => {
268
+ expect(getIds(result.current.requests)).toStrictEqual([second]);
269
+ });
270
+ expect(calls).toHaveLength(1);
271
+
272
+ act(() => {
273
+ result.current.start();
274
+ });
275
+
276
+ const nextCall = await waitForCall(1);
277
+ expect(nextCall.requestId).toBe(second);
278
+ });
279
+ it("should not mark the running request as canceled", async () => {
280
+ const { request, add, waitForCall } = setup();
281
+ const { result } = renderHook(() => useQueue(request));
282
+ add();
283
+ await waitForCall(0);
284
+
285
+ act(() => {
286
+ result.current.pause();
287
+ });
288
+
289
+ expect(result.current.requests[0].canceled).toBeFalse();
290
+ });
291
+ });
292
+
293
+ describe("when a single request gets stopped", () => {
294
+ it("should mark only that request as stopped", async () => {
295
+ const { request, add, waitForCall } = setup();
296
+ const { result } = renderHook(() => useQueue(request));
297
+ add();
298
+ add();
299
+ add();
300
+ await waitForCall(0);
301
+
302
+ act(() => {
303
+ result.current.requests[1].stopRequest();
304
+ });
305
+
306
+ expect(result.current.requests.map((item) => item.stopped)).toStrictEqual([false, true, false]);
307
+ expect(result.current.stopped).toBeFalse();
308
+ });
309
+ it("should cancel it when it is running", async () => {
310
+ const { request, add, waitForCall } = setup();
311
+ const { result } = renderHook(() => useQueue(request));
312
+ add();
313
+ const call = await waitForCall(0);
314
+
315
+ act(() => {
316
+ result.current.requests[0].stopRequest();
317
+ });
318
+
319
+ expect(call.aborted).toBeTrue();
320
+ await waitFor(() => {
321
+ expect(result.current.requests[0].canceled).toBeTrue();
322
+ });
323
+ expect(result.current.requests[0].stopped).toBeTrue();
324
+ });
325
+ it("should skip the stopped request and send the next one", async () => {
326
+ const { request, add, waitForCall } = setup();
327
+ const { result } = renderHook(() => useQueue(request));
328
+ add();
329
+ const second = add();
330
+ const third = add();
331
+ const firstCall = await waitForCall(0);
332
+
333
+ act(() => {
334
+ result.current.requests[1].stopRequest();
335
+ });
336
+ act(() => {
337
+ firstCall.succeed();
338
+ });
339
+
340
+ const nextCall = await waitForCall(1);
341
+ expect(nextCall.requestId).toBe(third);
342
+ await waitFor(() => {
343
+ expect(getIds(result.current.requests)).toStrictEqual([second, third]);
344
+ });
345
+ });
346
+ it("should keep the stopped request in the list", async () => {
347
+ const { request, add, waitForCall, getQueueIds } = setup();
348
+ const { result } = renderHook(() => useQueue(request));
349
+ const first = add();
350
+ const second = add();
351
+ await waitForCall(0);
352
+
353
+ act(() => {
354
+ result.current.requests[1].stopRequest();
355
+ });
356
+
357
+ expect(getIds(result.current.requests)).toStrictEqual([first, second]);
358
+ expect(getQueueIds()).toStrictEqual([first, second]);
359
+ });
360
+ });
361
+
362
+ describe("when a single stopped request gets started", () => {
363
+ it("should clear its stopped status", async () => {
364
+ const { request, add, waitForCall } = setup();
365
+ const { result } = renderHook(() => useQueue(request));
366
+ add();
367
+ add();
368
+ await waitForCall(0);
369
+ act(() => {
370
+ result.current.requests[1].stopRequest();
371
+ });
372
+
373
+ act(() => {
374
+ result.current.requests[1].startRequest();
375
+ });
376
+
377
+ expect(result.current.requests.map((item) => item.stopped)).toStrictEqual([false, false]);
378
+ });
379
+ it("should send it again when nothing else is running", async () => {
380
+ const { request, add, waitForCall } = setup();
381
+ const { result } = renderHook(() => useQueue(request));
382
+ const requestId = add();
383
+ await waitForCall(0);
384
+ act(() => {
385
+ result.current.requests[0].stopRequest();
386
+ });
387
+ await waitFor(() => {
388
+ expect(result.current.requests[0].canceled).toBeTrue();
389
+ });
390
+
391
+ act(() => {
392
+ result.current.requests[0].startRequest();
393
+ });
394
+
395
+ const call = await waitForCall(1);
396
+ expect(call.requestId).toBe(requestId);
397
+ await waitFor(() => {
398
+ expect(result.current.requests[0].canceled).toBeFalse();
399
+ });
400
+ });
401
+ });
402
+
403
+ describe("when a single request gets deleted", () => {
404
+ it("should remove a waiting request without sending it", async () => {
405
+ const { request, add, waitForCall, calls, getQueueIds } = setup();
406
+ const { result } = renderHook(() => useQueue(request));
407
+ const first = add();
408
+ add();
409
+ const call = await waitForCall(0);
410
+
411
+ act(() => {
412
+ result.current.requests[1].deleteRequest();
413
+ });
414
+ act(() => {
415
+ call.succeed();
416
+ });
417
+
418
+ await waitFor(() => {
419
+ expect(result.current.requests).toStrictEqual([]);
420
+ });
421
+ expect(getQueueIds()).toStrictEqual([]);
422
+ expect(calls).toHaveLength(1);
423
+ expect(first).toBeString();
424
+ });
425
+ it("should cancel the running request and start the next one", async () => {
426
+ const { request, add, waitForCall } = setup();
427
+ const { result } = renderHook(() => useQueue(request));
428
+ add();
429
+ const second = add();
430
+ const call = await waitForCall(0);
431
+
432
+ act(() => {
433
+ result.current.requests[0].deleteRequest();
434
+ });
435
+
436
+ expect(call.aborted).toBeTrue();
437
+ const nextCall = await waitForCall(1);
438
+ expect(nextCall.requestId).toBe(second);
439
+ expect(getIds(result.current.requests)).toStrictEqual([second]);
440
+ });
441
+ it("should resolve the send promise of the deleted request with an error", async () => {
442
+ const { request, waitForCall } = setup();
443
+ const { result } = renderHook(() => useQueue(request));
444
+ let promise: ReturnType<typeof request.send> | null = null;
445
+ act(() => {
446
+ promise = request.send({ payload: { name: "Maciej" } });
447
+ });
448
+ await waitForCall(0);
449
+
450
+ act(() => {
451
+ result.current.requests[0].deleteRequest();
452
+ });
453
+
454
+ const response = await promise!;
455
+ expect(response.success).toBeFalse();
456
+ expect(response.data).toBeNull();
457
+ expect(response.error).toBeInstanceOf(Error);
458
+ });
459
+ it("should delete from a stopped queue", () => {
460
+ const { request, add, getQueueIds } = setup();
461
+ const { result } = renderHook(() => useQueue(request));
462
+ act(() => {
463
+ result.current.stop();
464
+ });
465
+ add();
466
+ const second = add();
467
+
468
+ act(() => {
469
+ result.current.requests[0].deleteRequest();
470
+ });
471
+
472
+ expect(getIds(result.current.requests)).toStrictEqual([second]);
473
+ expect(getQueueIds()).toStrictEqual([second]);
474
+ });
475
+ });
476
+
477
+ describe("when two hooks control the same queue", () => {
478
+ it("should show the stopped status in both", () => {
479
+ const { request } = setup();
480
+ const first = renderHook(() => useQueue(request));
481
+ const second = renderHook(() => useQueue(request));
482
+
483
+ act(() => {
484
+ first.result.current.stop();
485
+ });
486
+
487
+ expect(first.result.current.stopped).toBeTrue();
488
+ expect(second.result.current.stopped).toBeTrue();
489
+ });
490
+ it("should let one hook start the queue stopped by the other", () => {
491
+ const { request } = setup();
492
+ const first = renderHook(() => useQueue(request));
493
+ const second = renderHook(() => useQueue(request));
494
+
495
+ act(() => {
496
+ first.result.current.stop();
497
+ });
498
+ act(() => {
499
+ second.result.current.start();
500
+ });
501
+
502
+ expect(first.result.current.stopped).toBeFalse();
503
+ expect(second.result.current.stopped).toBeFalse();
504
+ });
505
+ it("should remove a request deleted by the other hook", async () => {
506
+ const { request, add, waitForCall } = setup();
507
+ const first = renderHook(() => useQueue(request));
508
+ const second = renderHook(() => useQueue(request));
509
+ const firstId = add();
510
+ add();
511
+ await waitForCall(0);
512
+
513
+ act(() => {
514
+ second.result.current.requests[1].deleteRequest();
515
+ });
516
+
517
+ expect(getIds(first.result.current.requests)).toStrictEqual([firstId]);
518
+ expect(getIds(second.result.current.requests)).toStrictEqual([firstId]);
519
+ });
520
+ it("should show the single request stopped by the other hook", async () => {
521
+ const { request, add, waitForCall } = setup();
522
+ const first = renderHook(() => useQueue(request));
523
+ const second = renderHook(() => useQueue(request));
524
+ add();
525
+ add();
526
+ await waitForCall(0);
527
+
528
+ act(() => {
529
+ second.result.current.requests[1].stopRequest();
530
+ });
531
+
532
+ expect(first.result.current.requests[1].stopped).toBeTrue();
533
+ });
534
+ });
535
+
536
+ describe("when the hook subscribes to events", () => {
537
+ it("should remove every listener on unmount", () => {
538
+ const { request, client } = setup();
539
+ const requestListeners = countListeners(client.requestManager.emitter);
540
+ const dispatcherListeners = countListeners(client.submitDispatcher.emitter);
541
+
542
+ const view = renderHook(() => useQueue(request));
543
+ expect(countListeners(client.requestManager.emitter)).toBeGreaterThan(requestListeners);
544
+ expect(countListeners(client.submitDispatcher.emitter)).toBeGreaterThan(dispatcherListeners);
545
+
546
+ view.unmount();
547
+
548
+ expect(countListeners(client.requestManager.emitter)).toBe(requestListeners);
549
+ expect(countListeners(client.submitDispatcher.emitter)).toBe(dispatcherListeners);
550
+ });
551
+ it("should not add listeners as the queue changes", async () => {
552
+ const { request, client, dispatcher, waitForCall } = setup();
553
+ const { result } = renderHook(() => useQueue(request));
554
+ const dispatcherListeners = countListeners(client.submitDispatcher.emitter);
555
+
556
+ act(() => {
557
+ result.current.pause();
558
+ });
559
+ const requestListeners = countListeners(client.requestManager.emitter);
560
+ act(() => {
561
+ for (let i = 0; i < 10; i += 1) {
562
+ dispatcher.add(request);
563
+ }
564
+ });
565
+ act(() => {
566
+ result.current.requests[3].stopRequest();
567
+ result.current.requests[5].deleteRequest();
568
+ });
569
+
570
+ expect(countListeners(client.requestManager.emitter)).toBe(requestListeners);
571
+ expect(countListeners(client.submitDispatcher.emitter)).toBe(dispatcherListeners);
572
+ expect(result.current.requests).toHaveLength(9);
573
+ act(() => {
574
+ result.current.start();
575
+ });
576
+ await waitForCall(0);
577
+ });
578
+ it("should remove the listeners of the previous queue when the request changes", () => {
579
+ const { request, client } = setup();
580
+ const otherRequest = client.createRequest()({ endpoint: "/other", method: "POST", queued: true });
581
+ const view = renderHook(({ current }: { current: RequestInstance }) => useQueue(current), {
582
+ initialProps: { current: request as RequestInstance },
583
+ });
584
+ const requestListeners = countListeners(client.requestManager.emitter);
585
+ const dispatcherListeners = countListeners(client.submitDispatcher.emitter);
586
+
587
+ view.rerender({ current: otherRequest });
588
+
589
+ expect(countListeners(client.requestManager.emitter)).toBe(requestListeners);
590
+ expect(countListeners(client.submitDispatcher.emitter)).toBe(dispatcherListeners);
591
+ });
592
+ });
593
+ });