@hyper-fetch/react 7.5.2 → 7.5.3
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- 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,382 @@
|
|
|
1
|
+
import { createClient } from "@hyper-fetch/core";
|
|
2
|
+
import { act, waitFor } from "@testing-library/react";
|
|
3
|
+
import { createHttpMockingServer } from "@hyper-fetch/testing";
|
|
4
|
+
|
|
5
|
+
import { renderUseTrackedState } from "../../../utils";
|
|
6
|
+
|
|
7
|
+
const { resetMocks, startServer, stopServer } = createHttpMockingServer();
|
|
8
|
+
|
|
9
|
+
describe("useTrackedState [ Actions ]", () => {
|
|
10
|
+
let client = createClient({ url: "http://localhost:3000" });
|
|
11
|
+
let request = client.createRequest<{ response: any }>()({ endpoint: "test" });
|
|
12
|
+
|
|
13
|
+
beforeAll(() => {
|
|
14
|
+
startServer();
|
|
15
|
+
});
|
|
16
|
+
|
|
17
|
+
afterEach(() => {
|
|
18
|
+
resetMocks();
|
|
19
|
+
});
|
|
20
|
+
|
|
21
|
+
afterAll(() => {
|
|
22
|
+
stopServer();
|
|
23
|
+
jest.resetModules();
|
|
24
|
+
jest.resetAllMocks();
|
|
25
|
+
client.clear();
|
|
26
|
+
});
|
|
27
|
+
|
|
28
|
+
beforeEach(() => {
|
|
29
|
+
client = createClient({ url: "http://localhost:3000" });
|
|
30
|
+
request = client.createRequest<{ response: any }>()({ endpoint: "test" });
|
|
31
|
+
request.setMock(() => {
|
|
32
|
+
return {
|
|
33
|
+
data: 123,
|
|
34
|
+
status: 200,
|
|
35
|
+
};
|
|
36
|
+
});
|
|
37
|
+
});
|
|
38
|
+
|
|
39
|
+
describe("when updating the local state", () => {
|
|
40
|
+
it("should allow to set data", async () => {
|
|
41
|
+
const value = { test: 1 };
|
|
42
|
+
const { result } = renderUseTrackedState(request);
|
|
43
|
+
|
|
44
|
+
act(() => {
|
|
45
|
+
result.current[1].setData(value);
|
|
46
|
+
});
|
|
47
|
+
|
|
48
|
+
expect(result.current[0].data).toBe(value);
|
|
49
|
+
});
|
|
50
|
+
it("should allow to set error", async () => {
|
|
51
|
+
const value = { test: 1 };
|
|
52
|
+
const { result } = renderUseTrackedState(request);
|
|
53
|
+
|
|
54
|
+
act(() => {
|
|
55
|
+
result.current[1].setError(value as unknown as Error);
|
|
56
|
+
});
|
|
57
|
+
|
|
58
|
+
expect(result.current[0].error).toBe(value);
|
|
59
|
+
});
|
|
60
|
+
it("should allow to set loading", async () => {
|
|
61
|
+
const { result } = renderUseTrackedState(request);
|
|
62
|
+
|
|
63
|
+
act(() => {
|
|
64
|
+
result.current[1].setLoading(true);
|
|
65
|
+
});
|
|
66
|
+
|
|
67
|
+
expect(result.current[0].loading).toBeTrue();
|
|
68
|
+
});
|
|
69
|
+
it("should allow to set status", async () => {
|
|
70
|
+
const { result } = renderUseTrackedState(request);
|
|
71
|
+
|
|
72
|
+
act(() => {
|
|
73
|
+
result.current[1].setStatus(900);
|
|
74
|
+
});
|
|
75
|
+
|
|
76
|
+
expect(result.current[0].status).toBe(900);
|
|
77
|
+
});
|
|
78
|
+
it("should allow to set success", async () => {
|
|
79
|
+
const { result } = renderUseTrackedState(request);
|
|
80
|
+
|
|
81
|
+
act(() => {
|
|
82
|
+
result.current[1].setSuccess(false);
|
|
83
|
+
});
|
|
84
|
+
|
|
85
|
+
await waitFor(() => {
|
|
86
|
+
expect(result.current[0].success).toBe(false);
|
|
87
|
+
});
|
|
88
|
+
});
|
|
89
|
+
it("should allow to set extra", async () => {
|
|
90
|
+
const extra = { headers: { test: "1" } };
|
|
91
|
+
const { result } = renderUseTrackedState(request);
|
|
92
|
+
|
|
93
|
+
act(() => {
|
|
94
|
+
result.current[1].setExtra(extra);
|
|
95
|
+
});
|
|
96
|
+
|
|
97
|
+
await waitFor(() => {
|
|
98
|
+
expect(result.current[0].extra).toBe(extra);
|
|
99
|
+
});
|
|
100
|
+
});
|
|
101
|
+
it("should allow to set response timestamp", async () => {
|
|
102
|
+
const value = new Date();
|
|
103
|
+
const { result } = renderUseTrackedState(request);
|
|
104
|
+
|
|
105
|
+
act(() => {
|
|
106
|
+
result.current[1].setResponseTimestamp(value);
|
|
107
|
+
});
|
|
108
|
+
|
|
109
|
+
expect(result.current[0].responseTimestamp).toBe(value);
|
|
110
|
+
});
|
|
111
|
+
it("should allow to set request timestamp", async () => {
|
|
112
|
+
const value = new Date();
|
|
113
|
+
const { result } = renderUseTrackedState(request);
|
|
114
|
+
|
|
115
|
+
act(() => {
|
|
116
|
+
result.current[1].setRequestTimestamp(value);
|
|
117
|
+
});
|
|
118
|
+
|
|
119
|
+
expect(result.current[0].requestTimestamp).toBe(value);
|
|
120
|
+
});
|
|
121
|
+
it("should allow to set retries", async () => {
|
|
122
|
+
const { result } = renderUseTrackedState(request);
|
|
123
|
+
|
|
124
|
+
act(() => {
|
|
125
|
+
result.current[1].setRetries(999);
|
|
126
|
+
});
|
|
127
|
+
|
|
128
|
+
expect(result.current[0].retries).toBe(999);
|
|
129
|
+
});
|
|
130
|
+
});
|
|
131
|
+
describe("when using setData action", () => {
|
|
132
|
+
it("should not update cache", async () => {
|
|
133
|
+
await request.send();
|
|
134
|
+
const { result } = renderUseTrackedState(request);
|
|
135
|
+
|
|
136
|
+
// Then update state without emitting to hooks
|
|
137
|
+
act(() => {
|
|
138
|
+
result.current[1].setData("new-value");
|
|
139
|
+
});
|
|
140
|
+
|
|
141
|
+
// Cache should retain the initial value
|
|
142
|
+
const cacheData = request.client.cache.get(request.cacheKey);
|
|
143
|
+
expect(cacheData?.data).toBe(123);
|
|
144
|
+
// Local state should have the new value
|
|
145
|
+
expect(result.current[0].data).toBe("new-value");
|
|
146
|
+
});
|
|
147
|
+
|
|
148
|
+
it("should handle null previous data in function updates", async () => {
|
|
149
|
+
const { result } = renderUseTrackedState(request);
|
|
150
|
+
|
|
151
|
+
act(() => {
|
|
152
|
+
result.current[1].setData((prev: any) => {
|
|
153
|
+
expect(prev).toBe(null);
|
|
154
|
+
return "new-value";
|
|
155
|
+
});
|
|
156
|
+
});
|
|
157
|
+
|
|
158
|
+
const cacheData = request.client.cache.get(request.cacheKey);
|
|
159
|
+
expect(cacheData?.data).toBeUndefined();
|
|
160
|
+
expect(result.current[0].data).toBe("new-value");
|
|
161
|
+
});
|
|
162
|
+
});
|
|
163
|
+
describe("when using setError action", () => {
|
|
164
|
+
it("should handle null previous error in function updates", async () => {
|
|
165
|
+
const { result } = renderUseTrackedState(request);
|
|
166
|
+
|
|
167
|
+
act(() => {
|
|
168
|
+
result.current[1].setError((prev: Error | null) => {
|
|
169
|
+
expect(prev).toBe(null);
|
|
170
|
+
return new Error("new error");
|
|
171
|
+
});
|
|
172
|
+
});
|
|
173
|
+
|
|
174
|
+
expect(result.current[0].error).toBeInstanceOf(Error);
|
|
175
|
+
expect(result.current[0].success).toBe(false);
|
|
176
|
+
});
|
|
177
|
+
|
|
178
|
+
it("should not update cache when emitToCache is false", async () => {
|
|
179
|
+
const { result } = renderUseTrackedState(request);
|
|
180
|
+
const initialError = new Error("initial error");
|
|
181
|
+
|
|
182
|
+
// Set initial error in cache
|
|
183
|
+
act(() => {
|
|
184
|
+
result.current[1].setError(initialError);
|
|
185
|
+
});
|
|
186
|
+
|
|
187
|
+
// Update local state only
|
|
188
|
+
const newError = new Error("new error");
|
|
189
|
+
act(() => {
|
|
190
|
+
result.current[1].setError(newError);
|
|
191
|
+
});
|
|
192
|
+
|
|
193
|
+
// Cache should retain initial error
|
|
194
|
+
const cacheData = request.client.cache.get(request.cacheKey);
|
|
195
|
+
expect(cacheData).toBe(undefined);
|
|
196
|
+
// Local state should have new error
|
|
197
|
+
expect(result.current[0].error).toBe(newError);
|
|
198
|
+
});
|
|
199
|
+
});
|
|
200
|
+
describe("when using setLoading action", () => {
|
|
201
|
+
it("should not emit loading event when emitToHooks is false", async () => {
|
|
202
|
+
const { result } = renderUseTrackedState(request);
|
|
203
|
+
const spy = jest.spyOn(request.client.requestManager.events, "emitLoading");
|
|
204
|
+
|
|
205
|
+
act(() => {
|
|
206
|
+
result.current[1].setLoading(true);
|
|
207
|
+
});
|
|
208
|
+
|
|
209
|
+
expect(result.current[0].loading).toBe(true);
|
|
210
|
+
expect(spy).not.toHaveBeenCalled();
|
|
211
|
+
});
|
|
212
|
+
});
|
|
213
|
+
describe("when using setStatus action", () => {
|
|
214
|
+
it("should handle null previous status in function updates", async () => {
|
|
215
|
+
const { result } = renderUseTrackedState(request);
|
|
216
|
+
|
|
217
|
+
act(() => {
|
|
218
|
+
result.current[1].setStatus((prev: number | null) => {
|
|
219
|
+
expect(prev).toBe(null);
|
|
220
|
+
return 404;
|
|
221
|
+
});
|
|
222
|
+
});
|
|
223
|
+
|
|
224
|
+
expect(result.current[0].status).toBe(404);
|
|
225
|
+
});
|
|
226
|
+
|
|
227
|
+
it("should not update cache", async () => {
|
|
228
|
+
const { result } = renderUseTrackedState(request);
|
|
229
|
+
const spy = jest.spyOn(request.client.cache, "update");
|
|
230
|
+
|
|
231
|
+
// Then update state without emitting to cache
|
|
232
|
+
act(() => {
|
|
233
|
+
result.current[1].setStatus(404);
|
|
234
|
+
});
|
|
235
|
+
|
|
236
|
+
expect(spy).toHaveBeenCalledTimes(0);
|
|
237
|
+
// Local state should have the new value
|
|
238
|
+
expect(result.current[0].status).toBe(404);
|
|
239
|
+
});
|
|
240
|
+
});
|
|
241
|
+
describe("when using setSuccess action", () => {
|
|
242
|
+
it("should handle null previous success in function updates", async () => {
|
|
243
|
+
const { result } = renderUseTrackedState(request);
|
|
244
|
+
|
|
245
|
+
act(() => {
|
|
246
|
+
result.current[1].setSuccess((prev) => {
|
|
247
|
+
expect(prev).toBe(false);
|
|
248
|
+
return true;
|
|
249
|
+
});
|
|
250
|
+
});
|
|
251
|
+
|
|
252
|
+
expect(result.current[0].success).toBe(true);
|
|
253
|
+
});
|
|
254
|
+
});
|
|
255
|
+
describe("when using setExtra action", () => {
|
|
256
|
+
it("should handle null previous extra in function updates", async () => {
|
|
257
|
+
const { result } = renderUseTrackedState(request);
|
|
258
|
+
|
|
259
|
+
act(() => {
|
|
260
|
+
result.current[1].setExtra((prev: null | Record<string, any>) => {
|
|
261
|
+
expect(prev).not.toStrictEqual({ count: 1 });
|
|
262
|
+
return { count: 1 };
|
|
263
|
+
});
|
|
264
|
+
});
|
|
265
|
+
|
|
266
|
+
expect(result.current[0].extra).toEqual({ count: 1 });
|
|
267
|
+
});
|
|
268
|
+
});
|
|
269
|
+
describe("when using setRetries action", () => {
|
|
270
|
+
it("should handle initial retries value in function updates", async () => {
|
|
271
|
+
const { result } = renderUseTrackedState(request);
|
|
272
|
+
|
|
273
|
+
act(() => {
|
|
274
|
+
result.current[1].setRetries((prev) => {
|
|
275
|
+
expect(prev).toBe(0);
|
|
276
|
+
return 5;
|
|
277
|
+
});
|
|
278
|
+
});
|
|
279
|
+
|
|
280
|
+
expect(result.current[0].retries).toBe(5);
|
|
281
|
+
});
|
|
282
|
+
});
|
|
283
|
+
describe("when using setResponseTimestamp action", () => {
|
|
284
|
+
it("should handle null previous responseTimestamp in function updates", async () => {
|
|
285
|
+
const { result } = renderUseTrackedState(request);
|
|
286
|
+
const newDate = new Date();
|
|
287
|
+
|
|
288
|
+
act(() => {
|
|
289
|
+
result.current[1].setResponseTimestamp((prev: Date | null) => {
|
|
290
|
+
expect(prev).toBe(null);
|
|
291
|
+
return newDate;
|
|
292
|
+
});
|
|
293
|
+
});
|
|
294
|
+
|
|
295
|
+
expect(result.current[0].responseTimestamp).toBe(newDate);
|
|
296
|
+
});
|
|
297
|
+
|
|
298
|
+
it("should handle undefined responseTimestamp in function updates", async () => {
|
|
299
|
+
const { result } = renderUseTrackedState(request);
|
|
300
|
+
|
|
301
|
+
act(() => {
|
|
302
|
+
result.current[1].setResponseTimestamp((prev: Date | null) => {
|
|
303
|
+
expect(prev).toBe(null);
|
|
304
|
+
return undefined as any;
|
|
305
|
+
});
|
|
306
|
+
});
|
|
307
|
+
|
|
308
|
+
expect(result.current[0].responseTimestamp).toBe(undefined);
|
|
309
|
+
});
|
|
310
|
+
|
|
311
|
+
it("should handle string date conversion in function updates", async () => {
|
|
312
|
+
const { result } = renderUseTrackedState(request);
|
|
313
|
+
const dateStr = "2024-01-01T00:00:00.000Z";
|
|
314
|
+
const expectedDate = new Date(dateStr);
|
|
315
|
+
|
|
316
|
+
act(() => {
|
|
317
|
+
result.current[1].setResponseTimestamp(expectedDate);
|
|
318
|
+
});
|
|
319
|
+
|
|
320
|
+
expect(+result.current[0].responseTimestamp!).toBe(+expectedDate);
|
|
321
|
+
});
|
|
322
|
+
|
|
323
|
+
it("should handle converting previous string date in function updates", async () => {
|
|
324
|
+
const reqNoGarbageCollection = request.setCacheTime(Infinity);
|
|
325
|
+
await reqNoGarbageCollection.send();
|
|
326
|
+
const { result } = renderUseTrackedState(reqNoGarbageCollection);
|
|
327
|
+
const initialDateStr = "2024-01-01T00:00:00.000Z";
|
|
328
|
+
const expectedInitialDate = new Date(initialDateStr);
|
|
329
|
+
const laterDate = new Date(expectedInitialDate.getTime() + 1000);
|
|
330
|
+
|
|
331
|
+
// First set a string date
|
|
332
|
+
act(() => {
|
|
333
|
+
result.current[1].setResponseTimestamp(expectedInitialDate);
|
|
334
|
+
});
|
|
335
|
+
|
|
336
|
+
await waitFor(() => {
|
|
337
|
+
expect(result.current[0].responseTimestamp).toBe(expectedInitialDate);
|
|
338
|
+
});
|
|
339
|
+
|
|
340
|
+
// Then update with function that receives the converted date
|
|
341
|
+
act(() => {
|
|
342
|
+
result.current[1].setResponseTimestamp((prev: Date | null) => {
|
|
343
|
+
expect(+prev!).toBe(+expectedInitialDate);
|
|
344
|
+
return laterDate;
|
|
345
|
+
});
|
|
346
|
+
});
|
|
347
|
+
|
|
348
|
+
expect(+result.current[0].responseTimestamp!).toBe(+laterDate);
|
|
349
|
+
});
|
|
350
|
+
});
|
|
351
|
+
describe("when using setRequestTimestamp action", () => {
|
|
352
|
+
it("should handle null previous requestTimestamp in function updates", async () => {
|
|
353
|
+
const { result } = renderUseTrackedState(request);
|
|
354
|
+
const newDate = new Date();
|
|
355
|
+
|
|
356
|
+
act(() => {
|
|
357
|
+
result.current[1].setRequestTimestamp((prev: Date | null) => {
|
|
358
|
+
expect(prev).toBe(null);
|
|
359
|
+
return newDate;
|
|
360
|
+
});
|
|
361
|
+
});
|
|
362
|
+
|
|
363
|
+
expect(result.current[0].requestTimestamp).toBe(newDate);
|
|
364
|
+
});
|
|
365
|
+
|
|
366
|
+
it("should use true as default value for emitToCache parameter", async () => {
|
|
367
|
+
const reqNoGarbageCollection = request.setCacheTime(Infinity);
|
|
368
|
+
await reqNoGarbageCollection.send();
|
|
369
|
+
const { result } = renderUseTrackedState(reqNoGarbageCollection);
|
|
370
|
+
const newDate = new Date();
|
|
371
|
+
|
|
372
|
+
act(() => {
|
|
373
|
+
// Call setRequestTimestamp without the emitToCache parameter
|
|
374
|
+
result.current[1].setRequestTimestamp(newDate);
|
|
375
|
+
});
|
|
376
|
+
|
|
377
|
+
await waitFor(() => {
|
|
378
|
+
expect(result.current[0].requestTimestamp).toBeDefined();
|
|
379
|
+
});
|
|
380
|
+
});
|
|
381
|
+
});
|
|
382
|
+
});
|