@hyper-fetch/react 7.5.1 → 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,238 @@
1
+ import { act, waitFor } from "@testing-library/react";
2
+ import { createHttpMockingServer, sleep } from "@hyper-fetch/testing";
3
+
4
+ import {
5
+ addQueueElement,
6
+ client,
7
+ createRequest,
8
+ emitDownloadProgress,
9
+ emitUploadProgress,
10
+ renderUseQueue,
11
+ waitForRender,
12
+ } from "../../utils";
13
+
14
+ const { resetMocks, startServer, stopServer, mockRequest } = createHttpMockingServer();
15
+
16
+ describe("useQueue [ Actions ]", () => {
17
+ let request = createRequest({ method: "POST" });
18
+
19
+ beforeAll(() => {
20
+ startServer();
21
+ });
22
+
23
+ afterEach(() => {
24
+ resetMocks();
25
+ });
26
+
27
+ afterAll(() => {
28
+ stopServer();
29
+ });
30
+
31
+ beforeEach(() => {
32
+ jest.resetModules();
33
+ request = createRequest({ method: "POST" });
34
+ client.clear();
35
+ });
36
+
37
+ describe("given queue is running", () => {
38
+ describe("when stop gets triggered", () => {
39
+ it("should change stopped value", async () => {
40
+ const { result } = renderUseQueue(request);
41
+ act(() => {
42
+ result.current.stop();
43
+ });
44
+ await waitFor(() => {
45
+ expect(result.current.stopped).toBeTrue();
46
+ });
47
+ });
48
+ });
49
+ describe("when pause gets triggered", () => {
50
+ it("should change stopped value", async () => {
51
+ const { result } = renderUseQueue(request);
52
+ act(() => {
53
+ result.current.pause();
54
+ });
55
+ await waitFor(() => {
56
+ expect(result.current.stopped).toBeTrue();
57
+ });
58
+ });
59
+ });
60
+ describe("when stopping request", () => {
61
+ it("should cancel request and mark it as stopped", async () => {
62
+ mockRequest(request);
63
+ addQueueElement(request, { stop: true });
64
+ const { result } = renderUseQueue(request);
65
+
66
+ act(() => {
67
+ result.current.requests[0].stopRequest();
68
+ });
69
+
70
+ await waitFor(() => {
71
+ expect(result.current.requests[0].stopped).toBeTrue();
72
+ });
73
+ });
74
+ });
75
+ describe("when deleting request", () => {
76
+ it("should remove request from array", async () => {
77
+ mockRequest(request);
78
+ addQueueElement(request, { stop: true });
79
+ const { result } = renderUseQueue(request);
80
+
81
+ act(() => {
82
+ result.current.requests[0].deleteRequest();
83
+ });
84
+
85
+ await waitFor(() => {
86
+ expect(result.current.requests[0]).toBeUndefined();
87
+ });
88
+ });
89
+ });
90
+ });
91
+
92
+ describe("given queue is stopped", () => {
93
+ describe("when start gets triggered", () => {
94
+ it("should change start status", async () => {
95
+ const { result } = renderUseQueue(request);
96
+ act(() => {
97
+ result.current.stop();
98
+ });
99
+ await waitForRender();
100
+ act(() => {
101
+ result.current.start();
102
+ });
103
+
104
+ expect(result.current.stopped).toBeFalse();
105
+ });
106
+ });
107
+ describe("when starting request", () => {
108
+ it("should allow to change request stopped status", async () => {
109
+ mockRequest(request);
110
+ addQueueElement(request, { stop: true });
111
+ const { result } = renderUseQueue(request);
112
+
113
+ act(() => {
114
+ result.current.requests[0].stopRequest();
115
+ });
116
+ await waitForRender();
117
+ act(() => {
118
+ result.current.requests[0].startRequest();
119
+ });
120
+
121
+ await waitFor(() => {
122
+ expect(result.current.requests[0].stopped).toBeFalse();
123
+ });
124
+ });
125
+ });
126
+ });
127
+
128
+ describe("given queue is getting progress updates", () => {
129
+ describe("when upload progress get received", () => {
130
+ it("should update request upload progress state", async () => {
131
+ let timestamp = 0;
132
+ mockRequest(request);
133
+ addQueueElement(request, { stop: true });
134
+ const { result } = renderUseQueue(request);
135
+ expect(result.current.requests[0].uploading).toStrictEqual({
136
+ loaded: 0,
137
+ progress: 0,
138
+ sizeLeft: 0,
139
+ startTimestamp: 0,
140
+ timeLeft: 0,
141
+ total: 0,
142
+ });
143
+ act(() => {
144
+ timestamp = +emitUploadProgress(result.current.requests[0].requestId, request)[0];
145
+ });
146
+ await waitFor(() => {
147
+ expect(result.current.requests[0].uploading).toStrictEqual({
148
+ loaded: 25,
149
+ progress: 50,
150
+ sizeLeft: 25,
151
+ startTimestamp: +timestamp,
152
+ timeLeft: 20000,
153
+ total: 50,
154
+ });
155
+ });
156
+ });
157
+ it("should not throw when emitting wrong requestId", async () => {
158
+ mockRequest(request);
159
+ addQueueElement(request, { stop: true });
160
+ const { result } = renderUseQueue(request);
161
+ expect(result.current.requests[0].downloading).toStrictEqual({
162
+ loaded: 0,
163
+ progress: 0,
164
+ sizeLeft: 0,
165
+ startTimestamp: 0,
166
+ timeLeft: 0,
167
+ total: 0,
168
+ });
169
+ act(() => {
170
+ emitUploadProgress("wrong", request);
171
+ });
172
+ await sleep(5);
173
+ expect(result.current.requests[0].downloading).toStrictEqual({
174
+ loaded: 0,
175
+ progress: 0,
176
+ sizeLeft: 0,
177
+ startTimestamp: 0,
178
+ timeLeft: 0,
179
+ total: 0,
180
+ });
181
+ });
182
+ });
183
+ describe("when download progress get received", () => {
184
+ it("should update request download progress state", async () => {
185
+ let timestamp = 0;
186
+ mockRequest(request);
187
+ addQueueElement(request, { stop: true });
188
+ const { result } = renderUseQueue(request);
189
+ expect(result.current.requests[0].downloading).toStrictEqual({
190
+ loaded: 0,
191
+ progress: 0,
192
+ sizeLeft: 0,
193
+ startTimestamp: 0,
194
+ timeLeft: 0,
195
+ total: 0,
196
+ });
197
+ act(() => {
198
+ timestamp = +emitDownloadProgress(result.current.requests[0].requestId, request)[0];
199
+ });
200
+ await waitFor(() => {
201
+ expect(result.current.requests[0].downloading).toStrictEqual({
202
+ loaded: 25,
203
+ progress: 50,
204
+ sizeLeft: 25,
205
+ startTimestamp: +timestamp,
206
+ timeLeft: 20000,
207
+ total: 50,
208
+ });
209
+ });
210
+ });
211
+ it("should not throw when emitting wrong requestId", async () => {
212
+ mockRequest(request);
213
+ addQueueElement(request, { stop: true });
214
+ const { result } = renderUseQueue(request);
215
+ expect(result.current.requests[0].downloading).toStrictEqual({
216
+ loaded: 0,
217
+ progress: 0,
218
+ sizeLeft: 0,
219
+ startTimestamp: 0,
220
+ timeLeft: 0,
221
+ total: 0,
222
+ });
223
+ act(() => {
224
+ emitDownloadProgress("wrong", request);
225
+ });
226
+ await sleep(5);
227
+ expect(result.current.requests[0].downloading).toStrictEqual({
228
+ loaded: 0,
229
+ progress: 0,
230
+ sizeLeft: 0,
231
+ startTimestamp: 0,
232
+ timeLeft: 0,
233
+ total: 0,
234
+ });
235
+ });
236
+ });
237
+ });
238
+ });
@@ -0,0 +1,109 @@
1
+ import { act, waitFor } from "@testing-library/react";
2
+ import { createHttpMockingServer } from "@hyper-fetch/testing";
3
+
4
+ import { addQueueElement, client, createRequest, renderUseQueue } from "../../utils";
5
+
6
+ const { resetMocks, startServer, stopServer, mockRequest } = createHttpMockingServer();
7
+
8
+ describe("useQueue [ Base ]", () => {
9
+ let request = createRequest({ method: "POST" });
10
+
11
+ beforeAll(() => {
12
+ startServer();
13
+ });
14
+
15
+ afterEach(() => {
16
+ resetMocks();
17
+ });
18
+
19
+ afterAll(() => {
20
+ stopServer();
21
+ });
22
+
23
+ beforeEach(() => {
24
+ jest.resetModules();
25
+ client.clear();
26
+ request = createRequest({ method: "POST" });
27
+ });
28
+
29
+ describe("given hook is mounting", () => {
30
+ describe("when queue is processing requests", () => {
31
+ it("should initialize with all processed requests", async () => {
32
+ mockRequest(request);
33
+ addQueueElement(request, { stop: true });
34
+ const { result } = renderUseQueue(request);
35
+ expect(result.current.requests).toHaveLength(1);
36
+ });
37
+ it("should remove finished requests from queue", async () => {
38
+ mockRequest(request);
39
+ addQueueElement(request);
40
+ const { result } = renderUseQueue(request);
41
+ await waitFor(() => {
42
+ expect(result.current.requests).toHaveLength(0);
43
+ });
44
+ });
45
+ });
46
+ });
47
+ describe("given queue is empty", () => {
48
+ describe("when request is added to queue", () => {
49
+ it("should update the requests values", async () => {
50
+ mockRequest(request);
51
+ let requestId = "";
52
+ const progress = {
53
+ total: 200,
54
+ loaded: 100,
55
+ progress: 0.5,
56
+ timeLeft: 2000,
57
+ sizeLeft: 100,
58
+ startTimestamp: +new Date(),
59
+ };
60
+ const { result } = renderUseQueue(request);
61
+ act(() => {
62
+ requestId = addQueueElement(request, { stop: true });
63
+ });
64
+ await waitFor(() => {
65
+ expect(result.current.requests).toHaveLength(1);
66
+ });
67
+ act(() => {
68
+ client.requestManager.events.emitDownloadProgress({
69
+ ...progress,
70
+ requestId,
71
+ request,
72
+ });
73
+ });
74
+ await waitFor(() => {
75
+ expect(result.current.requests[0].downloading).toStrictEqual(progress);
76
+ });
77
+ });
78
+ it("should update upload progress of requests", async () => {
79
+ mockRequest(request);
80
+ let requestId = "";
81
+ const progress = {
82
+ total: 200,
83
+ loaded: 100,
84
+ progress: 0.5,
85
+ timeLeft: 2000,
86
+ sizeLeft: 100,
87
+ startTimestamp: +new Date(),
88
+ };
89
+ const { result } = renderUseQueue(request);
90
+ act(() => {
91
+ requestId = addQueueElement(request, { stop: true });
92
+ });
93
+ await waitFor(() => {
94
+ expect(result.current.requests).toHaveLength(1);
95
+ });
96
+ act(() => {
97
+ client.requestManager.events.emitUploadProgress({
98
+ ...progress,
99
+ requestId,
100
+ request,
101
+ });
102
+ });
103
+ await waitFor(() => {
104
+ expect(result.current.requests[0].uploading).toStrictEqual(progress);
105
+ });
106
+ });
107
+ });
108
+ });
109
+ });
@@ -0,0 +1,76 @@
1
+ import { act, waitFor } from "@testing-library/react";
2
+ import { createHttpMockingServer } from "@hyper-fetch/testing";
3
+
4
+ import { client, createRequest, renderUseSubmit, waitForRender } from "../../utils";
5
+ import { testInitialState, testSuccessState } from "../../shared";
6
+
7
+ const { resetMocks, startServer, stopServer, mockRequest } = createHttpMockingServer();
8
+
9
+ describe("useSubmit [ Base ]", () => {
10
+ let request = createRequest<{ response: any; payload: null }>({ method: "POST" });
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" });
28
+ });
29
+
30
+ describe("when submit method gets triggered", () => {
31
+ it("should not trigger request on mount", async () => {
32
+ mockRequest(request);
33
+ const response = renderUseSubmit(request);
34
+
35
+ await waitForRender(100);
36
+ await testInitialState(response);
37
+ });
38
+ it("should trigger request with submit method", async () => {
39
+ const mock = mockRequest(request);
40
+ const response = renderUseSubmit(request);
41
+
42
+ act(() => {
43
+ response.result.current.submit();
44
+ });
45
+
46
+ await testSuccessState(mock, response);
47
+ });
48
+ it("should listen to the data of last submitted request", async () => {
49
+ let count = 0;
50
+ let shouldThrow = false;
51
+ mockRequest(request, { data: count });
52
+ const response = renderUseSubmit(request.setRetry(1).setRetryTime(100));
53
+
54
+ act(() => {
55
+ response.result.current.onSubmitRequestStart(() => {
56
+ count += 1;
57
+ mockRequest(request, { data: count });
58
+ });
59
+ response.result.current.submit();
60
+ response.result.current.submit();
61
+ response.result.current.submit();
62
+ response.result.current.submit();
63
+ });
64
+
65
+ await waitFor(() => {
66
+ expect(shouldThrow).toBeFalse();
67
+ const { data } = response.result.current;
68
+ if (data && data !== 4) {
69
+ shouldThrow = true;
70
+ }
71
+
72
+ expect(data).toBe(4);
73
+ });
74
+ });
75
+ });
76
+ });
@@ -0,0 +1,46 @@
1
+ import { getErrorMessage } from "@hyper-fetch/core";
2
+ import { act } from "@testing-library/react";
3
+ import { createHttpMockingServer } from "@hyper-fetch/testing";
4
+
5
+ import { testErrorState } from "../../shared";
6
+ import { client, createRequest, renderUseSubmit } from "../../utils";
7
+
8
+ const { resetMocks, startServer, stopServer, mockRequest } = createHttpMockingServer();
9
+
10
+ describe("useSubmit [ Cancel ]", () => {
11
+ let request = createRequest<null, null>({ method: "POST" });
12
+
13
+ beforeAll(() => {
14
+ startServer();
15
+ });
16
+
17
+ afterEach(() => {
18
+ resetMocks();
19
+ });
20
+
21
+ afterAll(() => {
22
+ stopServer();
23
+ });
24
+
25
+ beforeEach(() => {
26
+ jest.resetModules();
27
+ client.clear();
28
+ request = createRequest({ method: "POST" });
29
+ });
30
+
31
+ describe("when aborting request", () => {
32
+ it("should allow to cancel the ongoing request", async () => {
33
+ mockRequest(request);
34
+ const response = renderUseSubmit(request);
35
+
36
+ act(() => {
37
+ response.result.current.onSubmitRequestStart(() => {
38
+ response.result.current.abort();
39
+ });
40
+ response.result.current.submit();
41
+ });
42
+
43
+ await testErrorState(getErrorMessage("abort"), response);
44
+ });
45
+ });
46
+ });
@@ -0,0 +1,62 @@
1
+ import { act } from "@testing-library/react";
2
+ import { createClient } from "@hyper-fetch/core";
3
+ import { createHttpMockingServer } from "@hyper-fetch/testing";
4
+
5
+ import { testSuccessState } from "../../shared";
6
+ import { renderUseSubmit, waitForRender } from "../../utils";
7
+
8
+ const { resetMocks, startServer, stopServer, mockRequest } = createHttpMockingServer();
9
+
10
+ describe("useSubmit [ Concurrency ]", () => {
11
+ let client = createClient({ url: "http://localhost:3000" });
12
+ let request = client.createRequest<{ response: null; payload: null }>()({ method: "POST", endpoint: "" });
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
+ client.clear();
29
+ client = createClient({ url: "http://localhost:3000" });
30
+ request = client.createRequest<{ response: null; payload: null }>()({ method: "POST", endpoint: "" });
31
+ });
32
+
33
+ describe("given multiple rendered hooks", () => {
34
+ describe("when used requests are equal", () => {
35
+ it("should share data between hooks", async () => {
36
+ const mock = mockRequest(request);
37
+ const responseOne = renderUseSubmit(request);
38
+ const responseTwo = renderUseSubmit(request);
39
+
40
+ act(() => {
41
+ responseOne.result.current.submit();
42
+ });
43
+
44
+ await testSuccessState(mock, responseOne);
45
+ await testSuccessState(mock, responseTwo);
46
+ });
47
+ it("should start in loading mode when another request is ongoing", async () => {
48
+ mockRequest(request);
49
+ const responseOne = renderUseSubmit(request);
50
+
51
+ act(() => {
52
+ responseOne.result.current.submit();
53
+ });
54
+
55
+ await waitForRender();
56
+
57
+ const responseTwo = renderUseSubmit(request);
58
+ expect(responseTwo.result.current.submitting).toBeTrue();
59
+ });
60
+ });
61
+ });
62
+ });