Open History to see the last commit
1// @vitest-environment node
2β
3import {
4 afterAll,
5 afterEach,
6 describe,
7 expect,
8 it,
9 onTestFinished,
10 vi,
11} from 'vitest'
12import { createMemoryHistory } from '@tanstack/history'
13import { createMiddleware } from '@tanstack/start-client-core'
14import {
15 BaseRootRoute,
16 BaseRoute,
17 RouterCore,
18 redirect,
19 type AnyRouter,
20} from '@tanstack/router-core'
21import {
22 createNonReactiveMutableStore,
23 createNonReactiveReadonlyStore,
24} from '@tanstack/router-core'
25import {
26 attachRouterServerSsrUtils,
27 createSsrStreamResponse,
28} from '@tanstack/router-core/ssr/server'
29import { createStartHandler } from '../src/createStartHandler'
30import {
31 getStaticHandlerInlineCssDefault,
32 resolveInlineCssForRequest,
33} from '../src/inlineCss'
34β
35const startMocks = vi.hoisted(() => {
36 const previousServerFnBase = process.env.TSS_SERVER_FN_BASE
37 process.env.TSS_SERVER_FN_BASE = '/_serverFn/'
38 return {
39 previousServerFnBase,
40 requestMiddleware: [] as Array<any>,
41 serverFnResult: undefined as undefined | Response | object,
42 router: undefined as undefined | AnyRouter,
43 routerFactory: undefined as undefined | (() => AnyRouter),
44 }
45})
46β
47vi.mock('#tanstack-start-entry', () => ({
48 startInstance: {
49 getOptions: () => ({
50 requestMiddleware: startMocks.requestMiddleware,
51 serializationAdapters: [],
52 }),
53 },
54}))
55β
56vi.mock('#tanstack-router-entry', () => ({
57 getRouter: () => startMocks.routerFactory?.() ?? startMocks.router,
58}))
59β
60vi.mock('../src/server-functions-handler', () => ({
61 handleServerAction: () => startMocks.serverFnResult,
62}))
63β
64const getStoreConfig = () => ({
65 createMutableStore: createNonReactiveMutableStore,
66 createReadonlyStore: createNonReactiveReadonlyStore,
67 batch: (fn: () => void) => fn(),
68})
69β
70function makeRouter() {
71 const rootRoute = new BaseRootRoute({})
72 const indexRoute = new BaseRoute({
73 getParentRoute: () => rootRoute,
74 path: '/',
75 component: () => null,
76 })
77 const router = new RouterCore(
78 {
79 history: createMemoryHistory({ initialEntries: ['/'] }),
80 routeTree: rootRoute.addChildren([indexRoute]),
81 },
82 getStoreConfig,
83 )
84 router.isServer = true
85 return router
86}
87β
88function makeRouterWithRouteWork(routeWork: {
89 beforeLoad?: (ctx: { abortController: AbortController }) => unknown
90 loader?: (ctx: { abortController: AbortController }) => unknown
91}) {
92 const rootRoute = new BaseRootRoute({})
93 const workRoute = new BaseRoute({
94 getParentRoute: () => rootRoute,
95 path: '/work',
96 component: () => null,
97 ...routeWork,
98 })
99 const router = new RouterCore(
100 {
101 history: createMemoryHistory({ initialEntries: ['/work'] }),
102 routeTree: rootRoute.addChildren([workRoute]),
103 },
104 getStoreConfig,
105 )
106 router.isServer = true
107 return router
108}
109β
110function waitForAbortOrRelease(signal: AbortSignal) {
111 return new Promise<void>((resolve) => {
112 const release = () => {
113 signal.removeEventListener('abort', release)
114 resolve()
115 }
116 signal.addEventListener('abort', release, { once: true })
117 })
118}
119β
120function makeStreamResponse(router: ReturnType<typeof makeRouter>) {
121 attachRouterServerSsrUtils({ router: router as any, manifest: undefined })
122 const stream = new ReadableStream({
123 start(controller) {
124 controller.enqueue(new TextEncoder().encode('stream'))
125 },
126 cancel() {
127 router.serverSsr?.cleanup()
128 },
129 })
130 return createSsrStreamResponse(router as any, new Response(stream))
131}
132β
133afterEach(() => {
134 startMocks.requestMiddleware = []
135 startMocks.serverFnResult = undefined
136 startMocks.router = undefined
137 startMocks.routerFactory = undefined
138 vi.unstubAllEnvs()
139})
140β
141afterAll(() => {
142 if (startMocks.previousServerFnBase === undefined) {
143 delete (process.env as Partial<NodeJS.ProcessEnv>).TSS_SERVER_FN_BASE
144 } else {
145 process.env.TSS_SERVER_FN_BASE = startMocks.previousServerFnBase
146 }
147})
148β
149describe('createStartHandler redirect safety', () => {
150 it.each(
151 [false, true].flatMap((rpc) =>
152 ['relative-to', 'functional-options'].flatMap((options) =>
153 ['/login', 'http://localhost/login', '//evil.example'].map((href) => ({
154 rpc,
155 options,
156 href,
157 })),
158 ),
159 ),
160 )(
161 'uses an explicit Location before ignored $options (RPC=$rpc, href=$href)',
162 async ({ rpc, options, href }) => {
163 const factory = vi.fn(makeRouter)
164 const updater = vi.fn(() => ({}))
165 const hash = vi.fn(() => 'ignored')
166 startMocks.routerFactory = factory
167 const headers = { Location: href }
168 const result =
169 options === 'relative-to'
170 ? redirect({ headers, to: 'ignored' })
171 : redirect({ headers, search: updater, params: updater, hash })
172 if (rpc) {
173 startMocks.serverFnResult = result
174 } else {
175 startMocks.requestMiddleware = [createMiddleware().server(() => result)]
176 }
177 const handler = createStartHandler(() => new Response('unused'))
178 const response = await handler(
179 new Request(`http://localhost/${rpc ? '_serverFn/test' : ''}`, {
180 headers: rpc ? { 'x-tsr-serverFn': 'true' } : undefined,
181 }),
182 {},
183 )
184 const blocked = href.startsWith('//')
185 expect(response.status).toBe(blocked ? 500 : rpc ? 200 : 307)
186 expect(response.headers.get('Location')).toBe(blocked ? null : '/login')
187 expect(factory).toHaveBeenCalledTimes(href === '/login' ? 0 : 1)
188 expect(updater).not.toHaveBeenCalled()
189 expect(hash).not.toHaveBeenCalled()
190 if (rpc && !blocked) {
191 expect(await response.json()).toMatchObject({
192 href: '/login',
193 isSerializedRedirect: true,
194 })
195 }
196 },
197 )
198β
199 it.each(
200 [undefined, ''].flatMap((location) =>
201 ['to', 'params', 'search', 'hash'].map((option) => ({
202 location,
203 option,
204 })),
205 ),
206 )(
207 'still validates unresolved $option with Location=$location',
208 async ({ location, option }) => {
209 const factory = vi.fn(makeRouter)
210 const updater = vi.fn(() => ({}))
211 const hash = vi.fn(() => 'ignored')
212 startMocks.routerFactory = factory
213 const headers =
214 location === undefined ? undefined : { Location: location }
215 const result =
216 option === 'to'
217 ? redirect({ headers, to: 'relative' })
218 : redirect({
219 headers,
220 to: '/login',
221 params: option === 'params' ? updater : undefined,
222 search: option === 'search' ? updater : undefined,
223 hash: option === 'hash' ? hash : undefined,
224 })
225 startMocks.requestMiddleware = [createMiddleware().server(() => result)]
226 const response = await createStartHandler(() => new Response('unused'))(
227 new Request('http://localhost/'),
228 {},
229 )
230 expect(response.status).toBe(500)
231 expect(response.headers.get('Location')).toBeNull()
232 expect(factory).not.toHaveBeenCalled()
233 expect(updater).not.toHaveBeenCalled()
234 expect(hash).not.toHaveBeenCalled()
235 },
236 )
237β
238 it('applies custom protocol policy to a header-only redirect with ignored options', async () => {
239 startMocks.routerFactory = () => {
240 const router = makeRouter()
241 router.update({ protocolAllowlist: [] })
242 return router
243 }
244 startMocks.requestMiddleware = [
245 createMiddleware().server(() =>
246 redirect({
247 to: 'ignored',
248 headers: { Location: 'https://other.example/login' },
249 }),
250 ),
251 ]
252 const response = await createStartHandler(() => new Response('unused'))(
253 new Request('http://localhost/'),
254 {},
255 )
256 expect(response.status).toBe(500)
257 expect(response.headers.get('Location')).toBeNull()
258 })
259β
260 it.each([
261 '/login',
262 '../login',
263 '?next=https://example.com',
264 '#details',
265 '/items/a:b',
266 ])(
267 'returns an early relative redirect to %j without initializing the router',
268 async (href) => {
269 const factory = vi.fn(makeRouter)
270 startMocks.routerFactory = factory
271 startMocks.requestMiddleware = [
272 createMiddleware().server(() => redirect({ href })),
273 ]
274 const handler = createStartHandler(() => new Response('unused'))
275β
276 const response = await handler(new Request('http://localhost/'), {})
277β
278 expect(response.status).toBe(307)
279 expect(response.headers.get('Location')).toBe(href)
280 expect(factory).not.toHaveBeenCalled()
281 },
282 )
283β
284 it('serializes an early relative server-function redirect without initializing the router', async () => {
285 const factory = vi.fn(makeRouter)
286 startMocks.routerFactory = factory
287 startMocks.serverFnResult = redirect({
288 href: '/ignored',
289 headers: { Location: '/login', 'set-cookie': 'session=secret; HttpOnly' },
290 })
291 const handler = createStartHandler(() => new Response('unused'))
292β
293 const response = await handler(
294 new Request('http://localhost/_serverFn/test', {
295 headers: { 'x-tsr-serverFn': 'true' },
296 }),
297 {},
298 )
299β
300 expect(response.status).toBe(200)
301 expect(response.headers.get('Location')).toBe('/login')
302 expect(response.headers.get('set-cookie')).toBe('session=secret; HttpOnly')
303 const body = await response.json()
304 expect(body).toMatchObject({ href: '/login', isSerializedRedirect: true })
305 expect(body).not.toHaveProperty('headers')
306 expect(factory).not.toHaveBeenCalled()
307 })
308β
309 it.each([
310 { href: 'https://example.com/login', protocols: [], status: 500 },
311 { href: 'myapp:login', protocols: ['myapp:'], status: 307 },
312 { href: 'myapp:login', protocols: [], status: 500 },
313 ])(
314 'uses router policy for an early redirect to $href with $protocols',
315 async ({ href, protocols, status }) => {
316 const factory = vi.fn(() => {
317 const router = makeRouter()
318 router.update({ protocolAllowlist: protocols })
319 return router
320 })
321 startMocks.routerFactory = factory
322 startMocks.requestMiddleware = [
323 createMiddleware().server(() =>
324 redirect({
325 href: '/ignored',
326 headers: { Location: href },
327 }),
328 ),
329 ]
330 const handler = createStartHandler(() => new Response('unused'))
331β
332 const response = await handler(new Request('http://localhost/'), {})
333β
334 expect(response.status).toBe(status)
335 expect(response.headers.get('Location')).toBe(
336 status === 307 ? href : null,
337 )
338 expect(factory).toHaveBeenCalledTimes(1)
339 },
340 )
341β
342 it('resolves route-based early redirects through the router', async () => {
343 const factory = vi.fn(() => makeRouterWithRouteWork({}))
344 startMocks.routerFactory = factory
345 startMocks.requestMiddleware = [
346 createMiddleware().server(() =>
347 redirect({
348 to: '/work',
349 search: { next: 'home' },
350 }),
351 ),
352 ]
353 const handler = createStartHandler(() => new Response('unused'))
354 const response = await handler(new Request('http://localhost/'), {})
355 expect(response.status).toBe(307)
356 expect(response.headers.get('Location')).toBe('/work?next=home')
357 expect(factory).toHaveBeenCalledTimes(1)
358 })
359β
360 it.each([
361 { href: '/login', status: 307, factories: 0, location: '/login' },
362 { href: '/\\evil.example', status: 500, factories: 1, location: null },
363 {
364 href: 'http://localhost/login',
365 status: 307,
366 factories: 1,
367 location: '/login',
368 },
369 ])(
370 'validates a header-only early redirect to $href',
371 async ({ href, status, factories, location }) => {
372 const factory = vi.fn(makeRouter)
373 startMocks.routerFactory = factory
374 startMocks.requestMiddleware = [
375 createMiddleware().server(() =>
376 redirect({
377 headers: { Location: href },
378 throw: true,
379 }),
380 ),
381 ]
382 const handler = createStartHandler(() => new Response('unused'))
383 const response = await handler(new Request('http://localhost/'), {})
384 expect(response.status).toBe(status)
385 expect(response.headers.get('Location')).toBe(location)
386 expect(factory).toHaveBeenCalledTimes(factories)
387 },
388 )
389β
390 it.each(
391 [
392 '//evil.example',
393 '/\\evil.example',
394 '/\\\\evil.example',
395 '/\\/evil.example',
396 '\\/evil.example',
397 '\\\\evil.example',
398 ].flatMap((href) => [false, true].map((rpc) => ({ href, rpc }))),
399 )(
400 'validates a resolved server function redirect to $href (RPC=$rpc)',
401 async ({ href, rpc }) => {
402 startMocks.router = makeRouter()
403 startMocks.serverFnResult = redirect({ href })
404 const handler = createStartHandler(() => new Response('unused'))
405β
406 const response = await handler(
407 new Request('http://localhost/_serverFn/test', {
408 headers: rpc ? { 'x-tsr-serverFn': 'true' } : undefined,
409 }),
410 {},
411 )
412β
413 expect(response.status).toBe(500)
414 expect(response.headers.get('Location')).toBeNull()
415 },
416 )
417β
418 it('validates a structured redirect before returning it directly', async () => {
419 startMocks.router = makeRouter()
420 startMocks.requestMiddleware = [
421 createMiddleware().server(() => redirect({ href: '/\\evil.example' })),
422 ]
423 const handler = createStartHandler(() => new Response('unused'))
424β
425 const response = await handler(new Request('http://localhost/'), {})
426β
427 expect(response.status).toBe(500)
428 expect(response.headers.get('Location')).toBeNull()
429 })
430β
431 it('does not serialize structured redirect headers into the response body', async () => {
432 startMocks.router = makeRouter()
433 startMocks.serverFnResult = redirect({
434 href: '/safe',
435 headers: { 'set-cookie': 'session=secret; HttpOnly' },
436 })
437 const handler = createStartHandler(() => new Response('unused'))
438β
439 const response = await handler(
440 new Request('http://localhost/_serverFn/test', {
441 headers: { 'x-tsr-serverFn': 'true' },
442 }),
443 {},
444 )
445β
446 expect(response.status).toBe(200)
447 expect(response.headers.get('set-cookie')).toBe('session=secret; HttpOnly')
448 const responseText = await response.text()
449 expect(responseText).not.toContain('session=secret')
450 expect(JSON.parse(responseText)).toEqual(
451 expect.objectContaining({
452 href: '/safe',
453 statusCode: 307,
454 isSerializedRedirect: true,
455 }),
456 )
457 })
458β
459 it('preserves redirect headers and caller options across RPC then native form reuse', async () => {
460 const headers = {
461 Location: '/work',
462 'set-cookie': 'session=secret; HttpOnly',
463 'content-type': 'text/plain',
464 }
465 const options = { href: '/work', statusCode: 303, headers }
466 const result = redirect(options)
467 startMocks.serverFnResult = result
468 const handler = createStartHandler(() => new Response('unused'))
469β
470 const rpcResponse = await handler(
471 new Request('http://localhost/_serverFn/test', {
472 headers: { 'x-tsr-serverFn': 'true' },
473 }),
474 {},
475 )
476 expect(rpcResponse.status).toBe(200)
477 expect(rpcResponse.headers.get('content-type')).toBe('application/json')
478 expect(await rpcResponse.json()).not.toHaveProperty('headers')
479 expect(options.headers).toBe(headers)
480 expect(result.headers.get('content-type')).toBe('text/plain')
481β
482 const formResponse = await handler(
483 new Request('http://localhost/_serverFn/test', {
484 method: 'POST',
485 headers: { 'content-type': 'application/x-www-form-urlencoded' },
486 body: 'name=test',
487 }),
488 {},
489 )
490 expect(formResponse.status).toBe(303)
491 expect(formResponse.headers.get('Location')).toBe('/work')
492 expect(formResponse.headers.get('set-cookie')).toBe(
493 'session=secret; HttpOnly',
494 )
495 expect(formResponse.headers.get('content-type')).toBe('text/plain')
496 expect(await formResponse.text()).toBe('')
497 })
498β
499 it('does not serialize an ordinary redirect with a spoofed server function header', async () => {
500 startMocks.router = makeRouter()
501 startMocks.requestMiddleware = [
502 createMiddleware().server(() => redirect({ href: '/safe' })),
503 ]
504 const handler = createStartHandler(() => new Response('unused'))
505β
506 const response = await handler(
507 new Request('http://localhost/', {
508 headers: { 'x-tsr-serverFn': 'true' },
509 }),
510 {},
511 )
512β
513 expect(response.status).toBe(307)
514 expect(response.headers.get('Location')).toBe('/safe')
515 expect(response.headers.get('content-type')).toBeNull()
516 expect(await response.text()).toBe('')
517 })
518β
519 it.each([{ href: '/work' }, { to: '/work' }, { hash: () => 'ignored' }])(
520 'preserves native form redirects for %j without the RPC header',
521 async (target) => {
522 startMocks.routerFactory = () => makeRouterWithRouteWork({})
523 startMocks.serverFnResult = redirect({
524 ...target,
525 statusCode: 303,
526 headers: {
527 'set-cookie': 'session=secret; HttpOnly',
528 ...('hash' in target ? { Location: '/work' } : undefined),
529 },
530 })
531 const handler = createStartHandler(() => new Response('unused'))
532β
533 const response = await handler(
534 new Request('http://localhost/_serverFn/test', {
535 method: 'POST',
536 headers: {
537 'content-type': 'application/x-www-form-urlencoded',
538 accept: 'text/html',
539 },
540 body: 'name=test',
541 }),
542 {},
543 )
544β
545 expect(response.status).toBe(303)
546 expect(response.headers.get('Location')).toBe('/work')
547 expect(response.headers.get('set-cookie')).toBe(
548 'session=secret; HttpOnly',
549 )
550 expect(response.headers.get('content-type')).not.toBe('application/json')
551 expect(await response.text()).toBe('')
552 },
553 )
554})
555β
556it('keeps the request URL when server code attempts navigation', async () => {
557 const loader = vi.fn(async () => {
558 const router = startMocks.router!
559 router.history.push('/pushed')
560 router.history.replace('/replaced')
561 await router.navigate({ to: '/navigated' })
562 return 'request data'
563 })
564 const router = makeRouterWithRouteWork({ loader })
565 startMocks.router = router
566 const load = vi.spyOn(router, 'load')
567 const handler = createStartHandler(({ router: loadedRouter }) => {
568 expect(loadedRouter.state.location.pathname).toBe('/work')
569 expect(loadedRouter.history.location.pathname).toBe('/work')
570 expect(loadedRouter.history.length).toBe(1)
571 return new Response(loadedRouter.state.matches.at(-1)?.loaderData as string)
572 })
573 const response = await handler(new Request('http://localhost/work'), {})
574β
575 expect(response.status).toBe(200)
576 expect(await response.text()).toBe('request data')
577 expect(loader).toHaveBeenCalledTimes(1)
578 expect(load).toHaveBeenCalledTimes(1)
579})
580β
581describe('createStartHandler SSR cleanup ownership', () => {
582 it('preserves serverFn stream cleanup ownership through early return', async () => {
583 startMocks.requestMiddleware = []
584 const router = makeRouter()
585 startMocks.router = router
586 const ssrResponse = makeStreamResponse(router)
587 startMocks.serverFnResult = ssrResponse
588 const dispose = vi.spyOn(ssrResponse as any, 'dispose')
589β
590 const handler = createStartHandler(() => new Response('unused'))
591 const response = await handler(
592 new Request('http://localhost/_serverFn/test', {
593 headers: { 'x-tsr-serverFn': 'true' },
594 }),
595 {},
596 )
597β
598 expect(response).toBe(ssrResponse.response)
599 expect(dispose).not.toHaveBeenCalled()
600 expect(router.serverSsr).toBeDefined()
601β
602 await response.body!.cancel('done')
603 expect(router.serverSsr).toBeUndefined()
604 })
605β
606 it('disposes stream response replaced by middleware result', async () => {
607 const router = makeRouter()
608 startMocks.router = router
609 const ssrResponse = makeStreamResponse(router)
610 startMocks.serverFnResult = ssrResponse
611 const dispose = vi.spyOn(ssrResponse as any, 'dispose')
612 const replacement = new Response('replacement')
613 startMocks.requestMiddleware = [
614 createMiddleware().server(async ({ next }) => {
615 await next()
616 return replacement
617 }),
618 ]
619β
620 const handler = createStartHandler(() => new Response('unused'))
621 const response = await handler(
622 new Request('http://localhost/_serverFn/test', {
623 headers: { 'x-tsr-serverFn': 'true' },
624 }),
625 {},
626 )
627β
628 expect(response).toBe(replacement)
629 expect(dispose).toHaveBeenCalledOnce()
630 expect(router.serverSsr).toBeUndefined()
631 })
632β
633 it('exposes Response to middleware while preserving stream ownership', async () => {
634 startMocks.requestMiddleware = []
635 const router = makeRouter()
636 startMocks.router = router
637 const ssrResponse = makeStreamResponse(router)
638 startMocks.serverFnResult = ssrResponse
639 const seenHeaders = [] as Array<Headers | undefined>
640 startMocks.requestMiddleware = [
641 createMiddleware().server(async ({ next }) => {
642 const result = await next()
643 seenHeaders.push(result.response.headers)
644 result.response.headers.set('x-test', 'true')
645 return result
646 }),
647 ]
648β
649 const handler = createStartHandler(() => new Response('unused'))
650 const response = await handler(
651 new Request('http://localhost/_serverFn/test', {
652 headers: { 'x-tsr-serverFn': 'true' },
653 }),
654 {},
655 )
656β
657 expect(response).toBe(ssrResponse.response)
658 expect(seenHeaders).toEqual([ssrResponse.response.headers])
659 expect(response.headers.get('x-test')).toBe('true')
660 expect(router.serverSsr).toBeDefined()
661β
662 await response.body!.cancel('done')
663 expect(router.serverSsr).toBeUndefined()
664 })
665β
666 it('preserves stream ownership through return next', async () => {
667 const router = makeRouter()
668 startMocks.router = router
669 const ssrResponse = makeStreamResponse(router)
670 startMocks.serverFnResult = ssrResponse
671 const dispose = vi.spyOn(ssrResponse as any, 'dispose')
672 startMocks.requestMiddleware = [
673 createMiddleware().server(({ next }) => {
674 return next()
675 }),
676 ]
677β
678 const handler = createStartHandler(() => new Response('unused'))
679 const response = await handler(
680 new Request('http://localhost/_serverFn/test', {
681 headers: { 'x-tsr-serverFn': 'true' },
682 }),
683 {},
684 )
685β
686 expect(response).toBe(ssrResponse.response)
687 expect(dispose).not.toHaveBeenCalled()
688 expect(router.serverSsr).toBeDefined()
689β
690 await response.body!.cancel('done')
691 expect(router.serverSsr).toBeUndefined()
692 })
693β
694 it('preserves stream ownership when middleware wraps same body', async () => {
695 const router = makeRouter()
696 startMocks.router = router
697 const ssrResponse = makeStreamResponse(router)
698 startMocks.serverFnResult = ssrResponse
699 const dispose = vi.spyOn(ssrResponse as any, 'dispose')
700 let wrappedResponse: Response | undefined
701 startMocks.requestMiddleware = [
702 createMiddleware().server(async ({ next }) => {
703 const result = await next()
704 wrappedResponse = new Response(result.response.body, result.response)
705 wrappedResponse.headers.set('x-wrapped', 'true')
706 return wrappedResponse
707 }),
708 ]
709β
710 const handler = createStartHandler(() => new Response('unused'))
711 const response = await handler(
712 new Request('http://localhost/_serverFn/test', {
713 headers: { 'x-tsr-serverFn': 'true' },
714 }),
715 {},
716 )
717β
718 expect(response).toBe(wrappedResponse)
719 expect(response).not.toBe(ssrResponse.response)
720 expect(response.headers.get('x-wrapped')).toBe('true')
721 expect(dispose).not.toHaveBeenCalled()
722 expect(router.serverSsr).toBeDefined()
723β
724 await response.body!.cancel('done')
725 expect(router.serverSsr).toBeUndefined()
726 })
727β
728 it('disposes stream response on middleware error after next', async () => {
729 const router = makeRouter()
730 startMocks.router = router
731 const ssrResponse = makeStreamResponse(router)
732 startMocks.serverFnResult = ssrResponse
733 const dispose = vi.spyOn(ssrResponse as any, 'dispose')
734 startMocks.requestMiddleware = [
735 createMiddleware().server(async ({ next }) => {
736 await next()
737 throw new Error('middleware failed')
738 }),
739 ]
740β
741 const handler = createStartHandler(() => new Response('unused'))
742 const response = await handler(
743 new Request('http://localhost/_serverFn/test', {
744 headers: { 'x-tsr-serverFn': 'true' },
745 }),
746 {},
747 )
748β
749 expect(response.status).toBe(500)
750 expect(dispose).toHaveBeenCalledOnce()
751 expect(router.serverSsr).toBeUndefined()
752 })
753β
754 it('disposes stream response replaced by thrown response', async () => {
755 const router = makeRouter()
756 startMocks.router = router
757 const ssrResponse = makeStreamResponse(router)
758 startMocks.serverFnResult = ssrResponse
759 const dispose = vi.spyOn(ssrResponse as any, 'dispose')
760 const replacement = new Response('handled', { status: 418 })
761 startMocks.requestMiddleware = [
762 createMiddleware().server(async ({ next }) => {
763 await next()
764 throw replacement
765 }),
766 ]
767β
768 const handler = createStartHandler(() => new Response('unused'))
769 const response = await handler(
770 new Request('http://localhost/_serverFn/test', {
771 headers: { 'x-tsr-serverFn': 'true' },
772 }),
773 {},
774 )
775β
776 expect(response).toBe(replacement)
777 expect(dispose).toHaveBeenCalledOnce()
778 expect(router.serverSsr).toBeUndefined()
779 })
780β
781 it('honors in-place response assignment on returned context', async () => {
782 const router = makeRouter()
783 startMocks.router = router
784 const ssrResponse = makeStreamResponse(router)
785 startMocks.serverFnResult = ssrResponse
786 const dispose = vi.spyOn(ssrResponse as any, 'dispose')
787 const replacement = new Response('replacement')
788 startMocks.requestMiddleware = [
789 createMiddleware().server(async ({ next }) => {
790 const result = await next()
791 result.response = replacement
792 return result
793 }),
794 ]
795β
796 const handler = createStartHandler(() => new Response('unused'))
797 const response = await handler(
798 new Request('http://localhost/_serverFn/test', {
799 headers: { 'x-tsr-serverFn': 'true' },
800 }),
801 {},
802 )
803β
804 expect(response).toBe(replacement)
805 expect(dispose).toHaveBeenCalledOnce()
806 expect(router.serverSsr).toBeUndefined()
807 })
808})
809β
810describe('createStartHandler request cancellation', () => {
811 it.each(['beforeLoad', 'loader'] as const)(
812 'aborts route %s work and does not render HTML',
813 async (hook) => {
814 let routeSignal: AbortSignal | undefined
815 let notifyStarted: (() => void) | undefined
816 const started = new Promise<void>((resolve) => {
817 notifyStarted = resolve
818 })
819 const routeWork = ({
820 abortController,
821 }: {
822 abortController: AbortController
823 }) => {
824 routeSignal = abortController.signal
825 notifyStarted?.()
826 return waitForAbortOrRelease(abortController.signal)
827 }
828 const router = makeRouterWithRouteWork({ [hook]: routeWork })
829 startMocks.router = router
830 const requestController = new AbortController()
831 const render = vi.fn(() => new Response('must not render'))
832 const handler = createStartHandler(render)
833 const response = handler(
834 new Request('http://localhost/work', {
835 signal: requestController.signal,
836 }),
837 {},
838 )
839β
840 await started
841 const cancellation = new Error('request disconnected')
842 requestController.abort(cancellation)
843β
844 expect((await response).status).toBe(500)
845 expect(routeSignal?.aborted).toBe(true)
846 expect(routeSignal?.reason).toBe(cancellation)
847 expect(render).not.toHaveBeenCalled()
848 },
849 )
850β
851 it('settles and cleans up while the render callback is still pending', async () => {
852 const router = makeRouter()
853 startMocks.router = router
854 const requestController = new AbortController()
855 let notifyRenderStarted!: () => void
856 const renderStarted = new Promise<void>((resolve) => {
857 notifyRenderStarted = resolve
858 })
859 let resolveRender!: (
860 value: ReturnType<typeof createSsrStreamResponse>,
861 ) => void
862 const renderResult = new Promise<
863 ReturnType<typeof createSsrStreamResponse>
864 >((resolve) => {
865 resolveRender = resolve
866 })
867 let cleanupCalls = 0
868 let cancelCalls = 0
869 let lateStreamResponse!: ReturnType<typeof createSsrStreamResponse>
870 const handler = createStartHandler(({ router: requestRouter }) => {
871 const serverSsr = requestRouter.serverSsr!
872 const cleanup = serverSsr.cleanup
873 serverSsr.cleanup = () => {
874 cleanupCalls++
875 cleanup()
876 }
877 lateStreamResponse = createSsrStreamResponse(
878 requestRouter,
879 new Response(
880 new ReadableStream({
881 cancel() {
882 cancelCalls++
883 return new Promise<void>(() => {})
884 },
885 }),
886 ),
887 )
888 notifyRenderStarted()
889 return renderResult
890 })
891 const response = handler(
892 new Request('http://localhost/', {
893 signal: requestController.signal,
894 }),
895 {},
896 )
897β
898 await renderStarted
899 requestController.abort(new Error('request disconnected'))
900β
901 expect((await response).status).toBe(500)
902 expect(cleanupCalls).toBe(1)
903 expect(router.serverSsr).toBeUndefined()
904β
905 resolveRender(lateStreamResponse)
906 await Promise.resolve()
907 await Promise.resolve()
908 expect(cleanupCalls).toBe(1)
909 expect(cancelCalls).toBe(1)
910 expect(router.serverSsr).toBeUndefined()
911 })
912β
913 it('cancels a plain response resolved by the render callback later', async () => {
914 const router = makeRouter()
915 startMocks.router = router
916 const requestController = new AbortController()
917 let notifyRenderStarted!: () => void
918 const renderStarted = new Promise<void>((resolve) => {
919 notifyRenderStarted = resolve
920 })
921 let resolveRender!: (value: Response) => void
922 const renderResult = new Promise<Response>((resolve) => {
923 resolveRender = resolve
924 })
925 const cancel = vi.fn((_reason: unknown) => new Promise<void>(() => {}))
926 const handler = createStartHandler(() => {
927 notifyRenderStarted()
928 return renderResult
929 })
930 const response = handler(
931 new Request('http://localhost/', {
932 signal: requestController.signal,
933 }),
934 {},
935 )
936β
937 await renderStarted
938 const cancellation = new Error('request disconnected')
939 requestController.abort(cancellation)
940β
941 expect((await response).status).toBe(500)
942 resolveRender(new Response(new ReadableStream({ cancel })))
943 await vi.waitFor(() => {
944 expect(cancel).toHaveBeenCalledTimes(1)
945 expect(cancel).toHaveBeenCalledWith(cancellation)
946 })
947 })
948β
949 it('cancels a plain response resolved by request middleware later', async () => {
950 const router = makeRouter()
951 startMocks.router = router
952 const requestController = new AbortController()
953 let notifyMiddlewareStarted!: () => void
954 const middlewareStarted = new Promise<void>((resolve) => {
955 notifyMiddlewareStarted = resolve
956 })
957 let resolveMiddleware!: (value: Response) => void
958 const middlewareResult = new Promise<Response>((resolve) => {
959 resolveMiddleware = resolve
960 })
961 const cancel = vi.fn((_reason: unknown) => new Promise<void>(() => {}))
962 startMocks.requestMiddleware = [
963 createMiddleware().server(() => {
964 notifyMiddlewareStarted()
965 return middlewareResult
966 }),
967 ]
968 const handler = createStartHandler(() => new Response('must not render'))
969 const response = handler(
970 new Request('http://localhost/', {
971 signal: requestController.signal,
972 }),
973 {},
974 )
975β
976 await middlewareStarted
977 const cancellation = new Error('request disconnected')
978 requestController.abort(cancellation)
979β
980 expect((await response).status).toBe(500)
981 resolveMiddleware(new Response(new ReadableStream({ cancel })))
982 await vi.waitFor(() => {
983 expect(cancel).toHaveBeenCalledTimes(1)
984 expect(cancel).toHaveBeenCalledWith(cancellation)
985 })
986 })
987β
988 it.each(['throw', 'reject'] as const)(
989 'reports a %s from disposal of a late render response',
990 async (failureMode) => {
991 const router = makeRouter()
992 startMocks.router = router
993 const requestController = new AbortController()
994 const cleanupError = new Error('late stream cleanup failed')
995 const dispose = vi.fn(() => {
996 if (failureMode === 'throw') {
997 throw cleanupError
998 }
999 return Promise.reject(cleanupError)
1000 })
1001 const consoleError = vi
1002 .spyOn(console, 'error')
1003 .mockImplementation(() => undefined)
1004 let notifyRenderStarted!: () => void
1005 const renderStarted = new Promise<void>((resolve) => {
1006 notifyRenderStarted = resolve
1007 })
1008 let resolveRender!: (value: any) => void
1009 const renderResult = new Promise<any>((resolve) => {
1010 resolveRender = resolve
1011 })
1012 onTestFinished(() => {
1013 consoleError.mockRestore()
1014 })
1015 onTestFinished(() => {
1016 router.serverSsr?.cleanup()
1017 })
1018β
1019 const handler = createStartHandler(() => {
1020 notifyRenderStarted()
1021 return renderResult
1022 })
1023 const response = handler(
1024 new Request('http://localhost/', {
1025 signal: requestController.signal,
1026 }),
1027 {},
1028 )
1029β
1030 await renderStarted
1031 requestController.abort(new Error('request disconnected'))
1032 expect((await response).status).toBe(500)
1033β
1034 resolveRender({
1035 response: new Response('stream'),
1036 serverSsrCleanup: 'stream',
1037 dispose,
1038 })
1039 await vi.waitFor(() => {
1040 expect(consoleError).toHaveBeenCalledWith(cleanupError)
1041 })
1042 expect(dispose).toHaveBeenCalledOnce()
1043 },
1044 )
1045β
1046 it.each(['throw', 'reject'] as const)(
1047 'reports a stream disposal %s when middleware is aborted',
1048 async (failureMode) => {
1049 const router = makeRouter()
1050 startMocks.router = router
1051 const requestController = new AbortController()
1052 const cleanupError = new Error('custom stream cleanup failed')
1053 const consoleError = vi
1054 .spyOn(console, 'error')
1055 .mockImplementation(() => undefined)
1056 const ssrResponse = makeStreamResponse(router)
1057 const dispose = vi.fn(() => {
1058 if (failureMode === 'throw') {
1059 throw cleanupError
1060 }
1061 return Promise.reject(cleanupError)
1062 })
1063 ;(ssrResponse as any).dispose = dispose
1064 startMocks.serverFnResult = ssrResponse
1065 let notifyMiddlewareStarted!: () => void
1066 const middlewareStarted = new Promise<void>((resolve) => {
1067 notifyMiddlewareStarted = resolve
1068 })
1069 startMocks.requestMiddleware = [
1070 createMiddleware().server(async ({ next }) => {
1071 await next()
1072 notifyMiddlewareStarted()
1073 return new Promise<Response>(() => {})
1074 }),
1075 ]
1076 onTestFinished(() => {
1077 consoleError.mockRestore()
1078 })
1079 onTestFinished(() => {
1080 router.serverSsr?.cleanup()
1081 })
1082β
1083 const handler = createStartHandler(() => new Response('unused'))
1084 const response = handler(
1085 new Request('http://localhost/_serverFn/test', {
1086 headers: { 'x-tsr-serverFn': 'true' },
1087 signal: requestController.signal,
1088 }),
1089 {},
1090 )
1091β
1092 await middlewareStarted
1093 requestController.abort(new Error('request disconnected'))
1094β
1095 expect((await response).status).toBe(500)
1096 await vi.waitFor(() => {
1097 expect(consoleError).toHaveBeenCalledWith(cleanupError)
1098 })
1099 expect(dispose).toHaveBeenCalledOnce()
1100 },
1101 )
1102β
1103 it('disposes a stream when the request aborts after response handoff', async () => {
1104 const router = makeRouter()
1105 startMocks.router = router
1106 const requestController = new AbortController()
1107 let cancelCalls = 0
1108 const handler = createStartHandler(({ router: requestRouter }) =>
1109 createSsrStreamResponse(
1110 requestRouter,
1111 new Response(
1112 new ReadableStream({
1113 cancel() {
1114 cancelCalls++
1115 return new Promise<void>(() => {})
1116 },
1117 }),
1118 ),
1119 ),
1120 )
1121β
1122 const response = await handler(
1123 new Request('http://localhost/', {
1124 signal: requestController.signal,
1125 }),
1126 {},
1127 )
1128 expect(response.body).not.toBeNull()
1129 expect(router.serverSsr).toBeDefined()
1130β
1131 requestController.abort(new Error('request disconnected'))
1132 await Promise.resolve()
1133β
1134 expect(cancelCalls).toBe(1)
1135 expect(router.serverSsr).toBeUndefined()
1136 })
1137β
1138 it('settles when request middleware ignores cancellation', async () => {
1139 const router = makeRouter()
1140 startMocks.router = router
1141 const requestController = new AbortController()
1142 let notifyMiddlewareStarted!: () => void
1143 const middlewareStarted = new Promise<void>((resolve) => {
1144 notifyMiddlewareStarted = resolve
1145 })
1146 const dispose = vi.fn(() => Promise.resolve())
1147 let releaseMiddleware!: (response: any) => void
1148 const middlewareResult = new Promise<any>((resolve) => {
1149 releaseMiddleware = resolve
1150 })
1151 startMocks.requestMiddleware = [
1152 createMiddleware().server(() => {
1153 notifyMiddlewareStarted()
1154 return middlewareResult
1155 }),
1156 ]
1157 const render = vi.fn(() => new Response('must not render'))
1158 const handler = createStartHandler(render)
1159 const response = handler(
1160 new Request('http://localhost/', {
1161 signal: requestController.signal,
1162 }),
1163 {},
1164 )
1165β
1166 await middlewareStarted
1167 requestController.abort(new Error('request disconnected'))
1168β
1169 expect((await response).status).toBe(500)
1170 expect(render).not.toHaveBeenCalled()
1171β
1172 releaseMiddleware({
1173 response: new Response('late'),
1174 serverSsrCleanup: 'stream',
1175 dispose,
1176 })
1177 await vi.waitFor(() => expect(dispose).toHaveBeenCalledOnce())
1178 expect(render).not.toHaveBeenCalled()
1179 })
1180β
1181 it('unwinds nested middleware when an inner operation ignores cancellation', async () => {
1182 const router = makeRouter()
1183 startMocks.router = router
1184 const requestController = new AbortController()
1185 const outerFinally = vi.fn()
1186 let notifyInnerStarted!: () => void
1187 const innerStarted = new Promise<void>((resolve) => {
1188 notifyInnerStarted = resolve
1189 })
1190 const pending = new Promise<Response>(() => {})
1191 startMocks.requestMiddleware = [
1192 createMiddleware().server(({ next }) => next()),
1193 createMiddleware().server(async ({ next }) => {
1194 try {
1195 return await next()
1196 } finally {
1197 outerFinally()
1198 }
1199 }),
1200 createMiddleware().server(() => {
1201 notifyInnerStarted()
1202 return pending
1203 }),
1204 ]
1205 const render = vi.fn(() => new Response('must not render'))
1206 const handler = createStartHandler(render)
1207 const response = handler(
1208 new Request('http://localhost/', {
1209 signal: requestController.signal,
1210 }),
1211 {},
1212 )
1213β
1214 await innerStarted
1215 requestController.abort(new Error('request disconnected'))
1216β
1217 expect((await response).status).toBe(500)
1218 expect(outerFinally).toHaveBeenCalledOnce()
1219 expect(render).not.toHaveBeenCalled()
1220 })
1221β
1222 it('cancels an all-synchronous direct next chain', async () => {
1223 const router = makeRouter()
1224 startMocks.router = router
1225 const requestController = new AbortController()
1226 let notifyInnerStarted!: () => void
1227 const innerStarted = new Promise<void>((resolve) => {
1228 notifyInnerStarted = resolve
1229 })
1230 startMocks.requestMiddleware = [
1231 createMiddleware().server(({ next }) => next()),
1232 createMiddleware().server(({ next }) => next()),
1233 createMiddleware().server(() => {
1234 notifyInnerStarted()
1235 return new Promise<Response>(() => {})
1236 }),
1237 ]
1238 const render = vi.fn(() => new Response('must not render'))
1239 const handler = createStartHandler(render)
1240 const response = handler(
1241 new Request('http://localhost/', {
1242 signal: requestController.signal,
1243 }),
1244 {},
1245 )
1246β
1247 await innerStarted
1248 requestController.abort(new Error('request disconnected'))
1249β
1250 expect((await response).status).toBe(500)
1251 expect(render).not.toHaveBeenCalled()
1252 })
1253β
1254 it('preserves the abort reason when direct next rejects during abort', async () => {
1255 const router = makeRouter()
1256 startMocks.router = router
1257 const requestController = new AbortController()
1258 const reason = new Error('request disconnected')
1259 startMocks.requestMiddleware = [
1260 createMiddleware().server(({ next }) => next()),
1261 createMiddleware().server(() => {
1262 requestController.abort(reason)
1263 throw new Response('must not escape', { status: 418 })
1264 }),
1265 ]
1266 const render = vi.fn(() => new Response('must not render'))
1267 const handler = createStartHandler(render)
1268β
1269 const response = await handler(
1270 new Request('http://localhost/', {
1271 signal: requestController.signal,
1272 }),
1273 {},
1274 )
1275β
1276 expect(response.status).toBe(500)
1277 expect(render).not.toHaveBeenCalled()
1278 })
1279β
1280 it('preserves aborts that race with a fulfilled direct next promise', async () => {
1281 const router = makeRouter()
1282 startMocks.router = router
1283 const requestController = new AbortController()
1284 const reason = new Error('request disconnected')
1285 const observedErrors: Array<unknown> = []
1286 const afterNext = vi.fn()
1287 const ssrResponse = makeStreamResponse(router)
1288 const dispose = vi.spyOn(ssrResponse as any, 'dispose')
1289 const cancel = vi.spyOn(ssrResponse.response.body!, 'cancel')
1290 startMocks.requestMiddleware = [
1291 createMiddleware().server(async ({ next }) => {
1292 try {
1293 const result = await next()
1294 afterNext()
1295 return result
1296 } catch (error) {
1297 observedErrors.push(error)
1298 throw error
1299 }
1300 }),
1301 createMiddleware().server(({ next }) => {
1302 const pending = next()
1303 void Promise.resolve(pending).then(() =>
1304 requestController.abort(reason),
1305 )
1306 return pending
1307 }),
1308 createMiddleware().server(() => ssrResponse as any),
1309 ]
1310 const render = vi.fn(() => new Response('must not render'))
1311 const handler = createStartHandler(render)
1312β
1313 const response = await handler(
1314 new Request('http://localhost/', {
1315 signal: requestController.signal,
1316 }),
1317 {},
1318 )
1319β
1320 expect(response.status).toBe(500)
1321 await vi.waitFor(() => expect(observedErrors).toEqual([reason]))
1322 await vi.waitFor(() => {
1323 expect(dispose).toHaveBeenCalledOnce()
1324 expect(dispose).toHaveBeenCalledWith(reason)
1325 expect(cancel).toHaveBeenCalledOnce()
1326 expect(cancel).toHaveBeenCalledWith(reason)
1327 })
1328 expect(afterNext).not.toHaveBeenCalled()
1329 expect(render).not.toHaveBeenCalled()
1330 })
1331β
1332 it('disposes a tagged final response once when abort wins handoff', async () => {
1333 const router = makeRouter()
1334 startMocks.router = router
1335 const requestController = new AbortController()
1336 const reason = new Error('request disconnected')
1337 const ssrResponse = makeStreamResponse(router)
1338 const dispose = vi.spyOn(ssrResponse as any, 'dispose')
1339 const cancel = vi.spyOn(ssrResponse.response.body!, 'cancel')
1340 startMocks.requestMiddleware = [
1341 createMiddleware().server(() => {
1342 queueMicrotask(() => {
1343 queueMicrotask(() => requestController.abort(reason))
1344 })
1345 return ssrResponse as any
1346 }),
1347 ]
1348 const render = vi.fn(() => new Response('must not render'))
1349 const handler = createStartHandler(render)
1350β
1351 const response = await handler(
1352 new Request('http://localhost/', {
1353 signal: requestController.signal,
1354 }),
1355 {},
1356 )
1357β
1358 expect(response.status).toBe(500)
1359 await vi.waitFor(() => {
1360 expect(dispose).toHaveBeenCalledOnce()
1361 expect(dispose).toHaveBeenCalledWith(reason)
1362 expect(cancel).toHaveBeenCalledOnce()
1363 expect(cancel).toHaveBeenCalledWith(reason)
1364 })
1365 expect(router.serverSsr).toBeUndefined()
1366 expect(render).not.toHaveBeenCalled()
1367 })
1368β
1369 it('ignores a late same-body alias after catch disposes its owner', async () => {
1370 const router = makeRouter()
1371 startMocks.router = router
1372 const requestController = new AbortController()
1373 const reason = new Error('request disconnected')
1374 let notifyResponseCaptured!: () => void
1375 const responseCaptured = new Promise<void>((resolve) => {
1376 notifyResponseCaptured = resolve
1377 })
1378 let releaseMiddleware!: () => void
1379 const middlewareRelease = new Promise<void>((resolve) => {
1380 releaseMiddleware = resolve
1381 })
1382 let notifyLateResultDelivered!: () => void
1383 const lateResultDelivered = new Promise<void>((resolve) => {
1384 notifyLateResultDelivered = resolve
1385 })
1386 startMocks.requestMiddleware = [
1387 createMiddleware().server(async ({ next }) => {
1388 const result = await next()
1389 const wrapped = new Response(result.response.body, result.response)
1390 notifyResponseCaptured()
1391 await middlewareRelease
1392 queueMicrotask(() => {
1393 queueMicrotask(notifyLateResultDelivered)
1394 })
1395 return wrapped
1396 }),
1397 ]
1398 const response = new Response(
1399 new ReadableStream({
1400 start(controller) {
1401 controller.enqueue(new TextEncoder().encode('stream'))
1402 },
1403 }),
1404 )
1405 const cancel = vi.spyOn(response.body!, 'cancel')
1406 let ssrResponse!: ReturnType<typeof createSsrStreamResponse>
1407 const render = vi.fn(({ router: requestRouter }) => {
1408 ssrResponse = createSsrStreamResponse(requestRouter, response)
1409 return ssrResponse
1410 })
1411 const handler = createStartHandler(render)
1412 const result = handler(
1413 new Request('http://localhost/', {
1414 signal: requestController.signal,
1415 }),
1416 {},
1417 )
1418β
1419 await responseCaptured
1420 const dispose = vi.spyOn(ssrResponse as any, 'dispose')
1421 requestController.abort(reason)
1422β
1423 expect((await result).status).toBe(500)
1424 releaseMiddleware()
1425 await lateResultDelivered
1426 await vi.waitFor(() => {
1427 expect(dispose).toHaveBeenCalledOnce()
1428 expect(dispose).toHaveBeenCalledWith(reason)
1429 expect(cancel).toHaveBeenCalledOnce()
1430 expect(cancel).toHaveBeenCalledWith(reason)
1431 })
1432 expect(router.serverSsr).toBeUndefined()
1433 })
1434})
1435β
1436describe('createStartHandler inlineCss option', () => {
1437 const request = new Request('https://example.com/')
1438β
1439 it('defaults to true', async () => {
1440 await expect(
1441 resolveInlineCssForRequest({
1442 request,
1443 handlerInlineCss: undefined,
1444 requestInlineCss: undefined,
1445 }),
1446 ).resolves.toBe(true)
1447 })
1448β
1449 it('uses the handler-level boolean default', async () => {
1450 await expect(
1451 resolveInlineCssForRequest({
1452 request,
1453 handlerInlineCss: false,
1454 requestInlineCss: undefined,
1455 }),
1456 ).resolves.toBe(false)
1457 })
1458β
1459 it('uses the handler-level callback default', async () => {
1460 const handlerInlineCss = vi.fn(({ request: req }) => {
1461 return req.headers.get('x-inline-css') !== 'false'
1462 })
1463 const callbackRequest = new Request('https://example.com/', {
1464 headers: { 'x-inline-css': 'false' },
1465 })
1466β
1467 await expect(
1468 resolveInlineCssForRequest({
1469 request: callbackRequest,
1470 handlerInlineCss,
1471 requestInlineCss: undefined,
1472 }),
1473 ).resolves.toBe(false)
1474 expect(handlerInlineCss).toHaveBeenCalledWith({ request: callbackRequest })
1475 })
1476β
1477 it('lets request options override handler-level options', async () => {
1478 const handlerInlineCss = vi.fn(() => false)
1479β
1480 await expect(
1481 resolveInlineCssForRequest({
1482 request,
1483 handlerInlineCss,
1484 requestInlineCss: true,
1485 }),
1486 ).resolves.toBe(true)
1487β
1488 expect(handlerInlineCss).not.toHaveBeenCalled()
1489 })
1490β
1491 it('returns a static inline CSS default only for non-callback options', () => {
1492 expect(getStaticHandlerInlineCssDefault(undefined)).toBe(true)
1493 expect(getStaticHandlerInlineCssDefault(true)).toBe(true)
1494 expect(getStaticHandlerInlineCssDefault(false)).toBe(false)
1495 expect(getStaticHandlerInlineCssDefault(() => true)).toBe(undefined)
1496 })
1497})