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

hydration.spec.ts

911 lines26.6 KB

1import { expect } from '@playwright/test'
2import { test } from '@tanstack/router-e2e-utils'
3import type { APIRequestContext, Page } from '@playwright/test'
4​
5async function clickAndExpectCount(
6 page: Page,
7 buttonTestId: string,
8 countTestId: string,
9 count: string,
10) {
11 await expect(page.getByTestId(buttonTestId)).toHaveAttribute(
12 'data-hydrated',
13 'true',
14 )
15 await page.getByTestId(buttonTestId).click()
16 await expect(page.getByTestId(countTestId)).toHaveText(count)
18​
19async function clickIntentAndExpectReplayedCount(
20 page: Page,
21 buttonTestId: string,
22 countTestId: string,
23 count: string,
24) {
25 await expectRouteToStayUnhydrated(page, buttonTestId)
26 await page.getByTestId(buttonTestId).click()
27 await expect(page.getByTestId(buttonTestId)).toHaveAttribute(
28 'data-hydrated',
29 'true',
30 )
31 await expect(page.getByTestId(countTestId)).toHaveText(count)
33​
34async function clickToHydrateThenClickAndExpectIncrement(
35 page: Page,
36 buttonTestId: string,
37 countTestId: string,
38) {
39 await expectRouteToStayUnhydrated(page, buttonTestId)
40 await page.getByTestId(buttonTestId).click()
41 await expect(page.getByTestId(buttonTestId)).toHaveAttribute(
42 'data-hydrated',
43 'true',
44 )
45 const previousCount = Number(
46 await page.getByTestId(countTestId).textContent(),
47 )
48 await page.getByTestId(buttonTestId).click()
49 await expect
50 .poll(async () => Number(await page.getByTestId(countTestId).textContent()))
51 .toBe(previousCount + 1)
53​
54async function hoverIntentAndExpectCount(
55 page: Page,
56 buttonTestId: string,
57 countTestId: string,
58 count: string,
59) {
60 await expectRouteToStayUnhydrated(page, buttonTestId)
61 await page.mouse.move(0, 0)
62 await page.getByTestId(buttonTestId).hover()
63 await clickAndExpectCount(page, buttonTestId, countTestId, count)
65​
66async function dispatchHydrationIntent(
67 page: Page,
68 buttonTestId: string,
69 eventName: string,
70) {
71 await page.getByTestId(buttonTestId).evaluate((element, eventName) => {
72 const marker = element.closest('[data-ts-hydrate-id]')
73​
74 if (!marker) {
75 throw new Error('Expected Hydrate marker to exist')
76 }
77​
78 marker.dispatchEvent(
79 new Event(eventName, { bubbles: true, cancelable: true }),
80 )
81 }, eventName)
83​
84async function trackBoundaryStability(page: Page, buttonTestId: string) {
85 await page.getByTestId(buttonTestId).evaluate((element, testId) => {
86 const marker = element.closest('[data-ts-hydrate-id]')
87​
88 if (!(marker instanceof HTMLElement)) {
89 throw new Error('Expected Hydrate marker to exist')
90 }
91​
92 const win = window as typeof window & {
93 __hydrateBoundaryVisualGapCount?: number
94 __hydrateBoundaryMaxScrollDelta?: number
95 __hydrateBoundaryStabilityDone?: boolean
96 }
97 const hasBoundaryButton = () =>
98 Array.from(marker.querySelectorAll('[data-testid]')).some(
99 (child) => child.getAttribute('data-testid') === testId,
100 )
101 const hasHydratedBoundaryButton = () =>
102 Array.from(marker.querySelectorAll('[data-testid]')).some(
103 (child) =>
104 child.getAttribute('data-testid') === testId &&
105 child.getAttribute('data-hydrated') === 'true',
106 )
107 const initialScrollY = window.scrollY
108​
109 win.__hydrateBoundaryVisualGapCount = 0
110 win.__hydrateBoundaryMaxScrollDelta = 0
111 win.__hydrateBoundaryStabilityDone = false
112​
113 let frameCount = 0
114 let hydratedFrameCount = 0
115 let observer: MutationObserver | undefined
116 const recordScroll = () => {
117 win.__hydrateBoundaryMaxScrollDelta = Math.max(
118 win.__hydrateBoundaryMaxScrollDelta ?? 0,
119 Math.abs(window.scrollY - initialScrollY),
120 )
121​
122 if (hasHydratedBoundaryButton()) hydratedFrameCount++
123​
124 frameCount++
125 if (hydratedFrameCount >= 10 || frameCount >= 300) {
126 observer?.disconnect()
127 win.__hydrateBoundaryStabilityDone = true
128 return
129 }
130​
131 requestAnimationFrame(recordScroll)
132 }
133​
134 observer = new MutationObserver(() => {
135 if (!hasBoundaryButton()) {
136 win.__hydrateBoundaryVisualGapCount!++
137 }
138 })
139 observer.observe(marker, { childList: true })
140​
141 requestAnimationFrame(recordScroll)
142 }, buttonTestId)
144​
145async function expectBoundaryStable(page: Page) {
146 await expect
147 .poll(() =>
148 page.evaluate(
149 () =>
150 (
151 window as typeof window & {
152 __hydrateBoundaryStabilityDone?: boolean
153 }
154 ).__hydrateBoundaryStabilityDone ?? false,
155 ),
156 )
157 .toBe(true)
158 await expect
159 .poll(() =>
160 page.evaluate(
161 () =>
162 (
163 window as typeof window & {
164 __hydrateBoundaryVisualGapCount?: number
165 }
166 ).__hydrateBoundaryVisualGapCount ?? 0,
167 ),
168 )
169 .toBe(0)
170 await expect
171 .poll(() =>
172 page.evaluate(
173 () =>
174 (
175 window as typeof window & {
176 __hydrateBoundaryMaxScrollDelta?: number
177 }
178 ).__hydrateBoundaryMaxScrollDelta ?? 0,
179 ),
180 )
181 .toBeLessThanOrEqual(1)
183​
184async function expectRouteToStayUnhydrated(
185 page: Page,
186 buttonTestId: string,
187 duration = 250,
188) {
189 await expect(page.getByTestId(buttonTestId)).toHaveAttribute(
190 'data-hydrated',
191 'false',
192 )
193 await page.waitForTimeout(duration)
194 await expect(page.getByTestId(buttonTestId)).toHaveAttribute(
195 'data-hydrated',
196 'false',
197 )
199​
200async function scrollToBoundary(page: Page, buttonTestId: string) {
201 const button = page.getByTestId(buttonTestId)
202 for (let attempt = 0; attempt < 3; attempt++) {
203 await button.evaluate((element) => {
204 element.scrollIntoView({ block: 'center', inline: 'nearest' })
205 })
206​
207 await page.waitForTimeout(100)
208 const isVisible = await button.evaluate((element) => {
209 const rect = element.getBoundingClientRect()
210 return rect.bottom > 0 && rect.top < window.innerHeight
211 })
212​
213 if (isVisible) return
214 }
215​
216 await expect(button).toBeInViewport()
218​
219async function expectCssProperty(
220 page: Page,
221 testId: string,
222 property: string,
223 value: string,
224) {
225 await expect
226 .poll(() =>
227 page.getByTestId(testId).evaluate((element, propertyName) => {
228 return getComputedStyle(element).getPropertyValue(propertyName)
229 }, property),
230 )
231 .toBe(value)
233​
234function htmlContainsText(html: string, text: string) {
235 const pattern = text.split(' ').join('(?:\\s|<!-- -->)+')
236 expect(html).toMatch(new RegExp(pattern))
238​
239function getModulePreloadHrefs(html: string) {
240 return Array.from(html.matchAll(/<link\b[^>]*>/g), (match) => match[0])
241 .filter((tag) => /\brel="modulepreload"/.test(tag))
242 .map((tag) => tag.match(/\bhref="([^"]+)"/)?.[1])
243 .filter((href): href is string => !!href)
245​
246async function modulePreloadContentsContain(
247 request: APIRequestContext,
248 hrefs: Array<string>,
249 marker: string,
250) {
251 for (const href of hrefs) {
252 const response = await request.get(href)
253 if (!response.ok()) continue
254​
255 const text = await response.text()
256 if (text.includes(marker)) return true
257 }
258​
259 return false
261​
262async function resourceContentsContain(
263 page: Page,
264 request: APIRequestContext,
265 marker: string,
266 filter: (url: string) => boolean,
267) {
268 const resourceUrls = await page.evaluate(() =>
269 performance.getEntriesByType('resource').map((entry) => entry.name),
270 )
271​
272 return modulePreloadContentsContain(
273 request,
274 resourceUrls.filter(filter),
275 marker,
276 )
278​
279async function documentModulePreloadHrefs(page: Page) {
280 return page.evaluate(() =>
281 Array.from(
282 document.querySelectorAll<HTMLLinkElement>('link[rel~="modulepreload"]'),
283 (link) => link.href,
284 ),
285 )
287​
288function isHydrateBoundaryResource(url: string) {
289 return (
290 url.includes('/assets/components-') ||
291 url.includes('/assets/js/async/') ||
292 url.includes('/static/js/async/')
293 )
295​
296function isClientJavaScriptResource(url: string) {
297 return (
298 url.includes('/assets/') ||
299 url.includes('/static/js/') ||
300 url.includes('/static/js/async/')
301 )
303​
304async function expectClientRouterReady(page: Page) {
305 await expect
306 .poll(() =>
307 page.evaluate(() =>
308 Boolean(
309 (
310 globalThis as typeof globalThis & {
311 __TSR_ROUTER__?: unknown
312 }
313 ).__TSR_ROUTER__,
314 ),
315 ),
316 )
317 .toBe(true)
319​
320async function gotoEnhanced(page: Page, search = '') {
321 await page.goto(`/enhanced${search}`)
322 await expectClientRouterReady(page)
324​
325test.describe('component-level Hydrate runtime strategies', () => {
326 test('renders SSR HTML and hydrates each runtime when appropriately', async ({
327 page,
328 request,
329 }) => {
330 await page.goto('/components')
331​
332 await expect(page.getByTestId('component-heading')).toHaveText(
333 'Component Deferred Hydration',
334 )
335​
336 await clickAndExpectCount(
337 page,
338 'component-load-button',
339 'component-load-count',
340 '1',
341 )
342 await clickAndExpectCount(
343 page,
344 'component-idle-button',
345 'component-idle-count',
346 '1',
347 )
348 await expect(
349 resourceContentsContain(page, request, 'component-visible', (url) =>
350 isHydrateBoundaryResource(url),
351 ),
352 ).resolves.toBe(false)
353 await expectRouteToStayUnhydrated(page, 'component-visible-button')
354 await scrollToBoundary(page, 'component-visible-button')
355 await clickAndExpectCount(
356 page,
357 'component-visible-button',
358 'component-visible-count',
359 '1',
360 )
361 await expect
362 .poll(() =>
363 resourceContentsContain(page, request, 'component-visible', (url) =>
364 isHydrateBoundaryResource(url),
365 ),
366 )
367 .toBe(true)
368 await clickAndExpectCount(
369 page,
370 'component-media-button',
371 'component-media-count',
372 '1',
373 )
374 await hoverIntentAndExpectCount(
375 page,
376 'component-interaction-button',
377 'component-interaction-count',
378 '1',
379 )
380 await expect(page.getByTestId('component-on-hydrated-count')).toHaveText(
381 '0',
382 )
383 await expectRouteToStayUnhydrated(page, 'component-custom-single-button')
384 await page.getByTestId('component-custom-single-button').hover()
385 await expectRouteToStayUnhydrated(page, 'component-custom-single-button')
386 await page.getByTestId('component-custom-single-button').click()
387 await expectRouteToStayUnhydrated(page, 'component-custom-single-button')
388 await dispatchHydrationIntent(
389 page,
390 'component-custom-single-button',
391 'dblclick',
392 )
393 await expect(
394 page.getByTestId('component-custom-single-button'),
395 ).toHaveAttribute('data-hydrated', 'true')
396 await expect(page.getByTestId('component-on-hydrated-count')).toHaveText(
397 '1',
398 )
399 await clickAndExpectCount(
400 page,
401 'component-custom-single-button',
402 'component-custom-single-count',
403 '1',
404 )
405 await expect(page.getByTestId('component-on-hydrated-count')).toHaveText(
406 '1',
407 )
408 await expectRouteToStayUnhydrated(page, 'component-custom-multi-button')
409 await dispatchHydrationIntent(
410 page,
411 'component-custom-multi-button',
412 'contextmenu',
413 )
414 await clickAndExpectCount(
415 page,
416 'component-custom-multi-button',
417 'component-custom-multi-count',
418 '1',
419 )
420 await expectRouteToStayUnhydrated(page, 'component-condition-button')
421 await page.getByTestId('component-enable-condition').click()
422 await clickAndExpectCount(
423 page,
424 'component-condition-button',
425 'component-condition-count',
426 '1',
427 )
428 await scrollToBoundary(page, 'component-click-replay-button')
429 await expectRouteToStayUnhydrated(page, 'component-click-replay-button')
430 await trackBoundaryStability(page, 'component-click-replay-button')
431 await page.getByTestId('component-click-replay-button').click()
432 await expect(
433 page.getByTestId('component-click-replay-button'),
434 ).toHaveAttribute('data-hydrated', 'true')
435 await expectBoundaryStable(page)
436 await expect(page.getByTestId('component-click-replay-count')).toHaveText(
437 '1',
438 )
439 await expectRouteToStayUnhydrated(page, 'component-prefetch-button')
440 await expect(
441 resourceContentsContain(page, request, 'component-prefetch', (url) =>
442 isHydrateBoundaryResource(url),
443 ),
444 ).resolves.toBe(false)
445 await page.mouse.move(0, 0)
446 await page.getByTestId('component-prefetch-button').hover()
447 await expect(page.getByTestId('component-prefetch-button')).toHaveAttribute(
448 'data-hydrated',
449 'false',
450 )
451 await expect
452 .poll(() =>
453 resourceContentsContain(page, request, 'component-prefetch', (url) =>
454 isHydrateBoundaryResource(url),
455 ),
456 )
457 .toBe(true)
458 await expect(page.getByTestId('component-prefetch-button')).toHaveAttribute(
459 'data-hydrated',
460 'false',
461 )
462 await page.getByTestId('component-prefetch-button').click()
463 await expect(page.getByTestId('component-prefetch-button')).toHaveAttribute(
464 'data-hydrated',
465 'true',
466 )
467 await expect(page.getByTestId('component-prefetch-count')).toHaveText('1')
468 await hoverIntentAndExpectCount(
469 page,
470 'component-nested-child-button',
471 'component-nested-child-count',
472 '1',
473 )
474​
475 await page.getByTestId('component-never-button').click()
476 await expect(page.getByTestId('component-never-count')).toHaveText('0')
477 })
478​
479 test('replays click after another interaction boundary hydrates first', async ({
480 page,
481 }) => {
482 await page.goto('/components')
483 await expectClientRouterReady(page)
484​
485 await scrollToBoundary(page, 'component-custom-multi-button')
486 await expectRouteToStayUnhydrated(page, 'component-custom-multi-button')
487 await page.getByTestId('component-custom-multi-button').click({
488 button: 'right',
489 })
490 await expect(
491 page.getByTestId('component-custom-multi-button'),
492 ).toHaveAttribute('data-hydrated', 'true')
493​
494 await scrollToBoundary(page, 'component-click-replay-button')
495 await expectRouteToStayUnhydrated(page, 'component-click-replay-button')
496 await trackBoundaryStability(page, 'component-click-replay-button')
497 await page.getByTestId('component-click-replay-button').click()
498 await expect(
499 page.getByTestId('component-click-replay-button'),
500 ).toHaveAttribute('data-hydrated', 'true')
501 await expectBoundaryStable(page)
502 await expect(page.getByTestId('component-click-replay-count')).toHaveText(
503 '1',
504 )
505 })
506​
507 test('keeps bottom scroll stable when a condition boundary hydrates', async ({
508 page,
509 }) => {
510 await page.goto('/components')
511 await expectClientRouterReady(page)
512 await expectRouteToStayUnhydrated(page, 'component-condition-button')
513​
514 await page.evaluate(() => {
515 window.scrollTo(0, document.documentElement.scrollHeight)
516 })
517 await page.waitForTimeout(100)
518 await expect(
519 page.getByTestId('component-enable-condition'),
520 ).toBeInViewport()
521​
522 await trackBoundaryStability(page, 'component-condition-button')
523 await page.getByTestId('component-enable-condition').click()
524 await expect(
525 page.getByTestId('component-condition-button'),
526 ).toHaveAttribute('data-hydrated', 'true')
527 await expectBoundaryStable(page)
528 await clickAndExpectCount(
529 page,
530 'component-condition-button',
531 'component-condition-count',
532 '1',
533 )
534 })
535​
536 test('shows fallback during a client-only mount while the child suspends', async ({
537 page,
538 }) => {
539 await page.goto('/components')
540 await expect(page.getByTestId('component-load-button')).toHaveAttribute(
541 'data-hydrated',
542 'true',
543 )
544 await page.getByTestId('component-show-client-fallback').click()
545​
546 await expect(page.getByTestId('component-client-fallback')).toHaveText(
547 'client fallback',
548 )
549 await expect(page.getByTestId('component-fallback-child')).toHaveText(
550 'fallback child',
551 )
552 await expect(page.getByTestId('component-client-fallback')).toHaveCount(0)
553 })
554})
555​
556test.describe('enhanced Hydrate API combinations', () => {
557 test('server renders dynamic markers without evaluating client-only callbacks or prefetch functions', async ({
558 request,
559 }) => {
560 const response = await request.get('/enhanced?dynamic=interaction')
561 const html = await response.text()
562​
563 expect(response.ok()).toBe(true)
564 htmlContainsText(html, 'Enhanced Hydrate APIs')
565 htmlContainsText(html, 'conditional dynamic')
566 expect(html).toContain('data-ts-hydrate-when="dynamic"')
567 expect(html).not.toContain('missing-element')
568 })
569​
570 test('dynamic when functions hydrate and replay interaction events', async ({
571 page,
572 }) => {
573 await gotoEnhanced(page, '?dynamic=interaction')
574 await expect(page.getByTestId('enhanced-heading')).toHaveText(
575 'Enhanced Hydrate APIs',
576 )
577 await clickIntentAndExpectReplayedCount(
578 page,
579 'enhanced-dynamic-interaction-button',
580 'enhanced-dynamic-interaction-count',
581 '1',
582 )
583​
584 await expectRouteToStayUnhydrated(
585 page,
586 'enhanced-dynamic-conditional-button',
587 )
588 await page.getByTestId('enhanced-dynamic-conditional-button').hover()
589 await expectRouteToStayUnhydrated(
590 page,
591 'enhanced-dynamic-conditional-button',
592 )
593 await clickIntentAndExpectReplayedCount(
594 page,
595 'enhanced-dynamic-conditional-button',
596 'enhanced-dynamic-conditional-count',
597 '1',
598 )
599 })
600​
601 test('procedural prefetch can block hydration, preload the split chunk, and prepare query-like work', async ({
602 page,
603 request,
604 }) => {
605 await gotoEnhanced(page)
606 await expect(
607 resourceContentsContain(
608 page,
609 request,
610 'enhanced-procedural-split-child',
611 isClientJavaScriptResource,
612 ),
613 ).resolves.toBe(false)
614​
615 await expectRouteToStayUnhydrated(page, 'enhanced-procedural-split-button')
616 await expect(page.getByTestId('enhanced-split-wait-reason')).toHaveText(
617 'waiting',
618 )
619 await dispatchHydrationIntent(
620 page,
621 'enhanced-procedural-split-button',
622 'pointerover',
623 )
624 await expect(page.getByTestId('enhanced-split-query')).toHaveText('element')
625 await expect(page.getByTestId('enhanced-split-wait-reason')).toHaveText(
626 'prefetch',
627 )
628 await expect(page.getByTestId('enhanced-split-preload')).toHaveText('done')
629 await expect
630 .poll(() =>
631 resourceContentsContain(
632 page,
633 request,
634 'enhanced-procedural-split-child',
635 isClientJavaScriptResource,
636 ),
637 )
638 .toBe(true)
639​
640 await page.getByTestId('enhanced-procedural-split-button').click()
641 await expect(
642 page.getByTestId('enhanced-procedural-split-button'),
643 ).toHaveAttribute('data-hydrated', 'false')
644 await expect(
645 page.getByTestId('enhanced-procedural-split-count'),
646 ).toHaveText('0')
647 await page.getByTestId('enhanced-release-split-prefetch').click()
648 await expect(
649 page.getByTestId('enhanced-procedural-split-button'),
650 ).toHaveAttribute('data-hydrated', 'true')
651 await expect(
652 page.getByTestId('enhanced-procedural-split-count'),
653 ).toHaveText('1')
654 await expect(page.getByTestId('enhanced-split-query')).toHaveText('done')
655 })
656​
657 test('function prefetch supports fire-and-forget work and waitFor hydrate-first resolution', async ({
658 page,
659 }) => {
660 await gotoEnhanced(page)
661​
662 await expect(page.getByTestId('enhanced-fire-wait-reason')).toHaveText(
663 'waiting',
664 )
665 await dispatchHydrationIntent(
666 page,
667 'enhanced-fire-and-forget-button',
668 'pointerover',
669 )
670 await expect(page.getByTestId('enhanced-fire-wait-reason')).toHaveText(
671 'prefetch',
672 )
673 await expect(page.getByTestId('enhanced-fire-status')).toHaveText('started')
674 await clickIntentAndExpectReplayedCount(
675 page,
676 'enhanced-fire-and-forget-button',
677 'enhanced-fire-and-forget-count',
678 '1',
679 )
680 await expect(page.getByTestId('enhanced-fire-query')).toHaveText('idle')
681 await page.getByTestId('enhanced-release-fire-prefetch').click()
682 await expect(page.getByTestId('enhanced-fire-query')).toHaveText('done')
683​
684 await clickIntentAndExpectReplayedCount(
685 page,
686 'enhanced-hydrate-first-button',
687 'enhanced-hydrate-first-count',
688 '1',
689 )
690 await expect(page.getByTestId('enhanced-hydrate-first-reason')).toHaveText(
691 'hydrate',
692 )
693 })
694​
695 test('split=false procedural prefetch blocks hydration without requiring a child preload chunk', async ({
696 page,
697 }) => {
698 await gotoEnhanced(page)
699​
700 await expectRouteToStayUnhydrated(page, 'enhanced-runtime-only-button')
701 await expect(page.getByTestId('enhanced-runtime-wait-reason')).toHaveText(
702 'waiting',
703 )
704 await dispatchHydrationIntent(
705 page,
706 'enhanced-runtime-only-button',
707 'pointerover',
708 )
709 await expect(page.getByTestId('enhanced-runtime-wait-reason')).toHaveText(
710 'prefetch',
711 )
712 await page.getByTestId('enhanced-runtime-only-button').click()
713 await expect(
714 page.getByTestId('enhanced-runtime-only-button'),
715 ).toHaveAttribute('data-hydrated', 'false')
716 await expect(page.getByTestId('enhanced-runtime-only-count')).toHaveText(
717 '0',
718 )
719 await page.getByTestId('enhanced-release-runtime-prefetch').click()
720 await expect(page.getByTestId('enhanced-runtime-status')).toHaveText(
721 'ready',
722 )
723 await expect(
724 page.getByTestId('enhanced-runtime-only-button'),
725 ).toHaveAttribute('data-hydrated', 'true')
726 await expect(page.getByTestId('enhanced-runtime-only-count')).toHaveText(
727 '1',
728 )
729 })
730​
731 test('procedural prefetch aborts waiters and signals when boundaries unmount', async ({
732 page,
733 }) => {
734 await gotoEnhanced(page)
735​
736 await expectRouteToStayUnhydrated(page, 'enhanced-wait-abort-button')
737 await expect(page.getByTestId('enhanced-wait-abort-reason')).toHaveText(
738 'waiting',
739 )
740 await page.getByTestId('enhanced-hide-wait-abort').click()
741 await expect(page.getByTestId('enhanced-wait-abort-reason')).toHaveText(
742 'abort',
743 )
744​
745 await expect(page.getByTestId('enhanced-abort-status')).toHaveText(
746 'listening',
747 )
748 await page.getByTestId('enhanced-hide-abort').click()
749 await expect(page.getByTestId('enhanced-abort-status')).toHaveText(
750 'aborted',
751 )
752 })
753​
754 test('nested dynamic interaction boundaries delegate through outer boundaries', async ({
755 page,
756 }) => {
757 await gotoEnhanced(page)
758​
759 await clickToHydrateThenClickAndExpectIncrement(
760 page,
761 'enhanced-dynamic-nested-button',
762 'enhanced-dynamic-nested-count',
763 )
764 await clickToHydrateThenClickAndExpectIncrement(
765 page,
766 'enhanced-cross-file-nested-button',
767 'enhanced-cross-file-nested-count',
768 )
769 })
770})
771​
772test.describe('Hydrate CSS delivery', () => {
773 test('ships CSS for deferred, never, shared, and nested boundaries without JavaScript', async ({
774 browser,
775 request,
776 }) => {
777 const response = await request.get('/css')
778 const html = await response.text()
779​
780 htmlContainsText(html, 'CSS Deferred Hydration')
781 htmlContainsText(html, 'Outer CSS')
782 htmlContainsText(html, 'Deferred CSS')
783 htmlContainsText(html, 'Never CSS')
784 htmlContainsText(html, 'Nested CSS')
785​
786 const context = await browser.newContext({ javaScriptEnabled: false })
787 const page = await context.newPage()
788​
789 try {
790 await page.goto('/css')
791​
792 await expect(page.getByTestId('css-heading')).toHaveText(
793 'CSS Deferred Hydration',
794 )
795 await expect(page.getByTestId('css-deferred')).toHaveText('Deferred CSS')
796 await expect(page.getByTestId('css-never')).toHaveText('Never CSS')
797 await expect(page.getByTestId('css-nested')).toHaveText('Nested CSS')
798​
799 await expectCssProperty(page, 'css-outer', 'color', 'rgb(12, 34, 56)')
800 await expectCssProperty(
801 page,
802 'css-deferred',
803 'background-color',
804 'rgb(23, 45, 67)',
805 )
806 await expectCssProperty(page, 'css-never', 'color', 'rgb(45, 67, 89)')
807 await expectCssProperty(
808 page,
809 'css-shared-outer',
810 'border-top-color',
811 'rgb(98, 76, 54)',
812 )
813 await expectCssProperty(
814 page,
815 'css-deferred',
816 'border-top-color',
817 'rgb(98, 76, 54)',
818 )
819 await expectCssProperty(
820 page,
821 'css-nested',
822 'border-left-color',
823 'rgb(67, 89, 123)',
824 )
825 await expectCssProperty(page, 'css-nested', 'border-left-width', '5px')
826 } finally {
827 await context.close()
828 }
829 })
830​
831 test('renders deferred content and omits never content after client-side navigation', async ({
832 page,
833 }) => {
834 await page.goto('/')
835 await expectClientRouterReady(page)
836 await page.getByRole('link', { name: 'CSS', exact: true }).click()
837 await expect(page).toHaveURL(/\/css$/)
838​
839 await expect(page.getByTestId('css-heading')).toHaveText(
840 'CSS Deferred Hydration',
841 )
842 await expect(page.getByTestId('css-deferred')).toHaveText('Deferred CSS')
843 await expect(page.getByTestId('css-never')).toHaveCount(0)
844 await expect(page.getByTestId('css-nested')).toHaveCount(0)
845​
846 await expectCssProperty(
847 page,
848 'css-deferred',
849 'background-color',
850 'rgb(23, 45, 67)',
851 )
852 })
853})
854​
855test.describe('imported Hydrate boundaries', () => {
856 test('does not emit filtered shared Hydrate child JS on the initial document', async ({
857 request,
858 }) => {
859 const response = await request.get('/imported')
860 const html = await response.text()
861​
862 htmlContainsText(html, 'Imported Hydrate')
863 htmlContainsText(html, 'Imported Hydrate Child')
864​
865 await expect(
866 modulePreloadContentsContain(
867 request,
868 getModulePreloadHrefs(html),
869 'imported-hydrate-child',
870 ),
871 ).resolves.toBe(false)
872 })
873​
874 test('does not preload Hydrate child chunks before client navigation', async ({
875 page,
876 request,
877 }) => {
878 await page.goto('/')
879 await expect(page.getByTestId('home-heading')).toHaveText(
880 'Deferred Hydration',
881 )
882 await expectClientRouterReady(page)
883​
884 const link = page.getByRole('link', { name: 'imported Hydrate' })
885 await page.mouse.move(0, 0)
886 await link.hover()
887 await link.focus()
888​
889 await expect(
890 modulePreloadContentsContain(
891 request,
892 await documentModulePreloadHrefs(page),
893 'imported-hydrate-child',
894 ),
895 ).resolves.toBe(false)
896 await expect(
897 resourceContentsContain(page, request, 'imported-hydrate-child', (url) =>
898 isClientJavaScriptResource(url),
899 ),
900 ).resolves.toBe(false)
901​
902 await page.getByRole('link', { name: 'imported Hydrate' }).click()
903 await expect(page).toHaveURL(/\/imported$/)
904 await expect(page.getByTestId('imported-hydrate-fallback')).toHaveCount(0)
905 await expect(page.getByTestId('imported-hydrate-child')).toContainText(
906 'Imported Hydrate Child',
907 )
908 await page.getByTestId('imported-hydrate-child').click()
909 await expect(page.getByTestId('imported-hydrate-count')).toHaveText('1')
910 })
911})