@hyper-fetch/react 9.6.1 → 9.6.2
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-tracked-state/use-tacked-state.actions.spec.ts +1 -1
- package/__tests__/features/helpers/use-tracked-state/use-tracked-state.keys.spec.ts +294 -0
- package/__tests__/features/helpers/utils.spec.ts +127 -0
- package/__tests__/features/provider/provider.config.spec.tsx +172 -0
- package/__tests__/features/use-app-manager/use-app-manager.events.spec.tsx +497 -0
- package/__tests__/features/use-cache/use-cache.state.spec.tsx +326 -0
- package/__tests__/features/use-emitter/use-emitter.lifecycle.spec.tsx +417 -0
- package/__tests__/features/use-fetch/use-fetch.bounce-timers.spec.ts +199 -0
- package/__tests__/features/use-fetch/use-fetch.cache-events.spec.ts +212 -0
- package/__tests__/features/use-fetch/use-fetch.callbacks.spec.tsx +359 -0
- package/__tests__/features/use-fetch/use-fetch.hydration.spec.tsx +126 -0
- package/__tests__/features/use-fetch/use-fetch.infinite.spec.ts +146 -0
- package/__tests__/features/use-fetch/use-fetch.initial-state.spec.ts +340 -0
- package/__tests__/features/use-fetch/use-fetch.keys.spec.tsx +559 -0
- package/__tests__/features/use-fetch/use-fetch.lifecycle.spec.ts +348 -0
- package/__tests__/features/use-fetch/use-fetch.mounting.spec.tsx +411 -0
- package/__tests__/features/use-fetch/use-fetch.pagination.spec.ts +177 -0
- package/__tests__/features/use-fetch/use-fetch.refresh-interval.spec.ts +355 -0
- package/__tests__/features/use-fetch/use-fetch.response-order.spec.ts +105 -0
- package/__tests__/features/use-fetch/use-fetch.retry.spec.ts +235 -0
- package/__tests__/features/use-fetch/use-fetch.return-types.spec.ts +186 -0
- package/__tests__/features/use-fetch/use-fetch.scope.spec.ts +333 -0
- package/__tests__/features/use-fetch/use-fetch.ssr.spec.tsx +195 -0
- package/__tests__/features/use-fetch/use-fetch.suspense-edge.spec.tsx +391 -0
- package/__tests__/features/use-fetch/use-fetch.throwing-callbacks.spec.tsx +112 -0
- package/__tests__/features/use-fetch/use-fetch.tracking.spec.tsx +364 -0
- package/__tests__/features/use-fetch/use-fetch.window-events.spec.ts +300 -0
- package/__tests__/features/use-infinite-fetch/use-infinite-fetch.parity.spec.tsx +1027 -0
- package/__tests__/features/use-infinite-fetch/use-infinite-fetch.resubscribe.spec.tsx +267 -0
- package/__tests__/features/use-infinite-fetch/use-infinite-fetch.typescript.spec.ts +64 -1
- package/__tests__/features/use-is-fetching/use-is-fetching.lifecycle.spec.tsx +301 -0
- package/__tests__/features/use-listener/use-listener.lifecycle.spec.tsx +507 -0
- package/__tests__/features/use-listener/use-listener.ssr.spec.tsx +89 -0
- package/__tests__/features/use-queue/use-queue.controls.spec.tsx +593 -0
- package/__tests__/features/use-queue/use-queue.list.spec.tsx +560 -0
- package/__tests__/features/use-queue/use-queue.progress.spec.tsx +650 -0
- package/__tests__/features/use-submit/use-submit.abort.spec.tsx +270 -0
- package/__tests__/features/use-submit/use-submit.actions.spec.tsx +446 -0
- package/__tests__/features/use-submit/use-submit.arguments.spec.tsx +732 -0
- package/__tests__/features/use-submit/use-submit.bounce.spec.tsx +644 -0
- package/__tests__/features/use-submit/use-submit.callbacks.spec.tsx +860 -0
- package/__tests__/features/use-submit/use-submit.chaining.spec.tsx +167 -0
- package/__tests__/features/use-submit/use-submit.double-submit.spec.tsx +552 -0
- package/__tests__/features/use-submit/use-submit.offline.spec.tsx +285 -0
- package/__tests__/features/use-submit/use-submit.optimistic-cache.spec.tsx +619 -0
- package/__tests__/features/use-submit/use-submit.optimistic-settlement.spec.ts +6 -0
- package/__tests__/features/use-submit/use-submit.optimistic.spec.ts +5 -1
- package/__tests__/features/use-submit/use-submit.state.spec.tsx +1025 -0
- package/__tests__/features/use-submit/use-submit.submit-types.spec.ts +194 -0
- package/__tests__/features/use-submit/use-submit.submitting.spec.tsx +180 -0
- package/__tests__/utils/gate.utils.ts +103 -0
- package/__tests__/utils/gated-client.utils.ts +158 -0
- package/__tests__/utils/helpers.utils.ts +19 -0
- package/dist/helpers/use-request-events/use-request-events.hooks.d.ts.map +1 -1
- package/dist/helpers/use-request-events/use-request-events.types.d.ts +1 -1
- package/dist/helpers/use-request-events/use-request-events.types.d.ts.map +1 -1
- package/dist/helpers/use-tracked-state/use-tracked-state.hooks.d.ts.map +1 -1
- package/dist/helpers/use-tracked-state/use-tracked-state.utils.d.ts +8 -0
- package/dist/helpers/use-tracked-state/use-tracked-state.utils.d.ts.map +1 -1
- package/dist/hooks/use-cache/use-cache.hooks.d.ts.map +1 -1
- package/dist/hooks/use-fetch/use-fetch.hooks.d.ts.map +1 -1
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.hooks.d.ts.map +1 -1
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts +3 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts.map +1 -1
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts +5 -3
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts.map +1 -1
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts +11 -1
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts.map +1 -1
- package/dist/hooks/use-listener/use-listener.hooks.d.ts.map +1 -1
- package/dist/hooks/use-queue/use-queue.hooks.d.ts.map +1 -1
- package/dist/hooks/use-submit/use-submit.hooks.d.ts.map +1 -1
- package/dist/index.mjs +630 -346
- package/dist/index.mjs.map +1 -1
- package/dist/provider/provider.d.ts.map +1 -1
- package/package.json +1 -1
- package/src/helpers/use-request-events/use-request-events.hooks.ts +141 -28
- package/src/helpers/use-request-events/use-request-events.types.ts +1 -1
- package/src/helpers/use-tracked-state/use-tracked-state.hooks.ts +148 -101
- package/src/helpers/use-tracked-state/use-tracked-state.utils.ts +26 -5
- package/src/hooks/use-cache/use-cache.hooks.ts +20 -5
- package/src/hooks/use-fetch/use-fetch.hooks.ts +194 -113
- package/src/hooks/use-infinite-fetch/use-infinite-fetch.hooks.ts +55 -26
- package/src/hooks/use-infinite-fetch/use-infinite-fetch.store.ts +35 -29
- package/src/hooks/use-infinite-fetch/use-infinite-fetch.types.ts +5 -3
- package/src/hooks/use-infinite-fetch/use-infinite-fetch.utils.ts +25 -1
- package/src/hooks/use-listener/use-listener.hooks.ts +2 -1
- package/src/hooks/use-queue/use-queue.hooks.ts +85 -60
- package/src/hooks/use-submit/use-submit.hooks.ts +163 -53
- package/src/provider/provider.tsx +9 -1
- package/__tests__/features/use-fetch/use-fetch.pagination.ts +0 -36
- package/__tests__/features/use-fetch/use-fetch.retry.ts +0 -38
|
@@ -0,0 +1,348 @@
|
|
|
1
|
+
import { act, renderHook } from "@testing-library/react";
|
|
2
|
+
import { useFetch } from "hooks/use-fetch";
|
|
3
|
+
|
|
4
|
+
import { client, createRequest } from "../../utils";
|
|
5
|
+
import { advance, gateRequest, setCacheResponse, settle } from "../../utils/gate.utils";
|
|
6
|
+
|
|
7
|
+
type User = { id: number; name: string };
|
|
8
|
+
type Snapshot = { data: User | null; error: string | null; loading: boolean; success: boolean; status: number | null };
|
|
9
|
+
|
|
10
|
+
const user: User = { id: 1, name: "Maciej" };
|
|
11
|
+
const updatedUser: User = { id: 1, name: "Updated" };
|
|
12
|
+
|
|
13
|
+
describe("useFetch [ Lifecycle ]", () => {
|
|
14
|
+
let request = createRequest<User>();
|
|
15
|
+
let calls = gateRequest(request);
|
|
16
|
+
|
|
17
|
+
/**
|
|
18
|
+
* Records distinct states returned by the hook in the order of rendering
|
|
19
|
+
*/
|
|
20
|
+
const renderLifecycle = (options?: Parameters<typeof useFetch<typeof request>>[1]) => {
|
|
21
|
+
const history: Snapshot[] = [];
|
|
22
|
+
const view = renderHook(() => {
|
|
23
|
+
const state = useFetch(request, options);
|
|
24
|
+
const snapshot: Snapshot = {
|
|
25
|
+
data: state.data,
|
|
26
|
+
error: state.error?.message ?? null,
|
|
27
|
+
loading: state.loading,
|
|
28
|
+
success: state.success,
|
|
29
|
+
status: state.status as number | null,
|
|
30
|
+
};
|
|
31
|
+
if (JSON.stringify(history.at(-1)) !== JSON.stringify(snapshot)) {
|
|
32
|
+
history.push(snapshot);
|
|
33
|
+
}
|
|
34
|
+
return state;
|
|
35
|
+
});
|
|
36
|
+
return { ...view, history };
|
|
37
|
+
};
|
|
38
|
+
|
|
39
|
+
beforeEach(() => {
|
|
40
|
+
vi.useFakeTimers();
|
|
41
|
+
client.clear();
|
|
42
|
+
request = createRequest<User>();
|
|
43
|
+
calls = gateRequest(request);
|
|
44
|
+
});
|
|
45
|
+
|
|
46
|
+
afterEach(() => {
|
|
47
|
+
vi.useRealTimers();
|
|
48
|
+
});
|
|
49
|
+
|
|
50
|
+
describe("when the first request succeeds", () => {
|
|
51
|
+
it("should go from loading to success in a single step", async () => {
|
|
52
|
+
const { history } = renderLifecycle();
|
|
53
|
+
await advance();
|
|
54
|
+
calls[0].succeed(user);
|
|
55
|
+
await settle();
|
|
56
|
+
|
|
57
|
+
expect(history).toStrictEqual([
|
|
58
|
+
{ data: null, error: null, loading: true, success: false, status: null },
|
|
59
|
+
{ data: user, error: null, loading: false, success: true, status: 200 },
|
|
60
|
+
]);
|
|
61
|
+
});
|
|
62
|
+
it("should never render an empty state without loading", async () => {
|
|
63
|
+
const { history } = renderLifecycle();
|
|
64
|
+
await advance();
|
|
65
|
+
calls[0].succeed(user);
|
|
66
|
+
await settle();
|
|
67
|
+
|
|
68
|
+
const hasFlicker = history.some((state) => !state.loading && state.data === null && state.error === null);
|
|
69
|
+
expect(hasFlicker).toBeFalse();
|
|
70
|
+
});
|
|
71
|
+
it("should set the timestamps and retries", async () => {
|
|
72
|
+
const { result } = renderLifecycle();
|
|
73
|
+
await advance();
|
|
74
|
+
calls[0].succeed(user);
|
|
75
|
+
await settle();
|
|
76
|
+
|
|
77
|
+
expect(result.current.responseTimestamp).toBeDate();
|
|
78
|
+
expect(result.current.requestTimestamp).toBeDate();
|
|
79
|
+
expect(result.current.retries).toBe(0);
|
|
80
|
+
});
|
|
81
|
+
it("should save the response in the cache", async () => {
|
|
82
|
+
renderLifecycle();
|
|
83
|
+
await advance();
|
|
84
|
+
calls[0].succeed(user);
|
|
85
|
+
await settle();
|
|
86
|
+
|
|
87
|
+
expect(client.cache.get(request.cacheKey)?.data).toStrictEqual(user);
|
|
88
|
+
});
|
|
89
|
+
it("should expose the custom status of the response", async () => {
|
|
90
|
+
const { result } = renderLifecycle();
|
|
91
|
+
await advance();
|
|
92
|
+
calls[0].succeed(user, 201);
|
|
93
|
+
await settle();
|
|
94
|
+
|
|
95
|
+
expect(result.current.status).toBe(201);
|
|
96
|
+
});
|
|
97
|
+
});
|
|
98
|
+
|
|
99
|
+
describe("when the first request fails", () => {
|
|
100
|
+
it("should go from loading to error in a single step", async () => {
|
|
101
|
+
const { history } = renderLifecycle();
|
|
102
|
+
await advance();
|
|
103
|
+
calls[0].fail(new Error("Not found"), 404);
|
|
104
|
+
await settle();
|
|
105
|
+
|
|
106
|
+
expect(history).toStrictEqual([
|
|
107
|
+
{ data: null, error: null, loading: true, success: false, status: null },
|
|
108
|
+
{ data: null, error: "Not found", loading: false, success: false, status: 404 },
|
|
109
|
+
]);
|
|
110
|
+
});
|
|
111
|
+
it("should not save the error in the cache", async () => {
|
|
112
|
+
renderLifecycle();
|
|
113
|
+
await advance();
|
|
114
|
+
calls[0].fail();
|
|
115
|
+
await settle();
|
|
116
|
+
|
|
117
|
+
expect(client.cache.get(request.cacheKey)).toBeUndefined();
|
|
118
|
+
});
|
|
119
|
+
it("should not send another request on its own", async () => {
|
|
120
|
+
renderLifecycle();
|
|
121
|
+
await advance();
|
|
122
|
+
calls[0].fail();
|
|
123
|
+
await settle();
|
|
124
|
+
await advance(60_000);
|
|
125
|
+
|
|
126
|
+
expect(calls).toHaveLength(1);
|
|
127
|
+
});
|
|
128
|
+
});
|
|
129
|
+
|
|
130
|
+
describe("when refetching", () => {
|
|
131
|
+
it("should keep the data visible while loading the new one", async () => {
|
|
132
|
+
const { result, history } = renderLifecycle();
|
|
133
|
+
await advance();
|
|
134
|
+
calls[0].succeed(user);
|
|
135
|
+
await settle();
|
|
136
|
+
|
|
137
|
+
act(() => {
|
|
138
|
+
result.current.refetch();
|
|
139
|
+
});
|
|
140
|
+
await advance();
|
|
141
|
+
calls[1].succeed(updatedUser);
|
|
142
|
+
await settle();
|
|
143
|
+
|
|
144
|
+
expect(history).toStrictEqual([
|
|
145
|
+
{ data: null, error: null, loading: true, success: false, status: null },
|
|
146
|
+
{ data: user, error: null, loading: false, success: true, status: 200 },
|
|
147
|
+
{ data: user, error: null, loading: true, success: true, status: 200 },
|
|
148
|
+
{ data: updatedUser, error: null, loading: false, success: true, status: 200 },
|
|
149
|
+
]);
|
|
150
|
+
});
|
|
151
|
+
it("should keep the data reference when the same response comes back", async () => {
|
|
152
|
+
const { result } = renderLifecycle();
|
|
153
|
+
await advance();
|
|
154
|
+
calls[0].succeed(user);
|
|
155
|
+
await settle();
|
|
156
|
+
const firstData = result.current.data;
|
|
157
|
+
|
|
158
|
+
act(() => {
|
|
159
|
+
result.current.refetch();
|
|
160
|
+
});
|
|
161
|
+
await advance();
|
|
162
|
+
calls[1].succeed({ ...user });
|
|
163
|
+
await settle();
|
|
164
|
+
|
|
165
|
+
expect(result.current.data).toBe(firstData);
|
|
166
|
+
});
|
|
167
|
+
it("should keep the last data and show the error when refetch fails", async () => {
|
|
168
|
+
const { result, history } = renderLifecycle();
|
|
169
|
+
await advance();
|
|
170
|
+
calls[0].succeed(user);
|
|
171
|
+
await settle();
|
|
172
|
+
|
|
173
|
+
act(() => {
|
|
174
|
+
result.current.refetch();
|
|
175
|
+
});
|
|
176
|
+
await advance();
|
|
177
|
+
calls[1].fail(new Error("Server error"), 500);
|
|
178
|
+
await settle();
|
|
179
|
+
|
|
180
|
+
expect(history.at(-1)).toStrictEqual({
|
|
181
|
+
data: user,
|
|
182
|
+
error: "Server error",
|
|
183
|
+
loading: false,
|
|
184
|
+
success: false,
|
|
185
|
+
status: 500,
|
|
186
|
+
});
|
|
187
|
+
});
|
|
188
|
+
it("should keep the valid data in the cache when refetch fails", async () => {
|
|
189
|
+
const { result } = renderLifecycle();
|
|
190
|
+
await advance();
|
|
191
|
+
calls[0].succeed(user);
|
|
192
|
+
await settle();
|
|
193
|
+
|
|
194
|
+
act(() => {
|
|
195
|
+
result.current.refetch();
|
|
196
|
+
});
|
|
197
|
+
await advance();
|
|
198
|
+
calls[1].fail();
|
|
199
|
+
await settle();
|
|
200
|
+
|
|
201
|
+
expect(client.cache.get(request.cacheKey)?.data).toStrictEqual(user);
|
|
202
|
+
expect(client.cache.get(request.cacheKey)?.success).toBeTrue();
|
|
203
|
+
});
|
|
204
|
+
it("should keep the error visible while retrying manually", async () => {
|
|
205
|
+
const { result, history } = renderLifecycle();
|
|
206
|
+
await advance();
|
|
207
|
+
calls[0].fail(new Error("First"), 500);
|
|
208
|
+
await settle();
|
|
209
|
+
|
|
210
|
+
act(() => {
|
|
211
|
+
result.current.refetch();
|
|
212
|
+
});
|
|
213
|
+
await advance();
|
|
214
|
+
|
|
215
|
+
expect(history.at(-1)).toStrictEqual({ data: null, error: "First", loading: true, success: false, status: 500 });
|
|
216
|
+
});
|
|
217
|
+
it("should clear the error after a successful refetch", async () => {
|
|
218
|
+
const { result, history } = renderLifecycle();
|
|
219
|
+
await advance();
|
|
220
|
+
calls[0].fail(new Error("First"), 500);
|
|
221
|
+
await settle();
|
|
222
|
+
|
|
223
|
+
act(() => {
|
|
224
|
+
result.current.refetch();
|
|
225
|
+
});
|
|
226
|
+
await advance();
|
|
227
|
+
calls[1].succeed(user);
|
|
228
|
+
await settle();
|
|
229
|
+
|
|
230
|
+
expect(history.at(-1)).toStrictEqual({ data: user, error: null, loading: false, success: true, status: 200 });
|
|
231
|
+
});
|
|
232
|
+
it("should replace the error with the next error", async () => {
|
|
233
|
+
const { result } = renderLifecycle();
|
|
234
|
+
await advance();
|
|
235
|
+
calls[0].fail(new Error("First"), 500);
|
|
236
|
+
await settle();
|
|
237
|
+
|
|
238
|
+
act(() => {
|
|
239
|
+
result.current.refetch();
|
|
240
|
+
});
|
|
241
|
+
await advance();
|
|
242
|
+
calls[1].fail(new Error("Second"), 404);
|
|
243
|
+
await settle();
|
|
244
|
+
|
|
245
|
+
expect(result.current.error?.message).toBe("Second");
|
|
246
|
+
expect(result.current.status).toBe(404);
|
|
247
|
+
});
|
|
248
|
+
it("should send a new request for every refetch call", async () => {
|
|
249
|
+
const { result } = renderLifecycle();
|
|
250
|
+
await advance();
|
|
251
|
+
calls[0].succeed(user);
|
|
252
|
+
await settle();
|
|
253
|
+
|
|
254
|
+
act(() => {
|
|
255
|
+
result.current.refetch();
|
|
256
|
+
result.current.refetch();
|
|
257
|
+
});
|
|
258
|
+
await advance();
|
|
259
|
+
|
|
260
|
+
expect(calls).toHaveLength(3);
|
|
261
|
+
});
|
|
262
|
+
it("should stay in loading state until all the requests are finished", async () => {
|
|
263
|
+
const { result } = renderLifecycle();
|
|
264
|
+
await advance();
|
|
265
|
+
|
|
266
|
+
act(() => {
|
|
267
|
+
result.current.refetch();
|
|
268
|
+
});
|
|
269
|
+
await advance();
|
|
270
|
+
expect(calls).toHaveLength(2);
|
|
271
|
+
|
|
272
|
+
calls[0].succeed(user);
|
|
273
|
+
await settle();
|
|
274
|
+
expect(result.current.loading).toBeTrue();
|
|
275
|
+
|
|
276
|
+
calls[1].succeed(updatedUser);
|
|
277
|
+
await settle();
|
|
278
|
+
expect(result.current.loading).toBeFalse();
|
|
279
|
+
expect(result.current.data).toStrictEqual(updatedUser);
|
|
280
|
+
});
|
|
281
|
+
it("should do nothing when the hook is disabled", async () => {
|
|
282
|
+
const { result } = renderLifecycle({ disabled: true });
|
|
283
|
+
await advance();
|
|
284
|
+
|
|
285
|
+
act(() => {
|
|
286
|
+
result.current.refetch();
|
|
287
|
+
});
|
|
288
|
+
await advance();
|
|
289
|
+
|
|
290
|
+
expect(calls).toHaveLength(0);
|
|
291
|
+
expect(result.current.loading).toBeFalse();
|
|
292
|
+
});
|
|
293
|
+
});
|
|
294
|
+
|
|
295
|
+
describe("when cache gets the data after an error", () => {
|
|
296
|
+
it("should replace the error state with the cached data", async () => {
|
|
297
|
+
const { result } = renderLifecycle();
|
|
298
|
+
await advance();
|
|
299
|
+
calls[0].fail(new Error("First"), 500);
|
|
300
|
+
await settle();
|
|
301
|
+
|
|
302
|
+
act(() => {
|
|
303
|
+
setCacheResponse(request, user);
|
|
304
|
+
});
|
|
305
|
+
|
|
306
|
+
expect(result.current.data).toStrictEqual(user);
|
|
307
|
+
expect(result.current.error).toBeNull();
|
|
308
|
+
expect(result.current.success).toBeTrue();
|
|
309
|
+
expect(result.current.status).toBe(200);
|
|
310
|
+
});
|
|
311
|
+
});
|
|
312
|
+
|
|
313
|
+
describe("when revalidating cached data", () => {
|
|
314
|
+
it("should go through loading with the data visible", async () => {
|
|
315
|
+
setCacheResponse(request, user);
|
|
316
|
+
const { history } = renderLifecycle();
|
|
317
|
+
await advance();
|
|
318
|
+
calls[0].succeed(updatedUser);
|
|
319
|
+
await settle();
|
|
320
|
+
|
|
321
|
+
expect(history.every((state) => state.data !== null)).toBeTrue();
|
|
322
|
+
expect(history.some((state) => state.loading)).toBeTrue();
|
|
323
|
+
expect(history.at(-1)).toStrictEqual({
|
|
324
|
+
data: updatedUser,
|
|
325
|
+
error: null,
|
|
326
|
+
loading: false,
|
|
327
|
+
success: true,
|
|
328
|
+
status: 200,
|
|
329
|
+
});
|
|
330
|
+
});
|
|
331
|
+
});
|
|
332
|
+
|
|
333
|
+
describe("when the response has no data", () => {
|
|
334
|
+
it("should finish loading with null data and success state", async () => {
|
|
335
|
+
const emptyRequest = createRequest<null>();
|
|
336
|
+
const emptyCalls = gateRequest(emptyRequest);
|
|
337
|
+
const { result } = renderHook(() => {
|
|
338
|
+
const state = useFetch(emptyRequest);
|
|
339
|
+
return { data: state.data, loading: state.loading, success: state.success, status: state.status };
|
|
340
|
+
});
|
|
341
|
+
await advance();
|
|
342
|
+
emptyCalls[0].succeed(null, 204);
|
|
343
|
+
await settle();
|
|
344
|
+
|
|
345
|
+
expect(result.current).toStrictEqual({ data: null, loading: false, success: true, status: 204 });
|
|
346
|
+
});
|
|
347
|
+
});
|
|
348
|
+
});
|