@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,527 @@
|
|
|
1
|
+
import { createClient, xhrExtra } from "@hyper-fetch/core";
|
|
2
|
+
import { act, waitFor } from "@testing-library/react";
|
|
3
|
+
import { createHttpMockingServer, sleep } from "@hyper-fetch/testing";
|
|
4
|
+
|
|
5
|
+
import { initialState } from "helpers";
|
|
6
|
+
import { renderUseTrackedState } from "../../../utils";
|
|
7
|
+
|
|
8
|
+
const { resetMocks, startServer, stopServer, mockRequest } = createHttpMockingServer();
|
|
9
|
+
|
|
10
|
+
describe("useTrackingState [ Events ]", () => {
|
|
11
|
+
let client = createClient({ url: "http://localhost:3000" });
|
|
12
|
+
let request = client.createRequest<{ response: any }>()({
|
|
13
|
+
endpoint: "/test",
|
|
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
|
+
client = createClient({ url: "http://localhost:3000" });
|
|
31
|
+
request = client.createRequest<{ response: any }>()({
|
|
32
|
+
endpoint: "/test",
|
|
33
|
+
});
|
|
34
|
+
});
|
|
35
|
+
|
|
36
|
+
describe("given state is initialized", () => {
|
|
37
|
+
describe("when cache is empty", () => {
|
|
38
|
+
it("should init with default data", async () => {
|
|
39
|
+
const { result } = renderUseTrackedState(request);
|
|
40
|
+
|
|
41
|
+
expect(result.current[0].data).toBe(initialState.data);
|
|
42
|
+
expect(result.current[0].error).toBe(initialState.error);
|
|
43
|
+
expect(result.current[0].status).toBe(initialState.status);
|
|
44
|
+
expect(result.current[0].success).toBe(initialState.success);
|
|
45
|
+
expect(result.current[0].extra).toStrictEqual(request.client.adapter.defaultExtra);
|
|
46
|
+
expect(result.current[0].retries).toBe(0);
|
|
47
|
+
expect(result.current[0].loading).toBe(initialState.loading);
|
|
48
|
+
});
|
|
49
|
+
});
|
|
50
|
+
});
|
|
51
|
+
describe("given dependency tracking is active", () => {
|
|
52
|
+
describe("when updating the state values and dependency tracking is on", () => {
|
|
53
|
+
it("should not rerender hook when deep equal values are the same", async () => {
|
|
54
|
+
const { result } = renderUseTrackedState(request, { dependencyTracking: true });
|
|
55
|
+
const renderCount = { value: 0 };
|
|
56
|
+
|
|
57
|
+
// Track data changes
|
|
58
|
+
act(() => {
|
|
59
|
+
result.current[2].setRenderKey("data");
|
|
60
|
+
});
|
|
61
|
+
|
|
62
|
+
// Set same data twice
|
|
63
|
+
act(() => {
|
|
64
|
+
result.current[2].setCacheData({
|
|
65
|
+
data: { test: "value" },
|
|
66
|
+
error: null,
|
|
67
|
+
status: 200,
|
|
68
|
+
success: true,
|
|
69
|
+
extra: xhrExtra,
|
|
70
|
+
retries: 0,
|
|
71
|
+
requestTimestamp: +new Date(),
|
|
72
|
+
responseTimestamp: +new Date(),
|
|
73
|
+
addedTimestamp: +new Date(),
|
|
74
|
+
triggerTimestamp: +new Date(),
|
|
75
|
+
cacheKey: request.cacheKey,
|
|
76
|
+
isCanceled: false,
|
|
77
|
+
isOffline: false,
|
|
78
|
+
staleTime: request.staleTime,
|
|
79
|
+
version: request.client.cache.version,
|
|
80
|
+
cacheTime: Infinity,
|
|
81
|
+
});
|
|
82
|
+
});
|
|
83
|
+
|
|
84
|
+
const firstRenderData = result.current[0].data;
|
|
85
|
+
renderCount.value += 1;
|
|
86
|
+
|
|
87
|
+
act(() => {
|
|
88
|
+
result.current[2].setCacheData({
|
|
89
|
+
data: { test: "value" },
|
|
90
|
+
error: null,
|
|
91
|
+
status: 200,
|
|
92
|
+
success: true,
|
|
93
|
+
extra: xhrExtra,
|
|
94
|
+
retries: 0,
|
|
95
|
+
requestTimestamp: +new Date(),
|
|
96
|
+
responseTimestamp: +new Date(),
|
|
97
|
+
addedTimestamp: +new Date(),
|
|
98
|
+
triggerTimestamp: +new Date(),
|
|
99
|
+
cacheKey: request.cacheKey,
|
|
100
|
+
isCanceled: false,
|
|
101
|
+
isOffline: false,
|
|
102
|
+
staleTime: request.staleTime,
|
|
103
|
+
version: request.client.cache.version,
|
|
104
|
+
cacheTime: Infinity,
|
|
105
|
+
});
|
|
106
|
+
});
|
|
107
|
+
|
|
108
|
+
expect(result.current[0].data).toEqual(firstRenderData);
|
|
109
|
+
});
|
|
110
|
+
it("should rerender component when attribute is used", async () => {
|
|
111
|
+
const { result } = renderUseTrackedState(request, { dependencyTracking: true });
|
|
112
|
+
|
|
113
|
+
// Track data changes
|
|
114
|
+
act(() => {
|
|
115
|
+
result.current[2].setRenderKey("data");
|
|
116
|
+
});
|
|
117
|
+
|
|
118
|
+
const initialData = result.current[0].data;
|
|
119
|
+
|
|
120
|
+
act(() => {
|
|
121
|
+
result.current[2].setCacheData({
|
|
122
|
+
data: "new-data",
|
|
123
|
+
error: null,
|
|
124
|
+
status: 200,
|
|
125
|
+
success: true,
|
|
126
|
+
extra: xhrExtra,
|
|
127
|
+
retries: 0,
|
|
128
|
+
requestTimestamp: +new Date(),
|
|
129
|
+
responseTimestamp: +new Date(),
|
|
130
|
+
addedTimestamp: +new Date(),
|
|
131
|
+
triggerTimestamp: +new Date(),
|
|
132
|
+
cacheKey: request.cacheKey,
|
|
133
|
+
isCanceled: false,
|
|
134
|
+
isOffline: false,
|
|
135
|
+
staleTime: request.staleTime,
|
|
136
|
+
version: request.client.cache.version,
|
|
137
|
+
cacheTime: Infinity,
|
|
138
|
+
});
|
|
139
|
+
});
|
|
140
|
+
|
|
141
|
+
expect(result.current[0].data).not.toEqual(initialData);
|
|
142
|
+
expect(result.current[0].data).toBe("new-data");
|
|
143
|
+
});
|
|
144
|
+
it("should not rerender component when attribute is not used", async () => {
|
|
145
|
+
const { result } = renderUseTrackedState(request, { dependencyTracking: true });
|
|
146
|
+
|
|
147
|
+
// Only track error changes
|
|
148
|
+
act(() => {
|
|
149
|
+
result.current[2].setRenderKey("error");
|
|
150
|
+
});
|
|
151
|
+
|
|
152
|
+
const initialData = result.current[0].data;
|
|
153
|
+
|
|
154
|
+
act(() => {
|
|
155
|
+
result.current[2].setCacheData({
|
|
156
|
+
data: "new-data",
|
|
157
|
+
error: null,
|
|
158
|
+
status: 200,
|
|
159
|
+
success: true,
|
|
160
|
+
extra: xhrExtra,
|
|
161
|
+
retries: 0,
|
|
162
|
+
requestTimestamp: +new Date(),
|
|
163
|
+
responseTimestamp: +new Date(),
|
|
164
|
+
addedTimestamp: +new Date(),
|
|
165
|
+
triggerTimestamp: +new Date(),
|
|
166
|
+
cacheKey: request.cacheKey,
|
|
167
|
+
isCanceled: false,
|
|
168
|
+
isOffline: false,
|
|
169
|
+
staleTime: request.staleTime,
|
|
170
|
+
version: request.client.cache.version,
|
|
171
|
+
cacheTime: Infinity,
|
|
172
|
+
});
|
|
173
|
+
});
|
|
174
|
+
|
|
175
|
+
// Data should not change since we're only tracking error
|
|
176
|
+
expect(result.current[0].data).toEqual(initialData);
|
|
177
|
+
});
|
|
178
|
+
});
|
|
179
|
+
});
|
|
180
|
+
describe("given dependency tracking is off", () => {
|
|
181
|
+
describe("when updating the state values", () => {
|
|
182
|
+
it("should rerender on any attribute change", async () => {
|
|
183
|
+
const { result } = renderUseTrackedState(request, { dependencyTracking: false });
|
|
184
|
+
|
|
185
|
+
const initialData = result.current[0].data;
|
|
186
|
+
|
|
187
|
+
act(() => {
|
|
188
|
+
result.current[2].setCacheData({
|
|
189
|
+
data: "new-data",
|
|
190
|
+
error: null,
|
|
191
|
+
status: 200,
|
|
192
|
+
success: true,
|
|
193
|
+
extra: xhrExtra,
|
|
194
|
+
retries: 0,
|
|
195
|
+
requestTimestamp: +new Date(),
|
|
196
|
+
responseTimestamp: +new Date(),
|
|
197
|
+
addedTimestamp: +new Date(),
|
|
198
|
+
triggerTimestamp: +new Date(),
|
|
199
|
+
cacheKey: request.cacheKey,
|
|
200
|
+
isCanceled: false,
|
|
201
|
+
isOffline: false,
|
|
202
|
+
staleTime: request.staleTime,
|
|
203
|
+
version: request.client.cache.version,
|
|
204
|
+
cacheTime: Infinity,
|
|
205
|
+
});
|
|
206
|
+
});
|
|
207
|
+
|
|
208
|
+
expect(result.current[0].data).not.toEqual(initialData);
|
|
209
|
+
expect(result.current[0].data).toBe("new-data");
|
|
210
|
+
});
|
|
211
|
+
});
|
|
212
|
+
});
|
|
213
|
+
describe("given request is mapping response", () => {
|
|
214
|
+
describe("when receiving data", () => {
|
|
215
|
+
it("should map the data", async () => {
|
|
216
|
+
const { result } = renderUseTrackedState(
|
|
217
|
+
request.setResponseMapper((response) => {
|
|
218
|
+
return { ...response, data: "new-data" };
|
|
219
|
+
}),
|
|
220
|
+
);
|
|
221
|
+
|
|
222
|
+
act(() => {
|
|
223
|
+
result.current[2].setRenderKey("data");
|
|
224
|
+
result.current[2].setCacheData({
|
|
225
|
+
data: true as any,
|
|
226
|
+
error: null,
|
|
227
|
+
status: 200,
|
|
228
|
+
success: true,
|
|
229
|
+
extra: xhrExtra,
|
|
230
|
+
retries: 0,
|
|
231
|
+
requestTimestamp: +new Date(),
|
|
232
|
+
responseTimestamp: +new Date(),
|
|
233
|
+
addedTimestamp: +new Date(),
|
|
234
|
+
triggerTimestamp: +new Date(),
|
|
235
|
+
cacheKey: request.cacheKey,
|
|
236
|
+
isCanceled: false,
|
|
237
|
+
isOffline: false,
|
|
238
|
+
staleTime: request.staleTime,
|
|
239
|
+
version: request.client.cache.version,
|
|
240
|
+
cacheTime: Infinity,
|
|
241
|
+
});
|
|
242
|
+
});
|
|
243
|
+
|
|
244
|
+
expect(result.current[0].data).toBe("new-data");
|
|
245
|
+
expect(result.current[0].error).toBe(null);
|
|
246
|
+
});
|
|
247
|
+
|
|
248
|
+
it("should map the cache data", async () => {
|
|
249
|
+
mockRequest(request);
|
|
250
|
+
|
|
251
|
+
await act(async () => {
|
|
252
|
+
await request.send({});
|
|
253
|
+
});
|
|
254
|
+
|
|
255
|
+
const { result, rerender } = renderUseTrackedState(
|
|
256
|
+
request.setResponseMapper((response) => {
|
|
257
|
+
return { ...response, data: "new-data" };
|
|
258
|
+
}),
|
|
259
|
+
);
|
|
260
|
+
|
|
261
|
+
act(() => {
|
|
262
|
+
rerender();
|
|
263
|
+
});
|
|
264
|
+
|
|
265
|
+
expect(result.current[0].data).toBe("new-data");
|
|
266
|
+
expect(result.current[0].error).toBe(null);
|
|
267
|
+
});
|
|
268
|
+
|
|
269
|
+
it("should map the async data", async () => {
|
|
270
|
+
const { result } = renderUseTrackedState(
|
|
271
|
+
request.setResponseMapper(async (response) => {
|
|
272
|
+
return Promise.resolve({ ...response, data: "new-data" });
|
|
273
|
+
}),
|
|
274
|
+
);
|
|
275
|
+
|
|
276
|
+
act(() => {
|
|
277
|
+
result.current[2].setRenderKey("data");
|
|
278
|
+
result.current[2].setCacheData({
|
|
279
|
+
data: true as any,
|
|
280
|
+
error: null,
|
|
281
|
+
status: 200,
|
|
282
|
+
success: true,
|
|
283
|
+
extra: xhrExtra,
|
|
284
|
+
retries: 0,
|
|
285
|
+
requestTimestamp: +new Date(),
|
|
286
|
+
responseTimestamp: +new Date(),
|
|
287
|
+
addedTimestamp: +new Date(),
|
|
288
|
+
triggerTimestamp: +new Date(),
|
|
289
|
+
cacheKey: request.cacheKey,
|
|
290
|
+
isCanceled: false,
|
|
291
|
+
isOffline: false,
|
|
292
|
+
staleTime: request.staleTime,
|
|
293
|
+
version: request.client.cache.version,
|
|
294
|
+
cacheTime: Infinity,
|
|
295
|
+
});
|
|
296
|
+
});
|
|
297
|
+
|
|
298
|
+
expect(result.current[0]).toStrictEqual(expect.objectContaining({ ...initialState, extra: xhrExtra }));
|
|
299
|
+
|
|
300
|
+
await waitFor(() => {
|
|
301
|
+
expect(result.current[0].data).toBe("new-data");
|
|
302
|
+
expect(result.current[0].error).toBe(null);
|
|
303
|
+
});
|
|
304
|
+
});
|
|
305
|
+
});
|
|
306
|
+
describe("when deepCompare is function", () => {
|
|
307
|
+
it("should trigger with two values", async () => {
|
|
308
|
+
const customDeepCompare = jest.fn().mockImplementation(() => true);
|
|
309
|
+
const { result } = renderUseTrackedState(request, { deepCompare: customDeepCompare });
|
|
310
|
+
|
|
311
|
+
act(() => {
|
|
312
|
+
result.current[2].setRenderKey("data");
|
|
313
|
+
result.current[2].setCacheData({
|
|
314
|
+
data: "test-data",
|
|
315
|
+
error: null,
|
|
316
|
+
status: 200,
|
|
317
|
+
success: true,
|
|
318
|
+
extra: xhrExtra,
|
|
319
|
+
retries: 0,
|
|
320
|
+
requestTimestamp: +new Date(),
|
|
321
|
+
responseTimestamp: +new Date(),
|
|
322
|
+
addedTimestamp: +new Date(),
|
|
323
|
+
triggerTimestamp: +new Date(),
|
|
324
|
+
cacheKey: request.cacheKey,
|
|
325
|
+
isCanceled: false,
|
|
326
|
+
isOffline: false,
|
|
327
|
+
staleTime: request.staleTime,
|
|
328
|
+
version: request.client.cache.version,
|
|
329
|
+
cacheTime: Infinity,
|
|
330
|
+
});
|
|
331
|
+
});
|
|
332
|
+
|
|
333
|
+
expect(customDeepCompare).toHaveBeenCalledWith(null, "test-data");
|
|
334
|
+
});
|
|
335
|
+
});
|
|
336
|
+
describe("when handling async response mapping", () => {
|
|
337
|
+
it("should handle async response mapper rejection", async () => {
|
|
338
|
+
const { result } = renderUseTrackedState(
|
|
339
|
+
request.setResponseMapper(async (response) => {
|
|
340
|
+
await sleep(1000);
|
|
341
|
+
return response;
|
|
342
|
+
}),
|
|
343
|
+
);
|
|
344
|
+
|
|
345
|
+
act(() => {
|
|
346
|
+
result.current[2].setRenderKey("data");
|
|
347
|
+
result.current[2].setCacheData({
|
|
348
|
+
data: true as any,
|
|
349
|
+
error: null,
|
|
350
|
+
status: 200,
|
|
351
|
+
success: true,
|
|
352
|
+
extra: xhrExtra,
|
|
353
|
+
retries: 0,
|
|
354
|
+
requestTimestamp: +new Date(),
|
|
355
|
+
responseTimestamp: +new Date(),
|
|
356
|
+
addedTimestamp: +new Date(),
|
|
357
|
+
triggerTimestamp: +new Date(),
|
|
358
|
+
cacheKey: request.cacheKey,
|
|
359
|
+
isCanceled: false,
|
|
360
|
+
isOffline: false,
|
|
361
|
+
staleTime: request.staleTime,
|
|
362
|
+
version: request.client.cache.version,
|
|
363
|
+
cacheTime: Infinity,
|
|
364
|
+
});
|
|
365
|
+
});
|
|
366
|
+
|
|
367
|
+
// Initial state should be maintained while processing
|
|
368
|
+
expect(result.current[0]).toStrictEqual(expect.objectContaining({ ...initialState, extra: xhrExtra }));
|
|
369
|
+
|
|
370
|
+
// Wait for the error to be processed
|
|
371
|
+
await expect(async () => {
|
|
372
|
+
await waitFor(() => {
|
|
373
|
+
expect(result.current[0].data).toBe(true);
|
|
374
|
+
});
|
|
375
|
+
}).not.toThrow();
|
|
376
|
+
});
|
|
377
|
+
|
|
378
|
+
it("should handle concurrent async response mapping", async () => {
|
|
379
|
+
let resolveFirst: (value: any) => void;
|
|
380
|
+
let resolveSecond: (value: any) => void;
|
|
381
|
+
|
|
382
|
+
const firstPromise = new Promise((resolve) => {
|
|
383
|
+
resolveFirst = resolve;
|
|
384
|
+
});
|
|
385
|
+
const secondPromise = new Promise((resolve) => {
|
|
386
|
+
resolveSecond = resolve;
|
|
387
|
+
});
|
|
388
|
+
|
|
389
|
+
let mapperCallCount = 0;
|
|
390
|
+
const { result } = renderUseTrackedState(
|
|
391
|
+
request.setResponseMapper(async (response) => {
|
|
392
|
+
mapperCallCount += 1;
|
|
393
|
+
if (mapperCallCount === 1) {
|
|
394
|
+
return firstPromise.then(() => ({ ...response, data: "first-data" }));
|
|
395
|
+
}
|
|
396
|
+
return secondPromise.then(() => ({ ...response, data: "second-data" }));
|
|
397
|
+
}),
|
|
398
|
+
);
|
|
399
|
+
|
|
400
|
+
// Set first data
|
|
401
|
+
act(() => {
|
|
402
|
+
result.current[2].setRenderKey("data");
|
|
403
|
+
result.current[2].setCacheData({
|
|
404
|
+
data: "initial" as any,
|
|
405
|
+
error: null,
|
|
406
|
+
status: 200,
|
|
407
|
+
success: true,
|
|
408
|
+
extra: xhrExtra,
|
|
409
|
+
retries: 0,
|
|
410
|
+
requestTimestamp: +new Date(),
|
|
411
|
+
responseTimestamp: +new Date(),
|
|
412
|
+
addedTimestamp: +new Date(),
|
|
413
|
+
triggerTimestamp: +new Date(),
|
|
414
|
+
cacheKey: request.cacheKey,
|
|
415
|
+
isCanceled: false,
|
|
416
|
+
isOffline: false,
|
|
417
|
+
staleTime: request.staleTime,
|
|
418
|
+
version: request.client.cache.version,
|
|
419
|
+
cacheTime: Infinity,
|
|
420
|
+
});
|
|
421
|
+
});
|
|
422
|
+
|
|
423
|
+
// Set second data before first resolves
|
|
424
|
+
act(() => {
|
|
425
|
+
result.current[2].setCacheData({
|
|
426
|
+
data: "newer" as any,
|
|
427
|
+
error: null,
|
|
428
|
+
status: 200,
|
|
429
|
+
success: true,
|
|
430
|
+
extra: xhrExtra,
|
|
431
|
+
retries: 0,
|
|
432
|
+
requestTimestamp: +new Date(),
|
|
433
|
+
responseTimestamp: +new Date(),
|
|
434
|
+
addedTimestamp: +new Date(),
|
|
435
|
+
triggerTimestamp: +new Date(),
|
|
436
|
+
cacheKey: request.cacheKey,
|
|
437
|
+
isCanceled: false,
|
|
438
|
+
isOffline: false,
|
|
439
|
+
staleTime: request.staleTime,
|
|
440
|
+
version: request.client.cache.version,
|
|
441
|
+
cacheTime: Infinity,
|
|
442
|
+
});
|
|
443
|
+
});
|
|
444
|
+
|
|
445
|
+
// Resolve promises in reverse order
|
|
446
|
+
act(() => {
|
|
447
|
+
resolveSecond({});
|
|
448
|
+
});
|
|
449
|
+
|
|
450
|
+
await waitFor(() => {
|
|
451
|
+
expect(result.current[0].data).toBe("second-data");
|
|
452
|
+
});
|
|
453
|
+
|
|
454
|
+
act(() => {
|
|
455
|
+
resolveFirst({});
|
|
456
|
+
});
|
|
457
|
+
|
|
458
|
+
// Should still show second data since it was the last update
|
|
459
|
+
await waitFor(() => {
|
|
460
|
+
expect(result.current[0].data).toBe("second-data");
|
|
461
|
+
});
|
|
462
|
+
});
|
|
463
|
+
});
|
|
464
|
+
});
|
|
465
|
+
describe("given custom deepCompare option is passed", () => {
|
|
466
|
+
describe("when deepCompare is function", () => {
|
|
467
|
+
it("should allow to use custom deepCompare", async () => {
|
|
468
|
+
const deepCompare = jest.fn().mockImplementation(() => false);
|
|
469
|
+
const { result } = renderUseTrackedState(request, { deepCompare, dependencyTracking: true });
|
|
470
|
+
|
|
471
|
+
act(() => {
|
|
472
|
+
result.current[2].setRenderKey("data");
|
|
473
|
+
result.current[2].setCacheData({
|
|
474
|
+
data: true,
|
|
475
|
+
error: null,
|
|
476
|
+
status: 200,
|
|
477
|
+
success: true,
|
|
478
|
+
extra: xhrExtra,
|
|
479
|
+
retries: 0,
|
|
480
|
+
requestTimestamp: +new Date(),
|
|
481
|
+
responseTimestamp: +new Date(),
|
|
482
|
+
addedTimestamp: +new Date(),
|
|
483
|
+
triggerTimestamp: +new Date(),
|
|
484
|
+
cacheKey: request.cacheKey,
|
|
485
|
+
isCanceled: false,
|
|
486
|
+
isOffline: false,
|
|
487
|
+
staleTime: request.staleTime,
|
|
488
|
+
version: request.client.cache.version,
|
|
489
|
+
cacheTime: Infinity,
|
|
490
|
+
});
|
|
491
|
+
});
|
|
492
|
+
|
|
493
|
+
expect(deepCompare).toHaveBeenCalled();
|
|
494
|
+
expect(result.current[0].data).toBeTrue();
|
|
495
|
+
});
|
|
496
|
+
});
|
|
497
|
+
describe("when deepCompare is false", () => {
|
|
498
|
+
it("should not compare values", async () => {
|
|
499
|
+
const { result } = renderUseTrackedState(request, { deepCompare: false, dependencyTracking: true });
|
|
500
|
+
|
|
501
|
+
act(() => {
|
|
502
|
+
result.current[2].setRenderKey("data");
|
|
503
|
+
result.current[2].setCacheData({
|
|
504
|
+
data: true,
|
|
505
|
+
error: null,
|
|
506
|
+
status: 200,
|
|
507
|
+
success: true,
|
|
508
|
+
extra: xhrExtra,
|
|
509
|
+
retries: 0,
|
|
510
|
+
requestTimestamp: +new Date(),
|
|
511
|
+
responseTimestamp: +new Date(),
|
|
512
|
+
addedTimestamp: +new Date(),
|
|
513
|
+
triggerTimestamp: +new Date(),
|
|
514
|
+
cacheKey: request.cacheKey,
|
|
515
|
+
isCanceled: false,
|
|
516
|
+
isOffline: false,
|
|
517
|
+
staleTime: request.staleTime,
|
|
518
|
+
version: request.client.cache.version,
|
|
519
|
+
cacheTime: Infinity,
|
|
520
|
+
});
|
|
521
|
+
});
|
|
522
|
+
|
|
523
|
+
expect(result.current[0].data).toBeTrue();
|
|
524
|
+
});
|
|
525
|
+
});
|
|
526
|
+
});
|
|
527
|
+
});
|