Unverified Commit 88ad471e authored by Dima Voytenko's avatar Dima Voytenko Committed by GitHub

Concept: test mode for Playwright and similar integration tools (#52520)

An experimental test mode that enables integration tests to mock server-side fetch requests in Playwright tests.

For explanation on how this works, see the [`next-playwright/README.md`](https://github.com/vercel/next.js/pull/52520/files#diff-3b8da7782c16f015df5afafe0ac11247f5b8e5a1c0dbede341ca2b5124dfd924).
parent 3958fc07
export * from '../../dist/experimental/testmode/playwright'
module.exports = require('../../dist/experimental/testmode/playwright')
export * from '../../../dist/experimental/testmode/playwright/msw'
module.exports = require('../../../dist/experimental/testmode/playwright/msw')
export * from '../../dist/experimental/testmode/proxy'
module.exports = require('../../dist/experimental/testmode/proxy')
...@@ -61,7 +61,13 @@ ...@@ -61,7 +61,13 @@
"headers.d.ts", "headers.d.ts",
"navigation-types", "navigation-types",
"web-vitals.js", "web-vitals.js",
"web-vitals.d.ts" "web-vitals.d.ts",
"experimental/testmode/playwright.js",
"experimental/testmode/playwright.d.ts",
"experimental/testmode/playwright/msw.js",
"experimental/testmode/playwright/msw.d.ts",
"experimental/testmode/proxy.js",
"experimental/testmode/proxy.d.ts"
], ],
"bin": { "bin": {
"next": "./dist/bin/next" "next": "./dist/bin/next"
...@@ -143,6 +149,7 @@ ...@@ -143,6 +149,7 @@
"@next/react-refresh-utils": "13.4.15", "@next/react-refresh-utils": "13.4.15",
"@next/swc": "13.4.15", "@next/swc": "13.4.15",
"@opentelemetry/api": "1.4.1", "@opentelemetry/api": "1.4.1",
"@playwright/test": "^1.35.1",
"@segment/ajv-human-errors": "2.1.2", "@segment/ajv-human-errors": "2.1.2",
"@taskr/clear": "1.1.0", "@taskr/clear": "1.1.0",
"@taskr/esnext": "1.1.0", "@taskr/esnext": "1.1.0",
...@@ -245,6 +252,7 @@ ...@@ -245,6 +252,7 @@
"lru-cache": "5.1.1", "lru-cache": "5.1.1",
"micromatch": "4.0.4", "micromatch": "4.0.4",
"mini-css-extract-plugin": "2.4.3", "mini-css-extract-plugin": "2.4.3",
"msw": "^1.2.2",
"nanoid": "3.1.32", "nanoid": "3.1.32",
"native-url": "0.3.4", "native-url": "0.3.4",
"neo-async": "2.6.1", "neo-async": "2.6.1",
...@@ -283,6 +291,7 @@ ...@@ -283,6 +291,7 @@
"stacktrace-parser": "0.1.10", "stacktrace-parser": "0.1.10",
"stream-browserify": "3.0.0", "stream-browserify": "3.0.0",
"stream-http": "3.1.1", "stream-http": "3.1.1",
"strict-event-emitter": "0.5.0",
"string-hash": "1.1.3", "string-hash": "1.1.3",
"string_decoder": "1.3.0", "string_decoder": "1.3.0",
"strip-ansi": "6.0.0", "strip-ansi": "6.0.0",
......
...@@ -189,6 +189,7 @@ const nextDev: CliCommand = async (argv) => { ...@@ -189,6 +189,7 @@ const nextDev: CliCommand = async (argv) => {
'--hostname': String, '--hostname': String,
'--turbo': Boolean, '--turbo': Boolean,
'--experimental-turbo': Boolean, '--experimental-turbo': Boolean,
'--experimental-test-proxy': Boolean,
// To align current messages with native binary. // To align current messages with native binary.
// Will need to adjust subcommand later. // Will need to adjust subcommand later.
...@@ -274,6 +275,7 @@ const nextDev: CliCommand = async (argv) => { ...@@ -274,6 +275,7 @@ const nextDev: CliCommand = async (argv) => {
// some set-ups that rely on listening on other interfaces // some set-ups that rely on listening on other interfaces
const host = args['--hostname'] const host = args['--hostname']
config = await loadConfig(PHASE_DEVELOPMENT_SERVER, dir) config = await loadConfig(PHASE_DEVELOPMENT_SERVER, dir)
const isExperimentalTestProxy = args['--experimental-test-proxy']
const devServerOptions: StartServerOptions = { const devServerOptions: StartServerOptions = {
dir, dir,
...@@ -281,6 +283,7 @@ const nextDev: CliCommand = async (argv) => { ...@@ -281,6 +283,7 @@ const nextDev: CliCommand = async (argv) => {
allowRetry, allowRetry,
isDev: true, isDev: true,
hostname: host, hostname: host,
isExperimentalTestProxy,
} }
if (args['--turbo']) { if (args['--turbo']) {
......
...@@ -14,6 +14,7 @@ const nextStart: CliCommand = async (argv) => { ...@@ -14,6 +14,7 @@ const nextStart: CliCommand = async (argv) => {
'--port': Number, '--port': Number,
'--hostname': String, '--hostname': String,
'--keepAliveTimeout': Number, '--keepAliveTimeout': Number,
'--experimental-test-proxy': Boolean,
// Aliases // Aliases
'-h': '--help', '-h': '--help',
...@@ -46,6 +47,8 @@ const nextStart: CliCommand = async (argv) => { ...@@ -46,6 +47,8 @@ const nextStart: CliCommand = async (argv) => {
const host = args['--hostname'] const host = args['--hostname']
const port = getPort(args) const port = getPort(args)
const isExperimentalTestProxy = args['--experimental-test-proxy']
const keepAliveTimeoutArg: number | undefined = args['--keepAliveTimeout'] const keepAliveTimeoutArg: number | undefined = args['--keepAliveTimeout']
if ( if (
typeof keepAliveTimeoutArg !== 'undefined' && typeof keepAliveTimeoutArg !== 'undefined' &&
...@@ -66,6 +69,7 @@ const nextStart: CliCommand = async (argv) => { ...@@ -66,6 +69,7 @@ const nextStart: CliCommand = async (argv) => {
await startServer({ await startServer({
dir, dir,
isDev: false, isDev: false,
isExperimentalTestProxy,
hostname: host, hostname: host,
port, port,
keepAliveTimeout, keepAliveTimeout,
......
# Experimental test mode for Playwright
### Prerequisites
You have a Next.js project.
### Install `@playwright/test` in your project
```sh
npm install -D @playwright/test
```
### Optionally install MSW in your project
[MSW](https://mswjs.io/) can be helpful for fetch mocking.
```sh
npm install -D msw
```
### Update `playwright.config.ts`
```javascript
import { defineConfig } from 'next/experimental/testmode/playwright'
export default defineConfig({
webServer: {
command: 'npm dev -- --experimental-test-proxy',
url: 'http://localhost:3000',
},
})
```
### Use the `next/experimental/testmode/playwright` to create tests
```javascript
import { test, expect } from 'next/experimental/testmode/playwright'
test('/product/shoe', async ({ page, next }) => {
next.onFetch((request) => {
if (request.url === 'http://my-db/product/shoe') {
return new Response(
JSON.stringify({
title: 'A shoe',
}),
{
headers: {
'Content-Type': 'application/json',
},
}
)
}
return 'abort'
})
await page.goto('/product/shoe')
await expect(page.locator('body')).toHaveText(/Shoe/)
})
```
### Or use the `next/experimental/testmode/playwright/msw`
```javascript
import { test, expect, rest } from 'next/experimental/testmode/playwright/msw'
test.use({
mswHandlers: [
rest.get('http://my-db/product/shoe', (req, res, ctx) => {
return res(
ctx.status(200),
ctx.json({
title: 'A shoe',
})
)
}),
],
})
test('/product/shoe', async ({ page, msw }) => {
msw.use(
rest.get('http://my-db/product/boot', (req, res, ctx) => {
return res.once(
ctx.status(200),
ctx.json({
title: 'A boot',
})
)
})
)
await page.goto('/product/boot')
await expect(page.locator('body')).toHaveText(/Boot/)
})
```
// eslint-disable-next-line import/no-extraneous-dependencies
import { test as base } from '@playwright/test'
import type { NextFixture } from './next-fixture'
import type { NextWorkerFixture } from './next-worker-fixture'
import { applyNextWorkerFixture } from './next-worker-fixture'
import { applyNextFixture } from './next-fixture'
// eslint-disable-next-line import/no-extraneous-dependencies
export * from '@playwright/test'
export type { NextFixture }
export type { FetchHandlerResult } from '../proxy'
export const test = base.extend<
{ next: NextFixture },
{ _nextWorker: NextWorkerFixture }
>({
_nextWorker: [
// eslint-disable-next-line no-empty-pattern
async ({}, use) => {
await applyNextWorkerFixture(use)
},
{ scope: 'worker', auto: true },
],
next: async ({ _nextWorker, page, extraHTTPHeaders }, use, testInfo) => {
await applyNextFixture(use, {
testInfo,
nextWorker: _nextWorker,
page,
extraHTTPHeaders,
})
},
})
export default test
import { test as base } from './index'
import type { NextFixture } from './next-fixture'
import {
type RequestHandler,
type MockedResponse,
MockedRequest,
handleRequest,
// eslint-disable-next-line import/no-extraneous-dependencies
} from 'msw'
// eslint-disable-next-line import/no-extraneous-dependencies
import { Emitter } from 'strict-event-emitter'
// eslint-disable-next-line import/no-extraneous-dependencies
export * from 'msw'
// eslint-disable-next-line import/no-extraneous-dependencies
export * from '@playwright/test'
export type { NextFixture }
export interface MswFixture {
use: (...handlers: RequestHandler[]) => void
}
export const test = base.extend<{
msw: MswFixture
mswHandlers: RequestHandler[]
}>({
mswHandlers: [],
msw: [
async ({ next, mswHandlers }, use) => {
const handlers: RequestHandler[] = [...mswHandlers]
const emitter = new Emitter()
next.onFetch(async (request) => {
const {
body,
method,
headers,
credentials,
cache,
redirect,
integrity,
keepalive,
mode,
destination,
referrer,
referrerPolicy,
} = request
const mockedRequest = new MockedRequest(new URL(request.url), {
body: body ? await request.arrayBuffer() : undefined,
method,
headers: Object.fromEntries(headers),
credentials,
cache,
redirect,
integrity,
keepalive,
mode,
destination,
referrer,
referrerPolicy,
})
let isPassthrough = false
let mockedResponse: MockedResponse | undefined
await handleRequest(
mockedRequest,
handlers.slice(0),
{ onUnhandledRequest: 'error' },
emitter as any,
{
onPassthroughResponse: () => {
isPassthrough = true
},
onMockedResponse: (r) => {
mockedResponse = r
},
}
)
if (isPassthrough) {
return 'continue'
}
if (mockedResponse) {
const {
status,
headers: responseHeaders,
body: responseBody,
delay,
} = mockedResponse
if (delay) {
await new Promise((resolve) => setTimeout(resolve, delay))
}
return new Response(responseBody, {
status,
headers: new Headers(responseHeaders),
})
}
return 'abort'
})
await use({
use: (...newHandlers) => {
handlers.unshift(...newHandlers)
},
})
handlers.length = 0
},
{ auto: true },
],
})
export default test
import type { Page, TestInfo } from '@playwright/test'
import type { NextWorkerFixture, FetchHandler } from './next-worker-fixture'
import { handleRoute } from './page-route'
export interface NextFixture {
onFetch: (handler: FetchHandler) => void
}
class NextFixtureImpl implements NextFixture {
private fetchHandler: FetchHandler | null = null
constructor(
public testId: string,
private worker: NextWorkerFixture,
private page: Page
) {
this.page.route('**', (route) =>
handleRoute(route, page, this.fetchHandler)
)
}
teardown(): void {
this.worker.cleanupTest(this.testId)
}
onFetch(handler: FetchHandler): void {
this.fetchHandler = handler
this.worker.onFetch(this.testId, handler)
}
}
export async function applyNextFixture(
use: (fixture: NextFixture) => Promise<void>,
{
testInfo,
nextWorker,
page,
extraHTTPHeaders,
}: {
testInfo: TestInfo
nextWorker: NextWorkerFixture
page: Page
extraHTTPHeaders: Record<string, string> | undefined
}
): Promise<void> {
const fixture = new NextFixtureImpl(testInfo.testId, nextWorker, page)
page.setExtraHTTPHeaders({
...extraHTTPHeaders,
'Next-Test-Proxy-Port': String(nextWorker.proxyPort),
'Next-Test-Data': fixture.testId,
})
await use(fixture)
fixture.teardown()
}
import type { FetchHandlerResult, ProxyServer } from '../proxy'
import { createProxyServer } from '../proxy'
export type FetchHandler = (
request: Request
) => FetchHandlerResult | Promise<FetchHandlerResult>
export interface NextWorkerFixture {
proxyPort: number
onFetch: (testId: string, handler: FetchHandler) => void
cleanupTest: (testId: string) => void
}
class NextWorkerFixtureImpl implements NextWorkerFixture {
public proxyPort: number = 0
private proxyServer: ProxyServer | null = null
private proxyFetchMap = new Map<string, FetchHandler>()
async setup(): Promise<void> {
const server = await createProxyServer({
onFetch: this.handleProxyFetch.bind(this),
})
this.proxyPort = server.port
this.proxyServer = server
}
teardown(): void {
if (this.proxyServer) {
this.proxyServer.close()
this.proxyServer = null
}
}
cleanupTest(testId: string): void {
this.proxyFetchMap.delete(testId)
}
onFetch(testId: string, handler: FetchHandler): void {
this.proxyFetchMap.set(testId, handler)
}
private async handleProxyFetch(
testId: string,
request: Request
): Promise<FetchHandlerResult> {
const handler = this.proxyFetchMap.get(testId)
return handler?.(request)
}
}
export async function applyNextWorkerFixture(
use: (fixture: NextWorkerFixture) => Promise<void>
): Promise<void> {
const fixture = new NextWorkerFixtureImpl()
await fixture.setup()
await use(fixture)
fixture.teardown()
}
import type { Page, Route } from '@playwright/test'
import type { FetchHandler } from './next-worker-fixture'
export async function handleRoute(
route: Route,
page: Page,
fetchHandler: FetchHandler | null
) {
const request = route.request()
// Continue the navigation and non-fetch requests.
if (request.isNavigationRequest() || request.resourceType() !== 'fetch') {
return route.continue()
}
// Continue the local requests. The followup requests will be intercepted
// on the server.
const pageOrigin = new URL(page.url()).origin
const requestOrigin = new URL(request.url()).origin
if (pageOrigin === requestOrigin) {
return route.continue()
}
if (!fetchHandler) {
return route.abort()
}
const postData = request.postDataBuffer()
const fetchRequest = new Request(request.url(), {
method: request.method(),
headers: Object.fromEntries(
Object.entries(request.headers()).filter(
([name]) => !name.toLowerCase().startsWith('next-test-')
)
),
body: postData ?? null,
})
const proxyResponse = await fetchHandler(fetchRequest)
if (!proxyResponse) {
return route.abort()
}
if (proxyResponse === 'abort') {
return route.abort()
}
if (proxyResponse === 'continue') {
return route.continue()
}
const { status, headers, body } = proxyResponse
return route.fulfill({
status,
headers: Object.fromEntries(headers),
body: body ? Buffer.from(await proxyResponse.arrayBuffer()) : undefined,
})
}
import type { ProxyFetchRequest, ProxyResponse } from './types'
import { ABORT, CONTINUE, UNHANDLED } from './types'
export type FetchHandlerResult =
| Response
| 'abort'
| 'continue'
| null
| undefined
export type FetchHandler = (
testData: string,
request: Request
) => FetchHandlerResult | Promise<FetchHandlerResult>
function buildRequest(req: ProxyFetchRequest): Request {
const { request: proxyRequest } = req
const { url, headers, body, ...options } = proxyRequest
return new Request(url, {
...options,
headers: new Headers(headers),
body: body ? Buffer.from(body, 'base64') : null,
})
}
async function buildResponse(
response: FetchHandlerResult
): Promise<ProxyResponse> {
if (!response) {
return UNHANDLED
}
if (response === 'abort') {
return ABORT
}
if (response === 'continue') {
return CONTINUE
}
const { status, headers, body } = response
return {
api: 'fetch',
response: {
status,
headers: Array.from(headers),
body: body
? Buffer.from(await response.arrayBuffer()).toString('base64')
: null,
},
}
}
export async function handleFetch(
req: ProxyFetchRequest,
onFetch: FetchHandler
): Promise<ProxyResponse> {
const { testData } = req
const request = buildRequest(req)
const response = await onFetch(testData, request)
return buildResponse(response)
}
export { createProxyServer } from './server'
export type { FetchHandler, FetchHandlerResult } from './fetch-api'
export type * from './types'
import http from 'http'
import type { IncomingMessage } from 'http'
import type { ProxyRequest, ProxyResponse, ProxyServer } from './types'
import { UNHANDLED } from './types'
import type { FetchHandler } from './fetch-api'
import { handleFetch } from './fetch-api'
function readBody(req: IncomingMessage): Promise<Buffer> {
return new Promise<Buffer>((resolve, reject) => {
const acc: Buffer[] = []
req.on('data', (chunk) => {
acc.push(chunk)
})
req.on('end', () => {
resolve(Buffer.concat(acc))
})
req.on('error', reject)
})
}
export async function createProxyServer({
onFetch,
}: {
onFetch?: FetchHandler
}): Promise<ProxyServer> {
const server = http.createServer(async (req, res) => {
if (req.url !== '/') {
res.writeHead(404)
res.end()
return
}
let json: ProxyRequest | undefined
try {
json = JSON.parse((await readBody(req)).toString('utf-8')) as ProxyRequest
} catch (e) {
res.writeHead(400)
res.end()
return
}
const { api } = json
let response: ProxyResponse | undefined
switch (api) {
case 'fetch':
if (onFetch) {
response = await handleFetch(json, onFetch)
}
break
default:
break
}
if (!response) {
response = UNHANDLED
}
res.writeHead(200, { 'Content-Type': 'application/json' })
res.write(JSON.stringify(response))
res.end()
})
await new Promise((resolve) => {
server.listen(0, 'localhost', () => {
resolve(undefined)
})
})
const address = server.address()
if (!address || typeof address !== 'object') {
server.close()
throw new Error('Failed to create a proxy server')
}
const port = address.port
const fetchWith: ProxyServer['fetchWith'] = (input, init, testData) => {
const request = new Request(input, init)
request.headers.set('Next-Test-Proxy-Port', String(port))
request.headers.set('Next-Test-Data', testData ?? '')
return fetch(request)
}
return { port, close: () => server.close(), fetchWith }
}
export interface ProxyServer {
readonly port: number
fetchWith(
input: string | URL,
init?: RequestInit,
testData?: string
): Promise<Response>
close(): void
}
interface ProxyRequestBase {
testData: string
api: string
}
interface ProxyResponseBase {
api: string
}
export interface ProxyUnhandledResponse extends ProxyResponseBase {
api: 'unhandled'
}
export interface ProxyAbortResponse extends ProxyResponseBase {
api: 'abort'
}
export interface ProxyContinueResponse extends ProxyResponseBase {
api: 'continue'
}
export interface ProxyFetchRequest extends ProxyRequestBase {
api: 'fetch'
request: {
url: string
headers: Array<[string, string]>
body: string | null
} & Omit<RequestInit, 'headers' | 'body'>
}
export interface ProxyFetchResponse extends ProxyResponseBase {
api: 'fetch'
response: {
status: number
headers: Array<[string, string]>
body: string | null
}
}
export type ProxyRequest = ProxyFetchRequest
export type ProxyResponse =
| ProxyUnhandledResponse
| ProxyAbortResponse
| ProxyContinueResponse
| ProxyFetchResponse
export const ABORT: ProxyResponse = { api: 'abort' }
export const CONTINUE: ProxyResponse = { api: 'continue' }
export const UNHANDLED: ProxyResponse = { api: 'unhandled' }
import { AsyncLocalStorage } from 'async_hooks'
import { NodeRequestHandler } from '../../server/next-server'
import type {
ProxyFetchRequest,
ProxyFetchResponse,
ProxyResponse,
} from './proxy'
interface TestReqInfo {
url: string
proxyPort: number
testData: string
}
const testStorage = new AsyncLocalStorage<TestReqInfo>()
type Fetch = typeof fetch
type FetchInputArg = Parameters<Fetch>[0]
type FetchInitArg = Parameters<Fetch>[1]
async function buildProxyRequest(
testData: string,
request: Request
): Promise<ProxyFetchRequest> {
const {
url,
method,
headers,
body,
cache,
credentials,
integrity,
mode,
redirect,
referrer,
referrerPolicy,
} = request
return {
testData,
api: 'fetch',
request: {
url,
method,
headers: Array.from(headers),
body: body
? Buffer.from(await request.arrayBuffer()).toString('base64')
: null,
cache,
credentials,
integrity,
mode,
redirect,
referrer,
referrerPolicy,
},
}
}
function buildResponse(proxyResponse: ProxyFetchResponse): Response {
const { status, headers, body } = proxyResponse.response
return new Response(body ? Buffer.from(body, 'base64') : null, {
status,
headers: new Headers(headers),
})
}
function interceptFetch() {
const originalFetch = global.fetch
global.fetch = async function testFetch(
input: FetchInputArg,
init?: FetchInitArg
): Promise<Response> {
// Passthrough internal requests.
// @ts-ignore
if (init?.next?.internal) {
return originalFetch(input, init)
}
const testInfo = testStorage.getStore()
if (!testInfo) {
throw new Error('No test info')
}
const { testData, proxyPort } = testInfo
const originalRequest = new Request(input, init)
const proxyRequest = await buildProxyRequest(testData, originalRequest)
const resp = await originalFetch(`http://localhost:${proxyPort}`, {
method: 'POST',
body: JSON.stringify(proxyRequest),
})
if (!resp.ok) {
throw new Error(`Proxy request failed: ${resp.status}`)
}
const proxyResponse = (await resp.json()) as ProxyResponse
const { api } = proxyResponse
switch (api) {
case 'continue':
return originalFetch(originalRequest)
case 'abort':
case 'unhandled':
throw new Error('Proxy request aborted')
default:
break
}
return buildResponse(proxyResponse)
}
}
export function interceptTestApis(): () => void {
const originalFetch = global.fetch
interceptFetch()
// Cleanup.
return () => {
global.fetch = originalFetch
}
}
export function wrapRequestHandler(
handler: NodeRequestHandler
): NodeRequestHandler {
return async (req, res, parsedUrl) => {
const proxyPortHeader = req.headers['next-test-proxy-port']
if (!proxyPortHeader) {
await handler(req, res, parsedUrl)
return
}
const url = req.url ?? ''
const proxyPort = Number(proxyPortHeader)
const testData = (req.headers['next-test-data'] as string | undefined) ?? ''
const testReqInfo: TestReqInfo = {
url,
proxyPort,
testData,
}
await testStorage.run(testReqInfo, () => handler(req, res, parsedUrl))
}
}
...@@ -145,6 +145,10 @@ export interface Options { ...@@ -145,6 +145,10 @@ export interface Options {
* Tells if Next.js is running in dev mode * Tells if Next.js is running in dev mode
*/ */
dev?: boolean dev?: boolean
/**
* Enables the experimental testing mode.
*/
experimentalTestProxy?: boolean
/** /**
* Where the Next project is located * Where the Next project is located
*/ */
......
...@@ -72,6 +72,7 @@ export async function initialize(opts: { ...@@ -72,6 +72,7 @@ export async function initialize(opts: {
isNodeDebugging: boolean isNodeDebugging: boolean
keepAliveTimeout?: number keepAliveTimeout?: number
serverFields?: any serverFields?: any
experimentalTestProxy: boolean
}): Promise<NonNullable<typeof result>> { }): Promise<NonNullable<typeof result>> {
// if we already setup the server return as we only need to do // if we already setup the server return as we only need to do
// this on first worker boot // this on first worker boot
......
...@@ -65,6 +65,7 @@ export async function initialize(opts: { ...@@ -65,6 +65,7 @@ export async function initialize(opts: {
isNodeDebugging: boolean isNodeDebugging: boolean
keepAliveTimeout?: number keepAliveTimeout?: number
customServer?: boolean customServer?: boolean
experimentalTestProxy?: boolean
}): Promise<[WorkerRequestHandler, WorkerUpgradeHandler]> { }): Promise<[WorkerRequestHandler, WorkerUpgradeHandler]> {
process.title = 'next-router-worker' process.title = 'next-router-worker'
...@@ -131,6 +132,7 @@ export async function initialize(opts: { ...@@ -131,6 +132,7 @@ export async function initialize(opts: {
dev: !!opts.dev, dev: !!opts.dev,
isNodeDebugging: !!opts.isNodeDebugging, isNodeDebugging: !!opts.isNodeDebugging,
serverFields: devInstance?.serverFields || {}, serverFields: devInstance?.serverFields || {},
experimentalTestProxy: !!opts.experimentalTestProxy,
} }
const renderWorkers: { const renderWorkers: {
app?: RenderWorker app?: RenderWorker
......
...@@ -25,6 +25,7 @@ export interface StartServerOptions { ...@@ -25,6 +25,7 @@ export interface StartServerOptions {
customServer?: boolean customServer?: boolean
minimalMode?: boolean minimalMode?: boolean
keepAliveTimeout?: number keepAliveTimeout?: number
isExperimentalTestProxy?: boolean
} }
export async function getRequestHandlers({ export async function getRequestHandlers({
...@@ -35,6 +36,7 @@ export async function getRequestHandlers({ ...@@ -35,6 +36,7 @@ export async function getRequestHandlers({
minimalMode, minimalMode,
isNodeDebugging, isNodeDebugging,
keepAliveTimeout, keepAliveTimeout,
experimentalTestProxy,
}: { }: {
dir: string dir: string
port: number port: number
...@@ -43,6 +45,7 @@ export async function getRequestHandlers({ ...@@ -43,6 +45,7 @@ export async function getRequestHandlers({
minimalMode?: boolean minimalMode?: boolean
isNodeDebugging?: boolean isNodeDebugging?: boolean
keepAliveTimeout?: number keepAliveTimeout?: number
experimentalTestProxy?: boolean
}): ReturnType<typeof initialize> { }): ReturnType<typeof initialize> {
return initialize({ return initialize({
dir, dir,
...@@ -53,6 +56,7 @@ export async function getRequestHandlers({ ...@@ -53,6 +56,7 @@ export async function getRequestHandlers({
workerType: 'router', workerType: 'router',
isNodeDebugging: isNodeDebugging || false, isNodeDebugging: isNodeDebugging || false,
keepAliveTimeout, keepAliveTimeout,
experimentalTestProxy,
}) })
} }
...@@ -64,6 +68,7 @@ export async function startServer({ ...@@ -64,6 +68,7 @@ export async function startServer({
minimalMode, minimalMode,
allowRetry, allowRetry,
keepAliveTimeout, keepAliveTimeout,
isExperimentalTestProxy,
logReady = true, logReady = true,
}: StartServerOptions): Promise<void> { }: StartServerOptions): Promise<void> {
let handlersReady = () => {} let handlersReady = () => {}
...@@ -203,6 +208,7 @@ export async function startServer({ ...@@ -203,6 +208,7 @@ export async function startServer({
minimalMode, minimalMode,
isNodeDebugging: Boolean(isNodeDebugging), isNodeDebugging: Boolean(isNodeDebugging),
keepAliveTimeout, keepAliveTimeout,
experimentalTestProxy: !!isExperimentalTestProxy,
}) })
requestHandler = initResult[0] requestHandler = initResult[0]
upgradeHandler = initResult[1] upgradeHandler = initResult[1]
......
...@@ -221,6 +221,12 @@ export default class NextNodeServer extends BaseServer { ...@@ -221,6 +221,12 @@ export default class NextNodeServer extends BaseServer {
// ensure options are set when loadConfig isn't called // ensure options are set when loadConfig isn't called
setHttpClientAndAgentOptions(this.nextConfig) setHttpClientAndAgentOptions(this.nextConfig)
// Intercept fetch and other testmode apis.
if (this.serverOptions.experimentalTestProxy) {
const { interceptTestApis } = require('../experimental/testmode/server')
interceptTestApis()
}
} }
protected async prepareImpl() { protected async prepareImpl() {
...@@ -1065,11 +1071,20 @@ export default class NextNodeServer extends BaseServer { ...@@ -1065,11 +1071,20 @@ export default class NextNodeServer extends BaseServer {
} }
public getRequestHandler(): NodeRequestHandler { public getRequestHandler(): NodeRequestHandler {
const handler = this.makeRequestHandler()
if (this.serverOptions.experimentalTestProxy) {
const { wrapRequestHandler } = require('../experimental/testmode/server')
return wrapRequestHandler(handler)
}
return handler
}
private makeRequestHandler(): NodeRequestHandler {
// This is just optimization to fire prepare as soon as possible // This is just optimization to fire prepare as soon as possible
// It will be properly awaited later // It will be properly awaited later
void this.prepare() void this.prepare()
const handler = super.getRequestHandler() const handler = super.getRequestHandler()
return async (req, res, parsedUrl) => { return (req, res, parsedUrl) => {
const normalizedReq = this.normalizeReq(req) const normalizedReq = this.normalizeReq(req)
const normalizedRes = this.normalizeRes(res) const normalizedRes = this.normalizeRes(res)
......
...@@ -2374,6 +2374,7 @@ export async function compile(task, opts) { ...@@ -2374,6 +2374,7 @@ export async function compile(task, opts) {
'shared_re_exported', 'shared_re_exported',
'shared_re_exported_esm', 'shared_re_exported_esm',
'server_wasm', 'server_wasm',
'experimental_testmode',
// we compile this each time so that fresh runtime data is pulled // we compile this each time so that fresh runtime data is pulled
// before each publish // before each publish
'ncc_amp_optimizer', 'ncc_amp_optimizer',
...@@ -2639,6 +2640,13 @@ export async function server_wasm(task, opts) { ...@@ -2639,6 +2640,13 @@ export async function server_wasm(task, opts) {
await task.source('src/server/**/*.+(wasm)').target('dist/server') await task.source('src/server/**/*.+(wasm)').target('dist/server')
} }
export async function experimental_testmode(task, opts) {
await task
.source('src/experimental/testmode/**/!(*.test).+(js|ts|tsx)')
.swc('server', {})
.target('dist/experimental/testmode')
}
export async function release(task) { export async function release(task) {
await task.clear('dist').start('build') await task.clear('dist').start('build')
} }
......
...@@ -18,6 +18,7 @@ ...@@ -18,6 +18,7 @@
"legacy/*.d.ts", "legacy/*.d.ts",
"types/compiled.d.ts", "types/compiled.d.ts",
"navigation-types/*.d.ts", "navigation-types/*.d.ts",
"navigation-types/compat/*.d.ts" "navigation-types/compat/*.d.ts",
"experimental/**/*.d.ts"
] ]
} }
This diff is collapsed.
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