@hyper-fetch/react 7.5.2 → 8.0.0
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/.eslintrc.cjs +12 -0
- 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 +213 -0
- package/__tests__/features/helpers/use-tracked-state/use-tacked-state.actions.spec.ts +550 -0
- package/__tests__/features/helpers/use-tracked-state/use-tracked-state.base.spec.ts +566 -0
- package/__tests__/features/helpers/use-tracked-state/use-tracked-state.utils.spec.ts +260 -0
- package/__tests__/features/provider/provider.hydration.spec.tsx +165 -0
- package/__tests__/features/provider/use-config-provider.base.spec.tsx +69 -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 +136 -0
- package/__tests__/features/use-cache/use-cache.helpers.ts +40 -0
- package/__tests__/features/use-cache/use-cache.typescript.spec.ts +111 -0
- package/__tests__/features/use-emitter/use-emitter.base.spec.ts +124 -0
- package/__tests__/features/use-fetch/use-fetch.base.spec.ts +372 -0
- package/__tests__/features/use-fetch/use-fetch.cancel.spec.ts +83 -0
- package/__tests__/features/use-fetch/use-fetch.clear-state.spec.ts +82 -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.keep-previous-data.spec.ts +215 -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 +187 -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 +237 -0
- package/__tests__/features/use-fetch/use-fetch.suspense.spec.tsx +505 -0
- package/__tests__/features/use-fetch/use-fetch.typescript.spec.ts +182 -0
- package/__tests__/features/use-fetch/use-fetch.utils.spec.ts +26 -0
- package/__tests__/features/use-fetch/use-fetch.window.spec.ts +131 -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 +367 -0
- package/__tests__/features/use-queue/use-queue.resolve.spec.ts +173 -0
- package/__tests__/features/use-stream/use-stream.base.spec.ts +481 -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 +276 -0
- package/__tests__/features/use-submit/use-submit.optimistic.spec.ts +548 -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 +234 -0
- package/__tests__/features/use-submit/use-submit.typescript.spec.ts +325 -0
- package/__tests__/shared/index.ts +2 -0
- package/__tests__/shared/isolation.tests.ts +12 -0
- package/__tests__/shared/response.tests.ts +128 -0
- package/__tests__/tsconfig.json +27 -0
- package/__tests__/utils/cache.utils.ts +55 -0
- package/__tests__/utils/client.utils.ts +3 -0
- package/__tests__/utils/emitter.utils.ts +8 -0
- package/__tests__/utils/helpers.utils.ts +9 -0
- package/__tests__/utils/index.ts +14 -0
- package/__tests__/utils/listener.utils.ts +11 -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 +12 -0
- package/__tests__/utils/use-emitter.utils.ts +12 -0
- package/__tests__/utils/use-fetch.utils.ts +12 -0
- package/__tests__/utils/use-listener.utils.ts +12 -0
- package/__tests__/utils/use-queue.utils.ts +70 -0
- package/__tests__/utils/use-request-events.utils.ts +43 -0
- package/__tests__/utils/use-socket-state.utils.ts +12 -0
- package/__tests__/utils/use-submit.utils.ts +12 -0
- package/__tests__/utils/use-tracked-state.utils.ts +27 -0
- package/__tests__/vitest.setup.ts +8 -0
- package/dist/helpers/index.d.ts +4 -0
- package/dist/helpers/index.d.ts.map +1 -0
- package/dist/helpers/use-request-events/index.d.ts +3 -0
- package/dist/helpers/use-request-events/index.d.ts.map +1 -0
- package/dist/helpers/use-request-events/use-request-events.hooks.d.ts +10 -0
- package/dist/helpers/use-request-events/use-request-events.hooks.d.ts.map +1 -0
- package/dist/helpers/use-request-events/use-request-events.types.d.ts +78 -0
- package/dist/helpers/use-request-events/use-request-events.types.d.ts.map +1 -0
- package/dist/helpers/use-socket-state/index.d.ts +4 -0
- package/dist/helpers/use-socket-state/index.d.ts.map +1 -0
- package/dist/helpers/use-socket-state/use-socket-state.constants.d.ts +4 -0
- package/dist/helpers/use-socket-state/use-socket-state.constants.d.ts.map +1 -0
- package/dist/helpers/use-socket-state/use-socket-state.hooks.d.ts +24 -0
- package/dist/helpers/use-socket-state/use-socket-state.hooks.d.ts.map +1 -0
- package/dist/helpers/use-socket-state/use-socket-state.types.d.ts +12 -0
- package/dist/helpers/use-socket-state/use-socket-state.types.d.ts.map +1 -0
- package/dist/helpers/use-tracked-state/index.d.ts +5 -0
- package/dist/helpers/use-tracked-state/index.d.ts.map +1 -0
- package/dist/helpers/use-tracked-state/use-tracked-state.constants.d.ts +3 -0
- package/dist/helpers/use-tracked-state/use-tracked-state.constants.d.ts.map +1 -0
- package/dist/helpers/use-tracked-state/use-tracked-state.hooks.d.ts +12 -0
- package/dist/helpers/use-tracked-state/use-tracked-state.hooks.d.ts.map +1 -0
- package/dist/helpers/use-tracked-state/use-tracked-state.types.d.ts +113 -0
- package/dist/helpers/use-tracked-state/use-tracked-state.types.d.ts.map +1 -0
- package/dist/helpers/use-tracked-state/use-tracked-state.utils.d.ts +29 -0
- package/dist/helpers/use-tracked-state/use-tracked-state.utils.d.ts.map +1 -0
- package/dist/hooks/use-app-manager/index.d.ts +3 -0
- package/dist/hooks/use-app-manager/index.d.ts.map +1 -0
- package/dist/hooks/use-app-manager/use-app-manager.hooks.d.ts +4 -0
- package/dist/hooks/use-app-manager/use-app-manager.hooks.d.ts.map +1 -0
- package/dist/hooks/use-app-manager/use-app-manager.types.d.ts +19 -0
- package/dist/hooks/use-app-manager/use-app-manager.types.d.ts.map +1 -0
- package/dist/hooks/use-cache/index.d.ts +4 -0
- package/dist/hooks/use-cache/index.d.ts.map +1 -0
- package/dist/hooks/use-cache/use-cache.constants.d.ts +6 -0
- package/dist/hooks/use-cache/use-cache.constants.d.ts.map +1 -0
- package/dist/hooks/use-cache/use-cache.hooks.d.ts +4 -0
- package/dist/hooks/use-cache/use-cache.hooks.d.ts.map +1 -0
- package/dist/hooks/use-cache/use-cache.types.d.ts +24 -0
- package/dist/hooks/use-cache/use-cache.types.d.ts.map +1 -0
- package/dist/hooks/use-emitter/index.d.ts +3 -0
- package/dist/hooks/use-emitter/index.d.ts.map +1 -0
- package/dist/hooks/use-emitter/use-emitter.hooks.d.ts +26 -0
- package/dist/hooks/use-emitter/use-emitter.hooks.d.ts.map +1 -0
- package/dist/hooks/use-emitter/use-emitter.types.d.ts +4 -0
- package/dist/hooks/use-emitter/use-emitter.types.d.ts.map +1 -0
- package/dist/hooks/use-fetch/index.d.ts +5 -0
- package/dist/hooks/use-fetch/index.d.ts.map +1 -0
- package/dist/hooks/use-fetch/use-fetch.constants.d.ts +8 -0
- package/dist/hooks/use-fetch/use-fetch.constants.d.ts.map +1 -0
- package/dist/hooks/use-fetch/use-fetch.hooks.d.ts +10 -0
- package/dist/hooks/use-fetch/use-fetch.hooks.d.ts.map +1 -0
- package/dist/hooks/use-fetch/use-fetch.types.d.ts +118 -0
- package/dist/hooks/use-fetch/use-fetch.types.d.ts.map +1 -0
- package/dist/hooks/use-fetch/use-fetch.utils.d.ts +2 -0
- package/dist/hooks/use-fetch/use-fetch.utils.d.ts.map +1 -0
- package/dist/hooks/use-listener/index.d.ts +3 -0
- package/dist/hooks/use-listener/index.d.ts.map +1 -0
- package/dist/hooks/use-listener/use-listener.hooks.d.ts +31 -0
- package/dist/hooks/use-listener/use-listener.hooks.d.ts.map +1 -0
- package/dist/hooks/use-listener/use-listener.types.d.ts +4 -0
- package/dist/hooks/use-listener/use-listener.types.d.ts.map +1 -0
- package/dist/hooks/use-queue/index.d.ts +4 -0
- package/dist/hooks/use-queue/index.d.ts.map +1 -0
- package/dist/hooks/use-queue/use-queue.constants.d.ts +4 -0
- package/dist/hooks/use-queue/use-queue.constants.d.ts.map +1 -0
- package/dist/hooks/use-queue/use-queue.hooks.d.ts +10 -0
- package/dist/hooks/use-queue/use-queue.hooks.d.ts.map +1 -0
- package/dist/hooks/use-queue/use-queue.types.d.ts +58 -0
- package/dist/hooks/use-queue/use-queue.types.d.ts.map +1 -0
- package/dist/hooks/use-stream/index.d.ts +3 -0
- package/dist/hooks/use-stream/index.d.ts.map +1 -0
- package/dist/hooks/use-stream/use-stream.hooks.d.ts +11 -0
- package/dist/hooks/use-stream/use-stream.hooks.d.ts.map +1 -0
- package/dist/hooks/use-stream/use-stream.types.d.ts +52 -0
- package/dist/hooks/use-stream/use-stream.types.d.ts.map +1 -0
- package/dist/hooks/use-submit/index.d.ts +4 -0
- package/dist/hooks/use-submit/index.d.ts.map +1 -0
- package/dist/hooks/use-submit/use-submit.constants.d.ts +8 -0
- package/dist/hooks/use-submit/use-submit.constants.d.ts.map +1 -0
- package/dist/hooks/use-submit/use-submit.hooks.d.ts +10 -0
- package/dist/hooks/use-submit/use-submit.hooks.d.ts.map +1 -0
- package/dist/hooks/use-submit/use-submit.types.d.ts +115 -0
- package/dist/hooks/use-submit/use-submit.types.d.ts.map +1 -0
- package/dist/index.d.ts +12 -733
- package/dist/index.d.ts.map +1 -0
- package/dist/index.mjs +1935 -0
- package/dist/index.mjs.map +1 -0
- package/dist/provider/index.d.ts +3 -0
- package/dist/provider/index.d.ts.map +1 -0
- package/dist/provider/provider.d.ts +13 -0
- package/dist/provider/provider.d.ts.map +1 -0
- package/dist/provider/provider.types.d.ts +31 -0
- package/dist/provider/provider.types.d.ts.map +1 -0
- package/dist/utils/bounce.utils.d.ts +8 -0
- package/dist/utils/bounce.utils.d.ts.map +1 -0
- package/dist/utils/deep-equal.utils.d.ts +14 -0
- package/dist/utils/deep-equal.utils.d.ts.map +1 -0
- package/dist/utils/index.d.ts +4 -0
- package/dist/utils/index.d.ts.map +1 -0
- package/dist/utils/tracked-proxy.utils.d.ts +7 -0
- package/dist/utils/tracked-proxy.utils.d.ts.map +1 -0
- package/package.json +21 -13
- package/project.json +4 -0
- package/src/helpers/use-request-events/use-request-events.hooks.ts +60 -14
- package/src/helpers/use-request-events/use-request-events.types.ts +19 -12
- package/src/helpers/use-socket-state/use-socket-state.constants.ts +2 -2
- package/src/helpers/use-socket-state/use-socket-state.hooks.ts +47 -13
- package/src/helpers/use-socket-state/use-socket-state.types.ts +1 -1
- package/src/helpers/use-tracked-state/use-tracked-state.constants.ts +1 -1
- package/src/helpers/use-tracked-state/use-tracked-state.hooks.ts +74 -22
- package/src/helpers/use-tracked-state/use-tracked-state.types.ts +7 -2
- package/src/helpers/use-tracked-state/use-tracked-state.utils.ts +39 -4
- package/src/hooks/use-app-manager/use-app-manager.hooks.ts +2 -2
- package/src/hooks/use-cache/use-cache.hooks.ts +33 -41
- package/src/hooks/use-cache/use-cache.types.ts +3 -3
- package/src/hooks/use-emitter/use-emitter.hooks.ts +17 -16
- package/src/hooks/use-fetch/use-fetch.constants.ts +5 -2
- package/src/hooks/use-fetch/use-fetch.hooks.ts +109 -51
- package/src/hooks/use-fetch/use-fetch.types.ts +18 -3
- package/src/hooks/use-listener/use-listener.hooks.ts +19 -27
- package/src/hooks/use-queue/use-queue.constants.ts +2 -2
- package/src/hooks/use-queue/use-queue.hooks.ts +25 -6
- package/src/hooks/use-queue/use-queue.types.ts +8 -2
- package/src/hooks/use-stream/index.ts +2 -0
- package/src/hooks/use-stream/use-stream.hooks.ts +164 -0
- package/src/hooks/use-stream/use-stream.types.ts +53 -0
- package/src/hooks/use-submit/use-submit.constants.ts +2 -2
- package/src/hooks/use-submit/use-submit.hooks.ts +43 -48
- package/src/hooks/use-submit/use-submit.types.ts +9 -9
- package/src/index.ts +1 -0
- package/src/provider/provider.tsx +1 -1
- package/src/provider/provider.types.ts +8 -8
- package/src/utils/index.ts +1 -0
- package/src/utils/tracked-proxy.utils.ts +19 -0
- package/tsconfig.json +1 -1
- package/vite.config.ts +45 -0
- package/.eslintrc.json +0 -11
- package/dist/index.js +0 -1541
- package/dist/index.js.map +0 -7
|
@@ -0,0 +1,505 @@
|
|
|
1
|
+
/// <reference types="vitest/globals" />
|
|
2
|
+
import type { ReactNode } from "react";
|
|
3
|
+
import { Suspense, StrictMode, Component, useState } from "react";
|
|
4
|
+
import { act, fireEvent, render, screen, waitFor } from "@testing-library/react";
|
|
5
|
+
import { createHttpMockingServer } from "@hyper-fetch/testing";
|
|
6
|
+
|
|
7
|
+
import { useFetch } from "hooks/use-fetch";
|
|
8
|
+
import { client, createRequest } from "../../utils";
|
|
9
|
+
|
|
10
|
+
const { resetMocks, startServer, stopServer, mockRequest } = createHttpMockingServer();
|
|
11
|
+
|
|
12
|
+
// ---------------------------------------------------------------------------
|
|
13
|
+
// Shared components
|
|
14
|
+
// ---------------------------------------------------------------------------
|
|
15
|
+
|
|
16
|
+
function DataView({ request, testId = "result" }: { request: any; testId?: string }) {
|
|
17
|
+
const { data, error, loading, status } = useFetch(request, {
|
|
18
|
+
suspense: true,
|
|
19
|
+
dependencyTracking: false,
|
|
20
|
+
});
|
|
21
|
+
|
|
22
|
+
return (
|
|
23
|
+
<div data-testid={testId} data-loading={loading} data-status={status}>
|
|
24
|
+
{error ? `error:${JSON.stringify(error)}` : `data:${JSON.stringify(data)}`}
|
|
25
|
+
</div>
|
|
26
|
+
);
|
|
27
|
+
}
|
|
28
|
+
|
|
29
|
+
interface ErrorBoundaryProps {
|
|
30
|
+
children: ReactNode;
|
|
31
|
+
fallback?: ReactNode;
|
|
32
|
+
}
|
|
33
|
+
|
|
34
|
+
interface ErrorBoundaryState {
|
|
35
|
+
error: Error | null;
|
|
36
|
+
}
|
|
37
|
+
|
|
38
|
+
class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
|
|
39
|
+
constructor(props: ErrorBoundaryProps) {
|
|
40
|
+
super(props);
|
|
41
|
+
this.state = { error: null };
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
static getDerivedStateFromError(error: Error) {
|
|
45
|
+
return { error };
|
|
46
|
+
}
|
|
47
|
+
|
|
48
|
+
render() {
|
|
49
|
+
const { error } = this.state;
|
|
50
|
+
const { fallback, children } = this.props;
|
|
51
|
+
if (error) {
|
|
52
|
+
return fallback ?? <div data-testid="error-boundary">{error.message}</div>;
|
|
53
|
+
}
|
|
54
|
+
return children;
|
|
55
|
+
}
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
// ---------------------------------------------------------------------------
|
|
59
|
+
// Tests
|
|
60
|
+
// ---------------------------------------------------------------------------
|
|
61
|
+
|
|
62
|
+
describe("useFetch [ Suspense ]", () => {
|
|
63
|
+
let request = createRequest();
|
|
64
|
+
|
|
65
|
+
beforeAll(() => {
|
|
66
|
+
startServer();
|
|
67
|
+
});
|
|
68
|
+
|
|
69
|
+
afterEach(() => {
|
|
70
|
+
resetMocks();
|
|
71
|
+
});
|
|
72
|
+
|
|
73
|
+
afterAll(() => {
|
|
74
|
+
stopServer();
|
|
75
|
+
});
|
|
76
|
+
|
|
77
|
+
beforeEach(() => {
|
|
78
|
+
vi.resetModules();
|
|
79
|
+
request = createRequest();
|
|
80
|
+
client.clear();
|
|
81
|
+
});
|
|
82
|
+
|
|
83
|
+
// -----------------------------------------------------------------------
|
|
84
|
+
// Fallback rendering
|
|
85
|
+
// -----------------------------------------------------------------------
|
|
86
|
+
|
|
87
|
+
describe("when rendering with a Suspense boundary", () => {
|
|
88
|
+
it("should show fallback while loading and render data once resolved", async () => {
|
|
89
|
+
const mock = mockRequest(request);
|
|
90
|
+
|
|
91
|
+
render(
|
|
92
|
+
<Suspense fallback={<div data-testid="fallback">Loading...</div>}>
|
|
93
|
+
<DataView request={request} />
|
|
94
|
+
</Suspense>,
|
|
95
|
+
);
|
|
96
|
+
|
|
97
|
+
expect(screen.getByTestId("fallback")).toBeInTheDocument();
|
|
98
|
+
|
|
99
|
+
await waitFor(() => {
|
|
100
|
+
const el = screen.getByTestId("result");
|
|
101
|
+
expect(el.textContent).toContain(JSON.stringify(mock));
|
|
102
|
+
expect(el).toHaveAttribute("data-loading", "false");
|
|
103
|
+
});
|
|
104
|
+
});
|
|
105
|
+
|
|
106
|
+
it("should render error response without crashing", async () => {
|
|
107
|
+
mockRequest(request, { status: 400 });
|
|
108
|
+
|
|
109
|
+
render(
|
|
110
|
+
<Suspense fallback={<div data-testid="fallback">Loading...</div>}>
|
|
111
|
+
<DataView request={request} />
|
|
112
|
+
</Suspense>,
|
|
113
|
+
);
|
|
114
|
+
|
|
115
|
+
expect(screen.getByTestId("fallback")).toBeInTheDocument();
|
|
116
|
+
|
|
117
|
+
await waitFor(() => {
|
|
118
|
+
const el = screen.getByTestId("result");
|
|
119
|
+
expect(el.textContent).toContain("error:");
|
|
120
|
+
});
|
|
121
|
+
});
|
|
122
|
+
|
|
123
|
+
it("should set correct status code on success", async () => {
|
|
124
|
+
mockRequest(request);
|
|
125
|
+
|
|
126
|
+
render(
|
|
127
|
+
<Suspense fallback={<div data-testid="fallback">Loading...</div>}>
|
|
128
|
+
<DataView request={request} />
|
|
129
|
+
</Suspense>,
|
|
130
|
+
);
|
|
131
|
+
|
|
132
|
+
await waitFor(() => {
|
|
133
|
+
expect(screen.getByTestId("result")).toHaveAttribute("data-status", "200");
|
|
134
|
+
});
|
|
135
|
+
});
|
|
136
|
+
|
|
137
|
+
it("should set correct status code on error", async () => {
|
|
138
|
+
mockRequest(request, { status: 500 });
|
|
139
|
+
|
|
140
|
+
render(
|
|
141
|
+
<Suspense fallback={<div data-testid="fallback">Loading...</div>}>
|
|
142
|
+
<DataView request={request} />
|
|
143
|
+
</Suspense>,
|
|
144
|
+
);
|
|
145
|
+
|
|
146
|
+
await waitFor(() => {
|
|
147
|
+
expect(screen.getByTestId("result")).toHaveAttribute("data-status", "500");
|
|
148
|
+
});
|
|
149
|
+
});
|
|
150
|
+
});
|
|
151
|
+
|
|
152
|
+
// -----------------------------------------------------------------------
|
|
153
|
+
// Cached data
|
|
154
|
+
// -----------------------------------------------------------------------
|
|
155
|
+
|
|
156
|
+
describe("when cache already has data", () => {
|
|
157
|
+
it("should render immediately without suspending", async () => {
|
|
158
|
+
const mock = mockRequest(request);
|
|
159
|
+
|
|
160
|
+
function CachedView({ testId }: { testId: string }) {
|
|
161
|
+
const { data, loading } = useFetch(request, {
|
|
162
|
+
suspense: true,
|
|
163
|
+
revalidate: false,
|
|
164
|
+
dependencyTracking: false,
|
|
165
|
+
});
|
|
166
|
+
return (
|
|
167
|
+
<div data-testid={testId}>
|
|
168
|
+
data:{JSON.stringify(data)},loading:{String(loading)}
|
|
169
|
+
</div>
|
|
170
|
+
);
|
|
171
|
+
}
|
|
172
|
+
|
|
173
|
+
// First render — suspends, then resolves
|
|
174
|
+
const first = render(
|
|
175
|
+
<Suspense fallback={<div data-testid="fallback">Loading...</div>}>
|
|
176
|
+
<CachedView testId="first" />
|
|
177
|
+
</Suspense>,
|
|
178
|
+
);
|
|
179
|
+
|
|
180
|
+
await waitFor(() => {
|
|
181
|
+
expect(screen.getByTestId("first").textContent).toContain(JSON.stringify(mock));
|
|
182
|
+
});
|
|
183
|
+
|
|
184
|
+
first.unmount();
|
|
185
|
+
|
|
186
|
+
// Second render — should NOT suspend since data is cached
|
|
187
|
+
render(
|
|
188
|
+
<Suspense fallback={<div data-testid="fallback2">Loading...</div>}>
|
|
189
|
+
<CachedView testId="second" />
|
|
190
|
+
</Suspense>,
|
|
191
|
+
);
|
|
192
|
+
|
|
193
|
+
// Synchronous assertion — no fallback, data rendered immediately
|
|
194
|
+
expect(screen.getByTestId("second").textContent).toContain(JSON.stringify(mock));
|
|
195
|
+
});
|
|
196
|
+
});
|
|
197
|
+
|
|
198
|
+
// -----------------------------------------------------------------------
|
|
199
|
+
// Disabled
|
|
200
|
+
// -----------------------------------------------------------------------
|
|
201
|
+
|
|
202
|
+
describe("when disabled", () => {
|
|
203
|
+
it("should not suspend and render with null data", () => {
|
|
204
|
+
function DisabledView() {
|
|
205
|
+
const { data, loading } = useFetch(request, {
|
|
206
|
+
suspense: true,
|
|
207
|
+
disabled: true,
|
|
208
|
+
dependencyTracking: false,
|
|
209
|
+
});
|
|
210
|
+
return (
|
|
211
|
+
<div data-testid="disabled">
|
|
212
|
+
data:{String(data)},loading:{String(loading)}
|
|
213
|
+
</div>
|
|
214
|
+
);
|
|
215
|
+
}
|
|
216
|
+
|
|
217
|
+
render(
|
|
218
|
+
<Suspense fallback={<div data-testid="fallback">Loading...</div>}>
|
|
219
|
+
<DisabledView />
|
|
220
|
+
</Suspense>,
|
|
221
|
+
);
|
|
222
|
+
|
|
223
|
+
expect(screen.getByTestId("disabled").textContent).toContain("data:null");
|
|
224
|
+
expect(screen.queryByTestId("fallback")).not.toBeInTheDocument();
|
|
225
|
+
});
|
|
226
|
+
});
|
|
227
|
+
|
|
228
|
+
// -----------------------------------------------------------------------
|
|
229
|
+
// Multiple components
|
|
230
|
+
// -----------------------------------------------------------------------
|
|
231
|
+
|
|
232
|
+
describe("when multiple components suspend under the same boundary", () => {
|
|
233
|
+
it("should show single fallback until all resolve", async () => {
|
|
234
|
+
const requestA = createRequest({ endpoint: "/suspense-a" });
|
|
235
|
+
const requestB = createRequest({ endpoint: "/suspense-b" });
|
|
236
|
+
|
|
237
|
+
const mockA = mockRequest(requestA);
|
|
238
|
+
const mockB = mockRequest(requestB, { delay: 50 });
|
|
239
|
+
|
|
240
|
+
render(
|
|
241
|
+
<Suspense fallback={<div data-testid="fallback">Loading all...</div>}>
|
|
242
|
+
<DataView request={requestA} testId="a" />
|
|
243
|
+
<DataView request={requestB} testId="b" />
|
|
244
|
+
</Suspense>,
|
|
245
|
+
);
|
|
246
|
+
|
|
247
|
+
expect(screen.getByTestId("fallback")).toBeInTheDocument();
|
|
248
|
+
|
|
249
|
+
await waitFor(() => {
|
|
250
|
+
expect(screen.getByTestId("a").textContent).toContain(JSON.stringify(mockA));
|
|
251
|
+
expect(screen.getByTestId("b").textContent).toContain(JSON.stringify(mockB));
|
|
252
|
+
});
|
|
253
|
+
});
|
|
254
|
+
|
|
255
|
+
it("should support independent Suspense boundaries per component", async () => {
|
|
256
|
+
const requestA = createRequest({ endpoint: "/suspense-ind-a" });
|
|
257
|
+
const requestB = createRequest({ endpoint: "/suspense-ind-b" });
|
|
258
|
+
|
|
259
|
+
const mockA = mockRequest(requestA);
|
|
260
|
+
mockRequest(requestB, { delay: 100 });
|
|
261
|
+
|
|
262
|
+
render(
|
|
263
|
+
<div>
|
|
264
|
+
<Suspense fallback={<div data-testid="fallback-a">Loading A...</div>}>
|
|
265
|
+
<DataView request={requestA} testId="a" />
|
|
266
|
+
</Suspense>
|
|
267
|
+
<Suspense fallback={<div data-testid="fallback-b">Loading B...</div>}>
|
|
268
|
+
<DataView request={requestB} testId="b" />
|
|
269
|
+
</Suspense>
|
|
270
|
+
</div>,
|
|
271
|
+
);
|
|
272
|
+
|
|
273
|
+
// Both should initially show fallbacks
|
|
274
|
+
expect(screen.getByTestId("fallback-a")).toBeInTheDocument();
|
|
275
|
+
expect(screen.getByTestId("fallback-b")).toBeInTheDocument();
|
|
276
|
+
|
|
277
|
+
// A resolves first (no delay)
|
|
278
|
+
await waitFor(() => {
|
|
279
|
+
expect(screen.getByTestId("a").textContent).toContain(JSON.stringify(mockA));
|
|
280
|
+
});
|
|
281
|
+
});
|
|
282
|
+
});
|
|
283
|
+
|
|
284
|
+
// -----------------------------------------------------------------------
|
|
285
|
+
// Nested Suspense boundaries
|
|
286
|
+
// -----------------------------------------------------------------------
|
|
287
|
+
|
|
288
|
+
describe("when using nested Suspense boundaries", () => {
|
|
289
|
+
it("should allow outer fallback to wrap inner components", async () => {
|
|
290
|
+
const outerRequest = createRequest({ endpoint: "/nested-outer" });
|
|
291
|
+
const innerRequest = createRequest({ endpoint: "/nested-inner" });
|
|
292
|
+
|
|
293
|
+
const outerMock = mockRequest(outerRequest);
|
|
294
|
+
const innerMock = mockRequest(innerRequest, { delay: 50 });
|
|
295
|
+
|
|
296
|
+
function InnerView() {
|
|
297
|
+
const { data } = useFetch(innerRequest, { suspense: true, dependencyTracking: false });
|
|
298
|
+
return <div data-testid="inner">inner:{JSON.stringify(data)}</div>;
|
|
299
|
+
}
|
|
300
|
+
|
|
301
|
+
function OuterView() {
|
|
302
|
+
const { data } = useFetch(outerRequest, { suspense: true, dependencyTracking: false });
|
|
303
|
+
return (
|
|
304
|
+
<div data-testid="outer">
|
|
305
|
+
outer:{JSON.stringify(data)}
|
|
306
|
+
<Suspense fallback={<div data-testid="inner-fallback">Inner loading...</div>}>
|
|
307
|
+
<InnerView />
|
|
308
|
+
</Suspense>
|
|
309
|
+
</div>
|
|
310
|
+
);
|
|
311
|
+
}
|
|
312
|
+
|
|
313
|
+
render(
|
|
314
|
+
<Suspense fallback={<div data-testid="outer-fallback">Outer loading...</div>}>
|
|
315
|
+
<OuterView />
|
|
316
|
+
</Suspense>,
|
|
317
|
+
);
|
|
318
|
+
|
|
319
|
+
expect(screen.getByTestId("outer-fallback")).toBeInTheDocument();
|
|
320
|
+
|
|
321
|
+
await waitFor(() => {
|
|
322
|
+
expect(screen.getByTestId("outer").textContent).toContain(JSON.stringify(outerMock));
|
|
323
|
+
});
|
|
324
|
+
|
|
325
|
+
await waitFor(() => {
|
|
326
|
+
expect(screen.getByTestId("inner").textContent).toContain(JSON.stringify(innerMock));
|
|
327
|
+
});
|
|
328
|
+
});
|
|
329
|
+
});
|
|
330
|
+
|
|
331
|
+
// -----------------------------------------------------------------------
|
|
332
|
+
// StrictMode compatibility
|
|
333
|
+
// -----------------------------------------------------------------------
|
|
334
|
+
|
|
335
|
+
describe("when rendering in StrictMode", () => {
|
|
336
|
+
it("should work correctly with StrictMode double-render", async () => {
|
|
337
|
+
const mock = mockRequest(request);
|
|
338
|
+
|
|
339
|
+
render(
|
|
340
|
+
<StrictMode>
|
|
341
|
+
<Suspense fallback={<div data-testid="fallback">Loading...</div>}>
|
|
342
|
+
<DataView request={request} />
|
|
343
|
+
</Suspense>
|
|
344
|
+
</StrictMode>,
|
|
345
|
+
);
|
|
346
|
+
|
|
347
|
+
await waitFor(() => {
|
|
348
|
+
const el = screen.getByTestId("result");
|
|
349
|
+
expect(el.textContent).toContain(JSON.stringify(mock));
|
|
350
|
+
});
|
|
351
|
+
});
|
|
352
|
+
});
|
|
353
|
+
|
|
354
|
+
// -----------------------------------------------------------------------
|
|
355
|
+
// Dynamic parameter changes
|
|
356
|
+
// -----------------------------------------------------------------------
|
|
357
|
+
|
|
358
|
+
describe("when request parameters change", () => {
|
|
359
|
+
it("should re-suspend when cache key changes", async () => {
|
|
360
|
+
const request1 = createRequest({ endpoint: "/suspense-param-1" });
|
|
361
|
+
const request2 = createRequest({ endpoint: "/suspense-param-2" });
|
|
362
|
+
|
|
363
|
+
const mock1 = mockRequest(request1);
|
|
364
|
+
const mock2 = mockRequest(request2, { delay: 50 });
|
|
365
|
+
|
|
366
|
+
function ParamView({ req }: { req: any }) {
|
|
367
|
+
const { data } = useFetch(req, { suspense: true, dependencyTracking: false });
|
|
368
|
+
return <div data-testid="param-result">{JSON.stringify(data)}</div>;
|
|
369
|
+
}
|
|
370
|
+
|
|
371
|
+
function Wrapper() {
|
|
372
|
+
const [req, setReq] = useState<typeof request1 | typeof request2>(request1);
|
|
373
|
+
return (
|
|
374
|
+
<>
|
|
375
|
+
<button type="button" data-testid="switch-btn" onClick={() => setReq(request2)}>
|
|
376
|
+
Switch
|
|
377
|
+
</button>
|
|
378
|
+
<Suspense fallback={<div data-testid="fallback">Loading...</div>}>
|
|
379
|
+
<ParamView req={req} />
|
|
380
|
+
</Suspense>
|
|
381
|
+
</>
|
|
382
|
+
);
|
|
383
|
+
}
|
|
384
|
+
|
|
385
|
+
render(<Wrapper />);
|
|
386
|
+
|
|
387
|
+
await waitFor(() => {
|
|
388
|
+
expect(screen.getByTestId("param-result").textContent).toContain(JSON.stringify(mock1));
|
|
389
|
+
});
|
|
390
|
+
|
|
391
|
+
act(() => {
|
|
392
|
+
fireEvent.click(screen.getByTestId("switch-btn"));
|
|
393
|
+
});
|
|
394
|
+
|
|
395
|
+
await waitFor(() => {
|
|
396
|
+
expect(screen.getByTestId("param-result").textContent).toContain(JSON.stringify(mock2));
|
|
397
|
+
});
|
|
398
|
+
});
|
|
399
|
+
});
|
|
400
|
+
|
|
401
|
+
// -----------------------------------------------------------------------
|
|
402
|
+
// ErrorBoundary integration
|
|
403
|
+
// -----------------------------------------------------------------------
|
|
404
|
+
|
|
405
|
+
describe("when combined with ErrorBoundary", () => {
|
|
406
|
+
it("should not trigger ErrorBoundary on normal error responses", async () => {
|
|
407
|
+
mockRequest(request, { status: 400 });
|
|
408
|
+
|
|
409
|
+
render(
|
|
410
|
+
<ErrorBoundary fallback={<div data-testid="error-boundary">Caught!</div>}>
|
|
411
|
+
<Suspense fallback={<div data-testid="fallback">Loading...</div>}>
|
|
412
|
+
<DataView request={request} />
|
|
413
|
+
</Suspense>
|
|
414
|
+
</ErrorBoundary>,
|
|
415
|
+
);
|
|
416
|
+
|
|
417
|
+
await waitFor(() => {
|
|
418
|
+
const el = screen.getByTestId("result");
|
|
419
|
+
expect(el.textContent).toContain("error:");
|
|
420
|
+
});
|
|
421
|
+
|
|
422
|
+
expect(screen.queryByTestId("error-boundary")).not.toBeInTheDocument();
|
|
423
|
+
});
|
|
424
|
+
});
|
|
425
|
+
|
|
426
|
+
// -----------------------------------------------------------------------
|
|
427
|
+
// Refetch after suspense
|
|
428
|
+
// -----------------------------------------------------------------------
|
|
429
|
+
|
|
430
|
+
describe("when refetching after initial suspense", () => {
|
|
431
|
+
it("should not re-suspend on refetch (data is already present)", async () => {
|
|
432
|
+
const mock = mockRequest(request);
|
|
433
|
+
const spy = vi.fn();
|
|
434
|
+
|
|
435
|
+
function RefetchView() {
|
|
436
|
+
const { data, refetch } = useFetch(request, {
|
|
437
|
+
suspense: true,
|
|
438
|
+
dependencyTracking: false,
|
|
439
|
+
});
|
|
440
|
+
spy(data);
|
|
441
|
+
return (
|
|
442
|
+
<div>
|
|
443
|
+
<div data-testid="refetch-data">{JSON.stringify(data)}</div>
|
|
444
|
+
<button type="button" data-testid="refetch-btn" onClick={refetch}>
|
|
445
|
+
Refetch
|
|
446
|
+
</button>
|
|
447
|
+
</div>
|
|
448
|
+
);
|
|
449
|
+
}
|
|
450
|
+
|
|
451
|
+
render(
|
|
452
|
+
<Suspense fallback={<div data-testid="fallback">Loading...</div>}>
|
|
453
|
+
<RefetchView />
|
|
454
|
+
</Suspense>,
|
|
455
|
+
);
|
|
456
|
+
|
|
457
|
+
await waitFor(() => {
|
|
458
|
+
expect(screen.getByTestId("refetch-data").textContent).toContain(JSON.stringify(mock));
|
|
459
|
+
});
|
|
460
|
+
|
|
461
|
+
const newMock = mockRequest(request, { data: { updated: true } });
|
|
462
|
+
|
|
463
|
+
act(() => {
|
|
464
|
+
fireEvent.click(screen.getByTestId("refetch-btn"));
|
|
465
|
+
});
|
|
466
|
+
|
|
467
|
+
// Should NOT show fallback during refetch
|
|
468
|
+
expect(screen.queryByTestId("fallback")).not.toBeInTheDocument();
|
|
469
|
+
|
|
470
|
+
await waitFor(() => {
|
|
471
|
+
expect(screen.getByTestId("refetch-data").textContent).toContain(JSON.stringify(newMock));
|
|
472
|
+
});
|
|
473
|
+
});
|
|
474
|
+
});
|
|
475
|
+
|
|
476
|
+
// -----------------------------------------------------------------------
|
|
477
|
+
// Non-suspense mode (default)
|
|
478
|
+
// -----------------------------------------------------------------------
|
|
479
|
+
|
|
480
|
+
describe("when suspense option is not set", () => {
|
|
481
|
+
it("should behave normally without suspending", async () => {
|
|
482
|
+
const mock = mockRequest(request);
|
|
483
|
+
|
|
484
|
+
function NormalView() {
|
|
485
|
+
const { data, loading } = useFetch(request, { dependencyTracking: false });
|
|
486
|
+
if (loading) return <div data-testid="normal-loading">Loading...</div>;
|
|
487
|
+
return <div data-testid="normal-data">{JSON.stringify(data)}</div>;
|
|
488
|
+
}
|
|
489
|
+
|
|
490
|
+
render(
|
|
491
|
+
<Suspense fallback={<div data-testid="fallback">Suspense fallback</div>}>
|
|
492
|
+
<NormalView />
|
|
493
|
+
</Suspense>,
|
|
494
|
+
);
|
|
495
|
+
|
|
496
|
+
// Should show component's own loading state, not Suspense fallback
|
|
497
|
+
expect(screen.getByTestId("normal-loading")).toBeInTheDocument();
|
|
498
|
+
expect(screen.queryByTestId("fallback")).not.toBeInTheDocument();
|
|
499
|
+
|
|
500
|
+
await waitFor(() => {
|
|
501
|
+
expect(screen.getByTestId("normal-data").textContent).toContain(JSON.stringify(mock));
|
|
502
|
+
});
|
|
503
|
+
});
|
|
504
|
+
});
|
|
505
|
+
});
|
|
@@ -0,0 +1,182 @@
|
|
|
1
|
+
import { expectType, expectNotType, expectFunctionParametersType } from "@hyper-fetch/testing";
|
|
2
|
+
import { Client } from "@hyper-fetch/core";
|
|
3
|
+
|
|
4
|
+
import type { UseFetchReturnType } from "hooks/use-fetch";
|
|
5
|
+
|
|
6
|
+
const client = new Client({
|
|
7
|
+
url: "http://localhost:3000",
|
|
8
|
+
});
|
|
9
|
+
|
|
10
|
+
// ---- Request definitions ----
|
|
11
|
+
|
|
12
|
+
const getUsers = client.createRequest<{
|
|
13
|
+
response: { id: string; name: string }[];
|
|
14
|
+
}>()({
|
|
15
|
+
method: "GET",
|
|
16
|
+
endpoint: "/users",
|
|
17
|
+
});
|
|
18
|
+
|
|
19
|
+
const getUser = client.createRequest<{
|
|
20
|
+
response: { id: string; name: string; email: string };
|
|
21
|
+
}>()({
|
|
22
|
+
method: "GET",
|
|
23
|
+
endpoint: "/users/:userId",
|
|
24
|
+
});
|
|
25
|
+
|
|
26
|
+
// eslint-disable-next-line @typescript-eslint/no-unused-vars
|
|
27
|
+
const getUserWithQuery = client.createRequest<{
|
|
28
|
+
response: { id: string; name: string }[];
|
|
29
|
+
queryParams: { search: string; page: number };
|
|
30
|
+
}>()({
|
|
31
|
+
method: "GET",
|
|
32
|
+
endpoint: "/users",
|
|
33
|
+
});
|
|
34
|
+
|
|
35
|
+
const getUserWithError = client.createRequest<{
|
|
36
|
+
response: { id: string };
|
|
37
|
+
error: { code: number; message: string; details: string[] };
|
|
38
|
+
}>()({
|
|
39
|
+
method: "GET",
|
|
40
|
+
endpoint: "/users/:userId",
|
|
41
|
+
});
|
|
42
|
+
|
|
43
|
+
// ---- Type-level tests using return type directly ----
|
|
44
|
+
|
|
45
|
+
type GetUsersReturn = UseFetchReturnType<typeof getUsers>;
|
|
46
|
+
type GetUserReturn = UseFetchReturnType<typeof getUser>;
|
|
47
|
+
type GetUserWithErrorReturn = UseFetchReturnType<typeof getUserWithError>;
|
|
48
|
+
|
|
49
|
+
describe("useFetch [Types]", () => {
|
|
50
|
+
describe("return type: data", () => {
|
|
51
|
+
it("should type data as response type or null", () => {
|
|
52
|
+
const data = null as unknown as GetUsersReturn["data"];
|
|
53
|
+
expectType<{ id: string; name: string }[] | null>().assert(data);
|
|
54
|
+
});
|
|
55
|
+
|
|
56
|
+
it("should not type data as just the response type (missing null)", () => {
|
|
57
|
+
const data = null as unknown as GetUsersReturn["data"];
|
|
58
|
+
expectNotType<{ id: string; name: string }[]>().assert(data);
|
|
59
|
+
});
|
|
60
|
+
|
|
61
|
+
it("should type data correctly for parameterized requests", () => {
|
|
62
|
+
const data = null as unknown as GetUserReturn["data"];
|
|
63
|
+
expectType<{ id: string; name: string; email: string } | null>().assert(data);
|
|
64
|
+
});
|
|
65
|
+
});
|
|
66
|
+
|
|
67
|
+
describe("return type: error", () => {
|
|
68
|
+
it("should type error as Error or null for default error type", () => {
|
|
69
|
+
const error = null as unknown as GetUsersReturn["error"];
|
|
70
|
+
expectType<Error | null>().assert(error);
|
|
71
|
+
});
|
|
72
|
+
|
|
73
|
+
it("should type error with custom error type", () => {
|
|
74
|
+
const error = null as unknown as GetUserWithErrorReturn["error"];
|
|
75
|
+
expectType<{ code: number; message: string; details: string[] } | Error | null>().assert(error);
|
|
76
|
+
});
|
|
77
|
+
});
|
|
78
|
+
|
|
79
|
+
describe("return type: loading", () => {
|
|
80
|
+
it("should type loading as boolean", () => {
|
|
81
|
+
const loading = false as GetUsersReturn["loading"];
|
|
82
|
+
expectType<boolean>().assert(loading);
|
|
83
|
+
});
|
|
84
|
+
});
|
|
85
|
+
|
|
86
|
+
describe("return type: success", () => {
|
|
87
|
+
it("should type success as boolean", () => {
|
|
88
|
+
const success = false as GetUsersReturn["success"];
|
|
89
|
+
expectType<boolean>().assert(success);
|
|
90
|
+
});
|
|
91
|
+
});
|
|
92
|
+
|
|
93
|
+
describe("return type: retries", () => {
|
|
94
|
+
it("should type retries as number", () => {
|
|
95
|
+
const retries = 0 as GetUsersReturn["retries"];
|
|
96
|
+
expectType<number>().assert(retries);
|
|
97
|
+
});
|
|
98
|
+
});
|
|
99
|
+
|
|
100
|
+
describe("return type: timestamps", () => {
|
|
101
|
+
it("should type responseTimestamp as Date or null", () => {
|
|
102
|
+
const ts = null as unknown as GetUsersReturn["responseTimestamp"];
|
|
103
|
+
expectType<Date | null>().assert(ts);
|
|
104
|
+
});
|
|
105
|
+
|
|
106
|
+
it("should type requestTimestamp as Date or null", () => {
|
|
107
|
+
const ts = null as unknown as GetUsersReturn["requestTimestamp"];
|
|
108
|
+
expectType<Date | null>().assert(ts);
|
|
109
|
+
});
|
|
110
|
+
});
|
|
111
|
+
|
|
112
|
+
describe("return type: actions", () => {
|
|
113
|
+
it("should have setData accepting the response type", () => {
|
|
114
|
+
const setData = (() => null) as unknown as GetUsersReturn["setData"];
|
|
115
|
+
expectFunctionParametersType(setData).assert([[{ id: "1", name: "test" }]]);
|
|
116
|
+
});
|
|
117
|
+
|
|
118
|
+
it("should have setData accepting null", () => {
|
|
119
|
+
const setData = (() => null) as unknown as GetUsersReturn["setData"];
|
|
120
|
+
expectFunctionParametersType(setData).assert([null]);
|
|
121
|
+
});
|
|
122
|
+
|
|
123
|
+
it("should have setLoading accepting boolean", () => {
|
|
124
|
+
const setLoading = (() => null) as unknown as GetUsersReturn["setLoading"];
|
|
125
|
+
expectFunctionParametersType(setLoading).assert([true]);
|
|
126
|
+
expectFunctionParametersType(setLoading).assert([false]);
|
|
127
|
+
});
|
|
128
|
+
|
|
129
|
+
it("should have setError accepting the error type or null", () => {
|
|
130
|
+
const setError = (() => null) as unknown as GetUserWithErrorReturn["setError"];
|
|
131
|
+
expectFunctionParametersType(setError).assert([
|
|
132
|
+
{ code: 400, message: "Bad Request", details: ["field is required"] },
|
|
133
|
+
]);
|
|
134
|
+
expectFunctionParametersType(setError).assert([null]);
|
|
135
|
+
});
|
|
136
|
+
});
|
|
137
|
+
|
|
138
|
+
describe("return type: event callbacks", () => {
|
|
139
|
+
it("should have onSuccess callback", () => {
|
|
140
|
+
const onSuccess = (() => null) as unknown as GetUsersReturn["onSuccess"];
|
|
141
|
+
expectType<(callback: any) => void>().assert(onSuccess);
|
|
142
|
+
});
|
|
143
|
+
|
|
144
|
+
it("should have onError callback", () => {
|
|
145
|
+
const onError = (() => null) as unknown as GetUsersReturn["onError"];
|
|
146
|
+
expectType<(callback: any) => void>().assert(onError);
|
|
147
|
+
});
|
|
148
|
+
|
|
149
|
+
it("should have onFinished callback", () => {
|
|
150
|
+
const onFinished = (() => null) as unknown as GetUsersReturn["onFinished"];
|
|
151
|
+
expectType<(callback: any) => void>().assert(onFinished);
|
|
152
|
+
});
|
|
153
|
+
|
|
154
|
+
it("should have abort function", () => {
|
|
155
|
+
const abort = (() => null) as unknown as GetUsersReturn["abort"];
|
|
156
|
+
expectType<() => void>().assert(abort);
|
|
157
|
+
});
|
|
158
|
+
|
|
159
|
+
it("should have onRequestStart callback", () => {
|
|
160
|
+
const onRequestStart = (() => null) as unknown as GetUsersReturn["onRequestStart"];
|
|
161
|
+
expectType<(callback: any) => void>().assert(onRequestStart);
|
|
162
|
+
});
|
|
163
|
+
|
|
164
|
+
it("should have onResponseStart callback", () => {
|
|
165
|
+
const onResponseStart = (() => null) as unknown as GetUsersReturn["onResponseStart"];
|
|
166
|
+
expectType<(callback: any) => void>().assert(onResponseStart);
|
|
167
|
+
});
|
|
168
|
+
});
|
|
169
|
+
|
|
170
|
+
describe("return type: refetch and bounce", () => {
|
|
171
|
+
it("should have refetch function", () => {
|
|
172
|
+
const refetch = (() => null) as unknown as GetUsersReturn["refetch"];
|
|
173
|
+
expectType<() => void>().assert(refetch);
|
|
174
|
+
});
|
|
175
|
+
|
|
176
|
+
it("should have bounce state with active and reset", () => {
|
|
177
|
+
const bounce = {} as GetUsersReturn["bounce"];
|
|
178
|
+
expectType<boolean>().assert(bounce.active);
|
|
179
|
+
expectType<() => void>().assert(bounce.reset);
|
|
180
|
+
});
|
|
181
|
+
});
|
|
182
|
+
});
|