Open History to see the last commit
1import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest'
2import { act, cleanup, fireEvent, render, screen } from '@testing-library/react'
3β
4import {
5 CatchBoundary,
6 ErrorComponent,
7 HeadContent,
8 Link,
9 Outlet,
10 RouterProvider,
11 Scripts,
12 createBrowserHistory,
13 createControlledPromise,
14 createLazyRoute,
15 createMemoryHistory,
16 createRootRoute,
17 createRoute,
18 createRouter,
19 notFound,
20} from '../src'
21import {
22 RouterServer,
23 createRequestHandler,
24 renderRouterToString,
25} from '../src/ssr/server'
26import type { ErrorComponentProps, RouterHistory } from '../src'
27β
28function MyErrorComponent(props: ErrorComponentProps) {
29 return <div>Error: {getErrorMessage(props.error)}</div>
30}
31β
32function getErrorMessage(error: unknown) {
33 return error instanceof Error ? error.message : String(error)
34}
35β
36async function asyncToThrowFn() {
37 await new Promise((resolve) => setTimeout(resolve, 500))
38 throw new Error('error thrown')
39}
40β
41function throwFn() {
42 throw new Error('error thrown')
43}
44β
45function primitiveThrowFn() {
46 throw 'primitive error thrown'
47}
48β
49let history: RouterHistory
50β
51beforeEach(() => {
52 history = createBrowserHistory()
53 expect(window.location.pathname).toBe('/')
54})
55β
56afterEach(() => {
57 history.destroy()
58 vi.resetAllMocks()
59 window.history.replaceState(null, 'root', '/')
60 cleanup()
61})
62β
63describe.each([true, false])(
64 'with lazy errorComponent=%s',
65 (isUsingLazyError) => {
66 describe.each([{ preload: false }, { preload: 'intent' }] as const)(
67 'errorComponent is rendered when the preload=$preload',
68 (options) => {
69 describe.each([true, false])('with async=%s', (isAsync) => {
70 const throwableFn = isAsync ? asyncToThrowFn : throwFn
71β
72 const callers = [
73 { caller: 'beforeLoad', testFn: throwableFn },
74 { caller: 'loader', testFn: throwableFn },
75 ]
76β
77 test.each(callers)(
78 'an Error is thrown on navigate in the route $caller function',
79 async ({ caller, testFn }) => {
80 const rootRoute = createRootRoute()
81 const indexRoute = createRoute({
82 getParentRoute: () => rootRoute,
83 path: '/',
84 component: function Home() {
85 return (
86 <div>
87 <Link to="/about">link to about</Link>
88 </div>
89 )
90 },
91 })
92 const aboutRoute = createRoute({
93 getParentRoute: () => rootRoute,
94 path: '/about',
95 beforeLoad: caller === 'beforeLoad' ? testFn : undefined,
96 loader: caller === 'loader' ? testFn : undefined,
97 component: function Home() {
98 return <div>About route content</div>
99 },
100 errorComponent: isUsingLazyError ? undefined : MyErrorComponent,
101 })
102β
103 if (isUsingLazyError) {
104 aboutRoute.lazy(() =>
105 Promise.resolve(
106 createLazyRoute('/about')({
107 errorComponent: MyErrorComponent,
108 }),
109 ),
110 )
111 }
112β
113 const routeTree = rootRoute.addChildren([indexRoute, aboutRoute])
114β
115 const router = createRouter({
116 routeTree,
117 defaultPreload: options.preload,
118 history,
119 })
120β
121 render(<RouterProvider router={router} />)
122β
123 const linkToAbout = await screen.findByRole('link', {
124 name: 'link to about',
125 })
126β
127 expect(linkToAbout).toBeInTheDocument()
128 fireEvent.mouseOver(linkToAbout)
129 fireEvent.focus(linkToAbout)
130 fireEvent.click(linkToAbout)
131β
132 const errorComponent = await screen.findByText(
133 `Error: error thrown`,
134 undefined,
135 { timeout: 1500 },
136 )
137 await expect(
138 screen.findByText('About route content'),
139 ).rejects.toThrow()
140 expect(errorComponent).toBeInTheDocument()
141 },
142 )
143β
144 test.each(callers)(
145 'an Error is thrown on first load in the route $caller function',
146 async ({ caller, testFn }) => {
147 const rootRoute = createRootRoute()
148 const indexRoute = createRoute({
149 getParentRoute: () => rootRoute,
150 path: '/',
151 beforeLoad: caller === 'beforeLoad' ? testFn : undefined,
152 loader: caller === 'loader' ? testFn : undefined,
153 component: function Home() {
154 return <div>Index route content</div>
155 },
156 errorComponent: isUsingLazyError ? undefined : MyErrorComponent,
157 })
158β
159 if (isUsingLazyError) {
160 indexRoute.lazy(() =>
161 Promise.resolve(
162 createLazyRoute('/')({
163 errorComponent: MyErrorComponent,
164 }),
165 ),
166 )
167 }
168β
169 const routeTree = rootRoute.addChildren([indexRoute])
170β
171 const router = createRouter({
172 routeTree,
173 defaultPreload: options.preload,
174 history,
175 })
176β
177 render(<RouterProvider router={router} />)
178β
179 const errorComponent = await screen.findByText(
180 `Error: error thrown`,
181 undefined,
182 { timeout: 750 },
183 )
184 await expect(
185 screen.findByText('Index route content'),
186 ).rejects.toThrow()
187 expect(errorComponent).toBeInTheDocument()
188 },
189 )
190 })
191 },
192 )
193β
194 describe('stale route errors do not leak after navigation', () => {
195 test.each([
196 {
197 caller: 'loader' as const,
198 routeOptions: {
199 loader: throwFn,
200 },
201 },
202 {
203 caller: 'render' as const,
204 routeOptions: {
205 component: function RenderErrorComponent() {
206 throwFn()
207 },
208 },
209 },
210 ])(
211 'navigating away from a $caller error does not call the next route errorComponent',
212 async ({ routeOptions }) => {
213 const rootRoute = createRootRoute()
214 const indexErrorComponent = vi.fn(() => <div>Index error</div>)
215β
216 const indexRoute = createRoute({
217 getParentRoute: () => rootRoute,
218 path: '/',
219 component: function Home() {
220 return (
221 <div>
222 <div>Index route content</div>
223 <Link to="/about">link to about</Link>
224 </div>
225 )
226 },
227 errorComponent: indexErrorComponent,
228 })
229β
230 const aboutRoute = createRoute({
231 getParentRoute: () => rootRoute,
232 path: '/about',
233 component: function About() {
234 return <div>About route content</div>
235 },
236 errorComponent: isUsingLazyError ? undefined : MyErrorComponent,
237 ...routeOptions,
238 })
239β
240 if (isUsingLazyError) {
241 aboutRoute.lazy(() =>
242 Promise.resolve(
243 createLazyRoute('/about')({
244 errorComponent: MyErrorComponent,
245 }),
246 ),
247 )
248 }
249β
250 const routeTree = rootRoute.addChildren([indexRoute, aboutRoute])
251β
252 const router = createRouter({
253 routeTree,
254 history,
255 })
256β
257 render(<RouterProvider router={router} />)
258β
259 const linkToAbout = await screen.findByRole('link', {
260 name: 'link to about',
261 })
262β
263 await act(() => fireEvent.click(linkToAbout))
264β
265 expect(
266 await screen.findByText('Error: error thrown', undefined, {
267 timeout: 1500,
268 }),
269 ).toBeInTheDocument()
270β
271 await act(() => router.navigate({ to: '/' }))
272β
273 expect(
274 await screen.findByText('Index route content'),
275 ).toBeInTheDocument()
276 expect(indexErrorComponent).not.toHaveBeenCalled()
277 },
278 )
279 })
280 },
281)
282β
283test('global catch boundary resets when a background child generation recovers', async () => {
284 const refresh = createControlledPromise<number>()
285 let loaderCalls = 0
286 const rootRoute = createRootRoute({ component: Outlet })
287 const childRoute = createRoute({
288 getParentRoute: () => rootRoute,
289 path: '/',
290 loader: {
291 staleReloadMode: 'background',
292 handler: () => (++loaderCalls === 1 ? 1 : refresh),
293 },
294 component: () => {
295 const revision = childRoute.useLoaderData()
296 if (revision === 1) {
297 throw new Error('stale child render failed')
298 }
299 return <div>Recovered child revision {revision}</div>
300 },
301 })
302 const router = createRouter({
303 routeTree: rootRoute.addChildren([childRoute]),
304 history,
305 })
306 vi.spyOn(console, 'warn').mockImplementation(() => {})
307 vi.spyOn(console, 'error').mockImplementation(() => {})
308β
309 render(<RouterProvider router={router} />)
310 expect(
311 await screen.findByText('stale child render failed'),
312 ).toBeInTheDocument()
313β
314 const invalidation = router.invalidate()
315 await vi.waitFor(() => expect(loaderCalls).toBe(2))
316 expect(screen.getByText('stale child render failed')).toBeInTheDocument()
317 expect(screen.queryByText(/Recovered child revision/)).not.toBeInTheDocument()
318 refresh.resolve(2)
319 await invalidation
320β
321 expect(
322 await screen.findByText('Recovered child revision 2'),
323 ).toBeInTheDocument()
324 expect(
325 screen.queryByText('stale child render failed'),
326 ).not.toBeInTheDocument()
327})
328β
329test('ancestor route errorComponent resets when a background child generation recovers', async () => {
330 const refresh = createControlledPromise<number>()
331 let loaderCalls = 0
332 const rootRoute = createRootRoute({
333 component: Outlet,
334 errorComponent: ({ error }) => (
335 <div>Ancestor error: {getErrorMessage(error)}</div>
336 ),
337 })
338 const childRoute = createRoute({
339 getParentRoute: () => rootRoute,
340 path: '/',
341 loader: {
342 staleReloadMode: 'background',
343 handler: () => (++loaderCalls === 1 ? 1 : refresh),
344 },
345 component: () => {
346 const revision = childRoute.useLoaderData()
347 if (revision === 1) {
348 throw new Error('stale child render failed')
349 }
350 return <div>Recovered child revision {revision}</div>
351 },
352 })
353 const router = createRouter({
354 routeTree: rootRoute.addChildren([childRoute]),
355 history,
356 })
357 vi.spyOn(console, 'warn').mockImplementation(() => {})
358 vi.spyOn(console, 'error').mockImplementation(() => {})
359β
360 let invalidation: Promise<void> | undefined
361 try {
362 render(<RouterProvider router={router} />)
363 expect(
364 await screen.findByText('Ancestor error: stale child render failed'),
365 ).toBeInTheDocument()
366β
367 invalidation = router.invalidate({
368 filter: (match) => match.routeId === childRoute.id,
369 })
370 await vi.waitFor(() => expect(loaderCalls).toBe(2))
371 expect(
372 screen.getByText('Ancestor error: stale child render failed'),
373 ).toBeInTheDocument()
374 refresh.resolve(2)
375 await invalidation
376β
377 expect(
378 await screen.findByText('Recovered child revision 2'),
379 ).toBeInTheDocument()
380 } finally {
381 refresh.resolve(2)
382 if (invalidation) {
383 await Promise.allSettled([invalidation])
384 }
385 }
386})
387β
388test('errorComponent receives primitive errors thrown from beforeLoad', async () => {
389 const rootRoute = createRootRoute()
390 const indexRoute = createRoute({
391 getParentRoute: () => rootRoute,
392 path: '/',
393 component: function Home() {
394 return (
395 <div>
396 <Link to="/about">link to about</Link>
397 </div>
398 )
399 },
400 })
401 const aboutRoute = createRoute({
402 getParentRoute: () => rootRoute,
403 path: '/about',
404 beforeLoad: primitiveThrowFn,
405 component: function About() {
406 return <div>About route content</div>
407 },
408 errorComponent: ({ error }) => <div>Error: {String(error)}</div>,
409 })
410β
411 const routeTree = rootRoute.addChildren([indexRoute, aboutRoute])
412β
413 const router = createRouter({
414 routeTree,
415 history,
416 })
417β
418 render(<RouterProvider router={router} />)
419β
420 const linkToAbout = await screen.findByRole('link', {
421 name: 'link to about',
422 })
423β
424 await act(() => fireEvent.click(linkToAbout))
425β
426 expect(
427 await screen.findByText('Error: primitive error thrown', undefined, {
428 timeout: 750,
429 }),
430 ).toBeInTheDocument()
431 expect(screen.queryByText('About route content')).not.toBeInTheDocument()
432})
433β
434test.each([
435 ['false', false],
436 ['zero', 0],
437 ['negative zero', -0],
438 ['bigint zero', 0n],
439 ['empty string', ''],
440 ['null', null],
441 ['undefined', undefined],
442 ['NaN', NaN],
443] as const)('CatchBoundary renders falsy thrown value %s', (_, thrown) => {
444 vi.spyOn(console, 'error').mockImplementation(() => {})
445 const onCatch = vi.fn()
446β
447 function ThrowFalsy(): never {
448 throw thrown
449 }
450β
451 render(
452 <CatchBoundary
453 getResetKey={() => 0}
454 errorComponent={({ error }) => (
455 <div>{Object.is(error, thrown) ? 'Caught value' : 'Wrong value'}</div>
456 )}
457 onCatch={onCatch}
458 >
459 <ThrowFalsy />
460 </CatchBoundary>,
461 )
462β
463 expect(screen.getByText('Caught value')).toBeInTheDocument()
464 expect(screen.queryByText('Wrong value')).not.toBeInTheDocument()
465 expect(onCatch).toHaveBeenCalledWith(thrown, expect.anything())
466})
467β
468test.each([
469 ['null', null],
470 ['undefined', undefined],
471] as const)('default error UI renders thrown %s', async (_, thrown) => {
472 vi.spyOn(console, 'error').mockImplementation(() => {})
473 vi.spyOn(console, 'warn').mockImplementation(() => {})
474β
475 function ThrowFalsy(): never {
476 throw thrown
477 }
478β
479 const rootRoute = createRootRoute({ component: ThrowFalsy })
480 const router = createRouter({
481 routeTree: rootRoute,
482 history: createMemoryHistory({ initialEntries: ['/'] }),
483 })
484β
485 render(<RouterProvider router={router} />)
486β
487 expect(await screen.findByText('Something went wrong!')).toBeInTheDocument()
488})
489β
490test.each(['beforeLoad', 'loader'] as const)(
491 'a Promise synchronously thrown from %s renders the route error UI',
492 async (hook) => {
493 const thrown = Promise.resolve('not route data')
494 const rootRoute = createRootRoute()
495 const indexRoute = createRoute({
496 getParentRoute: () => rootRoute,
497 path: '/',
498 beforeLoad:
499 hook === 'beforeLoad'
500 ? () => {
501 throw thrown
502 }
503 : undefined,
504 loader:
505 hook === 'loader'
506 ? () => {
507 throw thrown
508 }
509 : undefined,
510 errorComponent: ({ error }) => (
511 <div>
512 {error instanceof Error && error.cause === thrown
513 ? 'Promise route error'
514 : 'Wrong route error'}
515 </div>
516 ),
517 })
518 const router = createRouter({
519 routeTree: rootRoute.addChildren([indexRoute]),
520 history: createMemoryHistory({ initialEntries: ['/'] }),
521 })
522β
523 render(<RouterProvider router={router} />)
524β
525 expect(await screen.findByText('Promise route error')).toBeInTheDocument()
526 expect(screen.queryByText('Wrong route error')).not.toBeInTheDocument()
527 },
528)
529β
530test('SSR errorComponent receives primitive errors thrown from beforeLoad', async () => {
531 const rootRoute = createRootRoute({
532 shellComponent: function RootDocument({ children }) {
533 return (
534 <html>
535 <body>
536 {children}
537 <Scripts />
538 </body>
539 </html>
540 )
541 },
542 component: function Root() {
543 return <Outlet />
544 },
545 })
546 const aboutRoute = createRoute({
547 getParentRoute: () => rootRoute,
548 path: '/about',
549 beforeLoad: primitiveThrowFn,
550 component: function About() {
551 return <div>About route content</div>
552 },
553 errorComponent: ({ error }) => <div>Error: {String(error)}</div>,
554 })
555β
556 const handler = createRequestHandler({
557 request: new Request('http://localhost/about'),
558 createRouter: () =>
559 createRouter({
560 routeTree: rootRoute.addChildren([aboutRoute]),
561 isServer: true,
562 }),
563 })
564β
565 const response = await handler(({ router, responseHeaders }) =>
566 renderRouterToString({
567 router,
568 responseHeaders,
569 children: <RouterServer router={router} />,
570 }),
571 )
572β
573 expect(response.status).toBe(500)
574 const html = await response.text()
575 expect(html).toContain('Error:')
576 expect(html).toContain('primitive error thrown')
577})
578β
579test('a later fresh ancestor loader failure owns the reachable boundary', async () => {
580 const parentStarted = createControlledPromise<void>()
581 const childStarted = createControlledPromise<void>()
582 const parentGate = createControlledPromise<void>()
583 const childGate = createControlledPromise<void>()
584 const childSettled = createControlledPromise<void>()
585 const rootRoute = createRootRoute({ component: Outlet })
586 const indexRoute = createRoute({
587 getParentRoute: () => rootRoute,
588 path: '/',
589 component: () => <div>Home</div>,
590 })
591 const parentRoute = createRoute({
592 getParentRoute: () => rootRoute,
593 path: '/parent',
594 component: Outlet,
595 loader: async () => {
596 parentStarted.resolve()
597 await parentGate
598 throw new Error('later parent failure')
599 },
600 errorComponent: () => <div>Parent error boundary</div>,
601 })
602 const childRoute = createRoute({
603 getParentRoute: () => parentRoute,
604 path: '/child',
605 loader: async () => {
606 childStarted.resolve()
607 await childGate
608 childSettled.resolve()
609 throw new Error('first child failure')
610 },
611 errorComponent: () => <div>Child error boundary</div>,
612 })
613 const router = createRouter({
614 routeTree: rootRoute.addChildren([
615 indexRoute,
616 parentRoute.addChildren([childRoute]),
617 ]),
618 history: createMemoryHistory({ initialEntries: ['/'] }),
619 })
620β
621 await router.load()
622 render(<RouterProvider router={router} />)
623β
624 let navigation!: Promise<void>
625 await act(async () => {
626 navigation = router.navigate({ to: '/parent/child' })
627 await Promise.all([parentStarted, childStarted])
628 })
629 await act(async () => {
630 childGate.resolve()
631 await childSettled
632 parentGate.resolve()
633 await navigation
634 })
635β
636 expect(screen.getByText('Parent error boundary')).toBeInTheDocument()
637 expect(screen.queryByText('Child error boundary')).not.toBeInTheDocument()
638})
639β
640test('a fresh ancestor failure waits for lazy options before rendering its error', async () => {
641 const parentStarted = createControlledPromise<void>()
642 const childStarted = createControlledPromise<void>()
643 const parentGate = createControlledPromise<void>()
644 const childGate = createControlledPromise<void>()
645 const childSettled = createControlledPromise<void>()
646 const lazyParentOptions = createLazyRoute('/parent')({
647 component: () => (
648 <>
649 <div>Lazy parent shell</div>
650 <Outlet />
651 </>
652 ),
653 })
654 const parentChunk = createControlledPromise<typeof lazyParentOptions>()
655 const rootRoute = createRootRoute({ component: Outlet })
656 const indexRoute = createRoute({
657 getParentRoute: () => rootRoute,
658 path: '/',
659 component: () => <div>Home</div>,
660 })
661 const parentRoute = createRoute({
662 getParentRoute: () => rootRoute,
663 path: '/parent',
664 loader: async () => {
665 parentStarted.resolve()
666 await parentGate
667 throw new Error('later parent failure')
668 },
669 errorComponent: () => <div>Parent error boundary</div>,
670 }).lazy(() => parentChunk)
671 const childRoute = createRoute({
672 getParentRoute: () => parentRoute,
673 path: '/child',
674 loader: async () => {
675 childStarted.resolve()
676 await childGate
677 childSettled.resolve()
678 throw new Error('first child failure')
679 },
680 errorComponent: () => <div>Child error boundary</div>,
681 })
682 const router = createRouter({
683 routeTree: rootRoute.addChildren([
684 indexRoute,
685 parentRoute.addChildren([childRoute]),
686 ]),
687 history: createMemoryHistory({ initialEntries: ['/'] }),
688 })
689β
690 await router.load()
691 render(<RouterProvider router={router} />)
692β
693 let navigation: Promise<void> | undefined
694 try {
695 await act(async () => {
696 navigation = router.navigate({ to: '/parent/child' })
697 await Promise.all([parentStarted, childStarted])
698 })
699 await act(async () => {
700 childGate.resolve()
701 await childSettled
702 parentGate.resolve()
703 await Promise.resolve()
704 })
705β
706 expect(parentChunk.status).toBe('pending')
707 expect(screen.getByText('Home')).toBeInTheDocument()
708 expect(screen.queryByText('Parent error boundary')).not.toBeInTheDocument()
709 expect(screen.queryByText('Child error boundary')).not.toBeInTheDocument()
710 expect(screen.queryByText('Lazy parent shell')).not.toBeInTheDocument()
711 } finally {
712 await act(async () => {
713 childGate.resolve()
714 parentGate.resolve()
715 parentChunk.resolve(lazyParentOptions)
716 await navigation
717 })
718 }
719β
720 expect(screen.getByText('Parent error boundary')).toBeInTheDocument()
721 expect(screen.queryByText('Lazy parent shell')).not.toBeInTheDocument()
722 expect(screen.queryByText('Child error boundary')).not.toBeInTheDocument()
723})
724β
725test('SSR renders a later fresh ancestor loader failure', async () => {
726 const parentStarted = createControlledPromise<void>()
727 const childStarted = createControlledPromise<void>()
728 const parentGate = createControlledPromise<void>()
729 const childGate = createControlledPromise<void>()
730 const childSettled = createControlledPromise<void>()
731 const rootRoute = createRootRoute({
732 shellComponent: function RootDocument({ children }) {
733 return (
734 <html>
735 <body>
736 {children}
737 <Scripts />
738 </body>
739 </html>
740 )
741 },
742 component: Outlet,
743 })
744 const parentRoute = createRoute({
745 getParentRoute: () => rootRoute,
746 path: '/parent',
747 component: Outlet,
748 loader: async () => {
749 parentStarted.resolve()
750 await parentGate
751 throw new Error('later parent failure')
752 },
753 errorComponent: () => <div>Parent error boundary</div>,
754 })
755 const childRoute = createRoute({
756 getParentRoute: () => parentRoute,
757 path: '/child',
758 loader: async () => {
759 childStarted.resolve()
760 await childGate
761 childSettled.resolve()
762 throw new Error('first child failure')
763 },
764 errorComponent: () => <div>Child error boundary</div>,
765 })
766 const handler = createRequestHandler({
767 request: new Request('http://localhost/parent/child'),
768 createRouter: () =>
769 createRouter({
770 routeTree: rootRoute.addChildren([
771 parentRoute.addChildren([childRoute]),
772 ]),
773 isServer: true,
774 }),
775 })
776β
777 const responsePromise = handler(({ router, responseHeaders }) =>
778 renderRouterToString({
779 router,
780 responseHeaders,
781 children: <RouterServer router={router} />,
782 }),
783 )
784 await Promise.all([parentStarted, childStarted])
785 childGate.resolve()
786 await childSettled
787 parentGate.resolve()
788 const response = await responsePromise
789 const html = await response.text()
790β
791 expect(response.status).toBe(500)
792 expect(html).toContain('Parent error boundary')
793 expect(html).not.toContain('Child error boundary')
794})
795β
796// https://github.com/TanStack/router/issues/4684
797test('#4684: SSR renders head content when beforeLoad throws', async () => {
798 const rootRoute = createRootRoute({
799 head: () => ({
800 links: [{ rel: 'stylesheet', href: '/global.css' }],
801 }),
802 shellComponent: function RootDocument({ children }) {
803 return (
804 <html>
805 <head>
806 <HeadContent />
807 </head>
808 <body>
809 {children}
810 <Scripts />
811 </body>
812 </html>
813 )
814 },
815 component: Outlet,
816 })
817 const failingRoute = createRoute({
818 getParentRoute: () => rootRoute,
819 path: '/fail',
820 beforeLoad: () => {
821 throw new Error('beforeLoad failed')
822 },
823 head: ({ match }) => ({
824 meta: [{ title: match.error ? 'Error title' : 'Success title' }],
825 }),
826 component: function FailingRoute() {
827 return <div>Route content</div>
828 },
829 errorComponent: ({ error }) => (
830 <div>Error UI: {getErrorMessage(error)}</div>
831 ),
832 })
833β
834 const handler = createRequestHandler({
835 request: new Request('http://localhost/fail'),
836 createRouter: () =>
837 createRouter({
838 routeTree: rootRoute.addChildren([failingRoute]),
839 isServer: true,
840 }),
841 })
842β
843 const response = await handler(({ router, responseHeaders }) =>
844 renderRouterToString({
845 router,
846 responseHeaders,
847 children: <RouterServer router={router} />,
848 }),
849 )
850β
851 expect(response.status).toBe(500)
852 const html = await response.text()
853 const serverDocument = new DOMParser().parseFromString(html, 'text/html')
854β
855 expect(serverDocument.body.textContent).toContain(
856 'Error UI: beforeLoad failed',
857 )
858 expect(serverDocument.head.querySelector('title')?.textContent).toBe(
859 'Error title',
860 )
861 expect(
862 serverDocument.head.querySelector(
863 'link[rel="stylesheet"][href="/global.css"]',
864 ),
865 ).not.toBeNull()
866})
867β
868describe('notFoundComponent is rendered when an error is thrown in params.parse', () => {
869 test('displays notFoundComponent when error is thrown in params.parse', async () => {
870 const history = createMemoryHistory({ initialEntries: ['/'] })
871 const rootLoader = vi.fn(async () => {
872 await new Promise((resolve) => setTimeout(resolve, 1))
873 return { ok: true }
874 })
875β
876 const rootRoute = createRootRoute({
877 component: function Root() {
878 return <Outlet />
879 },
880 notFoundComponent: function NotFound() {
881 return <div>No pizza</div>
882 },
883 pendingComponent: function Pending() {
884 return <div>Loading...</div>
885 },
886 loader: rootLoader,
887 shouldReload: true,
888 pendingMs: 0,
889 pendingMinMs: 100,
890 wrapInSuspense: true,
891 })
892β
893 const indexRoute = createRoute({
894 getParentRoute: () => rootRoute,
895 path: '/',
896 component: function Home() {
897 return (
898 <div>
899 <Link to="/pizza/rotten" preload="intent">
900 link to rotten pizza
901 </Link>
902 </div>
903 )
904 },
905 })
906β
907 const restaurantRoute = createRoute({
908 getParentRoute: () => rootRoute,
909 id: 'restaurant',
910 component: function Restaurant() {
911 return <Outlet />
912 },
913 })
914β
915 const pizzaRoute = createRoute({
916 getParentRoute: () => restaurantRoute,
917 path: '/pizza/$pizzaType',
918 component: function Pizza() {
919 return <div>Pizza</div>
920 },
921 params: {
922 parse: (p) => {
923 if (p.pizzaType === 'rotten') {
924 throw new Error('404 No rotten pizzas')
925 }
926 return { pizzaType: p.pizzaType }
927 },
928 stringify: (p) => ({ pizzaType: p.pizzaType }),
929 },
930 onError: () => {
931 throw notFound()
932 },
933 })
934β
935 const routeTree = rootRoute.addChildren([
936 indexRoute,
937 restaurantRoute.addChildren([pizzaRoute]),
938 ])
939β
940 const router = createRouter({
941 routeTree,
942 history,
943 })
944β
945 render(<RouterProvider router={router} />)
946β
947 const linkToRottenPizza = await screen.findByRole('link', {
948 name: 'link to rotten pizza',
949 })
950β
951 expect(rootLoader).toHaveBeenCalledTimes(1)
952 expect(linkToRottenPizza).toBeInTheDocument()
953 await act(() => fireEvent.mouseOver(linkToRottenPizza))
954 await act(() => fireEvent.click(linkToRottenPizza))
955β
956 const notFoundComponent = await screen.findByText('No pizza', undefined, {
957 timeout: 750,
958 })
959 expect(rootLoader).toHaveBeenCalledTimes(2)
960 expect(notFoundComponent).toBeInTheDocument()
961 })
962})
963β
964test.each([
965 [new Error('Error message'), 'Error message'],
966 [{ message: 'Serialized message' }, 'Serialized message'],
967 [{ message: 0 }, undefined],
968 ['Thrown string', undefined],
969 [false, undefined],
970 [0, undefined],
971 [0n, undefined],
972 ['', undefined],
973 [null, undefined],
974 [undefined, undefined],
975 [NaN, undefined],
976 [Symbol('error'), undefined],
977 [Object.create(null), undefined],
978])('default error details render %s', (error, expected) => {
979 const { container } = render(<ErrorComponent error={error} />)
980β
981 expect(screen.getByText('Something went wrong!')).toBeInTheDocument()
982 expect(container.querySelector('code')?.textContent).toBe(expected)
983})
984β
985test.each([false, 0, -0, 0n, '', null, undefined, NaN])(
986 'CatchBoundary resets after throwing %s',
987 (thrown) => {
988 vi.spyOn(console, 'error').mockImplementation(() => {})
989 let shouldThrow = true
990 let resetKey = 0
991 const onCatch = vi.fn()
992β
993 function Child() {
994 if (shouldThrow) {
995 throw thrown
996 }
997 return <div>Recovered child</div>
998 }
999β
1000 function App() {
1001 return (
1002 <CatchBoundary
1003 getResetKey={() => resetKey}
1004 onCatch={onCatch}
1005 errorComponent={({ reset }) => <button onClick={reset}>Reset</button>}
1006 >
1007 <Child />
1008 </CatchBoundary>
1009 )
1010 }
1011β
1012 const { rerender } = render(<App />)
1013 shouldThrow = false
1014 rerender(<App />)
1015 expect(screen.queryByText('Recovered child')).not.toBeInTheDocument()
1016 fireEvent.click(screen.getByText('Reset'))
1017 expect(screen.getByText('Recovered child')).toBeInTheDocument()
1018β
1019 shouldThrow = true
1020 rerender(<App />)
1021 shouldThrow = false
1022 resetKey++
1023 rerender(<App />)
1024 expect(screen.getByText('Recovered child')).toBeInTheDocument()
1025 expect(onCatch).toHaveBeenCalledTimes(2)
1026 },
1027)
1028β
1029test('CatchBoundary tracks reset keys while healthy', () => {
1030 vi.spyOn(console, 'error').mockImplementation(() => {})
1031 let resetKey: unknown
1032 let shouldThrow = false
1033β
1034 function Child() {
1035 if (shouldThrow) {
1036 throw null
1037 }
1038 return <div>Healthy child</div>
1039 }
1040β
1041 function App() {
1042 return (
1043 <CatchBoundary
1044 getResetKey={() => resetKey}
1045 errorComponent={() => <div>Caught error</div>}
1046 >
1047 <Child />
1048 </CatchBoundary>
1049 )
1050 }
1051β
1052 const { rerender } = render(<App />)
1053 expect(screen.getByText('Healthy child')).toBeInTheDocument()
1054β
1055 resetKey = {}
1056 rerender(<App />)
1057 expect(screen.getByText('Healthy child')).toBeInTheDocument()
1058β
1059 shouldThrow = true
1060 rerender(<App />)
1061 expect(screen.getByText('Caught error')).toBeInTheDocument()
1062β
1063 shouldThrow = false
1064 rerender(<App />)
1065 expect(screen.getByText('Caught error')).toBeInTheDocument()
1066β
1067 resetKey = undefined
1068 rerender(<App />)
1069 expect(screen.getByText('Healthy child')).toBeInTheDocument()
1070β
1071 shouldThrow = true
1072 rerender(<App />)
1073 expect(screen.getByText('Caught error')).toBeInTheDocument()
1074})