chore(testRunner): expose pauseAtEnd/pauseOnError

dgozman · dgozman · commit e52434b0cb0a · 2025-10-20T11:25:00.000+01:00
diff --git a/packages/playwright/src/common/ipc.ts b/packages/playwright/src/common/ipc.ts
@@ -66,8 +66,8 @@ export type WorkerInitParams = {
   projectId: string;
   config: SerializedConfig;
   artifactsDir: string;
-  pauseOnError: boolean;
-  pauseAtEnd: boolean;
+  pauseOnError: 'mcp' | 'notify' | 'off';
+  pauseAtEnd: 'mcp' | 'notify' | 'off';
 };
 
 export type TestBeginPayload = {
@@ -86,6 +86,10 @@ export type AttachmentPayload = {
 
 export type TestInfoErrorImpl = TestInfoError;
 
+export type TestPausedPayload = {
+  errors: TestInfoErrorImpl[];
+};
+
 export type TestEndPayload = {
   testId: string;
   duration: number;
diff --git a/packages/playwright/src/index.ts b/packages/playwright/src/index.ts
@@ -237,7 +237,7 @@ const playwrightFixtures: Fixtures<TestFixtures, WorkerFixtures> = ({
       (testInfo as TestInfoImpl)._setDebugMode();
 
     playwright._defaultContextOptions = _combinedContextOptions;
-    playwright._defaultContextTimeout = (testInfo as TestInfoImpl)._pauseOnError() ? 5000 : actionTimeout || 0;
+    playwright._defaultContextTimeout = (testInfo as TestInfoImpl)._pauseOnError() === 'mcp' ? 5000 : actionTimeout || 0;
     playwright._defaultContextNavigationTimeout = navigationTimeout || 0;
     await use();
     playwright._defaultContextOptions = undefined;
diff --git a/packages/playwright/src/isomorphic/testServerConnection.ts b/packages/playwright/src/isomorphic/testServerConnection.ts
@@ -17,6 +17,7 @@
 import * as events from './events';
 
 import type { TestServerInterface, TestServerInterfaceEvents } from '@testIsomorphic/testServerInterface';
+import type * as reporterTypes from '../../types/testReporter';
 
 // -- Reuse boundary -- Everything below this line is reused in the vscode extension.
 
@@ -68,12 +69,14 @@ export class TestServerConnection implements TestServerInterface, TestServerInte
   readonly onStdio: events.Event<{ type: 'stderr' | 'stdout'; text?: string | undefined; buffer?: string | undefined; }>;
   readonly onTestFilesChanged: events.Event<{ testFiles: string[] }>;
   readonly onLoadTraceRequested: events.Event<{ traceUrl: string }>;
+  readonly onTestPaused: events.Event<{ errors: reporterTypes.TestError[] }>;
 
   private _onCloseEmitter = new events.EventEmitter<void>();
   private _onReportEmitter = new events.EventEmitter<any>();
   private _onStdioEmitter = new events.EventEmitter<{ type: 'stderr' | 'stdout'; text?: string | undefined; buffer?: string | undefined; }>();
   private _onTestFilesChangedEmitter = new events.EventEmitter<{ testFiles: string[] }>();
   private _onLoadTraceRequestedEmitter = new events.EventEmitter<{ traceUrl: string }>();
+  private _onTestPausedEmitter = new events.EventEmitter<{ errors: reporterTypes.TestError[] }>();
 
   private _lastId = 0;
   private _transport: TestServerTransport;
@@ -87,6 +90,7 @@ export class TestServerConnection implements TestServerInterface, TestServerInte
     this.onStdio = this._onStdioEmitter.event;
     this.onTestFilesChanged = this._onTestFilesChangedEmitter.event;
     this.onLoadTraceRequested = this._onLoadTraceRequestedEmitter.event;
+    this.onTestPaused = this._onTestPausedEmitter.event;
 
     this._transport = transport;
     this._transport.onmessage(data => {
@@ -147,6 +151,8 @@ export class TestServerConnection implements TestServerInterface, TestServerInte
       this._onTestFilesChangedEmitter.fire(params);
     else if (method === 'loadTraceRequested')
       this._onLoadTraceRequestedEmitter.fire(params);
+    else if (method === 'testPaused')
+      this._onTestPausedEmitter.fire(params);
   }
 
   async initialize(params: Parameters<TestServerInterface['initialize']>[0]): ReturnType<TestServerInterface['initialize']> {
diff --git a/packages/playwright/src/isomorphic/testServerInterface.ts b/packages/playwright/src/isomorphic/testServerInterface.ts
@@ -103,6 +103,8 @@ export interface TestServerInterface {
     reuseContext?: boolean;
     connectWsEndpoint?: string;
     timeout?: number;
+    pauseOnError?: boolean;
+    pauseAtEnd?: boolean;
   }): Promise<{
     status: reporterTypes.FullResult['status'];
   }>;
@@ -121,11 +123,13 @@ export interface TestServerInterfaceEvents {
   onStdio: Event<{ type: 'stdout' | 'stderr', text?: string, buffer?: string }>;
   onTestFilesChanged: Event<{ testFiles: string[] }>;
   onLoadTraceRequested: Event<{ traceUrl: string }>;
+  onTestPaused: Event<{ errors: reporterTypes.TestError[] }>;
 }
 
 export interface TestServerInterfaceEventEmitters {
   dispatchEvent(event: 'report', params: ReportEntry): void;
   dispatchEvent(event: 'stdio', params: { type: 'stdout' | 'stderr', text?: string, buffer?: string }): void;
   dispatchEvent(event: 'testFilesChanged', params: { testFiles: string[] }): void;
   dispatchEvent(event: 'loadTraceRequested', params: { traceUrl: string }): void;
+  dispatchEvent(event: 'testPaused', params: { errors: reporterTypes.TestError[] }): void;
 }
diff --git a/packages/playwright/src/mcp/test/browserBackend.ts b/packages/playwright/src/mcp/test/browserBackend.ts
@@ -31,7 +31,7 @@ export async function runBrowserBackendAtEnd(context: playwright.BrowserContext,
   if (!testInfo)
     return;
 
-  const shouldPause = errorMessage ? testInfo?._pauseOnError() : testInfo?._pauseAtEnd();
+  const shouldPause = errorMessage ? testInfo?._pauseOnError() === 'mcp' : testInfo?._pauseAtEnd() === 'mcp';
   if (!shouldPause)
     return;
 
diff --git a/packages/playwright/src/mcp/test/testContext.ts b/packages/playwright/src/mcp/test/testContext.ts
@@ -149,7 +149,7 @@ export class TestContext {
       projects: [projectName],
       timeout: 0,
       workers: 1,
-      pauseAtEnd: true,
+      pauseAtEnd: 'mcp',
       disableConfigReporters: true,
       failOnLoadErrors: true,
     });
diff --git a/packages/playwright/src/mcp/test/testTools.ts b/packages/playwright/src/mcp/test/testTools.ts
@@ -90,7 +90,7 @@ export const debugTest = defineTestTool({
       // For automatic recovery
       timeout: 0,
       workers: 1,
-      pauseOnError: true,
+      pauseOnError: 'mcp',
       disableConfigReporters: true,
     });
 
diff --git a/packages/playwright/src/reporters/internalReporter.ts b/packages/playwright/src/reporters/internalReporter.ts
@@ -117,7 +117,7 @@ export class InternalReporter implements ReporterV2 {
   }
 }
 
-function addLocationAndSnippetToError(config: FullConfig, error: TestError, file?: string) {
+export function addLocationAndSnippetToError(config: FullConfig, error: TestError, file?: string) {
   if (error.stack && !error.location)
     error.location = prepareErrorStack(error.stack).location;
   const location = error.location;
diff --git a/packages/playwright/src/runner/dispatcher.ts b/packages/playwright/src/runner/dispatcher.ts
@@ -20,6 +20,7 @@ import { colors } from 'playwright-core/lib/utils';
 import { addSuggestedRebaseline } from './rebase';
 import { WorkerHost } from './workerHost';
 import { serializeConfig } from '../common/ipc';
+import { addLocationAndSnippetToError } from '../reporters/internalReporter';
 
 import type { FailureTracker } from './failureTracker';
 import type { ProcessExitData } from './processHost';
@@ -98,7 +99,7 @@ export class Dispatcher {
 
     // 3. Claim both the job and the worker slot.
     this._queue.splice(jobIndex, 1);
-    const jobDispatcher = new JobDispatcher(job, this._reporter, this._failureTracker, () => this.stop().catch(() => {}));
+    const jobDispatcher = new JobDispatcher(job, this._config, this._reporter, this._failureTracker, () => this.stop().catch(() => {}));
     this._workerSlots[workerIndex].busy = true;
     this._workerSlots[workerIndex].jobDispatcher = jobDispatcher;
 
@@ -278,6 +279,7 @@ class JobDispatcher {
   jobResult = new ManualPromise<{ newJob?: TestGroup, didFail: boolean }>();
 
   readonly job: TestGroup;
+  private _config: FullConfigInternal;
   private _reporter: ReporterV2;
   private _failureTracker: FailureTracker;
   private _stopCallback: () => void;
@@ -290,8 +292,9 @@ class JobDispatcher {
   private _workerIndex = 0;
   private _currentlyRunning: { test: TestCase, result: TestResult } | undefined;
 
-  constructor(job: TestGroup, reporter: ReporterV2, failureTracker: FailureTracker, stopCallback: () => void) {
+  constructor(job: TestGroup, config: FullConfigInternal, reporter: ReporterV2, failureTracker: FailureTracker, stopCallback: () => void) {
     this.job = job;
+    this._config = config;
     this._reporter = reporter;
     this._failureTracker = failureTracker;
     this._stopCallback = stopCallback;
@@ -574,6 +577,11 @@ class JobDispatcher {
       eventsHelper.addEventListener(worker, 'stepBegin', this._onStepBegin.bind(this)),
       eventsHelper.addEventListener(worker, 'stepEnd', this._onStepEnd.bind(this)),
       eventsHelper.addEventListener(worker, 'attach', this._onAttach.bind(this)),
+      eventsHelper.addEventListener(worker, 'testPaused', params => {
+        for (const error of params.errors)
+          addLocationAndSnippetToError(this._config.config, error);
+        this._failureTracker.onTestPaused?.(params);
+      }),
       eventsHelper.addEventListener(worker, 'done', this._onDone.bind(this)),
       eventsHelper.addEventListener(worker, 'exit', this.onExit.bind(this)),
     ];
diff --git a/packages/playwright/src/runner/failureTracker.ts b/packages/playwright/src/runner/failureTracker.ts
@@ -14,21 +14,24 @@
  * limitations under the License.
  */
 
-import type { TestResult } from '../../types/testReporter';
+import type { TestResult, TestError } from '../../types/testReporter';
 import type { FullConfigInternal, FullProjectInternal } from '../common/config';
 import type { Suite, TestCase } from '../common/test';
 
 export class FailureTracker {
+  private _config: FullConfigInternal;
   private _failureCount = 0;
   private _hasWorkerErrors = false;
   private _rootSuite: Suite | undefined;
   private _topLevelProjects: FullProjectInternal[] = [];
-  private _pauseOnError: boolean;
-  private _pauseAtEnd: boolean;
+  private _pauseOnError: 'mcp' | 'notify' | 'off';
+  private _pauseAtEnd: 'mcp' | 'notify' | 'off';
+  onTestPaused?: (params: { errors: TestError[] }) => void;
 
-  constructor(private _config: FullConfigInternal, options?: { pauseOnError?: boolean, pauseAtEnd?: boolean }) {
-    this._pauseOnError = options?.pauseOnError ?? false;
-    this._pauseAtEnd = options?.pauseAtEnd ?? false;
+  constructor(config: FullConfigInternal, options?: { pauseOnError?: 'mcp' | 'notify' | 'off', pauseAtEnd?: 'mcp' | 'notify' | 'off' }) {
+    this._config = config;
+    this._pauseOnError = options?.pauseOnError ?? 'off';
+    this._pauseAtEnd = options?.pauseAtEnd ?? 'off';
   }
 
   onRootSuite(rootSuite: Suite, topLevelProjects: FullProjectInternal[]) {
@@ -46,12 +49,12 @@ export class FailureTracker {
     this._hasWorkerErrors = true;
   }
 
-  pauseOnError(): boolean {
+  pauseOnError() {
     return this._pauseOnError;
   }
 
-  pauseAtEnd(inProject: FullProjectInternal): boolean {
-    return this._pauseAtEnd && this._topLevelProjects.includes(inProject);
+  pauseAtEnd(inProject: FullProjectInternal) {
+    return this._topLevelProjects.includes(inProject) ? this._pauseAtEnd : 'off';
   }
 
   hasReachedMaxFailures() {
diff --git a/packages/playwright/src/runner/tasks.ts b/packages/playwright/src/runner/tasks.ts
@@ -65,7 +65,7 @@ export class TestRun {
   projectSuites: Map<FullProjectInternal, Suite[]> = new Map();
   topLevelProjects: FullProjectInternal[] = [];
 
-  constructor(config: FullConfigInternal, reporter: InternalReporter, options?: { pauseOnError?: boolean, pauseAtEnd?: boolean }) {
+  constructor(config: FullConfigInternal, reporter: InternalReporter, options?: { pauseOnError?: 'mcp' | 'notify' | 'off', pauseAtEnd?: 'mcp' | 'notify' | 'off' }) {
     this.config = config;
     this.reporter = reporter;
     this.failureTracker = new FailureTracker(config, options);
diff --git a/packages/playwright/src/runner/testRunner.ts b/packages/playwright/src/runner/testRunner.ts
@@ -42,10 +42,12 @@ import type { AnyReporter } from '../reporters/reporterV2';
 
 export const TestRunnerEvent = {
   TestFilesChanged: 'testFilesChanged',
+  TestPaused: 'testPaused',
 } as const;
 
 export type TestRunnerEventMap = {
   [TestRunnerEvent.TestFilesChanged]: [testFiles: string[]];
+  [TestRunnerEvent.TestPaused]: [params: { errors: reporterTypes.TestError[] }];
 };
 
 export type ListTestsParams = {
@@ -71,8 +73,8 @@ export type RunTestsParams = {
   projects?: string[];
   reuseContext?: boolean;
   connectWsEndpoint?: string;
-  pauseOnError?: boolean;
-  pauseAtEnd?: boolean;
+  pauseOnError?: 'mcp' | 'notify' | 'off';
+  pauseAtEnd?: 'mcp' | 'notify' | 'off';
   doNotRunDepsOutsideProjectFilter?: boolean;
   disableConfigReporters?: boolean;
   failOnLoadErrors?: boolean;
@@ -349,6 +351,7 @@ export class TestRunner extends EventEmitter<TestRunnerEventMap> {
       ...createRunTestsTasks(config),
     ];
     const testRun = new TestRun(config, reporter, { pauseOnError: params.pauseOnError, pauseAtEnd: params.pauseAtEnd });
+    testRun.failureTracker.onTestPaused = params => this.emit(TestRunnerEvent.TestPaused, params);
     const run = runTasks(testRun, tasks, 0, stop).then(async status => {
       this._testRun = undefined;
       return status;
diff --git a/packages/playwright/src/runner/testServer.ts b/packages/playwright/src/runner/testServer.ts
@@ -106,6 +106,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.TestPaused, params => this._dispatchEvent('testPaused', params));
   }
 
   private async _wireReporter(messageSink: (message: any) => void) {
@@ -203,6 +204,8 @@ export class TestServerDispatcher implements TestServerInterface {
     const { status } = await this._testRunner.runTests(wireReporter, {
       ...params,
       doNotRunDepsOutsideProjectFilter: true,
+      pauseAtEnd: params.pauseAtEnd ? 'notify' : 'off',
+      pauseOnError: params.pauseOnError ? 'notify' : 'off',
     });
     return { status };
   }
diff --git a/packages/playwright/src/runner/workerHost.ts b/packages/playwright/src/runner/workerHost.ts
@@ -34,8 +34,8 @@ type WorkerHostOptions = {
   config: SerializedConfig;
   extraEnv: Record<string, string | undefined>;
   outputDir: string;
-  pauseOnError: boolean;
-  pauseAtEnd: boolean;
+  pauseOnError: 'mcp' | 'notify' | 'off';
+  pauseAtEnd: 'mcp' | 'notify' | 'off';
 };
 
 export class WorkerHost extends ProcessHost {
diff --git a/packages/playwright/src/worker/testInfo.ts b/packages/playwright/src/worker/testInfo.ts
diff --git a/packages/playwright/src/worker/workerMain.ts b/packages/playwright/src/worker/workerMain.ts
diff --git a/tests/playwright-test/test-server.spec.ts b/tests/playwright-test/test-server.spec.ts

Original file line number	Diff line number	Diff line change
`@@ -117,7 +117,7 @@ export class InternalReporter implements ReporterV2 {`
`117`	`117`	`}`
`118`	`118`	`}`
`119`	`119`
`120`		`-function addLocationAndSnippetToError(config: FullConfig, error: TestError, file?: string) {`
	`120`	`+export function addLocationAndSnippetToError(config: FullConfig, error: TestError, file?: string) {`
`121`	`121`	`if (error.stack && !error.location)`
`122`	`122`	`error.location = prepareErrorStack(error.stack).location;`
`123`	`123`	`const location = error.location;`