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

createStartHandler.test.ts

1,497 lines47.2 KB

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
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
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 })
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))
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 {},
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 },
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
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 }),
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 {},
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 },
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 ),
1121​
1122 const response = await handler(
1123 new Request('http://localhost/', {
1124 signal: requestController.signal,
1125 }),
1126 {},
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 }),
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 {},
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()
1199 }),
1200 createMiddleware().server(() => {
1201 notifyInnerStarted()
1202 return pending
1203 }),
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 {},
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 }),
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 {},
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 }),
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 {},
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
1300 }),
1301 createMiddleware().server(({ next }) => {
1302 const pending = next()
1303 void Promise.resolve(pending).then(() =>
1304 requestController.abort(reason),
1306 return pending
1307 }),
1308 createMiddleware().server(() => ssrResponse as any),
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 {},
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 }),
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 {},
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 }),
1398 const response = new Response(
1399 new ReadableStream({
1400 start(controller) {
1401 controller.enqueue(new TextEncoder().encode('stream'))
1402 },
1403 }),
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 {},
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 })
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 })