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

renderRouterToStream.test.tsx

264 lines8.0 KB

1import { afterEach, describe, expect, onTestFinished, test, vi } from 'vitest'
2import { attachRouterServerSsrUtils } from '@tanstack/router-core/ssr/server'
3import { createMemoryHistory, createRootRoute, createRouter } from '../src'
4​
5const reactDomServerMocks = vi.hoisted(() => ({
6 renderToReadableStream: undefined as undefined | (() => unknown),
7 renderToPipeableStream: vi.fn(),
8}))
9​
10vi.mock('react-dom/server', () => ({
11 default: reactDomServerMocks,
12 ...reactDomServerMocks,
13}))
14​
15const { renderRouterToStream } = await import('../src/ssr/renderRouterToStream')
16​
17afterEach(() => {
18 reactDomServerMocks.renderToReadableStream = undefined
19 reactDomServerMocks.renderToPipeableStream.mockReset()
20 vi.restoreAllMocks()
21})
22​
23async function buildRouter() {
24 const rootRoute = createRootRoute({ component: () => null })
25 const router = createRouter({
26 history: createMemoryHistory({ initialEntries: ['/'] }),
27 routeTree: rootRoute,
28 })
29 router.isServer = true
30 attachRouterServerSsrUtils({ router, manifest: undefined })
31 await router.load()
32 await router.serverSsr!.dehydrate()
33 return router
35​
36async function expectBodyRejects(response: Response, message: string) {
37 const reader = response.body!.getReader()
38 await expect(
39 (async () => {
40 for (;;) {
41 const { done } = await reader.read()
42 if (done) return
43 }
44 })(),
45 ).rejects.toThrow(message)
47​
48function unwrapResponse(
49 result: Awaited<ReturnType<typeof renderRouterToStream>>,
50) {
51 return result.response
53​
54describe('renderRouterToStream - pipeable sync errors', () => {
55 test('request abort cancels readable rendering without consuming the response body', async () => {
56 const cancel = vi.fn()
57 const stream = Object.assign(new ReadableStream<Uint8Array>({ cancel }), {
58 allReady: Promise.resolve(),
59 })
60 reactDomServerMocks.renderToReadableStream = vi.fn(() => stream)
61​
62 const router = await buildRouter()
63 const controller = new AbortController()
64 onTestFinished(() => {
65 router.serverSsr?.cleanup()
66 })
67​
68 const response = unwrapResponse(
69 await renderRouterToStream({
70 request: new Request('http://localhost/', {
71 signal: controller.signal,
72 }),
73 router,
74 responseHeaders: new Headers(),
75 children: null,
76 }),
77 )
78​
79 expect(response.body).not.toBeNull()
80 controller.abort(new Error('request-gone'))
81 await vi.waitFor(() => expect(cancel).toHaveBeenCalledOnce())
82 })
83​
84 test('sync onError before pipeable is assigned still aborts pipeable', async () => {
85 const abort = vi.fn()
86 reactDomServerMocks.renderToPipeableStream.mockImplementationOnce(
87 (_children, opts) => {
88 opts.onError(new Error('sync-react-error'), { componentStack: '' })
89 return { abort, pipe: vi.fn() }
90 },
91 )
92​
93 const router = await buildRouter()
94 const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
95 try {
96 const response = unwrapResponse(
97 await renderRouterToStream({
98 request: new Request('http://localhost/'),
99 router,
100 responseHeaders: new Headers(),
101 children: null,
102 }),
103 )
104​
105 expect(abort).toHaveBeenCalledOnce()
106 await expectBodyRejects(response, 'sync-react-error')
107 } finally {
108 errorSpy.mockRestore()
109 router.serverSsr?.cleanup()
110 }
111 })
112​
113 test('sync non-Error onError before pipeable assignment still errors body', async () => {
114 const abort = vi.fn()
115 reactDomServerMocks.renderToPipeableStream.mockImplementationOnce(
116 (_children, opts) => {
117 opts.onError('string-react-error', { componentStack: '' })
118 return { abort, pipe: vi.fn() }
119 },
120 )
121​
122 const router = await buildRouter()
123 const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
124 try {
125 const response = unwrapResponse(
126 await renderRouterToStream({
127 request: new Request('http://localhost/'),
128 router,
129 responseHeaders: new Headers(),
130 children: null,
131 }),
132 )
133​
134 expect(abort).toHaveBeenCalledOnce()
135 await expectBodyRejects(response, 'string-react-error')
136 } finally {
137 errorSpy.mockRestore()
138 router.serverSsr?.cleanup()
139 }
140 })
141​
142 test('sync undefined onError before pipeable assignment still errors body', async () => {
143 const abort = vi.fn()
144 reactDomServerMocks.renderToPipeableStream.mockImplementationOnce(
145 (_children, opts) => {
146 opts.onError(undefined, { componentStack: '' })
147 return { abort, pipe: vi.fn() }
148 },
149 )
150​
151 const router = await buildRouter()
152 const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
153 try {
154 const response = unwrapResponse(
155 await renderRouterToStream({
156 request: new Request('http://localhost/'),
157 router,
158 responseHeaders: new Headers(),
159 children: null,
160 }),
161 )
162​
163 expect(abort).toHaveBeenCalledOnce()
164 await expectBodyRejects(response, 'SSR aborted')
165 } finally {
166 errorSpy.mockRestore()
167 router.serverSsr?.cleanup()
168 }
169 })
170​
171 test('undefined onError after response attach errors body', async () => {
172 const abort = vi.fn()
173 let onError!: (error: unknown, info: unknown) => void
174 reactDomServerMocks.renderToPipeableStream.mockImplementationOnce(
175 (_children, opts) => {
176 onError = opts.onError
177 return { abort, pipe: vi.fn() }
178 },
179 )
180​
181 const router = await buildRouter()
182 const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
183 try {
184 const response = unwrapResponse(
185 await renderRouterToStream({
186 request: new Request('http://localhost/'),
187 router,
188 responseHeaders: new Headers(),
189 children: null,
190 }),
191 )
192​
193 onError(undefined, { componentStack: '' })
194 expect(abort).toHaveBeenCalledOnce()
195 await expectBodyRejects(response, 'SSR aborted')
196 } finally {
197 errorSpy.mockRestore()
198 router.serverSsr?.cleanup()
199 }
200 })
201​
202 test('setup throw rejects instead of returning streamed 200', async () => {
203 const setupError = new Error('setup-boom')
204 reactDomServerMocks.renderToPipeableStream.mockImplementationOnce(() => {
205 throw setupError
206 })
207​
208 const router = await buildRouter()
209 const cleanup = vi.spyOn(router.serverSsr!, 'cleanup')
210 const originalServerSsr = router.serverSsr!
211 const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
212 try {
213 await expect(
214 renderRouterToStream({
215 request: new Request('http://localhost/'),
216 router,
217 responseHeaders: new Headers(),
218 children: null,
219 }),
220 ).rejects.toThrow('setup-boom')
221​
222 expect(cleanup).toHaveBeenCalledOnce()
223 } finally {
224 errorSpy.mockRestore()
225 originalServerSsr.cleanup()
226 }
227 })
228​
229 test('request abort cancels pipeable rendering before the response body is consumed', async () => {
230 const abort = vi.fn()
231 reactDomServerMocks.renderToPipeableStream.mockImplementationOnce(
232 (_children, opts) => {
233 queueMicrotask(() => opts.onShellReady())
234 return { abort, pipe: vi.fn() }
235 },
236 )
237​
238 const router = await buildRouter()
239 const controller = new AbortController()
240 try {
241 const response = unwrapResponse(
242 await renderRouterToStream({
243 request: new Request('http://localhost/', {
244 signal: controller.signal,
245 }),
246 router,
247 responseHeaders: new Headers(),
248 children: null,
249 }),
250 )
251​
252 expect(response.body).not.toBeNull()
253 controller.abort(new Error('request-gone'))
254 await vi.waitFor(() => expect(abort).toHaveBeenCalledOnce())
255 const terminated = await Promise.race<true | false>([
256 expectBodyRejects(response, 'request-gone').then(() => true),
257 new Promise<false>((resolve) => setTimeout(() => resolve(false), 2000)),
258 ])
259 expect(terminated).toBe(true)
260 } finally {
261 router.serverSsr?.cleanup()
262 }
263 })
264})