@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.
- package/__tests__/features/helpers/use-request-events/use-request-events.base.spec.ts +115 -0
- package/__tests__/features/helpers/use-request-events/use-request-events.utils.spec.ts +69 -0
- package/__tests__/features/helpers/use-socket-state/use-socket-state.base.spec.ts +175 -0
- package/__tests__/features/helpers/use-tracked-state/use-tacked-state.actions.spec.ts +382 -0
- package/__tests__/features/helpers/use-tracked-state/use-tracked-state.base.spec.ts +527 -0
- package/__tests__/features/helpers/use-tracked-state/use-tracked-state.utils.spec.ts +260 -0
- package/__tests__/features/provider/provider.hydration.spec.tsx +161 -0
- package/__tests__/features/provider/use-config-provider.base.spec.tsx +68 -0
- package/__tests__/features/use-app-manager/use-app-manager.base.spec.ts +85 -0
- package/__tests__/features/use-cache/use-cache.base.spec.ts +133 -0
- package/__tests__/features/use-cache/use-cache.helpers.ts +40 -0
- package/__tests__/features/use-emitter/use-emitter.base.spec.ts +124 -0
- package/__tests__/features/use-fetch/use-fetch.base.spec.ts +284 -0
- package/__tests__/features/use-fetch/use-fetch.cancel.spec.ts +83 -0
- package/__tests__/features/use-fetch/use-fetch.concurrency.spec.ts +91 -0
- package/__tests__/features/use-fetch/use-fetch.debounce.spec.ts +153 -0
- package/__tests__/features/use-fetch/use-fetch.deduplication.spec.ts +80 -0
- package/__tests__/features/use-fetch/use-fetch.infinite.ts +39 -0
- package/__tests__/features/use-fetch/use-fetch.integration.spec.tsx +172 -0
- package/__tests__/features/use-fetch/use-fetch.methods.spec.ts +233 -0
- package/__tests__/features/use-fetch/use-fetch.offline.spec.ts +103 -0
- package/__tests__/features/use-fetch/use-fetch.pagination.ts +36 -0
- package/__tests__/features/use-fetch/use-fetch.prefetch.spec.tsx +73 -0
- package/__tests__/features/use-fetch/use-fetch.refresh.spec.ts +153 -0
- package/__tests__/features/use-fetch/use-fetch.rerender.spec.tsx +151 -0
- package/__tests__/features/use-fetch/use-fetch.retry.ts +38 -0
- package/__tests__/features/use-fetch/use-fetch.revalidate.spec.ts +235 -0
- package/__tests__/features/use-fetch/use-fetch.suspense.ts +37 -0
- package/__tests__/features/use-fetch/use-fetch.typescript.spec.ts +59 -0
- package/__tests__/features/use-fetch/use-fetch.utils.spec.ts +26 -0
- package/__tests__/features/use-fetch/use-fetch.window.spec.ts +59 -0
- package/__tests__/features/use-listener/use-listener.base.spec.ts +57 -0
- package/__tests__/features/use-queue/use-queue.actions.spec.ts +238 -0
- package/__tests__/features/use-queue/use-queue.base.spec.ts +109 -0
- package/__tests__/features/use-submit/use-submit.base.spec.ts +76 -0
- package/__tests__/features/use-submit/use-submit.cancel.spec.ts +46 -0
- package/__tests__/features/use-submit/use-submit.concurrency.spec.ts +62 -0
- package/__tests__/features/use-submit/use-submit.debounce.spec.ts +320 -0
- package/__tests__/features/use-submit/use-submit.methods.spec.ts +278 -0
- package/__tests__/features/use-submit/use-submit.queue.spec.ts +84 -0
- package/__tests__/features/use-submit/use-submit.retry.spec.ts +92 -0
- package/__tests__/features/use-submit/use-submit.revalidate.spec.ts +99 -0
- package/__tests__/features/use-submit/use-submit.submit.spec.ts +233 -0
- package/__tests__/global.d.ts +1 -0
- package/__tests__/jest.setup.ts +9 -0
- package/__tests__/shared/index.ts +2 -0
- package/__tests__/shared/isolation.tests.ts +12 -0
- package/__tests__/shared/response.tests.ts +127 -0
- package/__tests__/tsconfig.json +8 -0
- package/__tests__/utils/cache.utils.ts +53 -0
- package/__tests__/utils/client.utils.ts +3 -0
- package/__tests__/utils/emitter.utils.ts +7 -0
- package/__tests__/utils/helpers.utils.ts +9 -0
- package/__tests__/utils/index.ts +14 -0
- package/__tests__/utils/listener.utils.ts +10 -0
- package/__tests__/utils/request.utils.ts +12 -0
- package/__tests__/utils/state.utils.ts +7 -0
- package/__tests__/utils/use-app-manager.utils.ts +10 -0
- package/__tests__/utils/use-cache.utils.ts +11 -0
- package/__tests__/utils/use-emitter.utils.ts +11 -0
- package/__tests__/utils/use-fetch.utils.ts +11 -0
- package/__tests__/utils/use-listener.utils.ts +11 -0
- package/__tests__/utils/use-queue.utils.ts +68 -0
- package/__tests__/utils/use-request-events.utils.ts +42 -0
- package/__tests__/utils/use-socket-state.utils.ts +11 -0
- package/__tests__/utils/use-submit.utils.ts +11 -0
- package/__tests__/utils/use-tracked-state.utils.ts +26 -0
- package/jest.config.ts +6 -0
- package/package.json +1 -1
- package/project.json +4 -0
|
@@ -0,0 +1,235 @@
|
|
|
1
|
+
import { xhrExtra } from "@hyper-fetch/core";
|
|
2
|
+
import { act, waitFor } from "@testing-library/react";
|
|
3
|
+
import { createHttpMockingServer, sleep } from "@hyper-fetch/testing";
|
|
4
|
+
|
|
5
|
+
import { testSuccessState } from "../../shared";
|
|
6
|
+
import { client, createRequest, renderUseFetch, waitForRender } from "../../utils";
|
|
7
|
+
|
|
8
|
+
const { resetMocks, startServer, stopServer, mockRequest } = createHttpMockingServer();
|
|
9
|
+
|
|
10
|
+
describe("useFetch [ refetch ]", () => {
|
|
11
|
+
let request = createRequest();
|
|
12
|
+
let mock = mockRequest(request, {
|
|
13
|
+
data: { someData: 12345 },
|
|
14
|
+
});
|
|
15
|
+
|
|
16
|
+
beforeAll(() => {
|
|
17
|
+
startServer();
|
|
18
|
+
});
|
|
19
|
+
|
|
20
|
+
afterEach(() => {
|
|
21
|
+
resetMocks();
|
|
22
|
+
});
|
|
23
|
+
|
|
24
|
+
afterAll(() => {
|
|
25
|
+
stopServer();
|
|
26
|
+
});
|
|
27
|
+
|
|
28
|
+
beforeEach(() => {
|
|
29
|
+
jest.resetModules();
|
|
30
|
+
request = createRequest();
|
|
31
|
+
client.clear();
|
|
32
|
+
mock = mockRequest(request, {
|
|
33
|
+
data: { someData: 12345 },
|
|
34
|
+
});
|
|
35
|
+
});
|
|
36
|
+
|
|
37
|
+
it("should allow to prevent invalidation on mount with cache data", async () => {
|
|
38
|
+
const spy = jest.fn();
|
|
39
|
+
const customMock = { something: "123" };
|
|
40
|
+
client.cache.set(request, {
|
|
41
|
+
data: customMock,
|
|
42
|
+
error: null,
|
|
43
|
+
status: 200,
|
|
44
|
+
success: true,
|
|
45
|
+
extra: { headers: { "content-type": "application/json" } },
|
|
46
|
+
retries: 0,
|
|
47
|
+
addedTimestamp: +new Date(),
|
|
48
|
+
triggerTimestamp: +new Date(),
|
|
49
|
+
requestTimestamp: +new Date(),
|
|
50
|
+
responseTimestamp: +new Date(),
|
|
51
|
+
isCanceled: false,
|
|
52
|
+
isOffline: false,
|
|
53
|
+
});
|
|
54
|
+
|
|
55
|
+
const response = renderUseFetch(request, { revalidate: false });
|
|
56
|
+
act(() => {
|
|
57
|
+
response.result.current.onFinished(spy);
|
|
58
|
+
});
|
|
59
|
+
|
|
60
|
+
await testSuccessState(customMock, response);
|
|
61
|
+
await sleep(50);
|
|
62
|
+
expect(spy).toHaveBeenCalledTimes(0);
|
|
63
|
+
});
|
|
64
|
+
it("should allow invalidation on mount", async () => {
|
|
65
|
+
const spy = jest.fn();
|
|
66
|
+
const response = renderUseFetch(request, { revalidate: false });
|
|
67
|
+
|
|
68
|
+
act(() => {
|
|
69
|
+
response.result.current.onFinished(() => {
|
|
70
|
+
spy();
|
|
71
|
+
response.unmount();
|
|
72
|
+
});
|
|
73
|
+
});
|
|
74
|
+
renderUseFetch(request, { revalidate: false });
|
|
75
|
+
|
|
76
|
+
await waitForRender(50);
|
|
77
|
+
expect(spy).toHaveBeenCalledTimes(1);
|
|
78
|
+
});
|
|
79
|
+
it("should allow to refetch on mount", async () => {
|
|
80
|
+
const customMock = { something: "123" };
|
|
81
|
+
client.cache.set(request, {
|
|
82
|
+
data: customMock,
|
|
83
|
+
error: null,
|
|
84
|
+
status: 200,
|
|
85
|
+
success: true,
|
|
86
|
+
extra: xhrExtra,
|
|
87
|
+
retries: 0,
|
|
88
|
+
addedTimestamp: +new Date(),
|
|
89
|
+
triggerTimestamp: +new Date(),
|
|
90
|
+
requestTimestamp: +new Date(),
|
|
91
|
+
responseTimestamp: +new Date(),
|
|
92
|
+
isCanceled: false,
|
|
93
|
+
isOffline: false,
|
|
94
|
+
});
|
|
95
|
+
|
|
96
|
+
const response = renderUseFetch(request, { revalidate: true });
|
|
97
|
+
|
|
98
|
+
await waitFor(async () => {
|
|
99
|
+
await testSuccessState(mock, response);
|
|
100
|
+
});
|
|
101
|
+
});
|
|
102
|
+
it("should allow to refetch current hook", async () => {
|
|
103
|
+
const response = renderUseFetch(request);
|
|
104
|
+
|
|
105
|
+
await waitFor(async () => {
|
|
106
|
+
await testSuccessState(mock, response);
|
|
107
|
+
});
|
|
108
|
+
const customMock = mockRequest(request, { data: { something: 123 } });
|
|
109
|
+
|
|
110
|
+
act(() => {
|
|
111
|
+
response.result.current.refetch();
|
|
112
|
+
});
|
|
113
|
+
|
|
114
|
+
await waitFor(async () => {
|
|
115
|
+
await testSuccessState(customMock, response);
|
|
116
|
+
});
|
|
117
|
+
});
|
|
118
|
+
it("should allow to refetch hook by RegExp", async () => {
|
|
119
|
+
const regexp = /(Maciej|Kacper)/;
|
|
120
|
+
const responseOne = renderUseFetch(request.setCacheKey("Maciej"));
|
|
121
|
+
const responseTwo = renderUseFetch(request.setCacheKey("Kacper"));
|
|
122
|
+
|
|
123
|
+
await waitFor(async () => {
|
|
124
|
+
await testSuccessState(mock, responseOne);
|
|
125
|
+
await testSuccessState(mock, responseTwo);
|
|
126
|
+
});
|
|
127
|
+
const customMock = mockRequest(request, { data: { something: 123 } });
|
|
128
|
+
|
|
129
|
+
act(() => {
|
|
130
|
+
client.cache.invalidate(regexp);
|
|
131
|
+
});
|
|
132
|
+
|
|
133
|
+
await waitFor(async () => {
|
|
134
|
+
await testSuccessState(customMock, responseOne);
|
|
135
|
+
await testSuccessState(customMock, responseTwo);
|
|
136
|
+
});
|
|
137
|
+
});
|
|
138
|
+
it("should allow to refetch hook by keys array", async () => {
|
|
139
|
+
const responseOne = renderUseFetch(request.setCacheKey("Maciej"));
|
|
140
|
+
const responseTwo = renderUseFetch(request.setCacheKey("Kacper"));
|
|
141
|
+
|
|
142
|
+
await waitFor(async () => {
|
|
143
|
+
await testSuccessState(mock, responseOne);
|
|
144
|
+
await testSuccessState(mock, responseTwo);
|
|
145
|
+
});
|
|
146
|
+
const customMock = mockRequest(request, { data: { something: 123 } });
|
|
147
|
+
|
|
148
|
+
act(() => {
|
|
149
|
+
client.cache.invalidate(["Maciej"]);
|
|
150
|
+
});
|
|
151
|
+
|
|
152
|
+
await waitFor(async () => {
|
|
153
|
+
await testSuccessState(customMock, responseOne);
|
|
154
|
+
await testSuccessState(mock, responseTwo);
|
|
155
|
+
});
|
|
156
|
+
});
|
|
157
|
+
it("should allow to refetch hook by key", async () => {
|
|
158
|
+
const responseOne = renderUseFetch(request.setCacheKey("Maciej"));
|
|
159
|
+
const responseTwo = renderUseFetch(request.setCacheKey("Kacper"));
|
|
160
|
+
|
|
161
|
+
await waitFor(async () => {
|
|
162
|
+
await testSuccessState(mock, responseOne);
|
|
163
|
+
await testSuccessState(mock, responseTwo);
|
|
164
|
+
});
|
|
165
|
+
const customMock = mockRequest(request, { data: { something: 123 } });
|
|
166
|
+
|
|
167
|
+
act(() => {
|
|
168
|
+
client.cache.invalidate("Maciej");
|
|
169
|
+
});
|
|
170
|
+
|
|
171
|
+
await waitFor(async () => {
|
|
172
|
+
await testSuccessState(customMock, responseOne);
|
|
173
|
+
await testSuccessState(mock, responseTwo);
|
|
174
|
+
});
|
|
175
|
+
});
|
|
176
|
+
it("should allow to refetch hook by request", async () => {
|
|
177
|
+
const responseOne = renderUseFetch(request.setQueryParams("?something=123"));
|
|
178
|
+
const responseTwo = renderUseFetch(request.setQueryParams("?other=999"));
|
|
179
|
+
|
|
180
|
+
await waitFor(async () => {
|
|
181
|
+
await testSuccessState(mock, responseOne);
|
|
182
|
+
await testSuccessState(mock, responseTwo);
|
|
183
|
+
});
|
|
184
|
+
const customMock = mockRequest(request, { data: { something: 123 } });
|
|
185
|
+
|
|
186
|
+
act(() => {
|
|
187
|
+
client.cache.invalidate(request.setQueryParams("?something=123"));
|
|
188
|
+
});
|
|
189
|
+
|
|
190
|
+
await waitFor(async () => {
|
|
191
|
+
await testSuccessState(customMock, responseOne);
|
|
192
|
+
await testSuccessState(mock, responseTwo);
|
|
193
|
+
});
|
|
194
|
+
});
|
|
195
|
+
it("should not refetch while toggling query", async () => {
|
|
196
|
+
const spy = jest.fn();
|
|
197
|
+
|
|
198
|
+
const revalidateRequest = createRequest({ endpoint: "123-revalidate" });
|
|
199
|
+
const revalidateMock = mockRequest(revalidateRequest, { data: { something: 123 } });
|
|
200
|
+
|
|
201
|
+
// First request
|
|
202
|
+
const response = renderUseFetch(request, { revalidate: false });
|
|
203
|
+
|
|
204
|
+
response.result.current.onFinished(() => {
|
|
205
|
+
spy();
|
|
206
|
+
});
|
|
207
|
+
|
|
208
|
+
await testSuccessState(mock, response);
|
|
209
|
+
expect(spy).toHaveBeenCalledTimes(1);
|
|
210
|
+
|
|
211
|
+
act(() => {
|
|
212
|
+
// Second request
|
|
213
|
+
response.rerender({ request: revalidateRequest, revalidate: false });
|
|
214
|
+
});
|
|
215
|
+
|
|
216
|
+
await testSuccessState(revalidateMock, response);
|
|
217
|
+
expect(spy).toHaveBeenCalledTimes(2);
|
|
218
|
+
|
|
219
|
+
// Check revalidation
|
|
220
|
+
act(() => {
|
|
221
|
+
// Third request
|
|
222
|
+
response.rerender({ request, revalidate: false });
|
|
223
|
+
});
|
|
224
|
+
await testSuccessState(mock, response);
|
|
225
|
+
expect(spy).toHaveBeenCalledTimes(2);
|
|
226
|
+
|
|
227
|
+
act(() => {
|
|
228
|
+
// Fourth request
|
|
229
|
+
response.rerender({ request: revalidateRequest, revalidate: false });
|
|
230
|
+
});
|
|
231
|
+
|
|
232
|
+
await testSuccessState(revalidateMock, response);
|
|
233
|
+
expect(spy).toHaveBeenCalledTimes(2);
|
|
234
|
+
});
|
|
235
|
+
});
|
|
@@ -0,0 +1,37 @@
|
|
|
1
|
+
import { createHttpMockingServer } from "@hyper-fetch/testing";
|
|
2
|
+
|
|
3
|
+
import { client } from "../../utils";
|
|
4
|
+
|
|
5
|
+
const { resetMocks, startServer, stopServer } = createHttpMockingServer();
|
|
6
|
+
|
|
7
|
+
describe("useFetch [ Suspense ]", () => {
|
|
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
|
+
it("should render fallback", async () => {
|
|
26
|
+
// TODO
|
|
27
|
+
});
|
|
28
|
+
it("should render multiple fallbacks", async () => {
|
|
29
|
+
// TODO
|
|
30
|
+
});
|
|
31
|
+
it("should throw errors", async () => {
|
|
32
|
+
// TODO
|
|
33
|
+
});
|
|
34
|
+
it("should render cached data with error", async () => {
|
|
35
|
+
// TODO
|
|
36
|
+
});
|
|
37
|
+
});
|
|
@@ -0,0 +1,59 @@
|
|
|
1
|
+
import { useFetch } from "hooks/use-fetch";
|
|
2
|
+
|
|
3
|
+
describe("useFetch", () => {
|
|
4
|
+
it("dummy test", () => {
|
|
5
|
+
expect(useFetch).toBeDefined();
|
|
6
|
+
});
|
|
7
|
+
});
|
|
8
|
+
|
|
9
|
+
// import { expectType } from "@hyper-fetch/testing";
|
|
10
|
+
// import { Client, ExtractHasPayloadType, ExtractHasParamsType, ExtractHasQueryParamsType } from "@hyper-fetch/core";
|
|
11
|
+
|
|
12
|
+
// import { UseFetchRequest } from "hooks/use-fetch";
|
|
13
|
+
|
|
14
|
+
// const client = new Client({
|
|
15
|
+
// url: "http://localhost:3000",
|
|
16
|
+
// });
|
|
17
|
+
|
|
18
|
+
// describe("when using useFetch request", () => {
|
|
19
|
+
// it("should require params", () => {
|
|
20
|
+
// const getUser = client.createRequest<{ response: { id: string } }>()({
|
|
21
|
+
// method: "GET",
|
|
22
|
+
// endpoint: "/users/:id",
|
|
23
|
+
// });
|
|
24
|
+
// const getUserWithParams = getUser.setParams({ id: 1 });
|
|
25
|
+
// expectType<ExtractHasParamsType<UseFetchRequest<typeof getUser>>>().assert(false);
|
|
26
|
+
// expectType<ExtractHasParamsType<UseFetchRequest<typeof getUserWithParams>>>().assert(true);
|
|
27
|
+
// });
|
|
28
|
+
// it("should require payload", () => {
|
|
29
|
+
// const postUser = client.createRequest<{ response: { id: string }; payload: { name: string } }>()({
|
|
30
|
+
// method: "POST",
|
|
31
|
+
// endpoint: "/users",
|
|
32
|
+
// });
|
|
33
|
+
// const postUserWithPayload = postUser.setPayload({ name: "test" });
|
|
34
|
+
|
|
35
|
+
// expectType<ExtractHasPayloadType<UseFetchRequest<typeof postUser>>>().assert(false);
|
|
36
|
+
// expectType<ExtractHasPayloadType<UseFetchRequest<typeof postUserWithPayload>>>().assert(true);
|
|
37
|
+
// });
|
|
38
|
+
// it("should require params and payload", () => {
|
|
39
|
+
// const patchUser = client.createRequest<{
|
|
40
|
+
// response: { id: string };
|
|
41
|
+
// payload: { name: string };
|
|
42
|
+
// queryParams: { name: string };
|
|
43
|
+
// }>()({
|
|
44
|
+
// method: "PATCH",
|
|
45
|
+
// endpoint: "/users/:id",
|
|
46
|
+
// });
|
|
47
|
+
// const patchUserWithParams = patchUser.setParams({ id: 1 });
|
|
48
|
+
// const patchUserWithPayload = patchUser.setPayload({ name: "test" });
|
|
49
|
+
// const patchUserWithQueryParams = patchUser.setQueryParams({ name: "test" });
|
|
50
|
+
|
|
51
|
+
// expectType<false>().assert<ExtractHasParamsType<UseFetchRequest<typeof patchUser>>>(false);
|
|
52
|
+
// expectType<false>().assert<ExtractHasPayloadType<UseFetchRequest<typeof patchUser>>>(false);
|
|
53
|
+
// expectType<false>().assert<ExtractHasQueryParamsType<UseFetchRequest<typeof patchUser>>>(false);
|
|
54
|
+
|
|
55
|
+
// expectType<true>().assert<ExtractHasParamsType<UseFetchRequest<typeof patchUserWithParams>>>(true);
|
|
56
|
+
// expectType<true>().assert<ExtractHasPayloadType<UseFetchRequest<typeof patchUserWithPayload>>>(true);
|
|
57
|
+
// expectType<true>().assert<ExtractHasQueryParamsType<UseFetchRequest<typeof patchUserWithQueryParams>>>(true);
|
|
58
|
+
// });
|
|
59
|
+
// });
|
|
@@ -0,0 +1,26 @@
|
|
|
1
|
+
import { getRefreshTime } from "hooks/use-fetch";
|
|
2
|
+
|
|
3
|
+
describe("useFetch [ Utils ]", () => {
|
|
4
|
+
const refreshTime = 1000;
|
|
5
|
+
describe("given using getRefreshTime util", () => {
|
|
6
|
+
describe("when state is available", () => {
|
|
7
|
+
it("should give the reduced refresh time based on timestamp", async () => {
|
|
8
|
+
const timestamp = new Date(+new Date() - 500);
|
|
9
|
+
const time = getRefreshTime(refreshTime, timestamp);
|
|
10
|
+
expect(time).toBeLessThanOrEqual(500);
|
|
11
|
+
expect(time).toBeGreaterThanOrEqual(490);
|
|
12
|
+
});
|
|
13
|
+
it("should give refreshTime on old timestamp", async () => {
|
|
14
|
+
const timestamp = new Date(+new Date() - refreshTime);
|
|
15
|
+
const time = getRefreshTime(refreshTime, timestamp);
|
|
16
|
+
expect(time).toBe(refreshTime);
|
|
17
|
+
});
|
|
18
|
+
});
|
|
19
|
+
describe("when only refreshTime gets provided", () => {
|
|
20
|
+
it("should give refreshTime", async () => {
|
|
21
|
+
const time = getRefreshTime(refreshTime);
|
|
22
|
+
expect(time).toBe(refreshTime);
|
|
23
|
+
});
|
|
24
|
+
});
|
|
25
|
+
});
|
|
26
|
+
});
|
|
@@ -0,0 +1,59 @@
|
|
|
1
|
+
import { act, waitFor } 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 [ Basic ]", () => {
|
|
9
|
+
let request = createRequest({ cancelable: true });
|
|
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
|
+
request = createRequest({ cancelable: true });
|
|
26
|
+
client.clear();
|
|
27
|
+
});
|
|
28
|
+
|
|
29
|
+
it("should refresh on tab focus", async () => {
|
|
30
|
+
const spy = jest.fn();
|
|
31
|
+
mockRequest(request, { delay: 0 });
|
|
32
|
+
const response = renderUseFetch(request, { refetchOnFocus: true });
|
|
33
|
+
|
|
34
|
+
await waitForRender();
|
|
35
|
+
|
|
36
|
+
act(() => {
|
|
37
|
+
response.result.current.onRequestStart(spy);
|
|
38
|
+
client.appManager.setFocused(false);
|
|
39
|
+
client.appManager.setFocused(true);
|
|
40
|
+
});
|
|
41
|
+
await waitFor(() => {
|
|
42
|
+
expect(spy).toHaveBeenCalledTimes(1);
|
|
43
|
+
});
|
|
44
|
+
});
|
|
45
|
+
it("should refresh on tab blur", async () => {
|
|
46
|
+
const spy = jest.fn();
|
|
47
|
+
mockRequest(request, { delay: 0 });
|
|
48
|
+
const response = renderUseFetch(request, { refetchOnBlur: true });
|
|
49
|
+
|
|
50
|
+
await waitForRender();
|
|
51
|
+
act(() => {
|
|
52
|
+
response.result.current.onRequestStart(spy);
|
|
53
|
+
window.dispatchEvent(new Event("blur"));
|
|
54
|
+
});
|
|
55
|
+
await waitFor(() => {
|
|
56
|
+
expect(spy).toHaveBeenCalledTimes(1);
|
|
57
|
+
});
|
|
58
|
+
});
|
|
59
|
+
});
|
|
@@ -0,0 +1,57 @@
|
|
|
1
|
+
import { act, waitFor } from "@testing-library/react";
|
|
2
|
+
import { createWebsocketMockingServer, waitForConnection } from "@hyper-fetch/testing";
|
|
3
|
+
|
|
4
|
+
import { createListener } from "../../utils/listener.utils";
|
|
5
|
+
import { renderUseListener } from "../../utils/use-listener.utils";
|
|
6
|
+
|
|
7
|
+
describe("useListener [ Base ]", () => {
|
|
8
|
+
const { startServer, stopServer, emitListenerEvent } = createWebsocketMockingServer();
|
|
9
|
+
const spy = jest.fn();
|
|
10
|
+
let listener = createListener();
|
|
11
|
+
|
|
12
|
+
beforeEach(async () => {
|
|
13
|
+
startServer();
|
|
14
|
+
listener = createListener();
|
|
15
|
+
await waitForConnection(listener.socket);
|
|
16
|
+
jest.resetModules();
|
|
17
|
+
jest.resetAllMocks();
|
|
18
|
+
});
|
|
19
|
+
|
|
20
|
+
afterEach(() => {
|
|
21
|
+
stopServer();
|
|
22
|
+
});
|
|
23
|
+
|
|
24
|
+
describe("when hook receive event", () => {
|
|
25
|
+
it("should set state with data", async () => {
|
|
26
|
+
const message = { name: "Maciej", age: 99 };
|
|
27
|
+
const view = renderUseListener(listener);
|
|
28
|
+
emitListenerEvent(listener, message);
|
|
29
|
+
await waitFor(() => {
|
|
30
|
+
expect(view.result.current.data).toBeTruthy();
|
|
31
|
+
expect(view.result.current.extra).toBeObject();
|
|
32
|
+
expect(view.result.current.connected).toBeTrue();
|
|
33
|
+
expect(view.result.current.connecting).toBeFalse();
|
|
34
|
+
expect(view.result.current.timestamp).toBeNumber();
|
|
35
|
+
});
|
|
36
|
+
});
|
|
37
|
+
it("should trigger onEvent callback", async () => {
|
|
38
|
+
const message = { name: "Maciej", age: 99 };
|
|
39
|
+
const view = renderUseListener(listener);
|
|
40
|
+
let receivedData: any;
|
|
41
|
+
let receivedEventData: any;
|
|
42
|
+
act(() => {
|
|
43
|
+
view.result.current.onEvent(({ data, extra }) => {
|
|
44
|
+
receivedData = data;
|
|
45
|
+
receivedEventData = extra;
|
|
46
|
+
spy();
|
|
47
|
+
});
|
|
48
|
+
});
|
|
49
|
+
emitListenerEvent(listener, message);
|
|
50
|
+
await waitFor(() => {
|
|
51
|
+
expect(spy).toHaveBeenCalledTimes(1);
|
|
52
|
+
expect(receivedData).toEqual(message);
|
|
53
|
+
expect(receivedEventData).toBeDefined();
|
|
54
|
+
});
|
|
55
|
+
});
|
|
56
|
+
});
|
|
57
|
+
});
|