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

renderRouterToStream.test.tsx

895 lines28.1 KB

1import { afterEach, describe, expect, test, vi } from 'vitest'
2import { attachRouterServerSsrUtils } from '@tanstack/router-core/ssr/server'
3import { createMemoryHistory, createRootRoute, createRouter } from '../src'
4import type { RouterManagedTag } from '@tanstack/router-core'
5import type * as RouterSsrServer from '@tanstack/router-core/ssr/server'
6import type * as ReactDomServer from 'react-dom/server'
7​
8type ReadableRenderOptions = NonNullable<
9 Parameters<typeof ReactDomServer.renderToReadableStream>[1]
11​
12const reactDomServerMocks = vi.hoisted(() => ({
13 renderToReadableStream: undefined as
14 | undefined
15 | ((children: unknown, options: ReadableRenderOptions) => unknown),
16 renderToPipeableStream: vi.fn(),
17}))
18const routerTransformMocks = vi.hoisted(() => ({
19 readableOptions: vi.fn(),
20}))
21​
22vi.mock('@tanstack/router-core/ssr/server', async (importOriginal) => {
23 const actual = await importOriginal<typeof RouterSsrServer>()
24 return {
25 ...actual,
26 transformReadableStreamWithRouter: (
27 ...args: Parameters<typeof actual.transformReadableStreamWithRouter>
28 ) => {
29 routerTransformMocks.readableOptions(args[2])
30 return actual.transformReadableStreamWithRouter(...args)
31 },
32 }
33})
34​
35vi.mock('react-dom/server', () => ({
36 default: reactDomServerMocks,
37 ...reactDomServerMocks,
38}))
39​
40const actualReactDomServer = await vi.importActual<typeof ReactDomServer>(
41 'react-dom/server.node',
43​
44const { renderRouterToStream } = await import('../src/ssr/renderRouterToStream')
45​
46afterEach(() => {
47 reactDomServerMocks.renderToReadableStream = undefined
48 reactDomServerMocks.renderToPipeableStream.mockReset()
49 routerTransformMocks.readableOptions.mockReset()
50 vi.restoreAllMocks()
51})
52​
53async function buildRouter(dehydratedData?: { lateData: Promise<string> }) {
54 const rootRoute = createRootRoute({ component: () => null })
55 const router = createRouter({
56 history: createMemoryHistory({ initialEntries: ['/'] }),
57 routeTree: rootRoute,
58 ...(dehydratedData === undefined
59 ? {}
60 : { dehydrate: () => dehydratedData }),
61 })
62 router.isServer = true
63 attachRouterServerSsrUtils({ router, manifest: undefined })
64 await router.load()
65 await router.serverSsr!.dehydrate()
66 return router
68​
69async function expectBodyRejects(response: Response, message: string) {
70 await expect(response.text()).rejects.toThrow(message)
72​
73function unwrapResponse(
74 result: Awaited<ReturnType<typeof renderRouterToStream>>,
75) {
76 return result.response
78​
79function renderScript(tag: RouterManagedTag) {
80 const attrs = tag.attrs ?? {}
81 const id = attrs.id ? ` id="${attrs.id}"` : ''
82 const nonce = attrs.nonce ? ` nonce="${attrs.nonce}"` : ''
83 const streamPart =
84 'data-tsr-stream-part' in attrs ? ' data-tsr-stream-part=""' : ''
85 return `<script${id}${nonce}${streamPart}>${tag.children ?? ''}</script>`
87​
88function takeInitialScriptHtml(
89 router: Awaited<ReturnType<typeof buildRouter>>,
90) {
91 const scripts = router.serverSsr!.takeInitialHydrationScriptTags()!
92 return [...scripts.before, scripts.boundary].map(renderScript).join('')
94​
95async function readWithTimeout(
96 reader: ReadableStreamDefaultReader<Uint8Array>,
97) {
98 let timeout: ReturnType<typeof setTimeout> | undefined
99 try {
100 return await Promise.race([
101 reader.read(),
102 new Promise<never>((_resolve, reject) => {
103 timeout = setTimeout(
104 () => reject(new Error('Timed out waiting for streamed HTML')),
105 2000,
106 )
107 }),
108 ])
109 } finally {
110 if (timeout) {
111 clearTimeout(timeout)
112 }
113 }
115​
116async function readUntil(
117 reader: ReadableStreamDefaultReader<Uint8Array>,
118 decoder: TextDecoder,
119 state: { html: string },
120 needle: string,
121) {
122 while (!state.html.includes(needle)) {
123 const { done, value } = await readWithTimeout(reader)
124 if (done) {
125 throw new Error(`Response ended before it contained ${needle}`)
126 }
127 state.html += decoder.decode(value, { stream: true })
128 }
130​
131describe('renderRouterToStream - renderer selection and pipeable errors', () => {
132 test('already-aborted requests do not start the readable renderer', async () => {
133 const readable = vi.fn()
134 reactDomServerMocks.renderToReadableStream = readable
135 const controller = new AbortController()
136 controller.abort(new Error('already-gone-readable'))
137 const router = await buildRouter()
138​
139 try {
140 await expect(
141 renderRouterToStream({
142 request: new Request('http://localhost/', {
143 signal: controller.signal,
144 }),
145 router,
146 responseHeaders: new Headers(),
147 children: null,
148 }),
149 ).rejects.toThrow('already-gone-readable')
150​
151 expect(readable).not.toHaveBeenCalled()
152 expect(reactDomServerMocks.renderToPipeableStream).not.toHaveBeenCalled()
153 expect(router.serverSsr).toBeUndefined()
154 } finally {
155 router.serverSsr?.cleanup()
156 }
157 })
158​
159 test('already-aborted requests do not start the pipeable renderer', async () => {
160 const controller = new AbortController()
161 controller.abort(new Error('already-gone-pipeable'))
162 const router = await buildRouter()
163​
164 try {
165 await expect(
166 renderRouterToStream({
167 request: new Request('http://localhost/', {
168 signal: controller.signal,
169 }),
170 router,
171 responseHeaders: new Headers(),
172 children: null,
173 }),
174 ).rejects.toThrow('already-gone-pipeable')
175​
176 expect(reactDomServerMocks.renderToPipeableStream).not.toHaveBeenCalled()
177 expect(router.serverSsr).toBeUndefined()
178 } finally {
179 router.serverSsr?.cleanup()
180 }
181 })
182​
183 test('disables React progressive chunking for the readable renderer', async () => {
184 const router = await buildRouter()
185 const renderedScripts = takeInitialScriptHtml(router)
186 const rendererStream = Object.assign(
187 new ReadableStream<Uint8Array>({
188 start(controller) {
189 controller.enqueue(new TextEncoder().encode(renderedScripts))
190 controller.close()
191 },
192 }),
193 { allReady: Promise.resolve() },
194 )
195 const renderToReadableStream = vi.fn(() => Promise.resolve(rendererStream))
196 reactDomServerMocks.renderToReadableStream = renderToReadableStream
197​
198 try {
199 const response = unwrapResponse(
200 await renderRouterToStream({
201 request: new Request('http://localhost/'),
202 router,
203 responseHeaders: new Headers(),
204 children: null,
205 }),
206 )
207 await response.text()
208​
209 expect(renderToReadableStream).toHaveBeenCalledWith(
210 null,
211 expect.objectContaining({
212 progressiveChunkSize: Number.POSITIVE_INFINITY,
213 }),
214 )
215 } finally {
216 router.serverSsr?.cleanup()
217 }
218 })
219​
220 test('disables React progressive chunking for the pipeable renderer', async () => {
221 const router = await buildRouter()
222 const renderedScripts = takeInitialScriptHtml(router)
223 reactDomServerMocks.renderToPipeableStream.mockImplementationOnce(
224 (_children, options) => {
225 queueMicrotask(options.onShellReady)
226 return {
227 abort: vi.fn(),
228 pipe(destination: NodeJS.WritableStream) {
229 destination.write(renderedScripts)
230 destination.end()
231 },
232 }
233 },
234 )
235​
236 try {
237 const response = unwrapResponse(
238 await renderRouterToStream({
239 request: new Request('http://localhost/'),
240 router,
241 responseHeaders: new Headers(),
242 children: null,
243 }),
244 )
245 await response.text()
246​
247 expect(
248 reactDomServerMocks.renderToPipeableStream.mock.calls[0]![1],
249 ).toEqual(
250 expect.objectContaining({
251 progressiveChunkSize: Number.POSITIVE_INFINITY,
252 }),
253 )
254 } finally {
255 router.serverSsr?.cleanup()
256 }
257 })
258​
259 test('emits late router data after a complete React patch while rendering is still open', async () => {
260 let resolveLateData!: (value: string) => void
261 const lateData = new Promise<string>((resolve) => {
262 resolveLateData = resolve
263 })
264 const router = await buildRouter({ lateData })
265 const renderedScripts = takeInitialScriptHtml(router)
266​
267 let rendererController!: ReadableStreamDefaultController<Uint8Array>
268 let rendererClosed = false
269 const rendererStream = Object.assign(
270 new ReadableStream<Uint8Array>({
271 start(controller) {
272 rendererController = controller
273 },
274 }),
275 { allReady: new Promise<void>(() => {}) },
276 )
277 reactDomServerMocks.renderToReadableStream = vi.fn(() =>
278 Promise.resolve(rendererStream),
279 )
280​
281 const patch =
282 '<div hidden id="S:0">resolved</div>' +
283 '<script>applyPatch("B:0","S:0")</script>'
284 const response = unwrapResponse(
285 await renderRouterToStream({
286 request: new Request('http://localhost/'),
287 router,
288 responseHeaders: new Headers(),
289 children: null,
290 }),
291 )
292 const reader = response.body!.getReader()
293 const decoder = new TextDecoder()
294 const state = { html: '' }
295​
296 try {
297 rendererController.enqueue(
298 new TextEncoder().encode(
299 `<html><body>${renderedScripts}</body></html>${patch}`,
300 ),
301 )
302 await readUntil(reader, decoder, state, patch)
303​
304 resolveLateData('late-react-router-value')
305 await readUntil(reader, decoder, state, 'late-react-router-value')
306​
307 // Close React only after its patch allowed the late router value through.
308 rendererClosed = true
309 rendererController.close()
310 for (;;) {
311 const { done, value } = await readWithTimeout(reader)
312 if (done) {
313 break
314 }
315 state.html += decoder.decode(value, { stream: true })
316 }
317 state.html += decoder.decode()
318​
319 expect(state.html.indexOf(patch)).toBeLessThan(
320 state.html.indexOf('late-react-router-value'),
321 )
322 expect(state.html.indexOf('late-react-router-value')).toBeLessThan(
323 state.html.indexOf('</body></html>'),
324 )
325 expect(routerTransformMocks.readableOptions).toHaveBeenCalledWith(
326 expect.objectContaining({ rendererSafePoint: 'script-close' }),
327 )
328 } finally {
329 if (!rendererClosed) {
330 try {
331 rendererController.close()
332 } catch {
333 // The response may already have cancelled the renderer.
334 }
335 }
336 router.serverSsr?.cleanup()
337 }
338 })
339​
340 test('prefers the readable renderer when both APIs exist', async () => {
341 const cancelReadable = vi.fn()
342 const readableStream = Object.assign(
343 new ReadableStream<Uint8Array>({
344 cancel: cancelReadable,
345 }),
346 { allReady: Promise.resolve() },
347 )
348 const readable = vi.fn(() => Promise.resolve(readableStream))
349 reactDomServerMocks.renderToReadableStream = readable
350​
351 const router = await buildRouter()
352 const requestController = new AbortController()
353 try {
354 const response = unwrapResponse(
355 await renderRouterToStream({
356 request: new Request('http://localhost/', {
357 signal: requestController.signal,
358 }),
359 router,
360 responseHeaders: new Headers(),
361 children: null,
362 }),
363 )
364​
365 expect(readable).toHaveBeenCalledOnce()
366 expect(reactDomServerMocks.renderToPipeableStream).not.toHaveBeenCalled()
367 expect(routerTransformMocks.readableOptions).toHaveBeenCalledWith(
368 expect.objectContaining({ rendererSafePoint: 'script-close' }),
369 )
370​
371 requestController.abort(new Error('test-complete'))
372 await expectBodyRejects(response, 'test-complete')
373 expect(cancelReadable).toHaveBeenCalledOnce()
374 } finally {
375 router.serverSsr?.cleanup()
376 }
377 })
378​
379 test('readable renderer cancellation does not log a render error', async () => {
380 const cancelReadable = vi.fn()
381 reactDomServerMocks.renderToReadableStream = vi.fn((_children, options) => {
382 const readableStream = Object.assign(
383 new ReadableStream<Uint8Array>({
384 cancel(reason) {
385 cancelReadable(reason)
386 options.onError?.(reason, { componentStack: '' })
387 },
388 }),
389 { allReady: Promise.resolve() },
390 )
391 return Promise.resolve(readableStream)
392 })
393​
394 const router = await buildRouter()
395 const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
396 const reason = new Error('readable-consumer-gone')
397 try {
398 const response = unwrapResponse(
399 await renderRouterToStream({
400 request: new Request('http://localhost/'),
401 router,
402 responseHeaders: new Headers(),
403 children: null,
404 }),
405 )
406​
407 await response.body!.cancel(reason)
408 expect(cancelReadable).toHaveBeenCalledWith(reason)
409 expect(errorSpy).not.toHaveBeenCalled()
410 } finally {
411 errorSpy.mockRestore()
412 router.serverSsr?.cleanup()
413 }
414 })
415​
416 test('request abort does not log a renderer cancellation error', async () => {
417 const controller = new AbortController()
418 const renderError = new Error('renderer cancellation')
419 reactDomServerMocks.renderToReadableStream = vi.fn((_children, options) => {
420 controller.signal.addEventListener(
421 'abort',
422 () => options.onError?.(renderError, { componentStack: '' }),
423 { once: true },
424 )
425 return Promise.resolve(
426 Object.assign(new ReadableStream<Uint8Array>(), {
427 allReady: Promise.resolve(),
428 }),
429 )
430 })
431​
432 const router = await buildRouter()
433 const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
434 try {
435 const response = unwrapResponse(
436 await renderRouterToStream({
437 request: new Request('http://localhost/', {
438 signal: controller.signal,
439 }),
440 router,
441 responseHeaders: new Headers(),
442 children: null,
443 }),
444 )
445​
446 controller.abort(new Error('request-gone'))
447 await expectBodyRejects(response, 'request-gone')
448 expect(errorSpy).not.toHaveBeenCalled()
449 } finally {
450 errorSpy.mockRestore()
451 router.serverSsr?.cleanup()
452 }
453 })
454​
455 test('request abort unblocks the readable renderer bot wait', async () => {
456 let resolveCancel!: () => void
457 let markCancelStarted!: () => void
458 const cancelStarted = new Promise<void>((resolve) => {
459 markCancelStarted = resolve
460 })
461 const cancelReadable = vi.fn(
462 () =>
463 new Promise<void>((resolve) => {
464 resolveCancel = resolve
465 markCancelStarted()
466 }),
467 )
468 const readableStream = Object.assign(
469 new ReadableStream<Uint8Array>({
470 cancel: cancelReadable,
471 }),
472 { allReady: new Promise<void>(() => {}) },
473 )
474 reactDomServerMocks.renderToReadableStream = vi.fn(() =>
475 Promise.resolve(readableStream),
476 )
477​
478 const router = await buildRouter()
479 const cleanup = vi.spyOn(router.serverSsr!, 'cleanup')
480 const originalServerSsr = router.serverSsr!
481 const controller = new AbortController()
482 const reason = new Error('readable-bot-gone')
483 try {
484 const responsePromise = renderRouterToStream({
485 request: new Request('http://localhost/', {
486 headers: { 'User-Agent': 'Googlebot' },
487 signal: controller.signal,
488 }),
489 router,
490 responseHeaders: new Headers(),
491 children: null,
492 })
493​
494 await Promise.resolve()
495 controller.abort(reason)
496​
497 await cancelStarted
498 expect(cleanup).toHaveBeenCalledOnce()
499 expect(router.serverSsr).toBeUndefined()
500 resolveCancel()
501 await expect(responsePromise).rejects.toBe(reason)
502 expect(cancelReadable).toHaveBeenCalledOnce()
503 } finally {
504 resolveCancel?.()
505 originalServerSsr.cleanup()
506 }
507 })
508​
509 test('stream lifetime rejects the readable bot wait while readiness and cancellation stay pending', async () => {
510 let resolveReady!: () => void
511 const allReady = new Promise<void>((resolve) => {
512 resolveReady = resolve
513 })
514 const cancelReadable = vi.fn(() => new Promise<void>(() => {}))
515 const readableStream = Object.assign(
516 new ReadableStream<Uint8Array>({ cancel: cancelReadable }),
517 { allReady },
518 )
519 reactDomServerMocks.renderToReadableStream = vi.fn(() =>
520 Promise.resolve(readableStream),
521 )
522​
523 const router = await buildRouter()
524 const owner = router.serverSsr!
525 const cleanup = vi.fn()
526 owner.onCleanup(cleanup)
527 const request = new Request('http://localhost/', {
528 headers: { 'User-Agent': 'Googlebot' },
529 })
530 const resolved = vi.fn()
531 const rejected = vi.fn()
532 const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
533 vi.useFakeTimers()
534 const pending = renderRouterToStream({
535 request,
536 router,
537 responseHeaders: new Headers(),
538 children: null,
539 }).then(resolved, rejected)
540​
541 try {
542 await Promise.resolve()
543 expect(routerTransformMocks.readableOptions).toHaveBeenCalledOnce()
544 expect(rejected).not.toHaveBeenCalled()
545 await vi.advanceTimersByTimeAsync(120_000)
546​
547 const expectedError = expect.objectContaining({
548 message: 'Stream lifetime exceeded',
549 })
550 expect(rejected).toHaveBeenCalledExactlyOnceWith(expectedError)
551 expect(cancelReadable).toHaveBeenCalledExactlyOnceWith(expectedError)
552 expect(readableStream.locked).toBe(false)
553 expect(request.signal.aborted).toBe(false)
554 expect(cleanup).toHaveBeenCalledOnce()
555 expect(router.serverSsr).toBeUndefined()
556​
557 resolveReady()
558 await vi.advanceTimersByTimeAsync(0)
559 expect(resolved).not.toHaveBeenCalled()
560 } finally {
561 resolveReady()
562 await pending
563 owner.cleanup()
564 vi.useRealTimers()
565 warn.mockRestore()
566 }
567 })
568​
569 test('fatal shell errors reject before a response is created', async () => {
570 const shellError = new Error('fatal-react-shell-error')
571 reactDomServerMocks.renderToPipeableStream.mockImplementationOnce(
572 actualReactDomServer.renderToPipeableStream,
573 )
574 const Fatal = () => {
575 throw shellError
576 }
577​
578 const router = await buildRouter()
579 const cleanup = vi.spyOn(router.serverSsr!, 'cleanup')
580 const originalServerSsr = router.serverSsr!
581 const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
582 try {
583 await expect(
584 renderRouterToStream({
585 request: new Request('http://localhost/'),
586 router,
587 responseHeaders: new Headers(),
588 children: <Fatal />,
589 }),
590 ).rejects.toBe(shellError)
591​
592 expect(routerTransformMocks.readableOptions).toHaveBeenCalledOnce()
593 expect(cleanup).toHaveBeenCalled()
594 expect(router.serverSsr).toBeUndefined()
595 } finally {
596 errorSpy.mockRestore()
597 originalServerSsr.cleanup()
598 }
599 })
600​
601 test('transform abort wins after shell readiness resolves before continuation', async () => {
602 const reason = new Error('transform-aborted-after-ready')
603 const abort = vi.fn()
604 const pipe = vi.fn()
605 reactDomServerMocks.renderToPipeableStream.mockImplementationOnce(
606 (_children, options) => {
607 options.onShellReady()
608 return { abort, pipe }
609 },
610 )
611 routerTransformMocks.readableOptions.mockImplementationOnce((options) => {
612 options?.onAbort?.(reason)
613 })
614​
615 const router = await buildRouter()
616 const cleanup = vi.spyOn(router.serverSsr!, 'cleanup')
617 const originalServerSsr = router.serverSsr!
618 try {
619 await expect(
620 renderRouterToStream({
621 request: new Request('http://localhost/'),
622 router,
623 responseHeaders: new Headers(),
624 children: null,
625 }),
626 ).rejects.toBe(reason)
627​
628 expect(abort).toHaveBeenCalledWith(reason)
629 expect(pipe).not.toHaveBeenCalled()
630 expect(cleanup).toHaveBeenCalled()
631 expect(router.serverSsr).toBeUndefined()
632 } finally {
633 originalServerSsr.cleanup()
634 }
635 })
636​
637 test('synchronous renderer and transform setup failures do not orphan shell errors', async () => {
638 const rendererShellError = new Error('renderer-sync-shell-error')
639 const rendererSetupError = new Error('renderer-sync-setup-error')
640 const transformShellError = new Error('transform-sync-shell-error')
641 const transformSetupError = new Error('transform-sync-setup-error')
642 const unhandled: Array<unknown> = []
643 const onUnhandled = (error: unknown) => {
644 unhandled.push(error)
645 }
646 reactDomServerMocks.renderToPipeableStream
647 .mockImplementationOnce((_children, options) => {
648 options.onShellError(rendererShellError)
649 throw rendererSetupError
650 })
651 .mockImplementationOnce((_children, options) => {
652 options.onShellError(transformShellError)
653 return { abort: vi.fn(), pipe: vi.fn() }
654 })
655 routerTransformMocks.readableOptions.mockImplementationOnce(() => {
656 throw transformSetupError
657 })
658​
659 const rendererRouter = await buildRouter()
660 const transformRouter = await buildRouter()
661 const rendererServerSsr = rendererRouter.serverSsr!
662 const transformServerSsr = transformRouter.serverSsr!
663 process.on('unhandledRejection', onUnhandled)
664 try {
665 await expect(
666 renderRouterToStream({
667 request: new Request('http://localhost/'),
668 router: rendererRouter,
669 responseHeaders: new Headers(),
670 children: null,
671 }),
672 ).rejects.toBe(rendererSetupError)
673 await expect(
674 renderRouterToStream({
675 request: new Request('http://localhost/'),
676 router: transformRouter,
677 responseHeaders: new Headers(),
678 children: null,
679 }),
680 ).rejects.toBe(transformSetupError)
681 await new Promise<void>((resolve) => setTimeout(resolve, 0))
682​
683 expect(unhandled).toEqual([])
684 expect(rendererRouter.serverSsr).toBeUndefined()
685 expect(transformRouter.serverSsr).toBeUndefined()
686 } finally {
687 process.off('unhandledRejection', onUnhandled)
688 rendererServerSsr.cleanup()
689 transformServerSsr.cleanup()
690 }
691 })
692​
693 test('a live AbortError is logged without aborting the stream', async () => {
694 const abort = vi.fn()
695 const renderError = new DOMException('component failed', 'AbortError')
696 reactDomServerMocks.renderToPipeableStream.mockImplementationOnce(
697 (_children, opts) => {
698 queueMicrotask(() => opts.onShellReady())
699 return {
700 abort,
701 pipe(destination: NodeJS.WritableStream) {
702 destination.write('<html><body>shell')
703 opts.onError(renderError, {
704 componentStack: '',
705 })
706 destination.end('</body></html>')
707 },
708 }
709 },
710 )
711​
712 const router = await buildRouter()
713 expect(router.serverSsr!.takeInitialHydrationScriptTags()).toBeDefined()
714 const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
715 try {
716 const response = unwrapResponse(
717 await renderRouterToStream({
718 request: new Request('http://localhost/'),
719 router,
720 responseHeaders: new Headers(),
721 children: null,
722 }),
723 )
724​
725 await expect(response.text()).resolves.toContain('shell')
726 expect(routerTransformMocks.readableOptions).toHaveBeenCalledWith(
727 expect.objectContaining({ rendererSafePoint: 'script-close' }),
728 )
729 expect(abort).not.toHaveBeenCalled()
730 expect(errorSpy).toHaveBeenCalledWith(
731 'Error in renderToPipeableStream:',
732 renderError,
733 { componentStack: '' },
734 )
735 } finally {
736 errorSpy.mockRestore()
737 router.serverSsr?.cleanup()
738 }
739 })
740​
741 test('pipeable renderer cancellation does not log a render error', async () => {
742 let options:
743 | Parameters<typeof actualReactDomServer.renderToPipeableStream>[1]
744 | undefined
745 const abort = vi.fn((reason: unknown) => {
746 options?.onError?.(reason, { componentStack: '' })
747 })
748 reactDomServerMocks.renderToPipeableStream.mockImplementationOnce(
749 (_children, nextOptions) => {
750 options = nextOptions
751 queueMicrotask(() => nextOptions.onShellReady())
752 return { abort, pipe: vi.fn() }
753 },
754 )
755​
756 const router = await buildRouter()
757 const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
758 const reason = new Error('pipeable-consumer-gone')
759 try {
760 const response = unwrapResponse(
761 await renderRouterToStream({
762 request: new Request('http://localhost/'),
763 router,
764 responseHeaders: new Headers(),
765 children: null,
766 }),
767 )
768​
769 await response.body!.cancel(reason)
770 expect(abort).toHaveBeenCalledWith(reason)
771 expect(errorSpy).not.toHaveBeenCalled()
772 } finally {
773 errorSpy.mockRestore()
774 router.serverSsr?.cleanup()
775 }
776 })
777​
778 test('request abort cancels pipeable rendering before the response body is consumed', async () => {
779 const abort = vi.fn()
780 reactDomServerMocks.renderToPipeableStream.mockImplementationOnce(
781 (_children, opts) => {
782 queueMicrotask(() => opts.onShellReady())
783 return { abort, pipe: vi.fn() }
784 },
785 )
786​
787 const router = await buildRouter()
788 const controller = new AbortController()
789 const request = new Request('http://localhost/', {
790 signal: controller.signal,
791 })
792 try {
793 const response = unwrapResponse(
794 await renderRouterToStream({
795 request,
796 router,
797 responseHeaders: new Headers(),
798 children: null,
799 }),
800 )
801​
802 expect(response.body).not.toBeNull()
803 controller.abort(new Error('request-gone'))
804 await vi.waitFor(() => expect(abort).toHaveBeenCalledOnce())
805 await expectBodyRejects(response, 'request-gone')
806 } finally {
807 router.serverSsr?.cleanup()
808 }
809 })
810​
811 test('stream lifetime abort rejects before bot readiness even when React resolves onAllReady', async () => {
812 let options:
813 | Parameters<typeof actualReactDomServer.renderToPipeableStream>[1]
814 | undefined
815 const pipe = vi.fn()
816 const abort = vi.fn((_reason?: unknown) => {
817 options?.onAllReady?.()
818 })
819 reactDomServerMocks.renderToPipeableStream.mockImplementationOnce(
820 (_children, nextOptions) => {
821 options = nextOptions
822 return { abort, pipe }
823 },
824 )
825​
826 const router = await buildRouter()
827 const cleanup = vi.spyOn(router.serverSsr!, 'cleanup')
828 const originalServerSsr = router.serverSsr!
829 const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
830 vi.useFakeTimers()
831 try {
832 const responsePromise = renderRouterToStream({
833 request: new Request('http://localhost/', {
834 headers: { 'User-Agent': 'Googlebot' },
835 }),
836 router,
837 responseHeaders: new Headers(),
838 children: null,
839 })
840 const rejection = expect(responsePromise).rejects.toThrow(
841 'Stream lifetime exceeded',
842 )
843​
844 expect(routerTransformMocks.readableOptions).toHaveBeenCalledOnce()
845 expect(options?.onAllReady).toBeTypeOf('function')
846 await vi.runAllTimersAsync()
847​
848 await rejection
849 expect(abort).toHaveBeenCalledOnce()
850 expect(abort.mock.calls[0]![0]).toMatchObject({
851 message: 'Stream lifetime exceeded',
852 })
853 expect(pipe).not.toHaveBeenCalled()
854 expect(cleanup).toHaveBeenCalled()
855 expect(router.serverSsr).toBeUndefined()
856 } finally {
857 vi.useRealTimers()
858 warnSpy.mockRestore()
859 originalServerSsr.cleanup()
860 }
861 })
862​
863 test('request abort before shell readiness rejects and cleans up', async () => {
864 const abort = vi.fn()
865 const controller = new AbortController()
866 reactDomServerMocks.renderToPipeableStream.mockReturnValueOnce({
867 abort,
868 pipe: vi.fn(),
869 })
870​
871 const router = await buildRouter()
872 const cleanup = vi.spyOn(router.serverSsr!, 'cleanup')
873 const originalServerSsr = router.serverSsr!
874 const reason = new Error('request-gone-before-shell')
875 try {
876 const responsePromise = renderRouterToStream({
877 request: new Request('http://localhost/', {
878 signal: controller.signal,
879 }),
880 router,
881 responseHeaders: new Headers(),
882 children: null,
883 })
884 await Promise.resolve()
885 controller.abort(reason)
886​
887 await expect(responsePromise).rejects.toBe(reason)
888 expect(abort).toHaveBeenCalledOnce()
889 expect(cleanup).toHaveBeenCalledOnce()
890 expect(router.serverSsr).toBeUndefined()
891 } finally {
892 originalServerSsr.cleanup()
893 }
894 })
895})