Skip to content
Source
Sign inSign up
TanStack/router
Open History to see the last commit

errorComponent.test.tsx

322 lines9.8 KB

1import { afterEach, describe, expect, onTestFinished, test, vi } from 'vitest'
2import { cleanup, fireEvent, render, screen } from '@solidjs/testing-library'
3import { createControlledPromise } from '@tanstack/router-core'
4​
5import {
6 CatchBoundary,
7 ErrorComponent,
8 Link,
9 Outlet,
10 RouterProvider,
11 createLazyRoute,
12 createRootRoute,
13 createRoute,
14 createRouter,
15} from '../src'
16import type { ErrorComponentProps } from '../src'
17​
18function MyErrorComponent(props: ErrorComponentProps) {
19 return <div>Error: {getErrorMessage(props.error)}</div>
21​
22function getErrorMessage(error: unknown) {
23 return error instanceof Error ? error.message : String(error)
25​
26async function asyncToThrowFn() {
27 await new Promise((resolve) => setTimeout(resolve, 500))
28 throw new Error('error thrown')
30​
31function throwFn() {
32 throw new Error('error thrown')
34​
35afterEach(() => {
36 vi.resetAllMocks()
37 window.history.replaceState(null, 'root', '/')
38 cleanup()
39})
40​
41describe.each([true, false])(
42 'with lazy errorComponent=%s',
43 (isUsingLazyError) => {
44 describe.each([{ preload: false }, { preload: 'intent' }] as const)(
45 'errorComponent is rendered when the preload=$preload',
46 (options) => {
47 describe.each([true, false])('with async=%s', (isAsync) => {
48 const throwableFn = isAsync ? asyncToThrowFn : throwFn
49​
50 const callers = [
51 { caller: 'beforeLoad', testFn: throwableFn },
52 { caller: 'loader', testFn: throwableFn },
53 ]
54​
55 test.each(callers)(
56 'an Error is thrown on navigate in the route $caller function',
57 async ({ caller, testFn }) => {
58 const rootRoute = createRootRoute()
59 const indexRoute = createRoute({
60 getParentRoute: () => rootRoute,
61 path: '/',
62 component: function Home() {
63 return (
64 <div>
65 <Link to="/about">link to about</Link>
66 </div>
67 )
68 },
69 })
70 const aboutRoute = createRoute({
71 getParentRoute: () => rootRoute,
72 path: '/about',
73 beforeLoad: caller === 'beforeLoad' ? testFn : undefined,
74 loader: caller === 'loader' ? testFn : undefined,
75 component: function Home() {
76 return <div>About route content</div>
77 },
78 errorComponent: isUsingLazyError ? undefined : MyErrorComponent,
79 })
80​
81 if (isUsingLazyError) {
82 aboutRoute.lazy(() =>
83 Promise.resolve(
84 createLazyRoute('/about')({
85 errorComponent: MyErrorComponent,
86 }),
87 ),
88 )
89 }
90​
91 const routeTree = rootRoute.addChildren([indexRoute, aboutRoute])
92​
93 const router = createRouter({
94 routeTree,
95 defaultPreload: options.preload,
96 })
97​
98 render(() => <RouterProvider router={router} />)
99​
100 const linkToAbout = await screen.findByRole('link', {
101 name: 'link to about',
102 })
103​
104 expect(linkToAbout).toBeInTheDocument()
105 fireEvent.mouseOver(linkToAbout)
106 fireEvent.focus(linkToAbout)
107 fireEvent.click(linkToAbout)
108​
109 const errorComponent = await screen.findByText(
110 `Error: error thrown`,
111 undefined,
112 { timeout: 1500 },
113 )
114 await expect(
115 screen.findByText('About route content'),
116 ).rejects.toThrow()
117 expect(errorComponent).toBeInTheDocument()
118 },
119 )
120​
121 test.each(callers)(
122 'an Error is thrown on first load in the route $caller function',
123 async ({ caller, testFn }) => {
124 const rootRoute = createRootRoute()
125 const indexRoute = createRoute({
126 getParentRoute: () => rootRoute,
127 path: '/',
128 beforeLoad: caller === 'beforeLoad' ? testFn : undefined,
129 loader: caller === 'loader' ? testFn : undefined,
130 component: function Home() {
131 return <div>Index route content</div>
132 },
133 errorComponent: isUsingLazyError ? undefined : MyErrorComponent,
134 })
135​
136 if (isUsingLazyError) {
137 indexRoute.lazy(() =>
138 Promise.resolve(
139 createLazyRoute('/')({
140 errorComponent: MyErrorComponent,
141 }),
142 ),
143 )
144 }
145​
146 const routeTree = rootRoute.addChildren([indexRoute])
147​
148 const router = createRouter({
149 routeTree,
150 defaultPreload: options.preload,
151 })
152​
153 render(() => <RouterProvider router={router} />)
154​
155 const errorComponent = await screen.findByText(
156 `Error: error thrown`,
157 undefined,
158 { timeout: 750 },
159 )
160 await expect(
161 screen.findByText('Index route content'),
162 ).rejects.toThrow()
163 expect(errorComponent).toBeInTheDocument()
164 },
165 )
166 })
167 },
168 )
169 },
171​
172test('global catch boundary resets when a background child generation recovers', async () => {
173 const refresh = createControlledPromise<number>()
174 let loaderCalls = 0
175 const rootRoute = createRootRoute({ component: Outlet })
176 const childRoute = createRoute({
177 getParentRoute: () => rootRoute,
178 path: '/',
179 loader: {
180 staleReloadMode: 'background',
181 handler: () => (++loaderCalls === 1 ? 1 : refresh),
182 },
183 component: () => {
184 const revision = childRoute.useLoaderData()
185 if (revision() === 1) {
186 throw new Error('stale child render failed')
187 }
188 return <div>Recovered child revision {revision()}</div>
189 },
190 })
191 const router = createRouter({
192 routeTree: rootRoute.addChildren([childRoute]),
193 })
194 vi.spyOn(console, 'warn').mockImplementation(() => {})
195 vi.spyOn(console, 'error').mockImplementation(() => {})
196​
197 render(() => <RouterProvider router={router} />)
198 expect(
199 await screen.findByText('stale child render failed'),
200 ).toBeInTheDocument()
201​
202 const invalidation = router.invalidate()
203 await vi.waitFor(() => expect(loaderCalls).toBe(2))
204 expect(screen.getByText('stale child render failed')).toBeInTheDocument()
205 expect(screen.queryByText(/Recovered child revision/)).not.toBeInTheDocument()
206 refresh.resolve(2)
207 await invalidation
208​
209 expect(
210 await screen.findByText('Recovered child revision 2'),
211 ).toBeInTheDocument()
212 expect(
213 screen.queryByText('stale child render failed'),
214 ).not.toBeInTheDocument()
215})
216​
217test('ancestor route errorComponent resets when a background child generation recovers', async () => {
218 const refresh = createControlledPromise<number>()
219 let loaderCalls = 0
220 const rootRoute = createRootRoute({
221 component: Outlet,
222 errorComponent: ({ error }) => (
223 <div>Ancestor error: {getErrorMessage(error)}</div>
224 ),
225 })
226 const childRoute = createRoute({
227 getParentRoute: () => rootRoute,
228 path: '/',
229 loader: {
230 staleReloadMode: 'background',
231 handler: () => (++loaderCalls === 1 ? 1 : refresh),
232 },
233 component: () => {
234 const revision = childRoute.useLoaderData()
235 if (revision() === 1) {
236 throw new Error('stale child render failed')
237 }
238 return <div>Recovered child revision {revision()}</div>
239 },
240 })
241 const router = createRouter({
242 routeTree: rootRoute.addChildren([childRoute]),
243 })
244 vi.spyOn(console, 'warn').mockImplementation(() => {})
245 vi.spyOn(console, 'error').mockImplementation(() => {})
246​
247 render(() => <RouterProvider router={router} />)
248 expect(
249 await screen.findByText('Ancestor error: stale child render failed'),
250 ).toBeInTheDocument()
251​
252 const invalidation = router.invalidate({
253 filter: (match) => match.routeId === childRoute.id,
254 })
255 onTestFinished(async () => {
256 refresh.resolve(2)
257 await Promise.allSettled([invalidation])
258 })
259​
260 await vi.waitFor(() => expect(loaderCalls).toBe(2))
261 expect(
262 screen.getByText('Ancestor error: stale child render failed'),
263 ).toBeInTheDocument()
264 refresh.resolve(2)
265 await invalidation
266​
267 expect(
268 await screen.findByText('Recovered child revision 2'),
269 ).toBeInTheDocument()
270})
271​
272test.each([
273 ['false', false],
274 ['zero', 0],
275 ['negative zero', -0],
276 ['bigint zero', 0n],
277 ['empty string', ''],
278 ['null', null],
279 ['undefined', undefined],
280 ['NaN', NaN],
281] as const)('CatchBoundary renders falsy thrown value %s', (_, thrown) => {
282 vi.spyOn(console, 'error').mockImplementation(() => {})
283 let caught: unknown
284​
285 function ThrowFalsy(): never {
286 throw thrown
287 }
288​
289 render(() => (
290 <CatchBoundary
291 getResetKey={() => 0}
292 errorComponent={({ error }) => (
293 <div>
294 {error instanceof Error && Object.is(error.cause, thrown)
295 ? 'Caught value'
296 : 'Wrong value'}
297 </div>
298 )}
299 onCatch={(error) => {
300 caught = error
301 }}
302 >
303 <ThrowFalsy />
304 </CatchBoundary>
305 ))
306​
307 expect(screen.getByText('Caught value')).toBeInTheDocument()
308 expect(screen.queryByText('Wrong value')).not.toBeInTheDocument()
309 expect(caught).toBeInstanceOf(Error)
310 expect(Object.is((caught as Error).cause, thrown)).toBe(true)
311})
312​
313test.each([
314 [new Error('Error message'), 'Error message'],
315 [new Error('Wrapped error', { cause: false }), 'Wrapped error'],
316 [new Error(''), undefined],
317])('default error details render %s', (error, expected) => {
318 const { container } = render(() => <ErrorComponent error={error} />)
319​
320 expect(screen.getByText('Something went wrong!')).toBeInTheDocument()
321 expect(container.querySelector('code')?.textContent).toBe(expected)
322})