Unverified Commit 7b2b0de7 authored by vercel-fleet-prod[bot]'s avatar vercel-fleet-prod[bot] Committed by GitHub

test: cover dev overlay errors reported during webpack hot updates

Co-authored-by: 's avatarTobias Koppers <1365881+sokra@users.noreply.github.com>
parent 84e6d993
const mockCreateFromFetch = jest.fn()
const mockFetch = jest.fn()
const mockWaitForWebpackRuntimeHotUpdate = jest.fn()
jest.mock('react-server-dom-webpack/client', () => ({
createFromFetch: (...args: unknown[]) => mockCreateFromFetch(...args),
createFromReadableStream: jest.fn(),
}))
jest.mock('../segment-cache/fetch', () => ({
fetch: (...args: unknown[]) => mockFetch(...args),
}))
jest.mock('../../dev/hot-reloader/app/hot-reloader-app', () => ({
waitForWebpackRuntimeHotUpdate: () => mockWaitForWebpackRuntimeHotUpdate(),
}))
import { createFetch } from './fetch-server-response'
function createDeferred<T>() {
let resolve!: (value: T) => void
const promise = new Promise<T>((res) => {
resolve = res
})
return { promise, resolve }
}
// Resolves on the next macrotask, after all pending microtasks have run.
function waitForPendingMicrotasks() {
return new Promise((resolve) => setImmediate(resolve))
}
describe('createFetch', () => {
const originalEnv = process.env
const hadSelf = 'self' in globalThis
beforeAll(() => {
// `createFetch` reads `self.__next_r` in dev.
if (!hadSelf) {
;(globalThis as any).self = globalThis
}
})
afterAll(() => {
if (!hadSelf) {
delete (globalThis as any).self
}
})
beforeEach(() => {
process.env = { ...originalEnv }
delete process.env.__NEXT_SERVER_COMPONENTS_HMR_CANCELLATION
mockCreateFromFetch.mockReset()
mockFetch.mockReset()
mockWaitForWebpackRuntimeHotUpdate.mockReset()
mockCreateFromFetch.mockImplementation(
(promiseForResponse: Promise<Response>) =>
promiseForResponse.then(() => ({}))
)
})
afterEach(() => {
process.env = originalEnv
})
/**
* Starts a navigation fetch and returns the promise that was handed to the
* Flight client, once the Flight client has been created. The network
* response is still pending at that point.
*/
async function startFetch() {
const network = createDeferred<Response>()
const fetchStarted = createDeferred<void>()
mockFetch.mockImplementation(() => {
fetchStarted.resolve()
return network.promise
})
const rscResponsePromise = createFetch(
new URL('http://localhost/target'),
{},
null,
true
)
await fetchStarted.promise
// The Flight client is created as soon as the request starts (before the
// response arrives), so React's debug timing includes the network latency.
expect(mockCreateFromFetch).toHaveBeenCalledTimes(1)
const promiseForResponse: Promise<Response> =
mockCreateFromFetch.mock.calls[0][0]
let resolvedResponse: Response | null = null
promiseForResponse.then((res) => {
resolvedResponse = res
})
const response = new Response('', { status: 200 })
network.resolve(response)
await rscResponsePromise
return { response, getResolvedResponse: () => resolvedResponse }
}
it('defers Flight decoding until the pending webpack hot update is applied', async () => {
process.env.__NEXT_DEV_SERVER = '1'
delete process.env.TURBOPACK
const hotUpdate = createDeferred<void>()
mockWaitForWebpackRuntimeHotUpdate.mockReturnValue(hotUpdate.promise)
const { response, getResolvedResponse } = await startFetch()
// The response has arrived, but the Flight client must not process it
// (and replay server logs into the dev overlay) while the webpack hot
// update is still pending.
await waitForPendingMicrotasks()
expect(mockWaitForWebpackRuntimeHotUpdate).toHaveBeenCalledTimes(1)
expect(getResolvedResponse()).toBe(null)
hotUpdate.resolve()
await waitForPendingMicrotasks()
expect(getResolvedResponse()).toBe(response)
})
it('does not wait for a webpack hot update with Turbopack', async () => {
process.env.__NEXT_DEV_SERVER = '1'
process.env.TURBOPACK = '1'
mockWaitForWebpackRuntimeHotUpdate.mockReturnValue(new Promise(() => {}))
const { response, getResolvedResponse } = await startFetch()
await waitForPendingMicrotasks()
expect(getResolvedResponse()).toBe(response)
expect(mockWaitForWebpackRuntimeHotUpdate).not.toHaveBeenCalled()
})
it('does not wait for a webpack hot update outside of the dev server', async () => {
delete process.env.__NEXT_DEV_SERVER
delete process.env.TURBOPACK
mockWaitForWebpackRuntimeHotUpdate.mockReturnValue(new Promise(() => {}))
const { response, getResolvedResponse } = await startFetch()
await waitForPendingMicrotasks()
expect(getResolvedResponse()).toBe(response)
expect(mockWaitForWebpackRuntimeHotUpdate).not.toHaveBeenCalled()
})
})
import { HMR_MESSAGE_SENT_TO_BROWSER } from '../../../../server/dev/hot-reloader-types'
import type { HmrMessageSentToBrowser } from '../../../../server/dev/hot-reloader-types'
const mockCreateFromReadableStream = jest.fn()
jest.mock('react-server-dom-webpack/client', () => ({
createFromReadableStream: (...args: unknown[]) =>
mockCreateFromReadableStream(...args),
}))
jest.mock('next/dist/compiled/next-devtools', () => ({
dispatcher: new Proxy({}, { get: () => () => {} }),
getSerializedOverlayState: jest.fn(),
getSegmentTrieData: jest.fn(),
}))
jest.mock('../../report-hmr-latency', () => jest.fn())
jest.mock('../../../components/app-router-instance', () => ({
publicAppRouterInstance: { hmrRefresh: jest.fn() },
}))
// Resolves on the next macrotask, after all pending microtasks have run.
function waitForPendingMicrotasks() {
return new Promise((resolve) => setImmediate(resolve))
}
describe('processMessage - ERRORS_TO_SHOW_IN_BROWSER', () => {
const originalEnv = process.env
const hadSelf = 'self' in globalThis
let consoleErrorSpy: jest.SpyInstance
beforeAll(() => {
// The HMR client reads debugging flags from `self`.
if (!hadSelf) {
;(globalThis as any).self = globalThis
}
})
afterAll(() => {
if (!hadSelf) {
delete (globalThis as any).self
}
})
beforeEach(() => {
jest.resetModules()
process.env = { ...originalEnv }
mockCreateFromReadableStream.mockReset()
consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {})
jest.spyOn(console, 'log').mockImplementation(() => {})
})
afterEach(() => {
process.env = originalEnv
jest.restoreAllMocks()
jest.clearAllTimers()
jest.useRealTimers()
delete (globalThis as any).__webpack_hash__
})
function load() {
return require('./hot-reloader-app') as typeof import('./hot-reloader-app')
}
function send(
processMessage: ReturnType<typeof load>['processMessage'],
message: HmrMessageSentToBrowser
) {
processMessage(message, () => {}, jest.fn(), {
pathname: null,
appIsrManifest: null,
})
}
const errorsMessage: HmrMessageSentToBrowser = {
type: HMR_MESSAGE_SENT_TO_BROWSER.ERRORS_TO_SHOW_IN_BROWSER,
serializedErrors: new Uint8Array(),
}
it('waits for the pending webpack hot update before reporting server errors', async () => {
delete process.env.TURBOPACK
const { processMessage } = load()
const serverError = new Error('Route "/target": instant validation error')
mockCreateFromReadableStream.mockResolvedValue({ errors: [serverError] })
// A rebuild starts (e.g. on-demand compilation of a navigation target)...
send(processMessage, { type: HMR_MESSAGE_SENT_TO_BROWSER.BUILDING })
// ...and the server reports errors before the hot update is applied.
send(processMessage, errorsMessage)
await waitForPendingMicrotasks()
// Reporting now would let the upcoming Fast Refresh clear the error.
expect(consoleErrorSpy).not.toHaveBeenCalledWith(serverError)
// The build finishes and there is nothing left to apply, which resolves
// the pending hot update.
;(globalThis as any).__webpack_hash__ = 'hash-1'
send(processMessage, {
type: HMR_MESSAGE_SENT_TO_BROWSER.BUILT,
hash: 'hash-1',
errors: [],
warnings: [],
})
await waitForPendingMicrotasks()
expect(consoleErrorSpy).toHaveBeenCalledWith(serverError)
})
it('reports server errors immediately when no rebuild is pending', async () => {
delete process.env.TURBOPACK
const { processMessage } = load()
const serverError = new Error('Route "/target": instant validation error')
mockCreateFromReadableStream.mockResolvedValue({ errors: [serverError] })
send(processMessage, errorsMessage)
await waitForPendingMicrotasks()
expect(consoleErrorSpy).toHaveBeenCalledWith(serverError)
})
it('does not wait for a webpack hot update with Turbopack', async () => {
// Turbopack's BUILDING handler schedules a delayed HMR latency report.
// Keep it from outliving the test.
jest.useFakeTimers({ doNotFake: ['setImmediate', 'queueMicrotask'] })
process.env.TURBOPACK = '1'
const { processMessage } = load()
const serverError = new Error('Route "/target": instant validation error')
mockCreateFromReadableStream.mockResolvedValue({ errors: [serverError] })
send(processMessage, { type: HMR_MESSAGE_SENT_TO_BROWSER.BUILDING })
send(processMessage, errorsMessage)
await waitForPendingMicrotasks()
expect(consoleErrorSpy).toHaveBeenCalledWith(serverError)
})
})
import { connection } from 'next/server'
export const instant = true
// Reading uncached data without a Suspense boundary fails instant validation.
// The server reports the error via HMR after the navigation has finished.
export default async function Page() {
await connection()
return <p id="instant-validation-error">instant validation error</p>
}
import type { ReactNode } from 'react'
export default function Root({ children }: { children: ReactNode }) {
return (
<html>
<body>{children}</body>
</html>
)
}
import Link from 'next/link'
export default function Page() {
return (
<ul>
<li>
<Link href="/instant-validation-error" prefetch={false}>
instant validation error
</Link>
</li>
<li>
<Link href="/replayed-console-error" prefetch={false}>
replayed console error
</Link>
</li>
</ul>
)
}
// React replays this server log on the client while decoding the navigation's
// Flight response.
export default function Page() {
console.error('replayed server console error')
return <p id="replayed-console-error">replayed console error</p>
}
import { nextTestSetup } from 'e2e-utils'
import {
getRedboxDescription,
openRedbox,
retry,
} from '../../../lib/next-test-utils'
// Delay applying webpack hot updates. This widens the window between a rebuild
// starting and the Fast Refresh at the end of it, which reliably reproduces a
// race that is otherwise timing-dependent.
const HOT_UPDATE_DELAY_MS = 1500
describe('dev-overlay-hmr-race', () => {
const { next, isTurbopack } = nextTestSetup({
files: __dirname,
})
async function softNavigateToUncompiledRoute(href: string, id: string) {
const browser = await next.browser('/', {
async beforePageLoad(page) {
// Not using `page.route()`, because intercepting requests disables the
// browser cache, which makes Next.js bypass server caches and skip
// instant validation.
await page.addInitScript((delayMs) => {
const originalFetch = window.fetch
window.fetch = async (input, init) => {
const url = input instanceof Request ? input.url : String(input)
if (url.includes('.hot-update.json')) {
await new Promise((resolve) => setTimeout(resolve, delayMs))
}
return originalFetch(input, init)
}
}, HOT_UPDATE_DELAY_MS)
},
})
const logCountBeforeNavigation = (await browser.log()).length
// The target route hasn't been compiled yet, so the navigation triggers an
// on-demand rebuild, which is followed by a Fast Refresh.
await browser.elementByCss(`a[href="${href}"]`).click()
await browser.waitForElementByCss(`#${id}`, 20_000)
if (!isTurbopack) {
// Errors that the server reports for the navigation must survive the
// Fast Refresh, so only start looking for them once it's done.
await retry(
async () => {
const logs = (await browser.log()).slice(logCountBeforeNavigation)
expect(logs).toContainEqual(
expect.objectContaining({
message: expect.stringContaining('[Fast Refresh] done'),
})
)
},
20_000,
500,
'wait for Fast Refresh'
)
}
return browser
}
it('shows instant validation errors reported via HMR during a rebuild', async () => {
const browser = await softNavigateToUncompiledRoute(
'/instant-validation-error',
'instant-validation-error'
)
await openRedbox(browser)
expect(await getRedboxDescription(browser)).toContain(
'Next.js encountered uncached data'
)
})
it('shows server console errors replayed from the navigation response during a rebuild', async () => {
const browser = await softNavigateToUncompiledRoute(
'/replayed-console-error',
'replayed-console-error'
)
await openRedbox(browser)
expect(await getRedboxDescription(browser)).toContain(
'replayed server console error'
)
})
})
import type { NextConfig } from 'next'
const nextConfig: NextConfig = {
// Required for instant validation.
cacheComponents: true,
}
export default nextConfig
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment