@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,40 @@
1
+ import { createHttpMockingServer } from "@hyper-fetch/testing";
2
+
3
+ const { resetMocks, startServer, stopServer } = createHttpMockingServer();
4
+
5
+ describe("useCache [ Helpers ]", () => {
6
+ beforeAll(() => {
7
+ startServer();
8
+ });
9
+
10
+ afterEach(() => {
11
+ resetMocks();
12
+ });
13
+
14
+ afterAll(() => {
15
+ stopServer();
16
+ });
17
+
18
+ beforeEach(() => {
19
+ jest.resetModules();
20
+ });
21
+
22
+ describe("given hook is mounted", () => {
23
+ describe("when getting the response", () => {
24
+ it("should trigger onCacheSuccess helper", async () => {
25
+ // Todo
26
+ });
27
+ it("should trigger onCacheError helper", async () => {
28
+ // Todo
29
+ });
30
+ it("should trigger onCacheUpdate helper", async () => {
31
+ // Todo
32
+ });
33
+ });
34
+ describe("when invalidate gets triggered", () => {
35
+ it("should remove cached data", async () => {
36
+ // Todo
37
+ });
38
+ });
39
+ });
40
+ });
@@ -0,0 +1,124 @@
1
+ import { Socket } from "@hyper-fetch/sockets";
2
+ import { act, waitFor } from "@testing-library/react";
3
+ import { createWebsocketMockingServer, sleep, waitForConnection } from "@hyper-fetch/testing";
4
+
5
+ import { renderUseEmitter } from "../../utils/use-emitter.utils";
6
+
7
+ describe("useEmitter [ Base ]", () => {
8
+ const { url, startServer, stopServer, expectEmitterEvent } = createWebsocketMockingServer();
9
+ let socket = new Socket({ url });
10
+ let emitter = socket.createEmitter<{ name: string; age: number }>()({ topic: "test/:testId" });
11
+
12
+ beforeEach(async () => {
13
+ startServer();
14
+ socket = new Socket({ url });
15
+ emitter = socket.createEmitter<{ name: string; age: number }>()({ topic: "test/:testId" });
16
+ await waitForConnection(socket);
17
+
18
+ jest.resetModules();
19
+ jest.resetAllMocks();
20
+ });
21
+
22
+ afterEach(() => {
23
+ stopServer();
24
+ });
25
+
26
+ describe("when hook emit event", () => {
27
+ it("should set state with data", async () => {
28
+ const myEmitter = emitter.setParams({ testId: "1" });
29
+
30
+ const message = { name: "Maciej", age: 99 };
31
+ const view = renderUseEmitter(myEmitter);
32
+
33
+ act(() => {
34
+ view.result.current.emit({ payload: message });
35
+ });
36
+
37
+ await expectEmitterEvent(myEmitter.setParams({ testId: "1" }), message);
38
+
39
+ await waitFor(() => {
40
+ expect(view.result.current.connected).toBeTrue();
41
+ expect(view.result.current.connecting).toBeFalse();
42
+ });
43
+ });
44
+
45
+ it("should handle emit error correctly", async () => {
46
+ const error = new Error("Emit error");
47
+ const view = renderUseEmitter(emitter);
48
+ let capturedError: { error: Error } | null = null;
49
+
50
+ view.result.current.onEmitError((err) => {
51
+ capturedError = err;
52
+ });
53
+
54
+ act(() => {
55
+ emitter.socket.events.emitEmitterError({ error, emitter });
56
+ });
57
+
58
+ await waitFor(() => {
59
+ expect(capturedError).toEqual({ error });
60
+ });
61
+ });
62
+
63
+ it("should trigger onEmit callback when emitting", async () => {
64
+ const message = { name: "Test", age: 25 };
65
+ const instance = emitter.setParams({ testId: "1" });
66
+ const view = renderUseEmitter(instance);
67
+ let emitCalled = false;
68
+
69
+ view.result.current.onEmit(() => {
70
+ emitCalled = true;
71
+ });
72
+
73
+ act(() => {
74
+ view.result.current.emit({ payload: message });
75
+ });
76
+
77
+ await expectEmitterEvent(instance, message);
78
+
79
+ expect(emitCalled).toBeTrue();
80
+ });
81
+
82
+ it("should handle undefined onEmit callback", async () => {
83
+ const myEmitter = emitter.setParams({ testId: "1" });
84
+ renderUseEmitter(myEmitter);
85
+
86
+ // Should not throw when callback is undefined
87
+ act(() => {
88
+ myEmitter.socket.events.emitEmitterStartEvent({ emitter: myEmitter });
89
+ });
90
+
91
+ // No assertion needed - test passes if no error is thrown
92
+ await sleep(10);
93
+ });
94
+ });
95
+
96
+ describe("when emitter topic changes", () => {
97
+ it("should update event listeners", async () => {
98
+ const emitter1 = emitter.setParams({ testId: "1" });
99
+ const view = renderUseEmitter(emitter1);
100
+ let callCount = 0;
101
+
102
+ view.result.current.onEmit(() => {
103
+ callCount += 1;
104
+ });
105
+
106
+ act(() => {
107
+ view.result.current.emit({ payload: { name: "Maciej", age: 99 } });
108
+ });
109
+
110
+ await expectEmitterEvent(emitter1, { name: "Maciej", age: 99 });
111
+ expect(callCount).toBe(1);
112
+
113
+ const emitter2 = socket.createEmitter()({ topic: "test/:testId" }).setParams({ testId: "2" });
114
+ view.rerender({ emitter: emitter2 });
115
+
116
+ act(() => {
117
+ view.result.current.emit({ payload: { name: "Maciej", age: 12 } });
118
+ });
119
+
120
+ await expectEmitterEvent(emitter2, { name: "Maciej", age: 12 });
121
+ expect(callCount).toBe(2);
122
+ });
123
+ });
124
+ });
@@ -0,0 +1,284 @@
1
+ import { act, waitFor } from "@testing-library/react";
2
+ import { AdapterInstance, ResponseType, xhrExtra } from "@hyper-fetch/core";
3
+ import { createHttpMockingServer, sleep } from "@hyper-fetch/testing";
4
+
5
+ import { createRequest, renderUseFetch, createCacheData, client } from "../../utils";
6
+ import { testSuccessState, testErrorState, testInitialState, testCacheState, testClientIsolation } from "../../shared";
7
+
8
+ const { resetMocks, startServer, stopServer, mockRequest } = createHttpMockingServer();
9
+
10
+ describe("useFetch [ Base ]", () => {
11
+ let request = createRequest();
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
+ request = createRequest();
28
+ client.clear();
29
+ });
30
+
31
+ describe("when hook is initialized", () => {
32
+ it("should initialize in loading state", async () => {
33
+ await testClientIsolation(client);
34
+ mockRequest(request);
35
+ const view = renderUseFetch(request);
36
+
37
+ testInitialState(view);
38
+ });
39
+ it("should load cached data", async () => {
40
+ await testClientIsolation(client);
41
+ const mock = mockRequest(request);
42
+ const [cache] = createCacheData(request, {
43
+ data: {
44
+ data: mock,
45
+ error: null,
46
+ status: 200,
47
+ success: true,
48
+ extra: xhrExtra,
49
+ responseTimestamp: +new Date(),
50
+ requestTimestamp: +new Date(),
51
+ },
52
+ details: {
53
+ retries: 2,
54
+ },
55
+ });
56
+ const view = renderUseFetch(request);
57
+ await testCacheState(cache, view);
58
+ });
59
+ it("should not load stale cache data", async () => {
60
+ await testClientIsolation(client);
61
+ const timestamp = +new Date() - 11;
62
+ const mock = mockRequest(request, { delay: 50 });
63
+ act(() => {
64
+ createCacheData(request, {
65
+ data: {
66
+ data: mock,
67
+ error: null,
68
+ status: 200,
69
+ success: true,
70
+ extra: xhrExtra,
71
+ responseTimestamp: timestamp,
72
+ requestTimestamp: timestamp,
73
+ },
74
+ details: {
75
+ triggerTimestamp: timestamp,
76
+ responseTimestamp: timestamp,
77
+ requestTimestamp: timestamp,
78
+ retries: 3,
79
+ },
80
+ });
81
+ });
82
+
83
+ const view = renderUseFetch(request.setStaleTime(10));
84
+
85
+ await testCacheState(
86
+ {
87
+ data: null,
88
+ error: null,
89
+ status: null,
90
+ success: true,
91
+ extra: xhrExtra,
92
+ responseTimestamp: timestamp,
93
+ requestTimestamp: timestamp,
94
+ },
95
+ view,
96
+ );
97
+ });
98
+ it("should allow to use initial data", async () => {
99
+ await testClientIsolation(client);
100
+ const initialResponse: ResponseType<unknown, Error, AdapterInstance> = {
101
+ data: { test: [1, 2, 3] },
102
+ error: null,
103
+ status: 200,
104
+ success: true,
105
+ extra: { headers: { "content-type": "application/json" } },
106
+ responseTimestamp: +new Date(),
107
+ requestTimestamp: +new Date(),
108
+ };
109
+ const view = renderUseFetch(request, { disabled: true, initialResponse });
110
+
111
+ expect(view.result.current.data).toEqual(initialResponse.data);
112
+ await testSuccessState(initialResponse.data, view);
113
+ });
114
+ it("should allow to use initial data while requesting", async () => {
115
+ await testClientIsolation(client);
116
+ mockRequest(request);
117
+ const initialResponse: ResponseType<unknown, Error, AdapterInstance> = {
118
+ data: { test: [1, 2, 3] },
119
+ error: null,
120
+ status: 200,
121
+ success: true,
122
+ extra: { headers: { "content-type": "application/json" } },
123
+ responseTimestamp: +new Date(),
124
+ requestTimestamp: +new Date(),
125
+ };
126
+ const view = renderUseFetch(request, { initialResponse });
127
+ expect(view.result.current.data).toEqual(initialResponse.data);
128
+ });
129
+ it("should prefer cache data over initial data", async () => {
130
+ // Todo
131
+ });
132
+ it("should make only one request", async () => {
133
+ const spy = jest.spyOn(client.adapter, "fetch");
134
+ await testClientIsolation(client);
135
+ const mock = mockRequest(request);
136
+ const view = renderUseFetch(request);
137
+
138
+ await testSuccessState(mock, view);
139
+ await act(async () => {
140
+ await sleep(50);
141
+ });
142
+ expect(spy).toHaveBeenCalledTimes(1);
143
+ });
144
+ });
145
+ describe("when hook get success response", () => {
146
+ it("should set state with success data", async () => {
147
+ await testClientIsolation(client);
148
+ const mock = mockRequest(request);
149
+ const view = renderUseFetch(request);
150
+
151
+ await testSuccessState(mock, view);
152
+ });
153
+ it("should map the data on deps change", async () => {
154
+ mockRequest(request);
155
+ const request1 = request.setCacheKey("request1").setResponseMapper((response) => ({ ...response, data: 1 }));
156
+ const request2 = request.setCacheKey("request2").setResponseMapper((response) => ({ ...response, data: 2 }));
157
+
158
+ const { result, rerender } = renderUseFetch(request1);
159
+
160
+ act(() => {
161
+ rerender({ request: request2 });
162
+ rerender({ request: request1 });
163
+ result.current.refetch();
164
+ });
165
+
166
+ await waitFor(() => {
167
+ expect(result.current.data).toBe(1);
168
+ expect(result.current.error).toBe(null);
169
+ });
170
+
171
+ act(() => {
172
+ rerender({ request: request2 });
173
+ result.current.refetch();
174
+ });
175
+
176
+ await waitFor(() => {
177
+ expect(result.current.data).toBe(2);
178
+ expect(result.current.error).toBe(null);
179
+ });
180
+ });
181
+ it("should clear previous error state once success response is returned", async () => {
182
+ await testClientIsolation(client);
183
+ const errorMock = mockRequest(request, { status: 400 });
184
+ const view = renderUseFetch(request);
185
+
186
+ await testErrorState(errorMock, view);
187
+ const mock = mockRequest(request);
188
+
189
+ act(() => {
190
+ view.result.current.refetch();
191
+ });
192
+
193
+ await testSuccessState(mock, view);
194
+ });
195
+ it("should change loading to false on success", async () => {
196
+ // Todo
197
+ });
198
+ it("should map response data", async () => {
199
+ const mappedData = { test: 1, test2: 2, test3: 3 };
200
+ const mappedRequest = request.setResponseMapper((response) => ({
201
+ ...response,
202
+ data: mappedData,
203
+ }));
204
+ mockRequest(mappedRequest);
205
+ const view = renderUseFetch(mappedRequest);
206
+
207
+ await testSuccessState(mappedData, view);
208
+ });
209
+ it("should map async response data", async () => {
210
+ const spy = jest.fn();
211
+ const mappedData = { test: 1, test2: 2, test3: 3 };
212
+ const mappedRequest = request.setResponseMapper(async (response) => ({
213
+ ...response,
214
+ data: mappedData,
215
+ }));
216
+ mockRequest(mappedRequest);
217
+ const view = renderUseFetch(mappedRequest, { disabled: true });
218
+
219
+ act(() => {
220
+ view.result.current.onSuccess(() => {
221
+ expect(view.result.current.data).toEqual(null);
222
+ spy();
223
+ });
224
+ view.rerender({ disabled: false });
225
+ });
226
+
227
+ await waitFor(() => {
228
+ expect(spy).toHaveBeenCalledTimes(1);
229
+ });
230
+ await testSuccessState(mappedData, view);
231
+ });
232
+ });
233
+ describe("when hook get error response", () => {
234
+ it("should set state with error data", async () => {
235
+ await testClientIsolation(client);
236
+ const mock = mockRequest(request, { status: 400 });
237
+ const view = renderUseFetch(request);
238
+
239
+ await testErrorState(mock, view);
240
+ });
241
+ it("should keep previous success state once error response is returned", async () => {
242
+ await testClientIsolation(client);
243
+ const mock = mockRequest(request);
244
+ const view = renderUseFetch(request);
245
+
246
+ await testSuccessState(mock, view);
247
+
248
+ const errorMock = mockRequest(request, { status: 400 });
249
+
250
+ act(() => {
251
+ view.result.current.refetch();
252
+ });
253
+
254
+ await testErrorState(errorMock, view, mock);
255
+ });
256
+ it("should change loading to false on error", async () => {
257
+ // Todo
258
+ });
259
+ });
260
+ describe("when dependencies change", () => {
261
+ // Solves Issue #22
262
+ it("should fetch data when disabled prop changes", async () => {
263
+ const spy = jest.fn();
264
+ await testClientIsolation(client);
265
+ const mock = mockRequest(request);
266
+ const view = renderUseFetch(request, { disabled: true });
267
+
268
+ act(() => {
269
+ view.result.current.onRequestStart(spy);
270
+ });
271
+
272
+ await sleep(20);
273
+ expect(spy).toHaveBeenCalledTimes(0);
274
+
275
+ view.rerender({ disabled: false });
276
+
277
+ await testSuccessState(mock, view);
278
+ expect(spy).toHaveBeenCalledTimes(1);
279
+ });
280
+ it("should fetch when dependencies change", async () => {
281
+ // Todo
282
+ });
283
+ });
284
+ });
@@ -0,0 +1,83 @@
1
+ import { getErrorMessage } from "@hyper-fetch/core";
2
+ import { act, waitFor } from "@testing-library/react";
3
+ import { createHttpMockingServer } from "@hyper-fetch/testing";
4
+
5
+ import { testErrorState } from "../../shared";
6
+ import { client, createRequest, renderUseFetch, waitForRender } from "../../utils";
7
+
8
+ const { resetMocks, startServer, stopServer, mockRequest } = createHttpMockingServer();
9
+
10
+ describe("useFetch [ Cancel ]", () => {
11
+ let request = createRequest({ cacheKey: "test", queryKey: "testQueue", cancelable: true });
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
+ request = createRequest({ cacheKey: "test", queryKey: "testQueue", cancelable: true });
28
+ client.clear();
29
+ });
30
+
31
+ describe("given request is cancelable", () => {
32
+ describe("when aborting request", () => {
33
+ it("should allow to cancel the ongoing request", async () => {
34
+ mockRequest(request, { delay: 40 });
35
+ const response = renderUseFetch(request);
36
+
37
+ await waitForRender();
38
+
39
+ act(() => {
40
+ response.result.current.abort();
41
+ });
42
+
43
+ await testErrorState(getErrorMessage("abort"), response);
44
+ });
45
+
46
+ it("should allow to cancel deduplicated request", async () => {
47
+ mockRequest(request, { delay: 100 });
48
+ const response = renderUseFetch(request);
49
+ await waitForRender();
50
+ const dedupeResponse = renderUseFetch(request);
51
+ await waitForRender();
52
+
53
+ await act(() => {
54
+ dedupeResponse.result.current.abort();
55
+ });
56
+
57
+ await testErrorState(getErrorMessage("abort"), response);
58
+ await testErrorState(getErrorMessage("abort"), dedupeResponse);
59
+ });
60
+ it("should cancel previous requests when dependencies change", async () => {
61
+ const spy = jest.fn();
62
+
63
+ mockRequest(request, { delay: 50 });
64
+ const response = renderUseFetch(request, { dependencies: [{}] });
65
+ await waitForRender(1);
66
+
67
+ act(() => {
68
+ const params = { page: 1 };
69
+ response.result.current.onAbort(spy);
70
+ response.rerender({ request, dependencies: [params] });
71
+ });
72
+ await waitForRender();
73
+
74
+ await waitFor(() => {
75
+ expect(spy).toHaveBeenCalledTimes(1);
76
+ });
77
+ });
78
+ });
79
+ it("should clear request from dispatcher's queue on abort", async () => {
80
+ // TODO
81
+ });
82
+ });
83
+ });
@@ -0,0 +1,91 @@
1
+ import { act } from "@testing-library/react";
2
+ import { createHttpMockingServer } from "@hyper-fetch/testing";
3
+
4
+ import { testSuccessState } from "../../shared";
5
+ import { client, createRequest, renderUseFetch, waitForRender } from "../../utils";
6
+
7
+ const { resetMocks, startServer, stopServer, mockRequest } = createHttpMockingServer();
8
+
9
+ describe("useFetch [ Concurrency ]", () => {
10
+ let request = createRequest();
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
+ request = createRequest();
27
+ client.clear();
28
+ });
29
+
30
+ describe("given multiple rendered hooks", () => {
31
+ describe("when used the same non-dedupe requests", () => {
32
+ it("should allow to trigger request for each hook", async () => {
33
+ const spyOne = jest.fn();
34
+ const spyTwo = jest.fn();
35
+
36
+ const mock = mockRequest(request);
37
+ const responseOne = renderUseFetch(request.setQueryKey("1"));
38
+ const responseTwo = renderUseFetch(request.setQueryKey("2"));
39
+
40
+ act(() => {
41
+ responseOne.result.current.onRequestStart(spyOne);
42
+ responseTwo.result.current.onRequestStart(spyTwo);
43
+ });
44
+
45
+ await testSuccessState(mock, responseOne);
46
+ await testSuccessState(mock, responseTwo);
47
+
48
+ expect(spyOne).toHaveBeenCalledTimes(1);
49
+ expect(spyTwo).toHaveBeenCalledTimes(1);
50
+ });
51
+ it("should start in loading mode when request is already handled by the queue", async () => {
52
+ mockRequest(request);
53
+ act(() => {
54
+ client.fetchDispatcher.add(request);
55
+ });
56
+ const { result } = renderUseFetch(request);
57
+ expect(result.current.loading).toBeTrue();
58
+ await waitForRender();
59
+ expect(result.current.loading).toBeTrue();
60
+ });
61
+ it("should not start in loading mode when queue is paused", async () => {
62
+ act(() => {
63
+ const queueElement = client.fetchDispatcher.createStorageItem(request);
64
+ client.fetchDispatcher.addQueueItem(request.queryKey, queueElement);
65
+ client.fetchDispatcher.stop(request.queryKey);
66
+ });
67
+ mockRequest(request);
68
+ const { result } = renderUseFetch(request);
69
+ expect(result.current.loading).toBeFalse();
70
+ await waitForRender();
71
+ expect(result.current.loading).toBeFalse();
72
+ });
73
+ it("should share data between hooks", async () => {
74
+ const mock = mockRequest(request);
75
+ const responseOne = renderUseFetch(request);
76
+ await testSuccessState(mock, responseOne);
77
+
78
+ const responseTwo = renderUseFetch(request, { revalidate: false });
79
+ await testSuccessState(mock, responseTwo);
80
+ });
81
+ it("should share data with disabled hook", async () => {
82
+ const mock = mockRequest(request);
83
+ const responseOne = renderUseFetch(request);
84
+ const responseTwo = renderUseFetch(request, { disabled: true });
85
+
86
+ await testSuccessState(mock, responseOne);
87
+ await testSuccessState(mock, responseTwo);
88
+ });
89
+ });
90
+ });
91
+ });