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

errorComponent.test.tsx

230 lines7.2 KB

1import { Suspense, onCleanup } from 'solid-js'
2import { describe, expect, it, vi } from 'vitest'
3import {
4 Await,
5 createRootRoute,
6 createRoute,
7 createRouter,
8 lazyRouteComponent,
9} from '../../src'
10import {
11 RouterServer,
12 createRequestHandler,
13 renderRouterToStream,
14 renderRouterToString,
15} from '../../src/ssr/server'
16import type { AnyRouter } from '@tanstack/router-core'
17​
18function createLazyErrorComponent() {
19 return lazyRouteComponent(
20 () =>
21 Promise.resolve({
22 ErrorComponent: ({ error }: { error: Error }) => (
23 <div data-testid="error-component">Route error: {error.message}</div>
24 ),
25 }),
26 'ErrorComponent',
27 )
29​
30describe('errorComponent (server)', () => {
31 it('cleans up components and router state after a synchronous string-render error', async () => {
32 vi.useFakeTimers()
33 const consoleError = vi
34 .spyOn(console, 'error')
35 .mockImplementation(() => undefined)
36​
37 try {
38 const rootRoute = createRootRoute()
39 const handler = createRequestHandler({
40 request: new Request('http://localhost/'),
41 createRouter: () =>
42 createRouter({ routeTree: rootRoute, isServer: true }),
43 })
44 let requestRouter: AnyRouter | undefined
45 const componentCleanup = vi.fn()
46​
47 const response = await handler(({ router, responseHeaders }) => {
48 requestRouter = router
49 return renderRouterToString({
50 router,
51 responseHeaders,
52 children: () => {
53 onCleanup(componentCleanup)
54 throw new Error('render boom')
55 },
56 })
57 })
58​
59 expect(response.status).toBe(500)
60 expect(requestRouter?.serverSsr).toBeUndefined()
61 // Solid's synchronous renderer schedules disposal for the next task.
62 await vi.runOnlyPendingTimersAsync()
63 expect(componentCleanup).toHaveBeenCalledOnce()
64 expect(vi.getTimerCount()).toBe(0)
65 } finally {
66 consoleError.mockRestore()
67 vi.clearAllTimers()
68 vi.useRealTimers()
69 }
70 })
71​
72 it.each([
73 ['Error', new Error('loader boom')],
74 ['Error with cause', new Error('loader boom', { cause: false })],
75 ['string', 'loader boom'],
76 ['empty string', ''],
77 ['false', false],
78 ['zero', 0],
79 ['negative zero', -0],
80 ['bigint zero', 0n],
81 ['null', null],
82 ['undefined', undefined],
83 ['NaN', NaN],
84 ['object', { message: 'loader boom' }],
85 ])(
86 'normalizes a thrown %s for the SSR error component',
87 async (_, thrown) => {
88 const onError = vi.fn()
89 let renderedError: Error | undefined
90 const rootRoute = createRootRoute()
91​
92 const indexRoute = createRoute({
93 getParentRoute: () => rootRoute,
94 path: '/',
95 loader: () => {
96 throw thrown
97 },
98 component: () => <div>Index route</div>,
99 onError,
100 errorComponent: ({ error }) => {
101 renderedError = error
102 return (
103 <div data-testid="error-component">
104 Route error: {error.message}
105 </div>
106 )
107 },
108 })
109​
110 const routeTree = rootRoute.addChildren([indexRoute])
111 const handler = createRequestHandler({
112 request: new Request('http://localhost/'),
113 createRouter: () => createRouter({ routeTree, isServer: true }),
114 })
115​
116 const response = await handler(async ({ router, responseHeaders }) => {
117 const result = await renderRouterToString({
118 router,
119 responseHeaders,
120 children: () => <RouterServer router={router} />,
121 })
122 const match = router.stores.matches
123 .get()
124 .find((match) => match.routeId === indexRoute.id)
125 expect(match?.status).toBe('error')
126 expect(match?.error).toBe(thrown)
127 return result
128 })
129​
130 expect(response.status).toBe(500)
131 const html = await response.text()
132 expect(html).toContain('data-testid="error-component"')
133 expect(renderedError).toBeInstanceOf(Error)
134 if (thrown instanceof Error) {
135 expect(renderedError).toBe(thrown)
136 } else {
137 expect(renderedError?.message).toBe(
138 typeof thrown === 'string' ? thrown : 'Unknown error',
139 )
140 expect(renderedError?.cause).toBe(thrown)
141 }
142 expect(onError).toHaveBeenCalledWith(thrown)
143 expect(html).not.toContain('Index route')
144 },
145 )
146​
147 it.each(['string', 'stream'] as const)(
148 'handles a lazy error component during %s rendering',
149 async (mode) => {
150 const rootRoute = createRootRoute()
151 const indexRoute = createRoute({
152 getParentRoute: () => rootRoute,
153 path: '/',
154 component: () => {
155 throw new Error('render boom')
156 },
157 errorComponent: createLazyErrorComponent(),
158 })
159 const routeTree = rootRoute.addChildren([indexRoute])
160 const request = new Request('http://localhost/')
161 const handler = createRequestHandler({
162 request,
163 createRouter: () => createRouter({ routeTree, isServer: true }),
164 })
165​
166 const response = await handler(({ router, responseHeaders }) => {
167 const children = () => <RouterServer router={router} />
168 return mode === 'stream'
169 ? renderRouterToStream({ request, router, responseHeaders, children })
170 : renderRouterToString({ router, responseHeaders, children })
171 })
172 const html = await response.text()
173​
174 if (mode === 'stream') {
175 expect(html).toContain('data-testid="error-component"')
176 expect(html).toContain('render boom')
177 } else {
178 // The error boundary's Suspense fallback is blank during string rendering.
179 expect(html.startsWith('<!DOCTYPE html>')).toBe(true)
180 expect(html).not.toContain('data-testid="error-component"')
181 }
182 },
183 )
184​
185 it('renders the route error component when a streamed Await rejects', async () => {
186 let rejectDeferred!: (error: Error) => void
187 const deferred = new Promise<string>((_resolve, reject) => {
188 rejectDeferred = reject
189 })
190 const rootRoute = createRootRoute()
191 const indexRoute = createRoute({
192 getParentRoute: () => rootRoute,
193 path: '/',
194 loader: () => ({ deferred }),
195 component: () => {
196 const data = indexRoute.useLoaderData()
197 return (
198 <Suspense fallback={<span>pending</span>}>
199 <Await promise={data().deferred}>
200 {() => <span>resolved</span>}
201 </Await>
202 </Suspense>
203 )
204 },
205 errorComponent: createLazyErrorComponent(),
206 })
207 const routeTree = rootRoute.addChildren([indexRoute])
208 const request = new Request('http://localhost/')
209 const handler = createRequestHandler({
210 request,
211 createRouter: () => createRouter({ routeTree, isServer: true }),
212 })
213 const response = await handler(({ router, responseHeaders }) =>
214 renderRouterToStream({
215 request,
216 router,
217 responseHeaders,
218 children: () => <RouterServer router={router} />,
219 }),
220 )
221 const htmlPromise = response.text()
222​
223 rejectDeferred(new Error('deferred boom'))
224 const html = await htmlPromise
225​
226 expect(html).toContain('data-testid="error-component"')
227 expect(html).toContain('deferred boom')
228 expect(html).not.toContain('pending')
229 })
230})