@hyper-fetch/react 7.5.2 → 7.5.3

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 (70) hide show
  1. package/__tests__/features/helpers/use-request-events/use-request-events.base.spec.ts +115 -0
  2. package/__tests__/features/helpers/use-request-events/use-request-events.utils.spec.ts +69 -0
  3. package/__tests__/features/helpers/use-socket-state/use-socket-state.base.spec.ts +175 -0
  4. package/__tests__/features/helpers/use-tracked-state/use-tacked-state.actions.spec.ts +382 -0
  5. package/__tests__/features/helpers/use-tracked-state/use-tracked-state.base.spec.ts +527 -0
  6. package/__tests__/features/helpers/use-tracked-state/use-tracked-state.utils.spec.ts +260 -0
  7. package/__tests__/features/provider/provider.hydration.spec.tsx +161 -0
  8. package/__tests__/features/provider/use-config-provider.base.spec.tsx +68 -0
  9. package/__tests__/features/use-app-manager/use-app-manager.base.spec.ts +85 -0
  10. package/__tests__/features/use-cache/use-cache.base.spec.ts +133 -0
  11. package/__tests__/features/use-cache/use-cache.helpers.ts +40 -0
  12. package/__tests__/features/use-emitter/use-emitter.base.spec.ts +124 -0
  13. package/__tests__/features/use-fetch/use-fetch.base.spec.ts +284 -0
  14. package/__tests__/features/use-fetch/use-fetch.cancel.spec.ts +83 -0
  15. package/__tests__/features/use-fetch/use-fetch.concurrency.spec.ts +91 -0
  16. package/__tests__/features/use-fetch/use-fetch.debounce.spec.ts +153 -0
  17. package/__tests__/features/use-fetch/use-fetch.deduplication.spec.ts +80 -0
  18. package/__tests__/features/use-fetch/use-fetch.infinite.ts +39 -0
  19. package/__tests__/features/use-fetch/use-fetch.integration.spec.tsx +172 -0
  20. package/__tests__/features/use-fetch/use-fetch.methods.spec.ts +233 -0
  21. package/__tests__/features/use-fetch/use-fetch.offline.spec.ts +103 -0
  22. package/__tests__/features/use-fetch/use-fetch.pagination.ts +36 -0
  23. package/__tests__/features/use-fetch/use-fetch.prefetch.spec.tsx +73 -0
  24. package/__tests__/features/use-fetch/use-fetch.refresh.spec.ts +153 -0
  25. package/__tests__/features/use-fetch/use-fetch.rerender.spec.tsx +151 -0
  26. package/__tests__/features/use-fetch/use-fetch.retry.ts +38 -0
  27. package/__tests__/features/use-fetch/use-fetch.revalidate.spec.ts +235 -0
  28. package/__tests__/features/use-fetch/use-fetch.suspense.ts +37 -0
  29. package/__tests__/features/use-fetch/use-fetch.typescript.spec.ts +59 -0
  30. package/__tests__/features/use-fetch/use-fetch.utils.spec.ts +26 -0
  31. package/__tests__/features/use-fetch/use-fetch.window.spec.ts +59 -0
  32. package/__tests__/features/use-listener/use-listener.base.spec.ts +57 -0
  33. package/__tests__/features/use-queue/use-queue.actions.spec.ts +238 -0
  34. package/__tests__/features/use-queue/use-queue.base.spec.ts +109 -0
  35. package/__tests__/features/use-submit/use-submit.base.spec.ts +76 -0
  36. package/__tests__/features/use-submit/use-submit.cancel.spec.ts +46 -0
  37. package/__tests__/features/use-submit/use-submit.concurrency.spec.ts +62 -0
  38. package/__tests__/features/use-submit/use-submit.debounce.spec.ts +320 -0
  39. package/__tests__/features/use-submit/use-submit.methods.spec.ts +278 -0
  40. package/__tests__/features/use-submit/use-submit.queue.spec.ts +84 -0
  41. package/__tests__/features/use-submit/use-submit.retry.spec.ts +92 -0
  42. package/__tests__/features/use-submit/use-submit.revalidate.spec.ts +99 -0
  43. package/__tests__/features/use-submit/use-submit.submit.spec.ts +233 -0
  44. package/__tests__/global.d.ts +1 -0
  45. package/__tests__/jest.setup.ts +9 -0
  46. package/__tests__/shared/index.ts +2 -0
  47. package/__tests__/shared/isolation.tests.ts +12 -0
  48. package/__tests__/shared/response.tests.ts +127 -0
  49. package/__tests__/tsconfig.json +8 -0
  50. package/__tests__/utils/cache.utils.ts +53 -0
  51. package/__tests__/utils/client.utils.ts +3 -0
  52. package/__tests__/utils/emitter.utils.ts +7 -0
  53. package/__tests__/utils/helpers.utils.ts +9 -0
  54. package/__tests__/utils/index.ts +14 -0
  55. package/__tests__/utils/listener.utils.ts +10 -0
  56. package/__tests__/utils/request.utils.ts +12 -0
  57. package/__tests__/utils/state.utils.ts +7 -0
  58. package/__tests__/utils/use-app-manager.utils.ts +10 -0
  59. package/__tests__/utils/use-cache.utils.ts +11 -0
  60. package/__tests__/utils/use-emitter.utils.ts +11 -0
  61. package/__tests__/utils/use-fetch.utils.ts +11 -0
  62. package/__tests__/utils/use-listener.utils.ts +11 -0
  63. package/__tests__/utils/use-queue.utils.ts +68 -0
  64. package/__tests__/utils/use-request-events.utils.ts +42 -0
  65. package/__tests__/utils/use-socket-state.utils.ts +11 -0
  66. package/__tests__/utils/use-submit.utils.ts +11 -0
  67. package/__tests__/utils/use-tracked-state.utils.ts +26 -0
  68. package/jest.config.ts +6 -0
  69. package/package.json +1 -1
  70. package/project.json +4 -0
@@ -0,0 +1,320 @@
1
+ import { RequestInstance, ExtractAdapterResolvedType } from "@hyper-fetch/core";
2
+ import { act, waitFor } from "@testing-library/react";
3
+ import { createHttpMockingServer } from "@hyper-fetch/testing";
4
+
5
+ import { client, createRequest, renderUseSubmit, waitForRender } from "../../utils";
6
+
7
+ const { resetMocks, startServer, stopServer, mockRequest } = createHttpMockingServer();
8
+
9
+ describe("useSubmit [ Bounce ]", () => {
10
+ const hookDebounceOptions = { bounce: true, bounceType: "debounce", bounceTime: 50 } as const;
11
+ const hookThrottleOptions = { bounce: true, bounceType: "throttle", bounceTime: 50, bounceTimeout: 50 } as const;
12
+
13
+ let request = createRequest<null, null>({ method: "POST" });
14
+
15
+ beforeAll(() => {
16
+ startServer();
17
+ });
18
+
19
+ afterEach(() => {
20
+ resetMocks();
21
+ });
22
+
23
+ afterAll(() => {
24
+ stopServer();
25
+ });
26
+
27
+ beforeEach(() => {
28
+ jest.resetModules();
29
+ client.clear();
30
+ request = createRequest({ method: "POST" });
31
+ });
32
+
33
+ describe("given debounce is active", () => {
34
+ describe("when request is about to change", () => {
35
+ it("should debounce single request", async () => {
36
+ let submitTime: number | null = null;
37
+ let startTime: number | null = null;
38
+ mockRequest(request);
39
+ const response = renderUseSubmit(request, hookDebounceOptions);
40
+
41
+ act(() => {
42
+ response.result.current.onSubmitRequestStart(() => {
43
+ startTime = +new Date();
44
+ });
45
+ submitTime = +new Date();
46
+ response.result.current.submit();
47
+ });
48
+
49
+ await waitFor(() => {
50
+ expect(startTime).not.toBeNull();
51
+ });
52
+
53
+ expect((startTime || 0) - (submitTime || 0)).toBeGreaterThanOrEqual(hookDebounceOptions.bounceTime);
54
+ });
55
+ it("should debounce multiple request triggers by bounceTime", async () => {
56
+ const spy = jest.fn();
57
+ let submitTime: number | null = null;
58
+ let startTime: number | null = null;
59
+ mockRequest(request);
60
+ const response = renderUseSubmit(request, hookDebounceOptions);
61
+
62
+ await act(async () => {
63
+ response.result.current.onSubmitRequestStart(() => {
64
+ spy();
65
+ startTime = +new Date();
66
+ });
67
+ submitTime = +new Date();
68
+ response.result.current.submit();
69
+ await waitForRender(10);
70
+ response.result.current.submit();
71
+ await waitForRender(10);
72
+ response.result.current.submit();
73
+ await waitForRender(10);
74
+ response.result.current.submit();
75
+ });
76
+
77
+ await waitFor(() => {
78
+ expect(startTime).not.toBeNull();
79
+ });
80
+
81
+ expect((startTime || 0) - (submitTime || 0)).toBeGreaterThanOrEqual(hookDebounceOptions.bounceTime);
82
+ expect(spy).toHaveBeenCalledTimes(1);
83
+ });
84
+ it("should resolve debounced methods", async () => {
85
+ mockRequest(request);
86
+ const response = renderUseSubmit(request, hookDebounceOptions);
87
+
88
+ let value: ExtractAdapterResolvedType<RequestInstance>[] = [];
89
+ await act(async () => {
90
+ const promiseOne = await response.result.current.submit();
91
+ await waitForRender(1);
92
+ const promiseTwo = await response.result.current.submit();
93
+ await waitForRender(1);
94
+ const promiseThree = await response.result.current.submit();
95
+ await waitForRender(1);
96
+ const promiseFour = await response.result.current.submit();
97
+
98
+ value = [promiseOne, promiseTwo, promiseThree, promiseFour];
99
+ });
100
+
101
+ expect(value).toHaveLength(4);
102
+ const isResponse = (res: ExtractAdapterResolvedType<RequestInstance>) => {
103
+ return Boolean(!!res.data && !res.error && res.status === 200 && res.extra);
104
+ };
105
+ expect(value).toSatisfyAny(isResponse);
106
+ expect(value).toHaveLength(4);
107
+ });
108
+ it("should change debounce time", async () => {
109
+ const newBounceTime = 200;
110
+ const spy = jest.fn();
111
+ let submitTime: number | null = null;
112
+ let startTime: number | null = null;
113
+ mockRequest(request);
114
+ const response = renderUseSubmit(request, hookDebounceOptions);
115
+
116
+ await act(async () => {
117
+ await response.rerender({ bounceTime: newBounceTime });
118
+ });
119
+
120
+ await waitForRender(1);
121
+
122
+ await act(async () => {
123
+ response.result.current.onSubmitRequestStart(() => {
124
+ spy();
125
+ startTime = +new Date();
126
+ });
127
+ submitTime = +new Date();
128
+ response.result.current.submit();
129
+ await waitForRender(10);
130
+ response.result.current.submit();
131
+ await waitForRender(10);
132
+ response.result.current.submit();
133
+ await waitForRender(10);
134
+ response.result.current.submit();
135
+ });
136
+
137
+ await waitFor(() => {
138
+ expect(startTime).not.toBeNull();
139
+ });
140
+
141
+ expect((startTime || 0) - (submitTime || 0)).toBeGreaterThanOrEqual(newBounceTime);
142
+ expect(spy).toHaveBeenCalledTimes(1);
143
+ });
144
+ });
145
+ });
146
+
147
+ describe("given debounce is off", () => {
148
+ describe("when request is about to change", () => {
149
+ it("should not debounce multiple request triggers", async () => {
150
+ const spy = jest.fn();
151
+ let startTime: number | null = null;
152
+ mockRequest(request, { delay: 0 });
153
+ const response = renderUseSubmit(request);
154
+
155
+ await act(async () => {
156
+ response.result.current.onSubmitRequestStart(() => {
157
+ spy();
158
+ startTime = +new Date();
159
+ });
160
+ response.result.current.submit();
161
+ await waitForRender(10);
162
+ response.result.current.submit();
163
+ await waitForRender(10);
164
+ response.result.current.submit();
165
+ await waitForRender(10);
166
+ response.result.current.submit();
167
+ });
168
+
169
+ await waitFor(() => {
170
+ expect(startTime).not.toBeNull();
171
+ });
172
+
173
+ expect(spy).toHaveBeenCalledTimes(4);
174
+ });
175
+ });
176
+ });
177
+
178
+ describe("given throttle is active", () => {
179
+ describe("when request is about to change", () => {
180
+ it("should throttle single request", async () => {
181
+ let submitTime: number | null = null;
182
+ let startTime: number | null = null;
183
+ mockRequest(request);
184
+ const response = renderUseSubmit(request, hookThrottleOptions);
185
+
186
+ act(() => {
187
+ response.result.current.onSubmitRequestStart(() => {
188
+ startTime = +new Date();
189
+ });
190
+ submitTime = +new Date();
191
+ response.result.current.submit();
192
+ response.result.current.submit();
193
+ });
194
+
195
+ await waitFor(() => {
196
+ expect(startTime).not.toBeNull();
197
+ expect((startTime || 0) - (submitTime || 0)).toBeGreaterThanOrEqual(hookThrottleOptions.bounceTime);
198
+ });
199
+ });
200
+ it("should throttle multiple request triggers by bounceTime", async () => {
201
+ const spy = jest.fn();
202
+ let submitTime: number | null = null;
203
+ let startTime: number | null = null;
204
+ mockRequest(request);
205
+ const response = renderUseSubmit(request, hookThrottleOptions);
206
+
207
+ await act(async () => {
208
+ response.result.current.onSubmitRequestStart(() => {
209
+ spy();
210
+ startTime = +new Date();
211
+ });
212
+ submitTime = +new Date();
213
+ response.result.current.submit();
214
+ await waitForRender(10);
215
+ response.result.current.submit();
216
+ await waitForRender(10);
217
+ response.result.current.submit();
218
+ await waitForRender(10);
219
+ response.result.current.submit();
220
+ });
221
+
222
+ await waitFor(() => {
223
+ expect(startTime).not.toBeNull();
224
+ expect((startTime || 0) - (submitTime || 0)).toBeGreaterThanOrEqual(hookThrottleOptions.bounceTime);
225
+ expect(spy).toHaveBeenCalledTimes(2);
226
+ });
227
+ });
228
+ it("should resolve throttled methods", async () => {
229
+ mockRequest(request);
230
+ const response = renderUseSubmit(request, hookThrottleOptions);
231
+
232
+ let value: ExtractAdapterResolvedType<RequestInstance>[] = [];
233
+ await act(async () => {
234
+ const promiseOne = await response.result.current.submit();
235
+ await waitForRender(1);
236
+ const promiseTwo = await response.result.current.submit();
237
+ await waitForRender(1);
238
+ const promiseThree = await response.result.current.submit();
239
+ await waitForRender(1);
240
+ const promiseFour = await response.result.current.submit();
241
+
242
+ value = [promiseOne, promiseTwo, promiseThree, promiseFour];
243
+ });
244
+
245
+ expect(value).toHaveLength(4);
246
+ const isResponse = (res: ExtractAdapterResolvedType<RequestInstance>) => {
247
+ return !!res.data && !res.error && res.status === 200 && !!res.extra;
248
+ };
249
+ expect(value).toSatisfyAny(isResponse);
250
+ expect(value).toHaveLength(4);
251
+ });
252
+ it("should change throttle time", async () => {
253
+ const newBounceTime = 200;
254
+ const spy = jest.fn();
255
+ let submitTime: number | null = null;
256
+ let startTime: number | null = null;
257
+ mockRequest(request);
258
+ const response = renderUseSubmit(request, hookThrottleOptions);
259
+
260
+ await act(async () => {
261
+ await response.rerender({ bounceTime: newBounceTime, bounceTimeout: newBounceTime });
262
+ });
263
+
264
+ await waitForRender(1);
265
+
266
+ await act(async () => {
267
+ response.result.current.onSubmitRequestStart(() => {
268
+ spy();
269
+ startTime = +new Date();
270
+ });
271
+ submitTime = +new Date();
272
+ response.result.current.submit();
273
+ await waitForRender(10);
274
+ response.result.current.submit();
275
+ await waitForRender(10);
276
+ response.result.current.submit();
277
+ await waitForRender(10);
278
+ response.result.current.submit();
279
+ });
280
+
281
+ await waitFor(() => {
282
+ expect(startTime).not.toBeNull();
283
+ expect((startTime || 0) - (submitTime || 0)).toBeGreaterThanOrEqual(newBounceTime);
284
+ expect(spy).toHaveBeenCalledTimes(2);
285
+ });
286
+ });
287
+ });
288
+ });
289
+
290
+ describe("given throttle is off", () => {
291
+ describe("when request is about to change", () => {
292
+ it("should not throttle multiple request triggers", async () => {
293
+ const spy = jest.fn();
294
+ let startTime: number | null = null;
295
+ mockRequest(request, { delay: 0 });
296
+ const response = renderUseSubmit(request);
297
+
298
+ await act(async () => {
299
+ response.result.current.onSubmitRequestStart(() => {
300
+ spy();
301
+ startTime = +new Date();
302
+ });
303
+ response.result.current.submit();
304
+ await waitForRender(10);
305
+ response.result.current.submit();
306
+ await waitForRender(10);
307
+ response.result.current.submit();
308
+ await waitForRender(10);
309
+ response.result.current.submit();
310
+ });
311
+
312
+ await waitFor(() => {
313
+ expect(startTime).not.toBeNull();
314
+ });
315
+
316
+ expect(spy).toHaveBeenCalledTimes(4);
317
+ });
318
+ });
319
+ });
320
+ });
@@ -0,0 +1,278 @@
1
+ import { act, waitFor } from "@testing-library/react";
2
+ import { createHttpMockingServer } from "@hyper-fetch/testing";
3
+
4
+ import { testErrorState, testSuccessState } from "../../shared";
5
+ import { client, createRequest, renderUseSubmit } from "../../utils";
6
+
7
+ const { resetMocks, startServer, stopServer, mockRequest } = createHttpMockingServer();
8
+
9
+ describe("useSubmit [ Methods ]", () => {
10
+ let request = createRequest<{
11
+ queryParams?: string;
12
+ }>({ method: "POST" });
13
+
14
+ beforeAll(() => {
15
+ startServer();
16
+ });
17
+
18
+ afterEach(() => {
19
+ resetMocks();
20
+ });
21
+
22
+ afterAll(() => {
23
+ stopServer();
24
+ });
25
+
26
+ beforeEach(() => {
27
+ jest.resetModules();
28
+ request = createRequest<{ queryParams?: string }>({ method: "POST" });
29
+ client.clear();
30
+ });
31
+
32
+ describe("given hook is mounted", () => {
33
+ describe("when processing request", () => {
34
+ it("should trigger onRequestStart helper", async () => {
35
+ const spy = jest.fn();
36
+ const mock = mockRequest(request);
37
+ const response = renderUseSubmit(request);
38
+
39
+ act(() => {
40
+ response.result.current.onSubmitRequestStart(spy);
41
+ response.result.current.submit();
42
+ });
43
+
44
+ await testSuccessState(mock, response);
45
+ expect(spy).toHaveBeenCalledTimes(1);
46
+ });
47
+ it("should trigger onResponseStart helper", async () => {
48
+ const spy = jest.fn();
49
+ const mock = mockRequest(request);
50
+ const response = renderUseSubmit(request);
51
+
52
+ act(() => {
53
+ response.result.current.onSubmitResponseStart(spy);
54
+ response.result.current.submit();
55
+ });
56
+
57
+ await testSuccessState(mock, response);
58
+ expect(spy).toHaveBeenCalledTimes(1);
59
+ });
60
+ it("should trigger onDownloadProgress helper", async () => {
61
+ const spy = jest.fn();
62
+ const mock = mockRequest(request);
63
+ const response = renderUseSubmit(request);
64
+
65
+ act(() => {
66
+ response.result.current.onSubmitDownloadProgress(spy);
67
+ response.result.current.submit();
68
+ });
69
+
70
+ await testSuccessState(mock, response);
71
+ expect(spy).toHaveBeenCalledTimes(3);
72
+ });
73
+ it("should trigger onUploadProgress helper", async () => {
74
+ const spy = jest.fn();
75
+ const mock = mockRequest(request);
76
+ const response = renderUseSubmit(request);
77
+
78
+ act(() => {
79
+ response.result.current.onSubmitUploadProgress(spy);
80
+ response.result.current.submit();
81
+ });
82
+
83
+ await testSuccessState(mock, response);
84
+ expect(spy).toHaveBeenCalledTimes(3);
85
+ });
86
+ it("should allow to trigger all event methods on dynamic keys change", async () => {
87
+ const spy1 = jest.fn();
88
+ const spy2 = jest.fn();
89
+ const spy3 = jest.fn();
90
+ const spy4 = jest.fn();
91
+ const spy5 = jest.fn();
92
+ const spy6 = jest.fn();
93
+ const mock = mockRequest(request);
94
+ const response = renderUseSubmit(request);
95
+
96
+ act(() => {
97
+ response.result.current.onSubmitRequestStart(spy1);
98
+ response.result.current.onSubmitResponseStart(spy2);
99
+ response.result.current.onSubmitDownloadProgress(spy3);
100
+ response.result.current.onSubmitUploadProgress(spy4);
101
+ response.result.current.onSubmitSuccess(spy5);
102
+ response.result.current.onSubmitFinished(spy6);
103
+ response.result.current.submit();
104
+ response.result.current.submit({ queryParams: "something=old" });
105
+ response.result.current.submit({ queryParams: "something=new" });
106
+ });
107
+
108
+ await testSuccessState(mock, response);
109
+ expect(spy1).toHaveBeenCalledTimes(3);
110
+ expect(spy2).toHaveBeenCalledTimes(3);
111
+ expect(spy3).toHaveBeenCalledTimes(9);
112
+ expect(spy4).toHaveBeenCalledTimes(9);
113
+ expect(spy5).toHaveBeenCalledTimes(3);
114
+ expect(spy6).toHaveBeenCalledTimes(3);
115
+ });
116
+ });
117
+ describe("when getting the response", () => {
118
+ it("should trigger onSuccess helper", async () => {
119
+ const spy = jest.fn();
120
+ const unusedSpy = jest.fn();
121
+ const mock = mockRequest(request);
122
+ const response = renderUseSubmit(request);
123
+
124
+ act(() => {
125
+ response.result.current.onSubmitSuccess(spy);
126
+ response.result.current.onSubmitError(unusedSpy);
127
+ response.result.current.submit();
128
+ });
129
+
130
+ await testSuccessState(mock, response);
131
+ expect(spy).toHaveBeenCalledTimes(1);
132
+ expect(unusedSpy).toHaveBeenCalledTimes(0);
133
+ });
134
+ it("should trigger onError helper", async () => {
135
+ const spy = jest.fn();
136
+ const unusedSpy = jest.fn();
137
+ const mock = mockRequest(request, { status: 400 });
138
+ const response = renderUseSubmit(request);
139
+
140
+ act(() => {
141
+ response.result.current.onSubmitError(spy);
142
+ response.result.current.onSubmitSuccess(unusedSpy);
143
+ response.result.current.submit();
144
+ });
145
+
146
+ await testErrorState(mock, response);
147
+ expect(spy).toHaveBeenCalledTimes(1);
148
+ expect(unusedSpy).toHaveBeenCalledTimes(0);
149
+ });
150
+ it("should trigger onFinished helper on success", async () => {
151
+ const spy = jest.fn();
152
+ const mock = mockRequest(request);
153
+ const response = renderUseSubmit(request);
154
+
155
+ act(() => {
156
+ response.result.current.onSubmitFinished(spy);
157
+ response.result.current.submit();
158
+ });
159
+
160
+ await testSuccessState(mock, response);
161
+ expect(spy).toHaveBeenCalledTimes(1);
162
+ });
163
+ it("should trigger onFinished helper on error", async () => {
164
+ const spy = jest.fn();
165
+ const mock = mockRequest(request, { status: 400 });
166
+ const response = renderUseSubmit(request);
167
+
168
+ act(() => {
169
+ response.result.current.onSubmitFinished(spy);
170
+ response.result.current.submit();
171
+ });
172
+
173
+ await testErrorState(mock, response);
174
+ expect(spy).toHaveBeenCalledTimes(1);
175
+ });
176
+ });
177
+ describe("when getting internal error", () => {
178
+ it("should trigger onOfflineError helper", async () => {
179
+ const spy = jest.fn();
180
+ mockRequest(request, { status: 400 });
181
+ const response = renderUseSubmit(request.setOffline(true));
182
+
183
+ act(() => {
184
+ response.result.current.onSubmitOfflineError(spy);
185
+ response.result.current.submit();
186
+ client.appManager.setOnline(false);
187
+ });
188
+
189
+ await waitFor(() => {
190
+ expect(spy).toHaveBeenCalledTimes(1);
191
+ });
192
+ });
193
+
194
+ it("should trigger methods on retry", async () => {
195
+ const spy1 = jest.fn();
196
+ const spy2 = jest.fn();
197
+ const spy3 = jest.fn();
198
+ const spy4 = jest.fn();
199
+ const spy5 = jest.fn();
200
+ const spy6 = jest.fn();
201
+ const spy7 = jest.fn();
202
+ const spy8 = jest.fn();
203
+
204
+ const errorMock = mockRequest(request, { status: 400 });
205
+ const response = renderUseSubmit(request.setRetry(1).setRetryTime(100));
206
+
207
+ act(() => {
208
+ response.result.current.onSubmitRequestStart(spy1);
209
+ response.result.current.onSubmitResponseStart(spy2);
210
+ response.result.current.onSubmitDownloadProgress(spy3);
211
+ response.result.current.onSubmitUploadProgress(spy4);
212
+ response.result.current.onSubmitSuccess(spy5);
213
+ response.result.current.onSubmitError(spy6);
214
+ response.result.current.onSubmitFinished(spy7);
215
+ response.result.current.onSubmitOfflineError(spy8);
216
+ response.result.current.submit();
217
+ });
218
+
219
+ await testErrorState(errorMock, response);
220
+ const successMock = mockRequest(request);
221
+ await testSuccessState(successMock, response);
222
+
223
+ expect(spy1).toHaveBeenCalledTimes(2);
224
+ expect(spy2).toHaveBeenCalledTimes(2);
225
+ expect(spy3).toHaveBeenCalledTimes(6);
226
+ expect(spy4).toHaveBeenCalledTimes(6);
227
+ expect(spy5).toHaveBeenCalledTimes(1);
228
+ expect(spy6).toHaveBeenCalledTimes(1);
229
+ expect(spy7).toHaveBeenCalledTimes(2);
230
+ expect(spy8).toHaveBeenCalledTimes(0);
231
+ });
232
+ it("should trigger methods on coming back online", async () => {
233
+ const spy1 = jest.fn();
234
+ const spy2 = jest.fn();
235
+ const spy3 = jest.fn();
236
+ const spy4 = jest.fn();
237
+ const spy5 = jest.fn();
238
+ const spy6 = jest.fn();
239
+ const spy7 = jest.fn();
240
+ const spy8 = jest.fn();
241
+
242
+ const errorMock = mockRequest(request, { status: 400 });
243
+ const response = renderUseSubmit(request);
244
+
245
+ act(() => {
246
+ response.result.current.onSubmitRequestStart(spy1);
247
+ response.result.current.onSubmitResponseStart(spy2);
248
+ response.result.current.onSubmitDownloadProgress(spy3);
249
+ response.result.current.onSubmitUploadProgress(spy4);
250
+ response.result.current.onSubmitSuccess(spy5);
251
+ response.result.current.onSubmitError(spy6);
252
+ response.result.current.onSubmitFinished(spy7);
253
+ response.result.current.onSubmitOfflineError(spy8);
254
+
255
+ response.result.current.submit();
256
+ client.appManager.setOnline(false);
257
+ });
258
+
259
+ await testErrorState(errorMock, response);
260
+ const successMock = mockRequest(request);
261
+
262
+ act(() => {
263
+ client.appManager.setOnline(true);
264
+ });
265
+
266
+ await testSuccessState(successMock, response);
267
+ expect(spy1).toHaveBeenCalledTimes(2);
268
+ expect(spy2).toHaveBeenCalledTimes(2);
269
+ expect(spy3).toHaveBeenCalledTimes(6);
270
+ expect(spy4).toHaveBeenCalledTimes(6);
271
+ expect(spy5).toHaveBeenCalledTimes(1);
272
+ expect(spy6).toHaveBeenCalledTimes(0);
273
+ expect(spy7).toHaveBeenCalledTimes(2);
274
+ expect(spy8).toHaveBeenCalledTimes(1);
275
+ });
276
+ });
277
+ });
278
+ });
@@ -0,0 +1,84 @@
1
+ import { act } from "@testing-library/react";
2
+ import { createHttpMockingServer } from "@hyper-fetch/testing";
3
+
4
+ import { testData, testLoading } from "../../shared";
5
+ import { client, createRequest, renderUseSubmit, waitForRender } from "../../utils";
6
+
7
+ const { resetMocks, startServer, stopServer, mockRequest } = createHttpMockingServer();
8
+
9
+ describe("useSubmit [ Queue ]", () => {
10
+ let request = createRequest<{ response: any; payload: null }>({ method: "POST", queued: true });
11
+
12
+ beforeAll(() => {
13
+ startServer();
14
+ });
15
+
16
+ afterEach(() => {
17
+ resetMocks();
18
+ });
19
+
20
+ afterAll(() => {
21
+ stopServer();
22
+ });
23
+
24
+ beforeEach(() => {
25
+ jest.resetModules();
26
+ client.clear();
27
+ request = createRequest({ method: "POST", queued: true });
28
+ });
29
+
30
+ describe("given request is able to be queued", () => {
31
+ describe("when submitting request", () => {
32
+ it("should send requests one by one", async () => {
33
+ let count = 1;
34
+ const spy = jest.fn();
35
+ mockRequest(request, { data: count });
36
+ const response = renderUseSubmit(request);
37
+
38
+ act(() => {
39
+ response.result.current.onSubmitFinished(() => {
40
+ spy();
41
+ count += 1;
42
+ mockRequest(request, { data: count, delay: 50 });
43
+ });
44
+ response.result.current.submit();
45
+ response.result.current.submit();
46
+ response.result.current.submit();
47
+ response.result.current.submit();
48
+ });
49
+
50
+ await testData(1, response);
51
+ await testData(2, response);
52
+ await testData(3, response);
53
+ await testData(4, response);
54
+
55
+ expect(spy).toHaveBeenCalledTimes(4);
56
+ });
57
+ it("should start in loading mode when request in queue is ongoing", async () => {
58
+ mockRequest(request);
59
+ const previouslyRenderedHook = renderUseSubmit(request);
60
+
61
+ act(() => {
62
+ previouslyRenderedHook.result.current.submit();
63
+ });
64
+
65
+ await waitForRender();
66
+ const response = renderUseSubmit(request);
67
+ await testLoading(true, response);
68
+ });
69
+ it("should not start in loading mode when queue is paused", async () => {
70
+ mockRequest(request);
71
+ const previouslyRenderedHook = renderUseSubmit(request);
72
+
73
+ act(() => {
74
+ previouslyRenderedHook.result.current.submit();
75
+ client.submitDispatcher.stop(request.queryKey);
76
+ });
77
+
78
+ await waitForRender();
79
+ const response = renderUseSubmit(request);
80
+ await testLoading(false, response);
81
+ });
82
+ });
83
+ });
84
+ });