@hyper-fetch/react 9.6.0 → 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-request-events/use-request-events.async-mapper.spec.ts +243 -0
- 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.cancel.spec.ts +6 -3
- package/__tests__/features/use-fetch/use-fetch.debounce.spec.ts +72 -80
- 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.refresh.spec.ts +36 -13
- 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.utils.spec.ts +11 -2
- 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.base.spec.tsx +19 -9
- 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.concurrency.spec.ts +2 -1
- package/__tests__/features/use-submit/use-submit.debounce.spec.ts +100 -124
- 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 +8 -1
- package/__tests__/features/use-submit/use-submit.optimistic.spec.ts +5 -1
- package/__tests__/features/use-submit/use-submit.retry.spec.ts +51 -35
- 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__/features/use-submit/use-submit.unmount.spec.ts +2 -1
- 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/__tests__/utils/use-queue.utils.ts +8 -4
- 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 +633 -347
- 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 +147 -32
- 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,167 @@
|
|
|
1
|
+
import { act, renderHook, waitFor } from "@testing-library/react";
|
|
2
|
+
import { useSubmit } from "hooks/use-submit";
|
|
3
|
+
|
|
4
|
+
import { createGatedClient } from "../../utils/gated-client.utils";
|
|
5
|
+
|
|
6
|
+
type User = { id: number; name: string };
|
|
7
|
+
|
|
8
|
+
const setup = (options?: { queued?: boolean }) => {
|
|
9
|
+
const gated = createGatedClient();
|
|
10
|
+
const request = gated.client.createRequest<{ response: User; payload: { name: string } }>()({
|
|
11
|
+
endpoint: "/users",
|
|
12
|
+
method: "POST",
|
|
13
|
+
queued: options?.queued ?? false,
|
|
14
|
+
deduplicate: false,
|
|
15
|
+
});
|
|
16
|
+
/** Everything that got to the adapter, with the requests canceled by the library marked */
|
|
17
|
+
const sent = () =>
|
|
18
|
+
gated.calls.map((call) => ({ name: (call.request.payload as { name: string }).name, aborted: call.aborted }));
|
|
19
|
+
return { ...gated, request, sent };
|
|
20
|
+
};
|
|
21
|
+
|
|
22
|
+
/**
|
|
23
|
+
* The callbacks of a response run while the answered request is still in its queue. Submitting the next step
|
|
24
|
+
* from one of them must send only that step.
|
|
25
|
+
*/
|
|
26
|
+
describe("useSubmit [ Chaining ]", () => {
|
|
27
|
+
describe.each([
|
|
28
|
+
["concurrent", false],
|
|
29
|
+
["queued", true],
|
|
30
|
+
])("when the next %s submit is sent from a callback", (_name, queued) => {
|
|
31
|
+
it("should send only the next request from onSubmitSuccess", async () => {
|
|
32
|
+
const { request, waitForCall, sent } = setup({ queued });
|
|
33
|
+
const { result } = renderHook(() => {
|
|
34
|
+
const view = useSubmit(request, { dependencyTracking: false });
|
|
35
|
+
view.onSubmitSuccess(({ response }) => {
|
|
36
|
+
if (response.data.name === "First") {
|
|
37
|
+
view.submit({ payload: { name: "Second" } });
|
|
38
|
+
}
|
|
39
|
+
});
|
|
40
|
+
return view;
|
|
41
|
+
});
|
|
42
|
+
act(() => {
|
|
43
|
+
result.current.submit({ payload: { name: "First" } });
|
|
44
|
+
});
|
|
45
|
+
const firstCall = await waitForCall(0);
|
|
46
|
+
|
|
47
|
+
act(() => {
|
|
48
|
+
firstCall.succeed({ id: 1, name: "First" });
|
|
49
|
+
});
|
|
50
|
+
const secondCall = await waitForCall(1);
|
|
51
|
+
act(() => {
|
|
52
|
+
secondCall.succeed({ id: 2, name: "Second" });
|
|
53
|
+
});
|
|
54
|
+
await waitFor(() => {
|
|
55
|
+
expect(result.current.data).toStrictEqual({ id: 2, name: "Second" });
|
|
56
|
+
});
|
|
57
|
+
|
|
58
|
+
expect(sent()).toStrictEqual([
|
|
59
|
+
{ name: "First", aborted: false },
|
|
60
|
+
{ name: "Second", aborted: false },
|
|
61
|
+
]);
|
|
62
|
+
});
|
|
63
|
+
|
|
64
|
+
it("should send only the next request from onSubmitError", async () => {
|
|
65
|
+
const { request, waitForCall, sent } = setup({ queued });
|
|
66
|
+
let retried = false;
|
|
67
|
+
const { result } = renderHook(() => {
|
|
68
|
+
const view = useSubmit(request, { dependencyTracking: false });
|
|
69
|
+
view.onSubmitError(() => {
|
|
70
|
+
if (!retried) {
|
|
71
|
+
retried = true;
|
|
72
|
+
view.submit({ payload: { name: "Second" } });
|
|
73
|
+
}
|
|
74
|
+
});
|
|
75
|
+
return view;
|
|
76
|
+
});
|
|
77
|
+
act(() => {
|
|
78
|
+
result.current.submit({ payload: { name: "First" } });
|
|
79
|
+
});
|
|
80
|
+
const firstCall = await waitForCall(0);
|
|
81
|
+
|
|
82
|
+
act(() => {
|
|
83
|
+
firstCall.fail({ message: "Nope" }, 400);
|
|
84
|
+
});
|
|
85
|
+
const secondCall = await waitForCall(1);
|
|
86
|
+
act(() => {
|
|
87
|
+
secondCall.succeed({ id: 2, name: "Second" });
|
|
88
|
+
});
|
|
89
|
+
await waitFor(() => {
|
|
90
|
+
expect(result.current.data).toStrictEqual({ id: 2, name: "Second" });
|
|
91
|
+
});
|
|
92
|
+
|
|
93
|
+
expect(sent()).toStrictEqual([
|
|
94
|
+
{ name: "First", aborted: false },
|
|
95
|
+
{ name: "Second", aborted: false },
|
|
96
|
+
]);
|
|
97
|
+
});
|
|
98
|
+
|
|
99
|
+
it("should send only the next request from onSubmitFinished", async () => {
|
|
100
|
+
const { request, waitForCall, sent } = setup({ queued });
|
|
101
|
+
const { result } = renderHook(() => {
|
|
102
|
+
const view = useSubmit(request, { dependencyTracking: false });
|
|
103
|
+
view.onSubmitFinished(({ response }) => {
|
|
104
|
+
if (response.data?.name === "First") {
|
|
105
|
+
view.submit({ payload: { name: "Second" } });
|
|
106
|
+
}
|
|
107
|
+
});
|
|
108
|
+
return view;
|
|
109
|
+
});
|
|
110
|
+
act(() => {
|
|
111
|
+
result.current.submit({ payload: { name: "First" } });
|
|
112
|
+
});
|
|
113
|
+
const firstCall = await waitForCall(0);
|
|
114
|
+
|
|
115
|
+
act(() => {
|
|
116
|
+
firstCall.succeed({ id: 1, name: "First" });
|
|
117
|
+
});
|
|
118
|
+
const secondCall = await waitForCall(1);
|
|
119
|
+
act(() => {
|
|
120
|
+
secondCall.succeed({ id: 2, name: "Second" });
|
|
121
|
+
});
|
|
122
|
+
await waitFor(() => {
|
|
123
|
+
expect(result.current.submitting).toBeFalse();
|
|
124
|
+
});
|
|
125
|
+
|
|
126
|
+
expect(sent()).toStrictEqual([
|
|
127
|
+
{ name: "First", aborted: false },
|
|
128
|
+
{ name: "Second", aborted: false },
|
|
129
|
+
]);
|
|
130
|
+
});
|
|
131
|
+
|
|
132
|
+
it("should call the success callback once for every step", async () => {
|
|
133
|
+
const { request, waitForCall } = setup({ queued });
|
|
134
|
+
const names: string[] = [];
|
|
135
|
+
const { result } = renderHook(() => {
|
|
136
|
+
const view = useSubmit(request, { dependencyTracking: false });
|
|
137
|
+
view.onSubmitSuccess(({ response }) => {
|
|
138
|
+
names.push(response.data.name);
|
|
139
|
+
if (response.data.name === "First") {
|
|
140
|
+
view.submit({ payload: { name: "Second" } });
|
|
141
|
+
}
|
|
142
|
+
});
|
|
143
|
+
return view;
|
|
144
|
+
});
|
|
145
|
+
act(() => {
|
|
146
|
+
result.current.submit({ payload: { name: "First" } });
|
|
147
|
+
});
|
|
148
|
+
const firstCall = await waitForCall(0);
|
|
149
|
+
|
|
150
|
+
act(() => {
|
|
151
|
+
firstCall.succeed({ id: 1, name: "First" });
|
|
152
|
+
});
|
|
153
|
+
const secondCall = await waitForCall(1);
|
|
154
|
+
act(() => {
|
|
155
|
+
secondCall.succeed({ id: 2, name: "Second" });
|
|
156
|
+
});
|
|
157
|
+
await waitFor(() => {
|
|
158
|
+
expect(names).toHaveLength(2);
|
|
159
|
+
});
|
|
160
|
+
await waitFor(() => {
|
|
161
|
+
expect(result.current.submitting).toBeFalse();
|
|
162
|
+
});
|
|
163
|
+
|
|
164
|
+
expect(names).toStrictEqual(["First", "Second"]);
|
|
165
|
+
});
|
|
166
|
+
});
|
|
167
|
+
});
|
|
@@ -45,7 +45,8 @@ describe("useSubmit [ Concurrency ]", () => {
|
|
|
45
45
|
await testSuccessState(mock, responseTwo);
|
|
46
46
|
});
|
|
47
47
|
it("should start in loading mode when another request is ongoing", async () => {
|
|
48
|
-
|
|
48
|
+
// The default 20ms mock can resolve during the render pause below, so keep the request in flight explicitly
|
|
49
|
+
mockRequest(request, { delay: 1000 });
|
|
49
50
|
const responseOne = renderUseSubmit(request);
|
|
50
51
|
|
|
51
52
|
act(() => {
|
|
@@ -12,11 +12,42 @@ describe("useSubmit [ Bounce ]", () => {
|
|
|
12
12
|
|
|
13
13
|
let request = createRequest<null, null>({ method: "POST" });
|
|
14
14
|
|
|
15
|
+
/**
|
|
16
|
+
* Bouncing is decided by elapsed time, so the timing specs run on a fake clock. With real timers a stall between two
|
|
17
|
+
* submits moves them into separate bounce windows and the request count changes.
|
|
18
|
+
*/
|
|
19
|
+
const useFakeClock = () => {
|
|
20
|
+
vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout", "Date"] });
|
|
21
|
+
};
|
|
22
|
+
const advance = (ms: number) => act(() => vi.advanceTimersByTimeAsync(ms));
|
|
23
|
+
|
|
24
|
+
/**
|
|
25
|
+
* Submits four times, 10ms apart, all inside one bounce window
|
|
26
|
+
*/
|
|
27
|
+
const submitFourTimes = async (submit: () => unknown) => {
|
|
28
|
+
act(() => {
|
|
29
|
+
submit();
|
|
30
|
+
});
|
|
31
|
+
await advance(10);
|
|
32
|
+
act(() => {
|
|
33
|
+
submit();
|
|
34
|
+
});
|
|
35
|
+
await advance(10);
|
|
36
|
+
act(() => {
|
|
37
|
+
submit();
|
|
38
|
+
});
|
|
39
|
+
await advance(10);
|
|
40
|
+
act(() => {
|
|
41
|
+
submit();
|
|
42
|
+
});
|
|
43
|
+
};
|
|
44
|
+
|
|
15
45
|
beforeAll(() => {
|
|
16
46
|
startServer();
|
|
17
47
|
});
|
|
18
48
|
|
|
19
49
|
afterEach(() => {
|
|
50
|
+
vi.useRealTimers();
|
|
20
51
|
resetMocks();
|
|
21
52
|
});
|
|
22
53
|
|
|
@@ -33,52 +64,41 @@ describe("useSubmit [ Bounce ]", () => {
|
|
|
33
64
|
describe("given debounce is active", () => {
|
|
34
65
|
describe("when request is about to change", () => {
|
|
35
66
|
it("should debounce single request", async () => {
|
|
36
|
-
|
|
37
|
-
|
|
67
|
+
useFakeClock();
|
|
68
|
+
const spy = vi.fn();
|
|
38
69
|
mockRequest(request);
|
|
39
70
|
const response = renderUseSubmit(request, hookDebounceOptions);
|
|
40
71
|
|
|
41
72
|
act(() => {
|
|
42
|
-
response.result.current.onSubmitRequestStart(
|
|
43
|
-
startTime = Date.now();
|
|
44
|
-
});
|
|
45
|
-
submitTime = Date.now();
|
|
73
|
+
response.result.current.onSubmitRequestStart(spy);
|
|
46
74
|
response.result.current.submit();
|
|
47
75
|
});
|
|
48
76
|
|
|
49
|
-
await
|
|
50
|
-
|
|
51
|
-
});
|
|
77
|
+
await advance(hookDebounceOptions.bounceTime - 1);
|
|
78
|
+
expect(spy).not.toHaveBeenCalled();
|
|
52
79
|
|
|
53
|
-
|
|
80
|
+
await advance(1);
|
|
81
|
+
expect(spy).toHaveBeenCalledTimes(1);
|
|
54
82
|
});
|
|
55
83
|
it("should debounce multiple request triggers by bounceTime", async () => {
|
|
84
|
+
useFakeClock();
|
|
56
85
|
const spy = vi.fn();
|
|
57
|
-
let submitTime: number | null = null;
|
|
58
|
-
let startTime: number | null = null;
|
|
59
86
|
mockRequest(request);
|
|
60
87
|
const response = renderUseSubmit(request, hookDebounceOptions);
|
|
61
88
|
|
|
62
|
-
|
|
63
|
-
response.result.current.onSubmitRequestStart(
|
|
64
|
-
spy();
|
|
65
|
-
startTime = Date.now();
|
|
66
|
-
});
|
|
67
|
-
submitTime = Date.now();
|
|
68
|
-
response.result.current.submit();
|
|
69
|
-
await waitForRender(10);
|
|
70
|
-
response.result.current.submit();
|
|
71
|
-
await waitForRender(10);
|
|
72
|
-
response.result.current.submit();
|
|
73
|
-
await waitForRender(10);
|
|
74
|
-
response.result.current.submit();
|
|
89
|
+
act(() => {
|
|
90
|
+
response.result.current.onSubmitRequestStart(spy);
|
|
75
91
|
});
|
|
92
|
+
await submitFourTimes(response.result.current.submit);
|
|
76
93
|
|
|
77
|
-
|
|
78
|
-
|
|
79
|
-
|
|
94
|
+
// The window restarts with every submit, so it closes bounceTime after the last one
|
|
95
|
+
await advance(hookDebounceOptions.bounceTime - 1);
|
|
96
|
+
expect(spy).not.toHaveBeenCalled();
|
|
80
97
|
|
|
81
|
-
|
|
98
|
+
await advance(1);
|
|
99
|
+
expect(spy).toHaveBeenCalledTimes(1);
|
|
100
|
+
|
|
101
|
+
await advance(1000);
|
|
82
102
|
expect(spy).toHaveBeenCalledTimes(1);
|
|
83
103
|
});
|
|
84
104
|
it("should resolve debounced methods", async () => {
|
|
@@ -106,39 +126,24 @@ describe("useSubmit [ Bounce ]", () => {
|
|
|
106
126
|
expect(value).toHaveLength(4);
|
|
107
127
|
});
|
|
108
128
|
it("should change debounce time", async () => {
|
|
129
|
+
useFakeClock();
|
|
109
130
|
const newBounceTime = 200;
|
|
110
131
|
const spy = vi.fn();
|
|
111
|
-
let submitTime: number | null = null;
|
|
112
|
-
let startTime: number | null = null;
|
|
113
132
|
mockRequest(request);
|
|
114
133
|
const response = renderUseSubmit(request, hookDebounceOptions);
|
|
115
134
|
|
|
116
|
-
|
|
117
|
-
|
|
135
|
+
act(() => {
|
|
136
|
+
response.rerender({ bounceTime: newBounceTime });
|
|
118
137
|
});
|
|
119
|
-
|
|
120
|
-
|
|
121
|
-
|
|
122
|
-
await act(async () => {
|
|
123
|
-
response.result.current.onSubmitRequestStart(() => {
|
|
124
|
-
spy();
|
|
125
|
-
startTime = Date.now();
|
|
126
|
-
});
|
|
127
|
-
submitTime = Date.now();
|
|
128
|
-
response.result.current.submit();
|
|
129
|
-
await waitForRender(10);
|
|
130
|
-
response.result.current.submit();
|
|
131
|
-
await waitForRender(10);
|
|
132
|
-
response.result.current.submit();
|
|
133
|
-
await waitForRender(10);
|
|
134
|
-
response.result.current.submit();
|
|
138
|
+
act(() => {
|
|
139
|
+
response.result.current.onSubmitRequestStart(spy);
|
|
135
140
|
});
|
|
141
|
+
await submitFourTimes(response.result.current.submit);
|
|
136
142
|
|
|
137
|
-
await
|
|
138
|
-
|
|
139
|
-
});
|
|
143
|
+
await advance(newBounceTime - 1);
|
|
144
|
+
expect(spy).not.toHaveBeenCalled();
|
|
140
145
|
|
|
141
|
-
|
|
146
|
+
await advance(1);
|
|
142
147
|
expect(spy).toHaveBeenCalledTimes(1);
|
|
143
148
|
});
|
|
144
149
|
});
|
|
@@ -148,15 +153,11 @@ describe("useSubmit [ Bounce ]", () => {
|
|
|
148
153
|
describe("when request is about to change", () => {
|
|
149
154
|
it("should not debounce multiple request triggers", async () => {
|
|
150
155
|
const spy = vi.fn();
|
|
151
|
-
let startTime: number | null = null;
|
|
152
156
|
mockRequest(request, { delay: 0 });
|
|
153
157
|
const response = renderUseSubmit(request);
|
|
154
158
|
|
|
155
159
|
await act(async () => {
|
|
156
|
-
response.result.current.onSubmitRequestStart(
|
|
157
|
-
spy();
|
|
158
|
-
startTime = Date.now();
|
|
159
|
-
});
|
|
160
|
+
response.result.current.onSubmitRequestStart(spy);
|
|
160
161
|
response.result.current.submit();
|
|
161
162
|
await waitForRender(10);
|
|
162
163
|
response.result.current.submit();
|
|
@@ -167,10 +168,8 @@ describe("useSubmit [ Bounce ]", () => {
|
|
|
167
168
|
});
|
|
168
169
|
|
|
169
170
|
await waitFor(() => {
|
|
170
|
-
expect(
|
|
171
|
+
expect(spy).toHaveBeenCalledTimes(4);
|
|
171
172
|
});
|
|
172
|
-
|
|
173
|
-
expect(spy).toHaveBeenCalledTimes(4);
|
|
174
173
|
});
|
|
175
174
|
});
|
|
176
175
|
});
|
|
@@ -178,52 +177,48 @@ describe("useSubmit [ Bounce ]", () => {
|
|
|
178
177
|
describe("given throttle is active", () => {
|
|
179
178
|
describe("when request is about to change", () => {
|
|
180
179
|
it("should throttle single request", async () => {
|
|
181
|
-
|
|
182
|
-
|
|
180
|
+
useFakeClock();
|
|
181
|
+
const spy = vi.fn();
|
|
183
182
|
mockRequest(request);
|
|
184
183
|
const response = renderUseSubmit(request, hookThrottleOptions);
|
|
185
184
|
|
|
186
185
|
act(() => {
|
|
187
|
-
response.result.current.onSubmitRequestStart(
|
|
188
|
-
startTime = Date.now();
|
|
189
|
-
});
|
|
190
|
-
submitTime = Date.now();
|
|
186
|
+
response.result.current.onSubmitRequestStart(spy);
|
|
191
187
|
response.result.current.submit();
|
|
192
188
|
response.result.current.submit();
|
|
193
189
|
});
|
|
194
190
|
|
|
195
|
-
|
|
196
|
-
|
|
197
|
-
|
|
198
|
-
|
|
191
|
+
// Nothing was throttled yet, so the first submit is sent right away and the second waits for the timeout
|
|
192
|
+
await advance(0);
|
|
193
|
+
expect(spy).toHaveBeenCalledTimes(1);
|
|
194
|
+
|
|
195
|
+
await advance(hookThrottleOptions.bounceTimeout - 1);
|
|
196
|
+
expect(spy).toHaveBeenCalledTimes(1);
|
|
197
|
+
|
|
198
|
+
await advance(1);
|
|
199
|
+
expect(spy).toHaveBeenCalledTimes(2);
|
|
199
200
|
});
|
|
200
201
|
it("should throttle multiple request triggers by bounceTime", async () => {
|
|
202
|
+
useFakeClock();
|
|
201
203
|
const spy = vi.fn();
|
|
202
|
-
let submitTime: number | null = null;
|
|
203
|
-
let startTime: number | null = null;
|
|
204
204
|
mockRequest(request);
|
|
205
205
|
const response = renderUseSubmit(request, hookThrottleOptions);
|
|
206
206
|
|
|
207
|
-
|
|
208
|
-
response.result.current.onSubmitRequestStart(
|
|
209
|
-
spy();
|
|
210
|
-
startTime = Date.now();
|
|
211
|
-
});
|
|
212
|
-
submitTime = Date.now();
|
|
213
|
-
response.result.current.submit();
|
|
214
|
-
await waitForRender(10);
|
|
215
|
-
response.result.current.submit();
|
|
216
|
-
await waitForRender(10);
|
|
217
|
-
response.result.current.submit();
|
|
218
|
-
await waitForRender(10);
|
|
219
|
-
response.result.current.submit();
|
|
207
|
+
act(() => {
|
|
208
|
+
response.result.current.onSubmitRequestStart(spy);
|
|
220
209
|
});
|
|
210
|
+
await submitFourTimes(response.result.current.submit);
|
|
211
|
+
expect(spy).toHaveBeenCalledTimes(1);
|
|
221
212
|
|
|
222
|
-
|
|
223
|
-
|
|
224
|
-
|
|
225
|
-
|
|
226
|
-
|
|
213
|
+
// Only the last throttled submit is sent, bounceTimeout after it
|
|
214
|
+
await advance(hookThrottleOptions.bounceTimeout - 1);
|
|
215
|
+
expect(spy).toHaveBeenCalledTimes(1);
|
|
216
|
+
|
|
217
|
+
await advance(1);
|
|
218
|
+
expect(spy).toHaveBeenCalledTimes(2);
|
|
219
|
+
|
|
220
|
+
await advance(1000);
|
|
221
|
+
expect(spy).toHaveBeenCalledTimes(2);
|
|
227
222
|
});
|
|
228
223
|
it("should resolve throttled methods", async () => {
|
|
229
224
|
mockRequest(request);
|
|
@@ -250,39 +245,26 @@ describe("useSubmit [ Bounce ]", () => {
|
|
|
250
245
|
expect(value).toHaveLength(4);
|
|
251
246
|
});
|
|
252
247
|
it("should change throttle time", async () => {
|
|
248
|
+
useFakeClock();
|
|
253
249
|
const newBounceTime = 200;
|
|
254
250
|
const spy = vi.fn();
|
|
255
|
-
let submitTime: number | null = null;
|
|
256
|
-
let startTime: number | null = null;
|
|
257
251
|
mockRequest(request);
|
|
258
252
|
const response = renderUseSubmit(request, hookThrottleOptions);
|
|
259
253
|
|
|
260
|
-
|
|
261
|
-
|
|
254
|
+
act(() => {
|
|
255
|
+
response.rerender({ bounceTime: newBounceTime, bounceTimeout: newBounceTime });
|
|
262
256
|
});
|
|
263
|
-
|
|
264
|
-
|
|
265
|
-
|
|
266
|
-
await act(async () => {
|
|
267
|
-
response.result.current.onSubmitRequestStart(() => {
|
|
268
|
-
spy();
|
|
269
|
-
startTime = Date.now();
|
|
270
|
-
});
|
|
271
|
-
submitTime = Date.now();
|
|
272
|
-
response.result.current.submit();
|
|
273
|
-
await waitForRender(10);
|
|
274
|
-
response.result.current.submit();
|
|
275
|
-
await waitForRender(10);
|
|
276
|
-
response.result.current.submit();
|
|
277
|
-
await waitForRender(10);
|
|
278
|
-
response.result.current.submit();
|
|
257
|
+
act(() => {
|
|
258
|
+
response.result.current.onSubmitRequestStart(spy);
|
|
279
259
|
});
|
|
260
|
+
await submitFourTimes(response.result.current.submit);
|
|
261
|
+
expect(spy).toHaveBeenCalledTimes(1);
|
|
280
262
|
|
|
281
|
-
await
|
|
282
|
-
|
|
283
|
-
|
|
284
|
-
|
|
285
|
-
|
|
263
|
+
await advance(newBounceTime - 1);
|
|
264
|
+
expect(spy).toHaveBeenCalledTimes(1);
|
|
265
|
+
|
|
266
|
+
await advance(1);
|
|
267
|
+
expect(spy).toHaveBeenCalledTimes(2);
|
|
286
268
|
});
|
|
287
269
|
});
|
|
288
270
|
});
|
|
@@ -291,15 +273,11 @@ describe("useSubmit [ Bounce ]", () => {
|
|
|
291
273
|
describe("when request is about to change", () => {
|
|
292
274
|
it("should not throttle multiple request triggers", async () => {
|
|
293
275
|
const spy = vi.fn();
|
|
294
|
-
let startTime: number | null = null;
|
|
295
276
|
mockRequest(request, { delay: 0 });
|
|
296
277
|
const response = renderUseSubmit(request);
|
|
297
278
|
|
|
298
279
|
await act(async () => {
|
|
299
|
-
response.result.current.onSubmitRequestStart(
|
|
300
|
-
spy();
|
|
301
|
-
startTime = Date.now();
|
|
302
|
-
});
|
|
280
|
+
response.result.current.onSubmitRequestStart(spy);
|
|
303
281
|
response.result.current.submit();
|
|
304
282
|
await waitForRender(10);
|
|
305
283
|
response.result.current.submit();
|
|
@@ -310,10 +288,8 @@ describe("useSubmit [ Bounce ]", () => {
|
|
|
310
288
|
});
|
|
311
289
|
|
|
312
290
|
await waitFor(() => {
|
|
313
|
-
expect(
|
|
291
|
+
expect(spy).toHaveBeenCalledTimes(4);
|
|
314
292
|
});
|
|
315
|
-
|
|
316
|
-
expect(spy).toHaveBeenCalledTimes(4);
|
|
317
293
|
});
|
|
318
294
|
});
|
|
319
295
|
});
|