@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,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
+ });