@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,153 @@
1
+ import { waitFor, act } from "@testing-library/react";
2
+ import { createHttpMockingServer } from "@hyper-fetch/testing";
3
+
4
+ import { client, createRequest, renderUseFetch, waitForRender } from "../../utils";
5
+
6
+ const { resetMocks, startServer, stopServer, mockRequest } = createHttpMockingServer();
7
+
8
+ describe("useFetch [ Bounce ]", () => {
9
+ const hookDebounceOptions = { bounce: true, bounceType: "debounce", bounceTime: 50 } as const;
10
+ const hookThrottleOptions = { bounce: true, bounceType: "throttle", bounceTime: 50 } as const;
11
+ let request = createRequest();
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 debounce is active", () => {
31
+ describe("when request is about to change", () => {
32
+ it("should not debounce initial request", async () => {
33
+ const spy = jest.fn();
34
+ mockRequest(request);
35
+ const response = renderUseFetch(request, hookDebounceOptions);
36
+
37
+ act(() => {
38
+ response.result.current.onRequestStart(spy);
39
+ });
40
+
41
+ await waitForRender(0);
42
+ expect(spy).toHaveBeenCalledTimes(1);
43
+ });
44
+ it("should debounce multiple request triggers by 100ms", async () => {
45
+ const spy = jest.fn();
46
+ mockRequest(request, { delay: 0 });
47
+ const response = renderUseFetch(request, { ...hookDebounceOptions, dependencies: [{ test: 10 }] });
48
+
49
+ act(() => {
50
+ response.result.current.onRequestStart(spy);
51
+ });
52
+
53
+ const rerender = () => {
54
+ response.rerender({ dependencies: [{ test: Math.random() }] });
55
+ };
56
+
57
+ await waitForRender();
58
+
59
+ expect(spy).toHaveBeenCalledTimes(1);
60
+
61
+ act(() => {
62
+ rerender();
63
+ });
64
+ await waitForRender();
65
+
66
+ act(() => {
67
+ rerender();
68
+ });
69
+ await waitForRender();
70
+
71
+ await waitFor(() => {
72
+ expect(spy).toHaveBeenCalledTimes(2);
73
+ });
74
+
75
+ act(() => {
76
+ rerender();
77
+ });
78
+ await waitForRender();
79
+
80
+ act(() => {
81
+ rerender();
82
+ });
83
+ await waitForRender();
84
+
85
+ await waitFor(() => {
86
+ expect(spy).toHaveBeenCalledTimes(3);
87
+ });
88
+ });
89
+ });
90
+
91
+ describe("given throttle is active", () => {
92
+ describe("when request is about to change", () => {
93
+ it("should not throttle initial request", async () => {
94
+ const spy = jest.fn();
95
+ mockRequest(request);
96
+ const response = renderUseFetch(request, hookThrottleOptions);
97
+
98
+ act(() => {
99
+ response.result.current.onRequestStart(spy);
100
+ });
101
+
102
+ await waitForRender(0);
103
+ expect(spy).toHaveBeenCalledTimes(1);
104
+ });
105
+ it("should throttle multiple request triggers by 100ms", async () => {
106
+ const spy = jest.fn();
107
+ mockRequest(request, { delay: 0 });
108
+ const response = renderUseFetch(request, { ...hookThrottleOptions, dependencies: [{ test: 10 }] });
109
+
110
+ act(() => {
111
+ response.result.current.onRequestStart(spy);
112
+ });
113
+
114
+ const rerender = () => {
115
+ response.rerender({ dependencies: [{ test: Math.random() }] });
116
+ };
117
+
118
+ await waitForRender();
119
+
120
+ expect(spy).toHaveBeenCalledTimes(1);
121
+
122
+ act(() => {
123
+ rerender();
124
+ });
125
+ await waitForRender();
126
+
127
+ act(() => {
128
+ rerender();
129
+ });
130
+ await waitForRender();
131
+
132
+ await waitFor(() => {
133
+ expect(spy).toHaveBeenCalledTimes(2);
134
+ });
135
+
136
+ act(() => {
137
+ rerender();
138
+ });
139
+ await waitForRender();
140
+
141
+ act(() => {
142
+ rerender();
143
+ });
144
+ await waitForRender();
145
+
146
+ await waitFor(() => {
147
+ expect(spy).toHaveBeenCalledTimes(3);
148
+ });
149
+ });
150
+ });
151
+ });
152
+ });
153
+ });
@@ -0,0 +1,80 @@
1
+ import { createHttpMockingServer } from "@hyper-fetch/testing";
2
+
3
+ import { testErrorState, testSuccessState } from "../../shared";
4
+ import { client, createRequest, renderUseFetch, waitForRender } from "../../utils";
5
+
6
+ const { resetMocks, startServer, stopServer, mockRequest } = createHttpMockingServer();
7
+
8
+ describe("useFetch [ Deduplication ]", () => {
9
+ let dedupeRequest = createRequest({ deduplicate: true, deduplicateTime: 100, retry: 5, retryTime: 200 });
10
+
11
+ beforeAll(() => {
12
+ startServer();
13
+ });
14
+
15
+ afterEach(() => {
16
+ resetMocks();
17
+ });
18
+
19
+ afterAll(() => {
20
+ stopServer();
21
+ });
22
+
23
+ beforeEach(() => {
24
+ dedupeRequest = createRequest({ deduplicate: true, deduplicateTime: 100, retry: 5, retryTime: 200 });
25
+ jest.resetModules();
26
+ client.clear();
27
+ });
28
+
29
+ describe("given request deduplicate attribute is active", () => {
30
+ describe("when initializing two hooks with the same request", () => {
31
+ it("should send only one request", async () => {
32
+ mockRequest(dedupeRequest);
33
+ renderUseFetch(dedupeRequest);
34
+ renderUseFetch(dedupeRequest);
35
+
36
+ await waitForRender();
37
+
38
+ expect(client.fetchDispatcher.getQueueRequestCount(dedupeRequest.queryKey)).toBe(1);
39
+ });
40
+ it("should deduplicate requests within deduplication time", async () => {
41
+ mockRequest(dedupeRequest, { delay: 200 });
42
+
43
+ renderUseFetch(dedupeRequest);
44
+ await waitForRender(2);
45
+
46
+ renderUseFetch(dedupeRequest);
47
+ await waitForRender();
48
+
49
+ expect(client.fetchDispatcher.getQueueRequestCount(dedupeRequest.queryKey)).toBe(1);
50
+ });
51
+ });
52
+ describe("when response is failed", () => {
53
+ it("should perform one retry on failure", async () => {
54
+ const errorMock = mockRequest(dedupeRequest, { status: 400 });
55
+ const responseOne = renderUseFetch(dedupeRequest);
56
+ const responseTwo = renderUseFetch(dedupeRequest);
57
+
58
+ await waitForRender();
59
+ const successMock = mockRequest(dedupeRequest);
60
+ await testErrorState(errorMock, responseOne);
61
+ await testErrorState(errorMock, responseTwo);
62
+ await testSuccessState(successMock, responseOne);
63
+ await testSuccessState(successMock, responseTwo);
64
+
65
+ expect(client.fetchDispatcher.getQueueRequestCount(dedupeRequest.queryKey)).toBe(2);
66
+ });
67
+ });
68
+ describe("when response is successful", () => {
69
+ it("should share the success data with all hooks", async () => {
70
+ const mock = mockRequest(dedupeRequest);
71
+ const responseOne = renderUseFetch(dedupeRequest);
72
+ const responseTwo = renderUseFetch(dedupeRequest);
73
+
74
+ await waitForRender();
75
+ await testSuccessState(mock, responseOne);
76
+ await testSuccessState(mock, responseTwo);
77
+ });
78
+ });
79
+ });
80
+ });
@@ -0,0 +1,39 @@
1
+ import { createHttpMockingServer } from "@hyper-fetch/testing";
2
+
3
+ import { client } from "../../utils";
4
+
5
+ const { resetMocks, startServer, stopServer } = createHttpMockingServer();
6
+
7
+ describe("useFetch [ Infinite ]", () => {
8
+ beforeAll(() => {
9
+ startServer();
10
+ });
11
+
12
+ afterEach(() => {
13
+ resetMocks();
14
+ });
15
+
16
+ afterAll(() => {
17
+ stopServer();
18
+ });
19
+
20
+ beforeEach(() => {
21
+ jest.resetModules();
22
+ client.clear();
23
+ });
24
+
25
+ describe("when request query params are changed", () => {
26
+ it("should allow to cancel previous request on switching pages during requests", async () => {
27
+ // TODO
28
+ });
29
+ it("should use cached pages on mounting", async () => {
30
+ // TODO
31
+ });
32
+ it("should automatically generate request cacheKey for paginated views", async () => {
33
+ // TODO
34
+ });
35
+ it("should not remove previous page data until current is fetched", async () => {
36
+ // TODO
37
+ });
38
+ });
39
+ });
@@ -0,0 +1,172 @@
1
+ import { useState, StrictMode } from "react";
2
+ import { createHttpMockingServer } from "@hyper-fetch/testing";
3
+ import { fireEvent, render, screen, waitFor } from "@testing-library/react";
4
+
5
+ import { useFetch } from "hooks/use-fetch";
6
+ import { createRequest, waitForRender } from "../../utils";
7
+
8
+ const { resetMocks, startServer, stopServer, mockRequest } = createHttpMockingServer();
9
+
10
+ describe("useFetch [ Integration ]", () => {
11
+ const queryParams = { page: 1 };
12
+ const btnText = "refresh";
13
+ const depBtnText = "add dependency";
14
+
15
+ let request = createRequest({ endpoint: `/users/${Date.now()}` });
16
+
17
+ beforeAll(() => {
18
+ startServer();
19
+ });
20
+
21
+ afterEach(() => {
22
+ resetMocks();
23
+ });
24
+
25
+ afterAll(() => {
26
+ stopServer();
27
+ });
28
+
29
+ beforeEach(() => {
30
+ jest.resetModules();
31
+ request = createRequest({ endpoint: `/users/${Date.now()}` });
32
+ request.client.clear();
33
+ });
34
+
35
+ describe("given useFetch is initialized in the component", () => {
36
+ describe("when request is about to change", () => {
37
+ it("should use the latest request when its changed", async () => {
38
+ const Page = () => {
39
+ const [endpoint, setEndpoint] = useState("");
40
+ const [params, setParams] = useState({});
41
+ const { onRequestStart } = useFetch(request.setQueryParams(params), {
42
+ dependencyTracking: false,
43
+ dependencies: [],
44
+ });
45
+
46
+ onRequestStart((event) => {
47
+ setEndpoint(event.request.endpoint);
48
+ });
49
+
50
+ const addDependency = () => {
51
+ setParams(queryParams);
52
+ };
53
+
54
+ return (
55
+ <>
56
+ <button onClick={addDependency} type="button">
57
+ {btnText}
58
+ </button>
59
+ {endpoint}
60
+ </>
61
+ );
62
+ };
63
+
64
+ mockRequest(request);
65
+ mockRequest(request.setQueryParams(queryParams));
66
+
67
+ render(<Page />);
68
+
69
+ await waitForRender(1);
70
+ fireEvent.click(screen.getByText(btnText));
71
+
72
+ await waitFor(() => {
73
+ const printedDataElement = screen.getByText(request.setQueryParams(queryParams).endpoint);
74
+ expect(printedDataElement).toBeTruthy();
75
+ });
76
+ });
77
+ it("should fetch once in StrictMode", async () => {
78
+ const spy = jest.fn();
79
+
80
+ const Page = () => {
81
+ const { data, onFinished } = useFetch(request, {
82
+ dependencyTracking: false,
83
+ refresh: false,
84
+ });
85
+
86
+ onFinished(() => {
87
+ spy();
88
+ });
89
+
90
+ return <div>{JSON.stringify(data)}</div>;
91
+ };
92
+
93
+ mockRequest(request);
94
+ mockRequest(request.setQueryParams(queryParams));
95
+
96
+ render(
97
+ <StrictMode>
98
+ <Page />
99
+ </StrictMode>,
100
+ );
101
+
102
+ await waitForRender(100);
103
+
104
+ await waitFor(() => {
105
+ expect(spy).toHaveBeenCalledOnce();
106
+ });
107
+ });
108
+ it("should fetch sequence in StrictMode", async () => {
109
+ const spy = jest.fn();
110
+
111
+ const Page = () => {
112
+ const [params, setParams] = useState({});
113
+ const [dep, setDep] = useState({});
114
+ const { data, onFinished } = useFetch(request.setQueryParams(params), {
115
+ dependencies: [dep],
116
+ dependencyTracking: false,
117
+ refresh: false,
118
+ });
119
+
120
+ onFinished(() => {
121
+ spy();
122
+ });
123
+
124
+ const addDependency = () => {
125
+ setDep({ test: 1 });
126
+ };
127
+
128
+ const addParam = () => {
129
+ setParams(queryParams);
130
+ };
131
+
132
+ return (
133
+ <div>
134
+ {JSON.stringify(data)}
135
+ <button onClick={addDependency} type="button">
136
+ {depBtnText}
137
+ </button>
138
+ <button onClick={addParam} type="button">
139
+ {btnText}
140
+ </button>
141
+ </div>
142
+ );
143
+ };
144
+
145
+ mockRequest(request);
146
+ mockRequest(request.setQueryParams(queryParams));
147
+
148
+ render(
149
+ <StrictMode>
150
+ <Page />
151
+ </StrictMode>,
152
+ );
153
+
154
+ await waitFor(() => {
155
+ expect(spy).toHaveBeenCalledTimes(1);
156
+ });
157
+
158
+ fireEvent.click(screen.getByText(depBtnText));
159
+
160
+ await waitFor(() => {
161
+ expect(spy).toHaveBeenCalledTimes(2);
162
+ });
163
+
164
+ fireEvent.click(screen.getByText(btnText));
165
+
166
+ await waitFor(() => {
167
+ expect(spy).toHaveBeenCalledTimes(3);
168
+ });
169
+ });
170
+ });
171
+ });
172
+ });
@@ -0,0 +1,233 @@
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, renderUseFetch } from "../../utils";
6
+
7
+ const { resetMocks, startServer, stopServer, mockRequest } = createHttpMockingServer();
8
+
9
+ describe("useFetch [ Methods ]", () => {
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 hook is mounted", () => {
31
+ describe("when processing request", () => {
32
+ it("should trigger onRequestStart helper", async () => {
33
+ const spy = jest.fn();
34
+ const mock = mockRequest(request);
35
+ const response = renderUseFetch(request);
36
+
37
+ act(() => {
38
+ response.result.current.onRequestStart(spy);
39
+ });
40
+
41
+ await testSuccessState(mock, response);
42
+ expect(spy).toHaveBeenCalledTimes(1);
43
+ });
44
+ it("should trigger onResponseStart helper", async () => {
45
+ const spy = jest.fn();
46
+ const mock = mockRequest(request);
47
+ const response = renderUseFetch(request);
48
+
49
+ act(() => {
50
+ response.result.current.onResponseStart(spy);
51
+ });
52
+
53
+ await testSuccessState(mock, response);
54
+ expect(spy).toHaveBeenCalledTimes(1);
55
+ });
56
+ it("should trigger onDownloadProgress helper", async () => {
57
+ const spy = jest.fn();
58
+ const mock = mockRequest(request);
59
+ const response = renderUseFetch(request);
60
+
61
+ act(() => {
62
+ response.result.current.onDownloadProgress(spy);
63
+ });
64
+
65
+ await testSuccessState(mock, response);
66
+ expect(spy).toHaveBeenCalledTimes(3);
67
+ });
68
+ it("should trigger onUploadProgress helper", async () => {
69
+ const spy = jest.fn();
70
+ const mock = mockRequest(request);
71
+ const response = renderUseFetch(request);
72
+
73
+ act(() => {
74
+ response.result.current.onUploadProgress(spy);
75
+ });
76
+
77
+ await testSuccessState(mock, response);
78
+ expect(spy).toHaveBeenCalledTimes(3);
79
+ });
80
+ });
81
+ describe("when getting the response", () => {
82
+ it("should trigger onSuccess helper", async () => {
83
+ const spy = jest.fn();
84
+ const unusedSpy = jest.fn();
85
+ const mock = mockRequest(request);
86
+ const response = renderUseFetch(request);
87
+
88
+ act(() => {
89
+ response.result.current.onSuccess(spy);
90
+ response.result.current.onError(unusedSpy);
91
+ });
92
+
93
+ await testSuccessState(mock, response);
94
+ expect(spy).toHaveBeenCalledTimes(1);
95
+ expect(unusedSpy).toHaveBeenCalledTimes(0);
96
+ });
97
+ it("should trigger onError helper", async () => {
98
+ const spy = jest.fn();
99
+ const unusedSpy = jest.fn();
100
+ const mock = mockRequest(request, { status: 400 });
101
+ const response = renderUseFetch(request);
102
+
103
+ act(() => {
104
+ response.result.current.onError(spy);
105
+ response.result.current.onSuccess(unusedSpy);
106
+ });
107
+
108
+ await testErrorState(mock, response);
109
+ expect(spy).toHaveBeenCalledTimes(1);
110
+ expect(unusedSpy).toHaveBeenCalledTimes(0);
111
+ });
112
+ it("should trigger onFinished helper on success", async () => {
113
+ const spy = jest.fn();
114
+ const mock = mockRequest(request);
115
+ const response = renderUseFetch(request);
116
+
117
+ act(() => {
118
+ response.result.current.onFinished(spy);
119
+ });
120
+
121
+ await testSuccessState(mock, response);
122
+ expect(spy).toHaveBeenCalledTimes(1);
123
+ });
124
+ it("should trigger onFinished helper on error", async () => {
125
+ const spy = jest.fn();
126
+ const mock = mockRequest(request, { status: 400 });
127
+ const response = renderUseFetch(request);
128
+
129
+ act(() => {
130
+ response.result.current.onFinished(spy);
131
+ });
132
+
133
+ await testErrorState(mock, response);
134
+ expect(spy).toHaveBeenCalledTimes(1);
135
+ });
136
+ });
137
+ describe("when getting internal error", () => {
138
+ it("should trigger onOfflineError helper", async () => {
139
+ const spy = jest.fn();
140
+ mockRequest(request, { status: 400 });
141
+ const response = renderUseFetch(request.setOffline(true));
142
+
143
+ act(() => {
144
+ response.result.current.onOfflineError(spy);
145
+ client.appManager.setOnline(false);
146
+ });
147
+
148
+ await waitFor(() => {
149
+ expect(spy).toHaveBeenCalledTimes(1);
150
+ });
151
+ });
152
+ it("should trigger methods on retry", async () => {
153
+ const spy1 = jest.fn();
154
+ const spy2 = jest.fn();
155
+ const spy3 = jest.fn();
156
+ const spy4 = jest.fn();
157
+ const spy5 = jest.fn();
158
+ const spy6 = jest.fn();
159
+ const spy7 = jest.fn();
160
+ const spy8 = jest.fn();
161
+
162
+ const errorMock = mockRequest(request, { status: 400 });
163
+ const response = renderUseFetch(request.setRetry(1).setRetryTime(100));
164
+
165
+ act(() => {
166
+ response.result.current.onRequestStart(spy1);
167
+ response.result.current.onResponseStart(spy2);
168
+ response.result.current.onDownloadProgress(spy3);
169
+ response.result.current.onUploadProgress(spy4);
170
+ response.result.current.onSuccess(spy5);
171
+ response.result.current.onError(spy6);
172
+ response.result.current.onFinished(spy7);
173
+ response.result.current.onOfflineError(spy8);
174
+ });
175
+
176
+ await testErrorState(errorMock, response);
177
+ const successMock = mockRequest(request);
178
+ await testSuccessState(successMock, response);
179
+
180
+ expect(spy1).toHaveBeenCalledTimes(2);
181
+ expect(spy2).toHaveBeenCalledTimes(2);
182
+ expect(spy3).toHaveBeenCalledTimes(6);
183
+ expect(spy4).toHaveBeenCalledTimes(6);
184
+ expect(spy5).toHaveBeenCalledTimes(1);
185
+ expect(spy6).toHaveBeenCalledTimes(1);
186
+ expect(spy7).toHaveBeenCalledTimes(2);
187
+ expect(spy8).toHaveBeenCalledTimes(0);
188
+ });
189
+ it("should trigger methods on coming back online", async () => {
190
+ const spy1 = jest.fn();
191
+ const spy2 = jest.fn();
192
+ const spy3 = jest.fn();
193
+ const spy4 = jest.fn();
194
+ const spy5 = jest.fn();
195
+ const spy6 = jest.fn();
196
+ const spy7 = jest.fn();
197
+ const spy8 = jest.fn();
198
+
199
+ const errorMock = mockRequest(request, { status: 400 });
200
+ const response = renderUseFetch(request);
201
+
202
+ act(() => {
203
+ response.result.current.onRequestStart(spy1);
204
+ response.result.current.onResponseStart(spy2);
205
+ response.result.current.onDownloadProgress(spy3);
206
+ response.result.current.onUploadProgress(spy4);
207
+ response.result.current.onSuccess(spy5);
208
+ response.result.current.onError(spy6);
209
+ response.result.current.onFinished(spy7);
210
+ response.result.current.onOfflineError(spy8);
211
+ client.appManager.setOnline(false);
212
+ });
213
+
214
+ await testErrorState(errorMock, response);
215
+ const successMock = mockRequest(request);
216
+
217
+ act(() => {
218
+ client.appManager.setOnline(true);
219
+ });
220
+
221
+ await testSuccessState(successMock, response);
222
+ expect(spy1).toHaveBeenCalledTimes(2);
223
+ expect(spy2).toHaveBeenCalledTimes(2);
224
+ expect(spy3).toHaveBeenCalledTimes(6);
225
+ expect(spy4).toHaveBeenCalledTimes(6);
226
+ expect(spy5).toHaveBeenCalledTimes(1);
227
+ expect(spy6).toHaveBeenCalledTimes(0);
228
+ expect(spy7).toHaveBeenCalledTimes(2);
229
+ expect(spy8).toHaveBeenCalledTimes(1);
230
+ });
231
+ });
232
+ });
233
+ });