Skip to content

Playwright is a framework for Web Testing and Automation. It allows testing Chromium, Firefox and WebKit with a single API.

chore: allow mdb running over stdio (#37143)

Pavel Feldmane32f3ea1432a
diff --git a/packages/playwright/src/index.ts b/packages/playwright/src/index.ts
index d8fed58ca4..bdaeda9832 100644
--- a/packages/playwright/src/index.ts
+++ b/packages/playwright/src/index.ts
@@ -240,7 +240,7 @@ const playwrightFixtures: Fixtures<TestFixtures, WorkerFixtures> = ({
(testInfo as TestInfoImpl)._setDebugMode();
playwright._defaultContextOptions = _combinedContextOptions;
- playwright._defaultContextTimeout = process.env.PLAYWRIGHT_TEST_DEBUGGER_MCP ? 5000 : actionTimeout || 0;
+ playwright._defaultContextTimeout = process.env.PLAYWRIGHT_DEBUGGER_MCP ? 5000 : actionTimeout || 0;
playwright._defaultContextNavigationTimeout = navigationTimeout || 0;
await use();
playwright._defaultContextOptions = undefined;
diff --git a/packages/playwright/src/mcp/browser/backend.ts b/packages/playwright/src/mcp/browser/backend.ts
index 5e2b87c43c..cd815dc393 100644
--- a/packages/playwright/src/mcp/browser/backend.ts
+++ b/packages/playwright/src/mcp/browser/backend.ts
@@ -25,10 +25,16 @@ import type { Tool } from './tool';
import type * as playwright from '../../../index';
import type { ServerBackendOnPause } from '../sdk/mdb';
+type PageEx = playwright.Page & {
+ _snapshotForAI: () => Promise<string>;
+};
+
+const tools = [snapshot, pickLocator, evaluate];
+
export class BrowserBackend implements ServerBackendOnPause {
readonly name = 'Playwright';
readonly version = '0.0.1';
- private _tools: Tool<any>[] = [snapshot, pickLocator, evaluate];
+ private _tools: Tool<any>[] = tools;
private _page: playwright.Page;
constructor(page: playwright.Page) {
@@ -67,8 +73,16 @@ const doneToolSchema = defineToolSchema({
});
export async function runBrowserBackendOnError(page: playwright.Page, message: () => string) {
- if (!process.env.PLAYWRIGHT_TEST_DEBUGGER_MCP)
+ if (!process.env.PLAYWRIGHT_DEBUGGER_MCP)
return;
- const introMessage = `Paused on error:\n\n${stripAnsiEscapes(message())}\n\nTry recovering from the error prior to continuing.`;
- await runOnPauseBackendLoop(process.env.PLAYWRIGHT_TEST_DEBUGGER_MCP!, new BrowserBackend(page), introMessage);
+ const snapshot = await (page as PageEx)._snapshotForAI();
+ const introMessage = `### Paused on error:
+${stripAnsiEscapes(message())}
+
+### Current page snapshot:
+${snapshot}
+
+### Task
+Try recovering from the error prior to continuing, use following tools to recover: ${tools.map(tool => tool.schema.name).join(', ')}`;
+ await runOnPauseBackendLoop(process.env.PLAYWRIGHT_DEBUGGER_MCP!, new BrowserBackend(page), introMessage);
}
diff --git a/packages/playwright/src/mcp/browser/tools.ts b/packages/playwright/src/mcp/browser/tools.ts
index ee00bd62be..c9ddcccec9 100644
--- a/packages/playwright/src/mcp/browser/tools.ts
+++ b/packages/playwright/src/mcp/browser/tools.ts
@@ -28,9 +28,9 @@ type PageEx = playwright.Page & {
export const snapshot = defineTool({
schema: {
- name: 'browser_snapshot',
- title: 'Page snapshot',
- description: 'Capture accessibility snapshot of the current page, this is better than screenshot',
+ name: 'playwright_test_browser_snapshot',
+ title: 'Capture page snapshot',
+ description: 'Capture page snapshot for debugging',
inputSchema: mcp.z.object({}),
type: 'readOnly',
},
@@ -55,28 +55,26 @@ export const elementSchema = mcp.z.object({
export const pickLocator = defineTool({
schema: {
- name: 'browser_pick_locator',
- title: 'Pick locator',
- description: 'Pick a locator for the given element',
+ name: 'playwright_test_generate_locator',
+ title: 'Create locator for element',
+ description: 'Generate locator for the given element to use in tests',
inputSchema: elementSchema,
type: 'readOnly',
},
handle: async (page, params) => {
const locator = await refLocator(page, params);
- const locatorString = await generateLocator(locator);
- return {
- content: [
- {
- type: 'text',
- text: locatorString,
- },
- ],
- };
+
+ try {
+ const { resolvedSelector } = await (locator as any)._resolveSelector();
+ const locatorString = asLocator('javascript', resolvedSelector);
+ return { content: [{ type: 'text', text: locatorString }] };
+ } catch (e) {
+ throw new Error(`Ref not found, likely because element was removed. Use ${snapshot.schema.name} to see what elements are currently on the page.`);
+ }
},
});
-
const evaluateSchema = mcp.z.object({
function: mcp.z.string().describe('() => { /* code */ } or (element) => { /* code */ } when element is provided'),
element: mcp.z.string().optional().describe('Human-readable element description used to obtain permission to interact with the element'),
@@ -85,8 +83,8 @@ const evaluateSchema = mcp.z.object({
export const evaluate = defineTool({
schema: {
- name: 'browser_evaluate',
- title: 'Evaluate JavaScript',
+ name: 'playwright_test_evaluate_on_pause',
+ title: 'Evaluate in page',
description: 'Evaluate JavaScript expression on page or element',
inputSchema: evaluateSchema,
type: 'destructive',
@@ -114,12 +112,3 @@ async function refLocator(page: playwright.Page, elementRef: z.output<typeof ele
throw new Error(`Ref ${elementRef.ref} not found in the current page snapshot. Try capturing new snapshot.`);
return page.locator(`aria-ref=${elementRef.ref}`).describe(elementRef.element);
}
-
-async function generateLocator(locator: playwright.Locator): Promise<string> {
- try {
- const { resolvedSelector } = await (locator as any)._resolveSelector();
- return asLocator('javascript', resolvedSelector);
- } catch (e) {
- throw new Error('Ref not found, likely because element was removed. Use browser_snapshot to see what elements are currently on the page.');
- }
-}
diff --git a/packages/playwright/src/mcp/sdk/mdb.ts b/packages/playwright/src/mcp/sdk/mdb.ts
index b446587d5e..4c58863bde 100644
--- a/packages/playwright/src/mcp/sdk/mdb.ts
+++ b/packages/playwright/src/mcp/sdk/mdb.ts
@@ -24,19 +24,30 @@ import * as mcpBundle from './bundle.js';
import { defineToolSchema } from './tool.js';
import * as mcpServer from './server.js';
import * as mcpHttp from './http.js';
-import { callTool } from './call.js';
+import { wrapInProcess } from './server.js';
import type { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+const mdbDebug = debug('pw:mcp:mdb');
const errorsDebug = debug('pw:mcp:errors');
export class MDBBackend implements mcpServer.ServerBackend {
private _stack: { client: Client, toolNames: string[], resultPromise: ManualPromise<mcpServer.CallToolResult> | undefined }[] = [];
private _interruptPromise: ManualPromise<mcpServer.CallToolResult> | undefined;
- private _server!: mcpServer.Server;
+ private _topLevelBackend: mcpServer.ServerBackend;
+ private _initialized = false;
+
+ constructor(topLevelBackend: mcpServer.ServerBackend) {
+ this._topLevelBackend = topLevelBackend;
+ }
async initialize(server: mcpServer.Server): Promise<void> {
- this._server = server;
+ if (this._initialized)
+ return;
+ this._initialized = true;
+ const transport = await wrapInProcess(this._topLevelBackend);
+ await this._pushClient(transport);
}
async listTools(): Promise<mcpServer.Tool[]> {
@@ -48,11 +59,13 @@ export class MDBBackend implements mcpServer.ServerBackend {
if (name === pushToolsSchema.name)
return await this._pushTools(pushToolsSchema.inputSchema.parse(args || {}));
- this._interruptPromise = new ManualPromise<mcpServer.CallToolResult>();
+ const interruptPromise = new ManualPromise<mcpServer.CallToolResult>();
+ this._interruptPromise = interruptPromise;
let [entry] = this._stack;
// Pop the client while the tool is not found.
while (entry && !entry.toolNames.includes(name)) {
+ mdbDebug('popping client from stack for ', name);
this._stack.shift();
await entry.client.close();
entry = this._stack[0];
@@ -67,13 +80,19 @@ export class MDBBackend implements mcpServer.ServerBackend {
}).then(result => {
resultPromise.resolve(result as mcpServer.CallToolResult);
}).catch(e => {
+ mdbDebug('error in client call', e);
if (this._stack.length < 2)
throw e;
this._stack.shift();
const prevEntry = this._stack[0];
void prevEntry.resultPromise!.then(result => resultPromise.resolve(result));
});
- return await Promise.race([this._interruptPromise, resultPromise]);
+ const result = await Promise.race([interruptPromise, resultPromise]);
+ if (interruptPromise.isDone())
+ mdbDebug('client call intercepted', result);
+ else
+ mdbDebug('client call result', result);
+ return result;
}
private _client(): Client {
@@ -84,24 +103,29 @@ export class MDBBackend implements mcpServer.ServerBackend {
}
private async _pushTools(params: { mcpUrl: string, introMessage?: string }): Promise<mcpServer.CallToolResult> {
+ mdbDebug('pushing tools to the stack', params.mcpUrl);
+ const transport = new StreamableHTTPClientTransport(new URL(params.mcpUrl));
+ await this._pushClient(transport, params.introMessage);
+ return { content: [{ type: 'text', text: 'Tools pushed' }] };
+ }
+
+ private async _pushClient(transport: Transport, introMessage?: string): Promise<mcpServer.CallToolResult> {
+ mdbDebug('pushing client to the stack');
const client = new mcpBundle.Client({ name: 'Internal client', version: '0.0.0' });
client.setRequestHandler(PingRequestSchema, () => ({}));
- const transport = new StreamableHTTPClientTransport(new URL(params.mcpUrl));
await client.connect(transport);
-
+ mdbDebug('connected to the new client');
+ const { tools } = await client.listTools();
+ this._stack.unshift({ client, toolNames: tools.map(tool => tool.name), resultPromise: undefined });
+ mdbDebug('new tools added to the stack:', tools.map(tool => tool.name));
+ mdbDebug('interrupting current call:', !!this._interruptPromise);
this._interruptPromise?.resolve({
content: [{
type: 'text',
- text: params.introMessage || '',
+ text: introMessage || '',
}],
});
this._interruptPromise = undefined;
-
- const { tools } = await client.listTools();
- this._stack.unshift({ client, toolNames: tools.map(tool => tool.name), resultPromise: undefined });
- await this._server.notification({
- method: 'notifications/tools/list_changed',
- });
return { content: [{ type: 'text', text: 'Tools pushed' }] };
}
}
@@ -121,22 +145,21 @@ export type ServerBackendOnPause = mcpServer.ServerBackend & {
requestSelfDestruct?: () => void;
};
-export async function runToolsBackend(backendFactory: mcpServer.ServerBackendFactory, options: { port: number }): Promise<string> {
- const mdbBackend = new MDBBackend();
- const mdbBackendFactory = {
- name: 'Playwright MDB',
- nameInConfig: 'playwright-mdb',
- version: '0.0.0',
+export async function runMainBackend(backendFactory: mcpServer.ServerBackendFactory, options?: { port?: number }): Promise<string | undefined> {
+ const mdbBackend = new MDBBackend(backendFactory.create());
+ // Start HTTP unconditionally.
+ const factory: mcpServer.ServerBackendFactory = {
+ ...backendFactory,
create: () => mdbBackend
};
+ const url = await startAsHttp(factory, { port: options?.port || 0 });
+ process.env.PLAYWRIGHT_DEBUGGER_MCP = url;
- const mdbUrl = await startAsHttp(mdbBackendFactory, options);
+ if (options?.port !== undefined)
+ return url;
- const backendUrl = await startAsHttp(backendFactory, { port: 0 });
- const result = await callTool(mdbUrl, pushToolsSchema.name, { mcpUrl: backendUrl });
- if (result.isError)
- errorsDebug('Failed to push tools', result.content);
- return mdbUrl;
+ // Start stdio conditionally.
+ await mcpServer.connect(factory, new mcpBundle.StdioServerTransport(), false);
}
export async function runOnPauseBackendLoop(mdbUrl: string, backend: ServerBackendOnPause, introMessage: string) {
@@ -202,8 +225,8 @@ class OnceTimeServerBackendWrapper implements mcpServer.ServerBackend {
return this._backend.callTool(name, args);
}
- serverClosed() {
- this._backend.serverClosed?.();
+ serverClosed(server: mcpServer.Server) {
+ this._backend.serverClosed?.(server);
this._selfDestructPromise.resolve();
}
diff --git a/packages/playwright/src/mcp/sdk/server.ts b/packages/playwright/src/mcp/sdk/server.ts
index b6982a0fc4..74543a9fca 100644
--- a/packages/playwright/src/mcp/sdk/server.ts
+++ b/packages/playwright/src/mcp/sdk/server.ts
@@ -34,7 +34,7 @@ export interface ServerBackend {
initialize?(server: Server, clientVersion: ClientVersion, roots: Root[]): Promise<void>;
listTools(): Promise<Tool[]>;
callTool(name: string, args: CallToolRequest['params']['arguments']): Promise<CallToolResult>;
- serverClosed?(): void;
+ serverClosed?(server: Server): void;
}
export type ServerBackendFactory = {
@@ -104,7 +104,7 @@ export function createServer(name: string, version: string, backend: ServerBacke
errorsDebug(e);
}
});
- addServerListener(server, 'close', () => backend.serverClosed?.());
+ addServerListener(server, 'close', () => backend.serverClosed?.(server));
return server;
}
diff --git a/packages/playwright/src/mcp/test/backend.ts b/packages/playwright/src/mcp/test/backend.ts
index 3efa3f0274..30f9f7b8eb 100644
--- a/packages/playwright/src/mcp/test/backend.ts
+++ b/packages/playwright/src/mcp/test/backend.ts
@@ -30,8 +30,8 @@ export class TestServerBackend implements mcp.ServerBackend {
private _tools: Tool<any>[] = [listTests, runTests];
private _context: Context;
- constructor(resolvedLocation: ConfigLocation) {
- this._context = new Context(resolvedLocation);
+ constructor(resolvedLocation: ConfigLocation, options?: { muteConsole?: boolean }) {
+ this._context = new Context(resolvedLocation, options);
}
async listTools(): Promise<mcp.Tool[]> {
@@ -48,7 +48,11 @@ export class TestServerBackend implements mcp.ServerBackend {
if (!tool)
throw new Error(`Tool not found: ${name}. Available tools: ${this._tools.map(tool => tool.schema.name).join(', ')}`);
const parsedArguments = tool.schema.inputSchema.parse(args || {});
- return await tool.handle(this._context!, parsedArguments);
+ const result = await tool.handle(this._context!, parsedArguments);
+ const stdio = this._context.takeStdio();
+ if (stdio.trim())
+ result.content.push({ type: 'text', text: stdio });
+ return result;
}
serverClosed() {
diff --git a/packages/playwright/src/mcp/test/context.ts b/packages/playwright/src/mcp/test/context.ts
index fada1fb68d..05dcd8aa7b 100644
--- a/packages/playwright/src/mcp/test/context.ts
+++ b/packages/playwright/src/mcp/test/context.ts
@@ -14,27 +14,52 @@
* limitations under the License.
*/
-import { TestRunner } from '../../runner/testRunner';
+import { TestRunner, TestRunnerEvent } from '../../runner/testRunner';
import type { ConfigLocation } from '../../common/config';
export class Context {
private _testRunner: TestRunner | undefined;
readonly configLocation: ConfigLocation;
+ readonly options?: { muteConsole?: boolean };
+ private _stdio: { chunk: string | Buffer, stdio: 'stdout' | 'stderr' }[] = [];
- constructor(configLocation: ConfigLocation) {
+ constructor(configLocation: ConfigLocation, options?: { muteConsole?: boolean }) {
this.configLocation = configLocation;
+ this.options = options;
}
async createTestRunner(): Promise<TestRunner> {
if (this._testRunner)
await this._testRunner.stopTests();
const testRunner = new TestRunner(this.configLocation, {});
- await testRunner.initialize({});
+ await testRunner.initialize({
+ sendStdioEvents: true,
+ muteConsole: this.options?.muteConsole,
+ });
+ testRunner.on(TestRunnerEvent.StdioChunk, (chunk, stdio) => {
+ this._stdio.push({ chunk, stdio });
+ });
+ this._testRunner = testRunner;
+ testRunner.on(TestRunnerEvent.TestFilesChanged, testFiles => {
+ this._testRunner?.emit(TestRunnerEvent.TestFilesChanged, testFiles);
+ });
this._testRunner = testRunner;
return testRunner;
}
+ takeStdio(): string {
+ const text = this._stdio.map(entry => chunkToPayload(entry.stdio, entry.chunk)).join('\n');
+ this._stdio = [];
+ return text;
+ }
+
async close() {
}
}
+
+function chunkToPayload(type: 'stdout' | 'stderr', chunk: Buffer | string): string {
+ if (chunk instanceof Uint8Array)
+ return '<binary>';
+ return `[${type}] ${chunk}`;
+}
diff --git a/packages/playwright/src/mcp/test/program.ts b/packages/playwright/src/mcp/test/program.ts
deleted file mode 100644
index 4eecec8b90..0000000000
--- a/packages/playwright/src/mcp/test/program.ts
+++ /dev/null
@@ -1,46 +0,0 @@
-/**
- * Copyright (c) Microsoft Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import path from 'path';
-import { program } from 'playwright-core/lib/utilsBundle';
-
-import { resolveConfigLocation } from '../../common/configLoader';
-import { TestServerBackend } from './backend.js';
-import { runToolsBackend } from '../sdk/mdb';
-
-program
- .version('Version 0.0.1')
- .name('playwright-test-mcp')
- .option('--config <file>', 'Configuration file, or a test directory with optional "playwright.config.{m,c}?{js,ts}"')
- .option('--host <host>', 'host to bind server to. Default is localhost. Use 0.0.0.0 to bind to all interfaces.')
- .option('--port <port>', 'port to listen on for SSE transport.')
- .action(async options => {
- const resolvedLocation = resolveConfigLocation(options.config);
- // eslint-disable-next-line no-console
- console.error('Test config: ', path.relative(process.cwd(), resolvedLocation.resolvedConfigFile ?? resolvedLocation.configDir));
- const backendFactory = {
- name: 'Playwright Test',
- nameInConfig: 'playwright-test-mcp',
- version: '0.0.0',
- create: () => new TestServerBackend(resolvedLocation),
- };
- const mdbUrl = await runToolsBackend(backendFactory, { port: 9224 });
- process.env.PLAYWRIGHT_TEST_DEBUGGER_MCP = mdbUrl;
- // eslint-disable-next-line no-console
- console.error('MCP Listening on: ', mdbUrl);
- });
-
-void program.parseAsync(process.argv);
diff --git a/packages/playwright/src/mcp/test/runTests.ts b/packages/playwright/src/mcp/test/runTests.ts
index 4d75c0bc6d..3e9d6dc605 100644
--- a/packages/playwright/src/mcp/test/runTests.ts
+++ b/packages/playwright/src/mcp/test/runTests.ts
@@ -53,6 +53,7 @@ export const runTests = defineTool({
testIds: params.tests?.map(test => test.id),
// For automatic recovery
timeout: 0,
+ workers: 1,
});
const text = stream.content();
diff --git a/packages/playwright/src/program.ts b/packages/playwright/src/program.ts
index 5e955dbce7..5bef1dd87b 100644
--- a/packages/playwright/src/program.ts
+++ b/packages/playwright/src/program.ts
@@ -33,6 +33,9 @@ import * as testServer from './runner/testServer';
import { runWatchModeLoop } from './runner/watchMode';
import { runAllTestsWithConfig, TestRunner } from './runner/testRunner';
import { createErrorCollectingReporter } from './runner/reporters';
+import { ServerBackendFactory } from './mcp/sdk/server';
+import { TestServerBackend } from './mcp/test/backend';
+import { runMainBackend } from './mcp/sdk/mdb';
import type { ConfigCLIOverrides } from './common/ipc';
import type { TraceMode } from '../types/test';
@@ -140,6 +143,26 @@ Examples:
$ npx playwright merge-reports playwright-report`);
}
+function addMCPServerCommand(program: Command) {
+ const command = program.command('run-mcp-server', { hidden: true });
+ command.description('Interact with the test runner over MCP');
+ command.option('-c, --config <file>', `Configuration file, or a test directory with optional "playwright.config.{m,c}?{js,ts}"`);
+ command.option('--host <host>', 'host to bind server to. Default is localhost. Use 0.0.0.0 to bind to all interfaces.');
+ command.option('--port <port>', 'port to listen on for SSE transport.');
+ command.action(async options => {
+ const resolvedLocation = resolveConfigLocation(options.config);
+ const backendFactory: ServerBackendFactory = {
+ name: 'Playwright Test Runner',
+ nameInConfig: 'playwright-test-runner',
+ version: '0.0.0',
+ create: () => new TestServerBackend(resolvedLocation, { muteConsole: options.port === undefined }),
+ };
+ const mdbUrl = await runMainBackend(backendFactory, { port: options.port === undefined ? undefined : +options.port });
+ if (mdbUrl)
+ console.error('MCP Listening on: ', mdbUrl);
+ });
+}
+
async function runTests(args: string[], opts: { [key: string]: any }) {
await startProfiling();
const cliOverrides = overridesFromOptions(opts);
@@ -366,5 +389,6 @@ addTestCommand(program);
addShowReportCommand(program);
addMergeReportsCommand(program);
addClearCacheCommand(program);
+addMCPServerCommand(program);
addDevServerCommand(program);
addTestServerCommand(program);
diff --git a/packages/playwright/src/runner/testRunner.ts b/packages/playwright/src/runner/testRunner.ts
index b973a8852b..faf2e50d7f 100644
--- a/packages/playwright/src/runner/testRunner.ts
+++ b/packages/playwright/src/runner/testRunner.ts
@@ -17,7 +17,9 @@
import EventEmitter from 'events';
import fs from 'fs';
import path from 'path';
+import util from 'util';
+import { debug } from 'playwright-core/lib/utilsBundle';
import { registry } from 'playwright-core/lib/server';
import { ManualPromise, gracefullyProcessExitDoNotHang } from 'playwright-core/lib/utils';
@@ -42,10 +44,12 @@ import type { AnyReporter } from '../reporters/reporterV2';
export const TestRunnerEvent = {
TestFilesChanged: 'testFilesChanged',
+ StdioChunk: 'stdioChunk',
} as const;
export type TestRunnerEventMap = {
[TestRunnerEvent.TestFilesChanged]: [testFiles: string[]];
+ [TestRunnerEvent.StdioChunk]: [chunk: string | Buffer, stdio: 'stdout' | 'stderr'];
};
export type ListTestsParams = {
@@ -75,6 +79,12 @@ export type RunTestsParams = {
type FullResultStatus = reporterTypes.FullResult['status'];
+const originalDebugLog = debug.log;
+// eslint-disable-next-line no-restricted-properties
+const originalStdoutWrite = process.stdout.write;
+// eslint-disable-next-line no-restricted-properties
+const originalStderrWrite = process.stderr.write;
+
export class TestRunner extends EventEmitter<TestRunnerEventMap> {
readonly configLocation: ConfigLocation;
private _configCLIOverrides: ConfigCLIOverrides;
@@ -106,9 +116,15 @@ export class TestRunner extends EventEmitter<TestRunnerEventMap> {
async initialize(params: {
watchTestDirs?: boolean;
populateDependenciesOnList?: boolean;
+ sendStdioEvents?: boolean;
+ muteConsole?: boolean;
}) {
this._watchTestDirs = !!params.watchTestDirs;
this._populateDependenciesOnList = !!params.populateDependenciesOnList;
+ this._setInterceptStdio({
+ sendStdioEvents: !!params.sendStdioEvents,
+ muteConsole: !!params.muteConsole,
+ });
}
resizeTerminal(params: { cols: number, rows: number }) {
@@ -377,6 +393,11 @@ export class TestRunner extends EventEmitter<TestRunnerEventMap> {
gracefullyProcessExitDoNotHang(0);
}
+ async stop() {
+ this._setInterceptStdio({ sendStdioEvents: false, muteConsole: false });
+ await this.runGlobalTeardown();
+ }
+
private async _loadConfig(overrides?: ConfigCLIOverrides): Promise<{ config: FullConfigInternal | null, error?: reporterTypes.TestError }> {
try {
const config = await loadConfig(this.configLocation, overrides);
@@ -405,6 +426,42 @@ export class TestRunner extends EventEmitter<TestRunnerEventMap> {
await reporter.onExit();
return null;
}
+
+ _setInterceptStdio(options: { sendStdioEvents: boolean, muteConsole: boolean }) {
+ /* eslint-disable no-restricted-properties */
+ if (process.env.PWTEST_DEBUG)
+ return;
+ if (options.sendStdioEvents || options.muteConsole) {
+ if (debug.log === originalDebugLog) {
+ // Only if debug.log hasn't already been tampered with, don't intercept any DEBUG=* logging
+ debug.log = (...args) => {
+ const string = util.format(...args) + '\n';
+ return (originalStderrWrite as any).apply(process.stderr, [string]);
+ };
+ }
+ const stdoutWrite = (chunk: string | Buffer) => {
+ if (options.sendStdioEvents)
+ this.emit(TestRunnerEvent.StdioChunk, chunk, 'stdout');
+ if (!options.muteConsole)
+ originalStdoutWrite.apply(process.stdout, [chunk]);
+ return true;
+ };
+ const stderrWrite = (chunk: string | Buffer) => {
+ if (options.sendStdioEvents)
+ this.emit(TestRunnerEvent.StdioChunk, chunk, 'stderr');
+ if (!options.muteConsole)
+ originalStderrWrite.apply(process.stderr, [chunk]);
+ return true;
+ };
+ process.stdout.write = stdoutWrite;
+ process.stderr.write = stderrWrite;
+ } else {
+ debug.log = originalDebugLog;
+ process.stdout.write = originalStdoutWrite;
+ process.stderr.write = originalStderrWrite;
+ }
+ /* eslint-enable no-restricted-properties */
+ }
}
function printInternalError(e: Error) {
diff --git a/packages/playwright/src/runner/testServer.ts b/packages/playwright/src/runner/testServer.ts
index 4f8758623a..616fd6a53b 100644
--- a/packages/playwright/src/runner/testServer.ts
+++ b/packages/playwright/src/runner/testServer.ts
@@ -14,17 +14,15 @@
* limitations under the License.
*/
-import util from 'util';
-
import { installRootRedirect, openTraceInBrowser, openTraceViewerApp, startTraceViewerServer } from 'playwright-core/lib/server';
import { ManualPromise, gracefullyProcessExitDoNotHang, isUnderTest } from 'playwright-core/lib/utils';
-import { debug, open } from 'playwright-core/lib/utilsBundle';
+import { open } from 'playwright-core/lib/utilsBundle';
import { loadConfig, resolveConfigLocation } from '../common/configLoader';
import ListReporter from '../reporters/list';
import { createReporterForTestServer } from './reporters';
import { SigIntWatcher } from './sigIntWatcher';
-import { TestRunner } from './testRunner';
+import { TestRunner, TestRunnerEvent } from './testRunner';
import type { TraceViewerRedirectOptions, TraceViewerServerOptions } from 'playwright-core/lib/server/trace/viewer/traceViewer';
import type { HttpServer, Transport } from 'playwright-core/lib/utils';
@@ -34,12 +32,6 @@ import type { ConfigCLIOverrides } from '../common/ipc';
import type { ReportEntry, TestServerInterface, TestServerInterfaceEventEmitters } from '../isomorphic/testServerInterface';
import type { ReporterV2 } from '../reporters/reporterV2';
-const originalDebugLog = debug.log;
-// eslint-disable-next-line no-restricted-properties
-const originalStdoutWrite = process.stdout.write;
-// eslint-disable-next-line no-restricted-properties
-const originalStderrWrite = process.stderr.write;
-
class TestServer {
private _configLocation: ConfigLocation;
private _configCLIOverrides: ConfigCLIOverrides;
@@ -56,19 +48,10 @@ class TestServer {
}
async stop() {
- await this._dispatcher?._setInterceptStdio(false);
- await this._dispatcher?.runGlobalTeardown();
+ await this._dispatcher?.stop();
}
}
-export const TestRunnerEvent = {
- TestFilesChanged: 'testFilesChanged',
-} as const;
-
-export type TestRunnerEventMap = {
- [TestRunnerEvent.TestFilesChanged]: [testFiles: string[]];
-};
-
export type ListTestsParams = {
projects?: string[];
locations?: string[];
@@ -115,6 +98,7 @@ export class TestServerDispatcher implements TestServerInterface {
this._dispatchEvent = (method, params) => this.transport.sendEvent?.(method, params);
this._testRunner.on(TestRunnerEvent.TestFilesChanged, testFiles => this._dispatchEvent('testFilesChanged', { testFiles }));
+ this._testRunner.on(TestRunnerEvent.StdioChunk, (chunk, stdio) => this._dispatchEvent('stdio', chunkToPayload(stdio, chunk)));
}
private async _wireReporter(messageSink: (message: any) => void) {
@@ -133,10 +117,10 @@ export class TestServerDispatcher implements TestServerInterface {
// Note: this method can be called multiple times, for example from a new connection after UI mode reload.
this._serializer = params.serializer || require.resolve('./uiModeReporter');
this._closeOnDisconnect = !!params.closeOnDisconnect;
- await this._setInterceptStdio(!!params.interceptStdio);
await this._testRunner.initialize({
- watchTestDirs: !!params.watchTestDirs,
- populateDependenciesOnList: !!params.populateDependenciesOnList,
+ ...params,
+ sendStdioEvents: !!params.interceptStdio,
+ muteConsole: !!params.interceptStdio,
});
}
@@ -226,34 +210,8 @@ export class TestServerDispatcher implements TestServerInterface {
await this._testRunner.stopTests();
}
- async _setInterceptStdio(intercept: boolean) {
- /* eslint-disable no-restricted-properties */
- if (process.env.PWTEST_DEBUG)
- return;
- if (intercept) {
- if (debug.log === originalDebugLog) {
- // Only if debug.log hasn't already been tampered with, don't intercept any DEBUG=* logging
- debug.log = (...args) => {
- const string = util.format(...args) + '\n';
- return (originalStderrWrite as any).apply(process.stderr, [string]);
- };
- }
- const stdoutWrite = (chunk: string | Buffer) => {
- this._dispatchEvent('stdio', chunkToPayload('stdout', chunk));
- return true;
- };
- const stderrWrite = (chunk: string | Buffer) => {
- this._dispatchEvent('stdio', chunkToPayload('stderr', chunk));
- return true;
- };
- process.stdout.write = stdoutWrite;
- process.stderr.write = stderrWrite;
- } else {
- debug.log = originalDebugLog;
- process.stdout.write = originalStdoutWrite;
- process.stderr.write = originalStderrWrite;
- }
- /* eslint-enable no-restricted-properties */
+ async stop() {
+ await this._testRunner.stop();
}
async closeGracefully() {