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