Open History to see the last commit
1import { afterEach, describe, expect, test, vi } from 'vitest'
2import { attachRouterServerSsrUtils } from '@tanstack/router-core/ssr/server'
3import { createMemoryHistory, createRootRoute, createRouter } from '../src'
4import type * as RouterSsrServer from '@tanstack/router-core/ssr/server'
5import type * as SolidWeb from 'solid-js/web'
6β
7const solidMocks = vi.hoisted(() => ({
8 renderToStream: vi.fn(),
9 pipeTo: vi.fn(),
10}))
11const routerTransformMocks = vi.hoisted(() => ({
12 readableOptions: vi.fn(),
13}))
14β
15vi.mock('@tanstack/router-core/ssr/server', async (importOriginal) => {
16 const actual = await importOriginal<typeof RouterSsrServer>()
17 return {
18 ...actual,
19 transformReadableStreamWithRouter: (
20 ...args: Parameters<typeof actual.transformReadableStreamWithRouter>
21 ) => {
22 routerTransformMocks.readableOptions(args[2])
23 return actual.transformReadableStreamWithRouter(...args)
24 },
25 }
26})
27β
28vi.mock('solid-js/web', async () => {
29 const actual = await vi.importActual<typeof SolidWeb>('solid-js/web')
30 return {
31 ...actual,
32 renderToStream: solidMocks.renderToStream,
33 }
34})
35β
36// Imported after mock so the wrapper picks up the mocked binding.
37const { renderRouterToStream } = await import('../src/ssr/renderRouterToStream')
38β
39function unwrapResponse(
40 result: Awaited<ReturnType<typeof renderRouterToStream>>,
41) {
42 return result.response
43}
44β
45afterEach(() => {
46 solidMocks.renderToStream.mockReset()
47 solidMocks.pipeTo.mockReset()
48 routerTransformMocks.readableOptions.mockReset()
49 vi.restoreAllMocks()
50})
51β
52async function buildRouter() {
53 const rootRoute = createRootRoute({
54 component: () => null,
55 })
56 const router = createRouter({
57 history: createMemoryHistory({ initialEntries: ['/'] }),
58 routeTree: rootRoute,
59 })
60 router.isServer = true
61 attachRouterServerSsrUtils({ router, manifest: undefined })
62 await router.load()
63 return router
64}
65β
66function drainBody(response: Response) {
67 const reader = response.body!.getReader()
68 return (async () => {
69 for (;;) {
70 const { done } = await reader.read()
71 if (done) {
72 return true
73 }
74 }
75 })().catch(() => true)
76}
77β
78describe('renderRouterToStream', () => {
79 test('already-aborted requests do not start the Solid producer', async () => {
80 const abortController = new AbortController()
81 abortController.abort(new Error('already-gone'))
82 const router = await buildRouter()
83β
84 await expect(
85 renderRouterToStream({
86 request: new Request('http://localhost/', {
87 signal: abortController.signal,
88 }),
89 router,
90 responseHeaders: new Headers(),
91 children: () => null,
92 }),
93 ).rejects.toThrow('already-gone')
94β
95 expect(solidMocks.renderToStream).not.toHaveBeenCalled()
96 expect(router.serverSsr).toBeUndefined()
97 })
98β
99 test('request abort during bot wait terminates before piping starts', async () => {
100 const neverReady = new Promise<void>(() => {})
101 solidMocks.renderToStream.mockImplementationOnce(
102 () =>
103 ({
104 then: neverReady.then.bind(neverReady),
105 pipeTo: solidMocks.pipeTo,
106 }) as any,
107 )
108β
109 const router = await buildRouter()
110 const abortController = new AbortController()
111 const reason = new Error('client-gone')
112 try {
113 const responsePromise = renderRouterToStream({
114 request: new Request('http://localhost/', {
115 headers: { 'User-Agent': 'Googlebot' },
116 signal: abortController.signal,
117 }),
118 router,
119 responseHeaders: new Headers(),
120 children: () => null,
121 })
122β
123 await Promise.resolve()
124 abortController.abort(reason)
125β
126 await expect(responsePromise).rejects.toBe(reason)
127 expect(solidMocks.pipeTo).not.toHaveBeenCalled()
128 expect(router.serverSsr).toBeUndefined()
129 } finally {
130 router.serverSsr?.cleanup()
131 }
132 })
133β
134 test.each(['lifetime expiry', 'external cleanup'] as const)(
135 '%s rejects the bot wait and prevents late piping',
136 async (termination) => {
137 let resolveReady!: () => void
138 const ready = new Promise<void>((resolve) => {
139 resolveReady = resolve
140 })
141 solidMocks.renderToStream.mockImplementationOnce(
142 () =>
143 ({
144 then: ready.then.bind(ready),
145 pipeTo: solidMocks.pipeTo,
146 }) as any,
147 )
148 const router = await buildRouter()
149 const owner = router.serverSsr!
150 const cleanup = vi.fn()
151 owner.onCleanup(cleanup)
152 const request = new Request('http://localhost/', {
153 headers: { 'User-Agent': 'Googlebot' },
154 })
155 const resolved = vi.fn()
156 const rejected = vi.fn()
157 const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
158 vi.useFakeTimers()
159 const pending = renderRouterToStream({
160 request,
161 router,
162 responseHeaders: new Headers(),
163 children: () => null,
164 }).then(resolved, rejected)
165β
166 try {
167 await Promise.resolve()
168 expect(rejected).not.toHaveBeenCalled()
169 if (termination === 'lifetime expiry') {
170 await vi.advanceTimersByTimeAsync(120_000)
171 } else {
172 owner.cleanup()
173 await vi.advanceTimersByTimeAsync(0)
174 }
175β
176 expect(rejected).toHaveBeenCalledExactlyOnceWith(
177 expect.objectContaining({
178 message:
179 termination === 'lifetime expiry'
180 ? 'Stream lifetime exceeded'
181 : 'SSR stream transform aborted by router SSR cleanup',
182 }),
183 )
184 expect(request.signal.aborted).toBe(false)
185 expect(cleanup).toHaveBeenCalledOnce()
186 expect(router.serverSsr).toBeUndefined()
187 expect(solidMocks.pipeTo).not.toHaveBeenCalled()
188β
189 resolveReady()
190 await vi.advanceTimersByTimeAsync(0)
191 expect(resolved).not.toHaveBeenCalled()
192 expect(solidMocks.pipeTo).not.toHaveBeenCalled()
193 } finally {
194 resolveReady()
195 await pending
196 owner.cleanup()
197 vi.useRealTimers()
198 warn.mockRestore()
199 }
200 },
201 )
202β
203 test('bots wait for renderer readiness before piping', async () => {
204 let resolveReady!: () => void
205 const ready = new Promise<void>((resolve) => {
206 resolveReady = resolve
207 })
208 solidMocks.renderToStream.mockImplementationOnce(
209 () =>
210 ({
211 then: ready.then.bind(ready),
212 pipeTo: solidMocks.pipeTo.mockImplementation(
213 () => new Promise<void>(() => {}),
214 ),
215 }) as any,
216 )
217 const router = await buildRouter()
218 try {
219 let settled = false
220 const responsePromise = renderRouterToStream({
221 request: new Request('http://localhost/', {
222 headers: { 'User-Agent': 'Googlebot' },
223 }),
224 router,
225 responseHeaders: new Headers(),
226 children: () => null,
227 }).then((result) => {
228 settled = true
229 return result
230 })
231β
232 await Promise.resolve()
233 expect(settled).toBe(false)
234 expect(solidMocks.pipeTo).not.toHaveBeenCalled()
235β
236 resolveReady()
237 const result = await responsePromise
238 expect(unwrapResponse(result)).toBeInstanceOf(Response)
239 expect(solidMocks.pipeTo).toHaveBeenCalledOnce()
240 } finally {
241 router.serverSsr?.cleanup()
242 }
243 })
244β
245 test('bot response does not wait for a backpressured pipe', async () => {
246 const html = new TextEncoder().encode(
247 '<!DOCTYPE html><html><body>solid</body></html>',
248 )
249 let pipeCompletion: Promise<void> | undefined
250 solidMocks.renderToStream.mockImplementationOnce(
251 () =>
252 ({
253 then(resolve: () => void) {
254 resolve()
255 },
256 pipeTo(writable: WritableStream<Uint8Array>) {
257 const writer = writable.getWriter()
258 pipeCompletion = writer.write(html).then(() => writer.close())
259 return pipeCompletion
260 },
261 }) as any,
262 )
263β
264 const router = await buildRouter()
265 router.serverSsr!.disableHydration()
266 try {
267 const result = await renderRouterToStream({
268 request: new Request('http://localhost/', {
269 headers: { 'User-Agent': 'Googlebot' },
270 }),
271 router,
272 responseHeaders: new Headers(),
273 children: () => null,
274 })
275β
276 expect(pipeCompletion).toBeDefined()
277 const response = unwrapResponse(result)
278 await expect(response.text()).resolves.toBe(
279 new TextDecoder().decode(html),
280 )
281 await expect(pipeCompletion).resolves.toBeUndefined()
282 } finally {
283 router.serverSsr?.cleanup()
284 }
285 })
286β
287 test.each([
288 ['ordinary', new Error('solid-pipe-failed')],
289 [
290 'named AbortError',
291 Object.assign(new Error('solid-pipe-aborted'), { name: 'AbortError' }),
292 ],
293 ] as const)(
294 '%s pipeTo rejection logs, aborts the writer, and terminates the response',
295 async (_kind, pipeError) => {
296 solidMocks.renderToStream.mockImplementationOnce(
297 () =>
298 ({
299 pipeTo: () => Promise.reject(pipeError),
300 }) as any,
301 )
302β
303 const router = await buildRouter()
304 const request = new Request('http://localhost/')
305 const addEventListener = vi.spyOn(request.signal, 'addEventListener')
306 const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
307 try {
308 const response = unwrapResponse(
309 await renderRouterToStream({
310 request,
311 router,
312 responseHeaders: new Headers(),
313 children: () => null,
314 }),
315 )
316 expect(routerTransformMocks.readableOptions).toHaveBeenCalledWith(
317 expect.objectContaining({ rendererSafePoint: 'record-end' }),
318 )
319 expect(
320 addEventListener.mock.calls.filter(([type]) => type === 'abort'),
321 ).toHaveLength(1)
322β
323 expect(await drainBody(response)).toBe(true)
324 expect(errorSpy).toHaveBeenCalledWith(
325 'Error in Solid render stream:',
326 pipeError,
327 )
328 } finally {
329 errorSpy.mockRestore()
330 router.serverSsr?.cleanup()
331 }
332 },
333 )
334β
335 test('async pipe failure cleans an unread response immediately', async () => {
336 let rejectPipe!: (reason: unknown) => void
337 const pipeCompletion = new Promise<void>((_resolve, reject) => {
338 rejectPipe = reject
339 })
340 solidMocks.renderToStream.mockImplementationOnce(
341 () => ({ pipeTo: () => pipeCompletion }) as any,
342 )
343 const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
344 const router = await buildRouter()
345 try {
346 const result = await renderRouterToStream({
347 request: new Request('http://localhost/'),
348 router,
349 responseHeaders: new Headers(),
350 children: () => null,
351 })
352 expect(unwrapResponse(result).body).not.toBeNull()
353β
354 rejectPipe(new Error('solid-pipe-failed-unread'))
355 await vi.waitFor(() => expect(router.serverSsr).toBeUndefined())
356 } finally {
357 errorSpy.mockRestore()
358 router.serverSsr?.cleanup()
359 }
360 })
361β
362 test('request abort after attachment stops outgoing Solid writes', async () => {
363 let outboundWriter!: WritableStreamDefaultWriter<Uint8Array>
364 solidMocks.pipeTo.mockImplementationOnce(
365 (writable: WritableStream<Uint8Array>) => {
366 outboundWriter = writable.getWriter()
367 return new Promise<void>(() => {})
368 },
369 )
370 solidMocks.renderToStream.mockImplementationOnce(
371 () => ({ pipeTo: solidMocks.pipeTo }) as any,
372 )
373β
374 const router = await buildRouter()
375 const abortController = new AbortController()
376 const request = new Request('http://localhost/', {
377 signal: abortController.signal,
378 })
379 const addEventListener = vi.spyOn(request.signal, 'addEventListener')
380 try {
381 const response = unwrapResponse(
382 await renderRouterToStream({
383 request,
384 router,
385 responseHeaders: new Headers(),
386 children: () => null,
387 }),
388 )
389β
390 expect(solidMocks.pipeTo).toHaveBeenCalledOnce()
391 expect(
392 addEventListener.mock.calls.filter(([type]) => type === 'abort'),
393 ).toHaveLength(1)
394 abortController.abort(new Error('solid-request-gone'))
395β
396 await expect(
397 outboundWriter.write(new TextEncoder().encode('late Solid chunk')),
398 ).rejects.toBeDefined()
399β
400 expect(await drainBody(response)).toBe(true)
401 } finally {
402 router.serverSsr?.cleanup()
403 }
404 })
405β
406 test('request abort during renderer setup is caught before transform attachment', async () => {
407 const abortController = new AbortController()
408 solidMocks.renderToStream.mockImplementationOnce(() => {
409 abortController.abort(new Error('solid-setup-request-gone'))
410 return { pipeTo: solidMocks.pipeTo } as any
411 })
412β
413 const router = await buildRouter()
414 try {
415 await expect(
416 renderRouterToStream({
417 request: new Request('http://localhost/', {
418 signal: abortController.signal,
419 }),
420 router,
421 responseHeaders: new Headers(),
422 children: () => null,
423 }),
424 ).rejects.toThrow('solid-setup-request-gone')
425β
426 expect(solidMocks.pipeTo).not.toHaveBeenCalled()
427 expect(router.serverSsr).toBeUndefined()
428 } finally {
429 router.serverSsr?.cleanup()
430 }
431 })
432})