Fix hydration fallback test typing

Author: feedthejim

packages/next/src/client/components/router-reducer/create-initial-router-state.test.ts

@@ -87,7 +87,9 @@ describe('createInitialRouterState output export fallback', () => {
     createInitialRouterState({
       navigatedAt: Date.now(),
       initialRSCPayload,
-      location: new URL('https://example.com/hydrated/first/') as Location,
+      location: new URL(
+        'https://example.com/hydrated/first/'
+      ) as unknown as Location,
       outputExportFallbackBasePath: '/hydrated/__fallback',
     })
 
@@ -122,7 +124,9 @@ describe('createInitialRouterState output export fallback', () => {
         ...initialRSCPayload,
         p: new ReadableStream<Uint8Array>(),
       },
-      location: new URL('https://example.com/hydrated/first/') as Location,
+      location: new URL(
+        'https://example.com/hydrated/first/'
+      ) as unknown as Location,
       outputExportFallbackBasePath: '/hydrated/__fallback',
     })
 

packages/next/src/client/components/segment-cache/cache.test.ts

@@ -2,9 +2,11 @@ import {
   HEAD_REQUEST_KEY,
   type SegmentRequestKey,
 } from '../../../shared/lib/segment-cache/segment-value-encoding'
+import type { VaryParamsThenable } from '../../../shared/lib/segment-cache/vary-params-decoding'
 import { FetchStrategy } from './types'
 import { Fallback } from './cache-map'
 import {
+  EntryStatus,
   getOutputExportSegmentRequestUrl,
   invalidateEntirePrefetchCache,
   readSegmentCacheEntry,
@@ -104,13 +106,13 @@ describe('readOrCreateSegmentCacheEntry output export fallback', () => {
     )
 
     expect(firstEntry).toBe(secondEntry)
-    expect(secondTree.varyPath.parent.parent.value).toBe('second')
-    expect(
-      (
-        secondTree.varyPath.parent
-          .parent as typeof secondTree.varyPath.parent.parent
-      ).value
-    ).not.toBe(Fallback)
+    const secondThreadVaryPath = secondTree.varyPath.parent?.parent
+    expect(secondThreadVaryPath).not.toBeNull()
+    if (secondThreadVaryPath === null) {
+      throw new Error('expected metadata vary path to include thread params')
+    }
+    expect(secondThreadVaryPath.value).toBe('second')
+    expect(secondThreadVaryPath.value).not.toBe(Fallback)
   })
 
   it('rekeys runtime-prefetched fallback segments under generic params', () => {
@@ -137,15 +139,38 @@ describe('readOrCreateSegmentCacheEntry output export fallback', () => {
 
     const firstTree = makeTree('first')
     const secondTree = makeTree('second')
+    const emptyEntry = readOrCreateSegmentCacheEntry(
+      now,
+      FetchStrategy.PPRRuntime,
+      firstTree,
+      '/t/__fallback'
+    )
+    expect(emptyEntry.status).toBe(EntryStatus.Empty)
+    if (emptyEntry.status !== EntryStatus.Empty) {
+      throw new Error('expected a new empty segment cache entry')
+    }
     const ownedEntry = upgradeToPendingSegment(
-      readOrCreateSegmentCacheEntry(
-        now,
-        FetchStrategy.PPRRuntime,
-        firstTree,
-        '/t/__fallback'
-      ),
+      emptyEntry,
       FetchStrategy.PPRRuntime
     )
+    const fulfilledVaryParams = new Set(['threadId'])
+    const fulfilledVaryParamsThenable: VaryParamsThenable = {
+      status: 'fulfilled',
+      value: fulfilledVaryParams,
+      then<TResult1 = Set<string>, TResult2 = never>(
+        onfulfilled?:
+          | ((value: Set<string>) => TResult1 | PromiseLike<TResult1>)
+          | null,
+        _onrejected?:
+          | ((reason: unknown) => TResult2 | PromiseLike<TResult2>)
+          | null
+      ): PromiseLike<TResult1 | TResult2> {
+        if (onfulfilled) {
+          return Promise.resolve(onfulfilled(fulfilledVaryParams))
+        }
+        return Promise.resolve(fulfilledVaryParams as TResult1)
+      },
+    }
 
     writeDynamicRenderResponseIntoCache(
       now,
@@ -161,7 +186,7 @@ describe('readOrCreateSegmentCacheEntry output export fallback', () => {
             {},
             null,
             false,
-            Promise.resolve(new Set(['threadId'])),
+            fulfilledVaryParamsThenable,
           ],
           head: null,
           isHeadPartial: false,
@@ -187,6 +212,6 @@ describe('readOrCreateSegmentCacheEntry output export fallback', () => {
     const secondEntry = readSegmentCacheEntry(now, secondTree.varyPath)
 
     expect(secondEntry).toBe(ownedEntry)
-    expect(secondEntry?.status).toBe(2)
+    expect(secondEntry?.status).toBe(EntryStatus.Fulfilled)
   })
 })

packages/next/src/client/components/segment-cache/vary-path.test.ts

@@ -1,12 +1,23 @@
 import { Fallback } from './cache-map'
 import { FetchStrategy } from './types'
+import {
+  HEAD_REQUEST_KEY,
+  type SegmentRequestKey,
+} from '../../../shared/lib/segment-cache/segment-value-encoding'
 import {
   finalizeMetadataVaryPath,
   finalizePageVaryPath,
   getFulfilledSegmentVaryPath,
   getSegmentVaryPathForRequest,
 } from './vary-path'
 
+function getRequiredParent<T extends { parent: unknown | null }>(
+  path: T
+): Exclude<T['parent'], null> {
+  expect(path.parent).not.toBeNull()
+  return path.parent as Exclude<T['parent'], null>
+}
+
 describe('getSegmentVaryPathForRequest output export fallback', () => {
   it('reuses path params for normal static prefetches', () => {
     const varyPath = finalizeMetadataVaryPath(
@@ -22,8 +33,8 @@ describe('getSegmentVaryPathForRequest output export fallback', () => {
     const requestVaryPath = getSegmentVaryPathForRequest(
       FetchStrategy.PPR,
       {
-        requestKey: '/_head',
-        segment: '/_head',
+        requestKey: HEAD_REQUEST_KEY,
+        segment: HEAD_REQUEST_KEY,
         refreshState: null,
         varyPath,
         isPage: true,
@@ -33,7 +44,9 @@ describe('getSegmentVaryPathForRequest output export fallback', () => {
       null
     )
 
-    expect(requestVaryPath.parent.parent.value).toBe('j97358')
+    expect(getRequiredParent(getRequiredParent(requestVaryPath)).value).toBe(
+      'j97358'
+    )
   })
 
   it('treats path params as reusable for learned output export fallback routes', () => {
@@ -50,8 +63,8 @@ describe('getSegmentVaryPathForRequest output export fallback', () => {
     const requestVaryPath = getSegmentVaryPathForRequest(
       FetchStrategy.PPR,
       {
-        requestKey: '/t/$d$threadId/__PAGE__',
-        segment: '/t/$d$threadId',
+        requestKey: '/t/$d$threadId/__PAGE__' as SegmentRequestKey,
+        segment: '/t/$d$threadId' as SegmentRequestKey,
         refreshState: null,
         varyPath,
         isPage: true,
@@ -61,8 +74,10 @@ describe('getSegmentVaryPathForRequest output export fallback', () => {
       '/t/__fallback'
     )
 
-    expect(requestVaryPath.parent.value).toBe(Fallback)
-    expect(requestVaryPath.parent.parent.value).toBe(Fallback)
+    expect(getRequiredParent(requestVaryPath).value).toBe(Fallback)
+    expect(getRequiredParent(getRequiredParent(requestVaryPath)).value).toBe(
+      Fallback
+    )
   })
 
   it('keeps fulfilled fallback segment path params generic even when vary params include them', () => {
@@ -82,7 +97,9 @@ describe('getSegmentVaryPathForRequest output export fallback', () => {
       true
     )
 
-    expect(fulfilledVaryPath.parent.value).toBe('')
-    expect(fulfilledVaryPath.parent.parent.value).toBe(Fallback)
+    expect(getRequiredParent(fulfilledVaryPath).value).toBe('')
+    expect(getRequiredParent(getRequiredParent(fulfilledVaryPath)).value).toBe(
+      Fallback
+    )
   })
 })