Skip to content

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

chore: make launch, newContext and newPage progress "strict" (#36336)

Dmitry Gozman84c69edbb854
diff --git a/packages/playwright-core/src/server/browser.ts b/packages/playwright-core/src/server/browser.ts
index fc2fcccdf7..d985e96fa0 100644
--- a/packages/playwright-core/src/server/browser.ts
+++ b/packages/playwright-core/src/server/browser.ts
@@ -20,6 +20,7 @@ import { Download } from './download';
import { SdkObject } from './instrumentation';
import { Page } from './page';
import { ClientCertificatesProxy } from './socksClientCertificatesInterceptor';
+import { ProgressController } from './progress';
import type { CallMetadata } from './instrumentation';
import type * as types from './types';
@@ -28,6 +29,7 @@ import type { RecentLogsCollector } from './utils/debugLogger';
import type * as channels from '@protocol/channels';
import type { ChildProcess } from 'child_process';
import type { Language } from '../utils';
+import type { Progress } from './progress';
export interface BrowserProcess {
@@ -90,25 +92,26 @@ export abstract class Browser extends SdkObject {
return this.options.sdkLanguage || this.attribution.playwright.options.sdkLanguage;
}
- async newContext(metadata: CallMetadata, options: types.BrowserContextOptions): Promise<BrowserContext> {
+ newContextFromMetadata(metadata: CallMetadata, options: types.BrowserContextOptions): Promise<BrowserContext> {
+ const controller = new ProgressController(metadata, this, 'strict');
+ return controller.run(progress => this.newContext(progress, options));
+ }
+
+ async newContext(progress: Progress, options: types.BrowserContextOptions): Promise<BrowserContext> {
validateBrowserContextOptions(options, this.options);
let clientCertificatesProxy: ClientCertificatesProxy | undefined;
if (options.clientCertificates?.length) {
- clientCertificatesProxy = new ClientCertificatesProxy(options);
+ clientCertificatesProxy = await progress.raceWithCleanup(ClientCertificatesProxy.create(options), proxy => proxy.close());
options = { ...options };
- options.proxyOverride = await clientCertificatesProxy.listen();
+ options.proxyOverride = clientCertificatesProxy.proxySettings();
options.internalIgnoreHTTPSErrors = true;
}
- let context;
- try {
- context = await this.doCreateNewContext(options);
- } catch (error) {
- await clientCertificatesProxy?.close();
- throw error;
- }
+ const context = await progress.raceWithCleanup(this.doCreateNewContext(options), context => context.close({ reason: 'Failed to create context' }));
context._clientCertificatesProxy = clientCertificatesProxy;
+ if ((options as any).__testHookBeforeSetStorageState)
+ await progress.race((options as any).__testHookBeforeSetStorageState());
if (options.storageState)
- await context.setStorageState(metadata, options.storageState);
+ await context.setStorageState(progress, options.storageState);
this.emit(Browser.Events.Context, context);
return context;
}
@@ -118,7 +121,7 @@ export abstract class Browser extends SdkObject {
if (!this._contextForReuse || hash !== this._contextForReuse.hash || !this._contextForReuse.context.canResetForReuse()) {
if (this._contextForReuse)
await this._contextForReuse.context.close({ reason: 'Context reused' });
- this._contextForReuse = { context: await this.newContext(metadata, params), hash };
+ this._contextForReuse = { context: await this.newContextFromMetadata(metadata, params), hash };
return { context: this._contextForReuse.context, needsReset: false };
}
await this._contextForReuse.context.stopPendingOperations('Context recreated');
diff --git a/packages/playwright-core/src/server/browserContext.ts b/packages/playwright-core/src/server/browserContext.ts
index 5bd2577dad..0a5b7eac3a 100644
--- a/packages/playwright-core/src/server/browserContext.ts
+++ b/packages/playwright-core/src/server/browserContext.ts
@@ -218,7 +218,7 @@ export abstract class BrowserContext extends SdkObject {
// Navigate to about:blank first to ensure no page scripts are running after this point.
await page?.mainFrame().gotoImpl(progress, 'about:blank', {});
- await this._resetStorage();
+ await this._resetStorage(progress);
await this.clock.resetForReuse();
// TODO: following can be optimized to not perform noops.
if (this._options.permissions)
@@ -379,14 +379,13 @@ export abstract class BrowserContext extends SdkObject {
async _loadDefaultContextAsIs(progress: Progress): Promise<Page | undefined> {
if (!this.possiblyUninitializedPages().length) {
const waitForEvent = helper.waitForEvent(progress, this, BrowserContext.Events.Page);
- progress.cleanupWhenAborted(() => waitForEvent.dispose);
// Race against BrowserContext.close
await Promise.race([waitForEvent.promise, this._closePromise]);
}
const page = this.possiblyUninitializedPages()[0];
if (!page)
return;
- const pageOrError = await page.waitForInitializedOrError();
+ const pageOrError = await progress.race(page.waitForInitializedOrError());
if (pageOrError instanceof Error)
throw pageOrError;
await page.mainFrame()._waitForLoadState(progress, 'load');
@@ -402,7 +401,7 @@ export abstract class BrowserContext extends SdkObject {
// Workaround for:
// - chromium fails to change isMobile for existing page;
// - webkit fails to change locale for existing page.
- await this.newPage(progress.metadata);
+ await this.newPage(progress, false);
await defaultPage.close();
}
}
@@ -511,9 +510,14 @@ export abstract class BrowserContext extends SdkObject {
await this._closePromise;
}
- async newPage(metadata: CallMetadata): Promise<Page> {
- const page = await this.doCreateNewPage(metadata.isServerSide);
- const pageOrError = await page.waitForInitializedOrError();
+ newPageFromMetadata(metadata: CallMetadata): Promise<Page> {
+ const contoller = new ProgressController(metadata, this, 'strict');
+ return contoller.run(progress => this.newPage(progress, false));
+ }
+
+ async newPage(progress: Progress, isServerSide: boolean): Promise<Page> {
+ const page = await progress.raceWithCleanup(this.doCreateNewPage(isServerSide), page => page.close());
+ const pageOrError = await progress.race(page.waitForInitializedOrError());
if (pageOrError instanceof Page) {
if (pageOrError.isClosed())
throw new Error('Page has been closed.');
@@ -526,7 +530,12 @@ export abstract class BrowserContext extends SdkObject {
this._origins.add(origin);
}
- async storageState(indexedDB = false): Promise<channels.BrowserContextStorageStateResult> {
+ storageState(indexedDB = false): Promise<channels.BrowserContextStorageStateResult> {
+ const controller = new ProgressController(serverSideCallMetadata(), this, 'strict');
+ return controller.run(progress => this.storageStateImpl(progress, indexedDB));
+ }
+
+ async storageStateImpl(progress: Progress, indexedDB: boolean): Promise<channels.BrowserContextStorageStateResult> {
const result: channels.BrowserContextStorageStateResult = {
cookies: await this.cookies(),
origins: []
@@ -557,15 +566,14 @@ export abstract class BrowserContext extends SdkObject {
// If there are still origins to save, create a blank page to iterate over origins.
if (originsToSave.size) {
- const internalMetadata = serverSideCallMetadata();
- const page = await this.newPage(internalMetadata);
- page.addRequestInterceptor(route => {
+ const page = await this.newPage(progress, true);
+ await progress.race(page.addRequestInterceptor(route => {
route.fulfill({ body: '<html></html>' }).catch(() => {});
- }, 'prepend');
+ }, 'prepend'));
for (const origin of originsToSave) {
const frame = page.mainFrame();
- await frame.goto(internalMetadata, origin, { timeout: 0 });
- const storage: SerializedStorage = await frame.evaluateExpression(collectScript, { world: 'utility' });
+ await frame.gotoImpl(progress, origin, {});
+ const storage: SerializedStorage = await progress.race(frame.evaluateExpression(collectScript, { world: 'utility' }));
if (storage.localStorage.length || storage.indexedDB?.length)
result.origins.push({ origin, localStorage: storage.localStorage, indexedDB: storage.indexedDB });
}
@@ -574,29 +582,27 @@ export abstract class BrowserContext extends SdkObject {
return result;
}
- async _resetStorage() {
+ async _resetStorage(progress: Progress) {
const oldOrigins = this._origins;
const newOrigins = new Map(this._options.storageState?.origins?.map(p => [p.origin, p]) || []);
if (!oldOrigins.size && !newOrigins.size)
return;
let page = this.pages()[0];
- const internalMetadata = serverSideCallMetadata();
- page = page || await this.newPage({
- ...internalMetadata,
- // Do not mark this page as internal, because we will leave it for later reuse
- // as a user-visible page.
- isServerSide: false,
- });
+ // Do not mark this page as internal, because we will leave it for later reuse
+ // as a user-visible page.
+ page = page || await this.newPage(progress, false);
const interceptor = (route: network.Route) => {
route.fulfill({ body: '<html></html>' }).catch(() => {});
};
- await page.addRequestInterceptor(interceptor, 'prepend');
+
+ progress.cleanupWhenAborted(() => page.removeRequestInterceptor(interceptor));
+ await progress.race(page.addRequestInterceptor(interceptor, 'prepend'));
for (const origin of new Set([...oldOrigins, ...newOrigins.keys()])) {
const frame = page.mainFrame();
- await frame.goto(internalMetadata, origin, { timeout: 0 });
- await frame.resetStorageForCurrentOriginBestEffort(newOrigins.get(origin));
+ await frame.gotoImpl(progress, origin, {});
+ await progress.race(frame.resetStorageForCurrentOriginBestEffort(newOrigins.get(origin)));
}
await page.removeRequestInterceptor(interceptor);
@@ -615,27 +621,26 @@ export abstract class BrowserContext extends SdkObject {
return this._settingStorageState;
}
- async setStorageState(metadata: CallMetadata, state: NonNullable<channels.BrowserNewContextParams['storageState']>) {
+ async setStorageState(progress: Progress, state: NonNullable<channels.BrowserNewContextParams['storageState']>) {
this._settingStorageState = true;
try {
if (state.cookies)
- await this.addCookies(state.cookies);
+ await progress.race(this.addCookies(state.cookies));
if (state.origins && state.origins.length) {
- const internalMetadata = serverSideCallMetadata();
- const page = await this.newPage(internalMetadata);
- await page.addRequestInterceptor(route => {
+ const page = await this.newPage(progress, true);
+ await progress.race(page.addRequestInterceptor(route => {
route.fulfill({ body: '<html></html>' }).catch(() => {});
- }, 'prepend');
+ }, 'prepend'));
for (const originState of state.origins) {
const frame = page.mainFrame();
- await frame.goto(metadata, originState.origin, { timeout: 0 });
+ await frame.gotoImpl(progress, originState.origin, {});
const restoreScript = `(() => {
const module = {};
${rawStorageSource.source}
const script = new (module.exports.StorageScript())(${this._browser.options.name === 'firefox'});
return script.restore(${JSON.stringify(originState)});
})()`;
- await frame.evaluateExpression(restoreScript, { world: 'utility' });
+ await progress.race(frame.evaluateExpression(restoreScript, { world: 'utility' }));
}
await page.close();
}
diff --git a/packages/playwright-core/src/server/browserType.ts b/packages/playwright-core/src/server/browserType.ts
index 5882687e90..9febf7367a 100644
--- a/packages/playwright-core/src/server/browserType.ts
+++ b/packages/playwright-core/src/server/browserType.ts
@@ -23,7 +23,7 @@ import { debugMode } from './utils/debug';
import { assert } from '../utils/isomorphic/assert';
import { ManualPromise } from '../utils/isomorphic/manualPromise';
import { DEFAULT_PLAYWRIGHT_TIMEOUT } from '../utils/isomorphic/time';
-import { existsAsync } from './utils/fileUtils';
+import { existsAsync, removeFolders } from './utils/fileUtils';
import { helper } from './helper';
import { SdkObject } from './instrumentation';
import { PipeTransport } from './pipeTransport';
@@ -69,7 +69,7 @@ export abstract class BrowserType extends SdkObject {
async launch(metadata: CallMetadata, options: types.LaunchOptions, protocolLogger?: types.ProtocolLogger): Promise<Browser> {
options = this._validateLaunchOptions(options);
- const controller = new ProgressController(metadata, this);
+ const controller = new ProgressController(metadata, this, 'strict');
const browser = await controller.run(progress => {
const seleniumHubUrl = (options as any).__testHookSeleniumRemoteURL || process.env.SELENIUM_REMOTE_URL;
if (seleniumHubUrl)
@@ -81,17 +81,16 @@ export abstract class BrowserType extends SdkObject {
async launchPersistentContext(metadata: CallMetadata, userDataDir: string, options: channels.BrowserTypeLaunchPersistentContextOptions & { timeout: number, cdpPort?: number, internalIgnoreHTTPSErrors?: boolean, socksProxyPort?: number }): Promise<BrowserContext> {
const launchOptions = this._validateLaunchOptions(options);
- const controller = new ProgressController(metadata, this);
+ const controller = new ProgressController(metadata, this, 'strict');
const browser = await controller.run(async progress => {
// Note: Any initial TLS requests will fail since we rely on the Page/Frames initialize which sets ignoreHTTPSErrors.
let clientCertificatesProxy: ClientCertificatesProxy | undefined;
if (options.clientCertificates?.length) {
- clientCertificatesProxy = new ClientCertificatesProxy(options);
- launchOptions.proxyOverride = await clientCertificatesProxy?.listen();
+ clientCertificatesProxy = await progress.raceWithCleanup(ClientCertificatesProxy.create(options), proxy => proxy.close());
+ launchOptions.proxyOverride = clientCertificatesProxy.proxySettings();
options = { ...options };
options.internalIgnoreHTTPSErrors = true;
}
- progress.cleanupWhenAborted(() => clientCertificatesProxy?.close());
const browser = await this._innerLaunchWithRetries(progress, launchOptions, options, helper.debugProtocolLogger(), userDataDir).catch(e => { throw this._rewriteStartupLog(e); });
browser._defaultContext!._clientCertificatesProxy = clientCertificatesProxy;
return browser;
@@ -118,7 +117,7 @@ export abstract class BrowserType extends SdkObject {
const browserLogsCollector = new RecentLogsCollector();
const { browserProcess, userDataDir, artifactsDir, transport } = await this._launchProcess(progress, options, !!persistent, browserLogsCollector, maybeUserDataDir);
if ((options as any).__testHookBeforeCreateBrowser)
- await (options as any).__testHookBeforeCreateBrowser();
+ await progress.race((options as any).__testHookBeforeCreateBrowser());
const browserOptions: BrowserOptions = {
name: this._name,
isChromium: this._name === 'chromium',
@@ -140,7 +139,7 @@ export abstract class BrowserType extends SdkObject {
if (persistent)
validateBrowserContextOptions(persistent, browserOptions);
copyTestHooks(options, browserOptions);
- const browser = await this.connectToTransport(transport, browserOptions, browserLogsCollector);
+ const browser = await progress.race(this.connectToTransport(transport, browserOptions, browserLogsCollector));
(browser as any)._userDataDirForTest = userDataDir;
// We assume no control when using custom arguments, and do not prepare the default context in that case.
if (persistent && !options.ignoreAllDefaultArgs)
@@ -148,22 +147,16 @@ export abstract class BrowserType extends SdkObject {
return browser;
}
- private async _launchProcess(progress: Progress, options: types.LaunchOptions, isPersistent: boolean, browserLogsCollector: RecentLogsCollector, userDataDir?: string): Promise<{ browserProcess: BrowserProcess, artifactsDir: string, userDataDir: string, transport: ConnectionTransport }> {
+ private async _prepareToLaunch(options: types.LaunchOptions, isPersistent: boolean, userDataDir: string | undefined) {
const {
ignoreDefaultArgs,
ignoreAllDefaultArgs,
args = [],
executablePath = null,
- handleSIGINT = true,
- handleSIGTERM = true,
- handleSIGHUP = true,
} = options;
-
- const env = options.env ? envArrayToObject(options.env) : process.env;
-
await this._createArtifactDirs(options);
- const tempDirectories = [];
+ const tempDirectories: string[] = [];
const artifactsDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'playwright-artifacts-'));
tempDirectories.push(artifactsDir);
@@ -178,7 +171,7 @@ export abstract class BrowserType extends SdkObject {
}
await this.prepareUserDataDir(options, userDataDir);
- const browserArguments = [];
+ const browserArguments: string[] = [];
if (ignoreAllDefaultArgs)
browserArguments.push(...args);
else if (ignoreDefaultArgs)
@@ -199,15 +192,29 @@ export abstract class BrowserType extends SdkObject {
await registry.validateHostRequirementsForExecutablesIfNeeded([registryExecutable], this.attribution.playwright.options.sdkLanguage);
}
+ return { executable, browserArguments, userDataDir, artifactsDir, tempDirectories };
+ }
+
+ private async _launchProcess(progress: Progress, options: types.LaunchOptions, isPersistent: boolean, browserLogsCollector: RecentLogsCollector, userDataDir?: string): Promise<{ browserProcess: BrowserProcess, artifactsDir: string, userDataDir: string, transport: ConnectionTransport }> {
+ const {
+ handleSIGINT = true,
+ handleSIGTERM = true,
+ handleSIGHUP = true,
+ } = options;
+
+ const env = options.env ? envArrayToObject(options.env) : process.env;
+ const prepared = await progress.race(this._prepareToLaunch(options, isPersistent, userDataDir));
+ progress.cleanupWhenAborted(() => removeFolders(prepared.tempDirectories));
+
// Note: it is important to define these variables before launchProcess, so that we don't get
// "Cannot access 'browserServer' before initialization" if something went wrong.
let transport: ConnectionTransport | undefined = undefined;
let browserProcess: BrowserProcess | undefined = undefined;
const exitPromise = new ManualPromise();
const { launchedProcess, gracefullyClose, kill } = await launchProcess({
- command: executable,
- args: browserArguments,
- env: this.amendEnvironment(env, userDataDir, executable, browserArguments),
+ command: prepared.executable,
+ args: prepared.browserArguments,
+ env: this.amendEnvironment(env, prepared.userDataDir, prepared.executable, prepared.browserArguments),
handleSIGINT,
handleSIGTERM,
handleSIGHUP,
@@ -216,7 +223,7 @@ export abstract class BrowserType extends SdkObject {
browserLogsCollector.log(message);
},
stdio: 'pipe',
- tempDirectories,
+ tempDirectories: prepared.tempDirectories,
attemptToGracefullyClose: async () => {
if ((options as any).__testHookGracefullyClose)
await (options as any).__testHookGracefullyClose();
@@ -253,7 +260,7 @@ export abstract class BrowserType extends SdkObject {
kill
};
progress.cleanupWhenAborted(() => closeOrKill(progress.timeUntilDeadline()));
- const { wsEndpoint } = await Promise.race([
+ const { wsEndpoint } = await progress.race([
this.waitForReadyState(options, browserLogsCollector),
exitPromise.then(() => ({ wsEndpoint: undefined })),
]);
@@ -263,7 +270,8 @@ export abstract class BrowserType extends SdkObject {
const stdio = launchedProcess.stdio as unknown as [NodeJS.ReadableStream, NodeJS.WritableStream, NodeJS.WritableStream, NodeJS.WritableStream, NodeJS.ReadableStream];
transport = new PipeTransport(stdio[3], stdio[4]);
}
- return { browserProcess, artifactsDir, userDataDir, transport };
+ progress.cleanupWhenAborted(() => transport.close());
+ return { browserProcess, artifactsDir: prepared.artifactsDir, userDataDir: prepared.userDataDir, transport };
}
async _createArtifactDirs(options: types.LaunchOptions): Promise<void> {
diff --git a/packages/playwright-core/src/server/chromium/chromium.ts b/packages/playwright-core/src/server/chromium/chromium.ts
index 075e56a469..b35fbb83f0 100644
--- a/packages/playwright-core/src/server/chromium/chromium.ts
+++ b/packages/playwright-core/src/server/chromium/chromium.ts
@@ -63,7 +63,7 @@ export class Chromium extends BrowserType {
}
override async connectOverCDP(metadata: CallMetadata, endpointURL: string, options: { slowMo?: number, headers?: types.HeadersArray, timeout: number }) {
- const controller = new ProgressController(metadata, this);
+ const controller = new ProgressController(metadata, this, 'strict');
return controller.run(async progress => {
return await this._connectOverCDPInternal(progress, endpointURL, options);
}, options.timeout);
@@ -79,12 +79,11 @@ export class Chromium extends BrowserType {
else if (headersMap && !Object.keys(headersMap).some(key => key.toLowerCase() === 'user-agent'))
headersMap['User-Agent'] = getUserAgent();
- const artifactsDir = await fs.promises.mkdtemp(ARTIFACTS_FOLDER);
+ const artifactsDir = await progress.race(fs.promises.mkdtemp(ARTIFACTS_FOLDER));
const wsEndpoint = await urlToWSEndpoint(progress, endpointURL, headersMap);
- progress.throwIfAborted();
-
const chromeTransport = await WebSocketTransport.connect(progress, wsEndpoint, { headers: headersMap });
+ progress.cleanupWhenAborted(() => chromeTransport.close());
const cleanedUp = new ManualPromise<void>();
const doCleanup = async () => {
await removeFolders([artifactsDir]);
@@ -111,8 +110,7 @@ export class Chromium extends BrowserType {
originalLaunchOptions: { timeout: options.timeout },
};
validateBrowserContextOptions(persistent, browserOptions);
- progress.throwIfAborted();
- const browser = await CRBrowser.connect(this.attribution.playwright, chromeTransport, browserOptions);
+ const browser = await progress.race(CRBrowser.connect(this.attribution.playwright, chromeTransport, browserOptions));
browser._isCollocatedWithServer = false;
browser.on(Browser.Events.Disconnected, doCleanup);
return browser;
@@ -174,7 +172,7 @@ export class Chromium extends BrowserType {
}
override async _launchWithSeleniumHub(progress: Progress, hubUrl: string, options: types.LaunchOptions): Promise<CRBrowser> {
- await this._createArtifactDirs(options);
+ await progress.race(this._createArtifactDirs(options));
if (!hubUrl.endsWith('/'))
hubUrl = hubUrl + '/';
@@ -390,6 +388,7 @@ async function urlToWSEndpoint(progress: Progress, endpointURL: string, headers:
const json = await fetchData({
url: httpURL,
headers,
+ timeout: progress.timeUntilDeadline(),
}, async (_, resp) => new Error(`Unexpected status ${resp.statusCode} when connecting to ${httpURL}.\n` +
`This does not look like a DevTools server, try connecting via ws://.`)
);
diff --git a/packages/playwright-core/src/server/debugController.ts b/packages/playwright-core/src/server/debugController.ts
index 9338b59406..92b94211a6 100644
--- a/packages/playwright-core/src/server/debugController.ts
+++ b/packages/playwright-core/src/server/debugController.ts
@@ -106,7 +106,7 @@ export class DebugController extends SdkObject {
if (!pages.length) {
const [browser] = this._playwright.allBrowsers();
const { context } = await browser.newContextForReuse({}, internalMetadata);
- await context.newPage(internalMetadata);
+ await context.newPageFromMetadata(internalMetadata);
}
// Update test id attribute.
if (params.testIdAttributeName) {
diff --git a/packages/playwright-core/src/server/dispatchers/browserContextDispatcher.ts b/packages/playwright-core/src/server/dispatchers/browserContextDispatcher.ts
index 033efda435..9609d62a26 100644
--- a/packages/playwright-core/src/server/dispatchers/browserContextDispatcher.ts
+++ b/packages/playwright-core/src/server/dispatchers/browserContextDispatcher.ts
@@ -245,7 +245,7 @@ export class BrowserContextDispatcher extends Dispatcher<BrowserContext, channel
}
async newPage(params: channels.BrowserContextNewPageParams, metadata: CallMetadata): Promise<channels.BrowserContextNewPageResult> {
- return { page: PageDispatcher.from(this, await this._context.newPage(metadata)) };
+ return { page: PageDispatcher.from(this, await this._context.newPageFromMetadata(metadata)) };
}
async cookies(params: channels.BrowserContextCookiesParams): Promise<channels.BrowserContextCookiesResult> {
diff --git a/packages/playwright-core/src/server/dispatchers/browserDispatcher.ts b/packages/playwright-core/src/server/dispatchers/browserDispatcher.ts
index 186ec73faa..448440069a 100644
--- a/packages/playwright-core/src/server/dispatchers/browserDispatcher.ts
+++ b/packages/playwright-core/src/server/dispatchers/browserDispatcher.ts
@@ -60,14 +60,14 @@ export class BrowserDispatcher extends Dispatcher<Browser, channels.BrowserChann
async newContext(params: channels.BrowserNewContextParams, metadata: CallMetadata): Promise<channels.BrowserNewContextResult> {
if (!this._options.isolateContexts) {
- const context = await this._object.newContext(metadata, params);
+ const context = await this._object.newContextFromMetadata(metadata, params);
const contextDispatcher = BrowserContextDispatcher.from(this, context);
return { context: contextDispatcher };
}
if (params.recordVideo)
params.recordVideo.dir = this._object.options.artifactsDir;
- const context = await this._object.newContext(metadata, params);
+ const context = await this._object.newContextFromMetadata(metadata, params);
this._isolatedContexts.add(context);
context.on(BrowserContext.Events.Close, () => this._isolatedContexts.delete(context));
const contextDispatcher = BrowserContextDispatcher.from(this, context);
diff --git a/packages/playwright-core/src/server/dispatchers/electronDispatcher.ts b/packages/playwright-core/src/server/dispatchers/electronDispatcher.ts
index 7660526176..8ca84caade 100644
--- a/packages/playwright-core/src/server/dispatchers/electronDispatcher.ts
+++ b/packages/playwright-core/src/server/dispatchers/electronDispatcher.ts
@@ -24,6 +24,7 @@ import type { PageDispatcher } from './pageDispatcher';
import type { ConsoleMessage } from '../console';
import type { Electron } from '../electron/electron';
import type * as channels from '@protocol/channels';
+import type { CallMetadata } from '@protocol/callMetadata';
export class ElectronDispatcher extends Dispatcher<Electron, channels.ElectronChannel, RootDispatcher> implements channels.ElectronChannel {
@@ -35,10 +36,10 @@ export class ElectronDispatcher extends Dispatcher<Electron, channels.ElectronCh
this._denyLaunch = denyLaunch;
}
- async launch(params: channels.ElectronLaunchParams): Promise<channels.ElectronLaunchResult> {
+ async launch(params: channels.ElectronLaunchParams, metadata: CallMetadata): Promise<channels.ElectronLaunchResult> {
if (this._denyLaunch)
throw new Error(`Launching more browsers is not allowed.`);
- const electronApplication = await this._object.launch(params);
+ const electronApplication = await this._object.launch(metadata, params);
return { electronApplication: new ElectronApplicationDispatcher(this, electronApplication) };
}
}
diff --git a/packages/playwright-core/src/server/dispatchers/localUtilsDispatcher.ts b/packages/playwright-core/src/server/dispatchers/localUtilsDispatcher.ts
index 1a00d8c7f1..e614aae621 100644
--- a/packages/playwright-core/src/server/dispatchers/localUtilsDispatcher.ts
+++ b/packages/playwright-core/src/server/dispatchers/localUtilsDispatcher.ts
@@ -83,7 +83,7 @@ export class LocalUtilsDispatcher extends Dispatcher<SdkObject, channels.LocalUt
}
async connect(params: channels.LocalUtilsConnectParams, metadata: CallMetadata): Promise<channels.LocalUtilsConnectResult> {
- const controller = new ProgressController(metadata, this._object);
+ const controller = new ProgressController(metadata, this._object, 'strict');
return await controller.run(async progress => {
const wsHeaders = {
'User-Agent': getUserAgent(),
@@ -146,7 +146,6 @@ async function urlToWSEndpoint(progress: Progress, endpointURL: string): Promise
return new Error(`Unexpected status ${response.statusCode} when connecting to ${fetchUrl.toString()}.\n` +
`This does not look like a Playwright server, try connecting via ws://.`);
});
- progress.throwIfAborted();
const wsUrl = new URL(endpointURL);
let wsEndpointPath = JSON.parse(json).wsEndpointPath;
diff --git a/packages/playwright-core/src/server/electron/electron.ts b/packages/playwright-core/src/server/electron/electron.ts
index b0c154effa..d687571d47 100644
--- a/packages/playwright-core/src/server/electron/electron.ts
+++ b/packages/playwright-core/src/server/electron/electron.ts
@@ -19,7 +19,7 @@ import os from 'os';
import path from 'path';
import * as readline from 'readline';
-import { ManualPromise } from '../../utils';
+import { ManualPromise, removeFolders } from '../../utils';
import { wrapInASCIIBox } from '../utils/ascii';
import { RecentLogsCollector } from '../utils/debugLogger';
import { eventsHelper } from '../utils/eventsHelper';
@@ -30,7 +30,7 @@ import { createHandle, CRExecutionContext } from '../chromium/crExecutionContext
import { toConsoleMessageLocation } from '../chromium/crProtocolHelper';
import { ConsoleMessage } from '../console';
import { helper } from '../helper';
-import { SdkObject, serverSideCallMetadata } from '../instrumentation';
+import { CallMetadata, SdkObject } from '../instrumentation';
import * as js from '../javascript';
import { envArrayToObject, launchProcess } from '../utils/processLauncher';
import { ProgressController } from '../progress';
@@ -152,18 +152,15 @@ export class ElectronApplication extends SdkObject {
export class Electron extends SdkObject {
constructor(playwright: Playwright) {
super(playwright, 'electron');
+ this.logName = 'browser';
}
- async launch(options: channels.ElectronLaunchParams): Promise<ElectronApplication> {
- const {
- args = [],
- } = options;
- const controller = new ProgressController(serverSideCallMetadata(), this);
- controller.setLogName('browser');
+ async launch(metadata: CallMetadata, options: channels.ElectronLaunchParams): Promise<ElectronApplication> {
+ const controller = new ProgressController(metadata, this, 'strict');
return controller.run(async progress => {
let app: ElectronApplication | undefined = undefined;
// --remote-debugging-port=0 must be the last playwright's argument, loader.ts relies on it.
- let electronArguments = ['--inspect=0', '--remote-debugging-port=0', ...args];
+ let electronArguments = ['--inspect=0', '--remote-debugging-port=0', ...(options.args || [])];
if (os.platform() === 'linux') {
const runningAsRoot = process.geteuid && process.geteuid() === 0;
@@ -171,7 +168,8 @@ export class Electron extends SdkObject {
electronArguments.unshift('--no-sandbox');
}
- const artifactsDir = await fs.promises.mkdtemp(ARTIFACTS_FOLDER);
+ const artifactsDir = await progress.race(fs.promises.mkdtemp(ARTIFACTS_FOLDER));
+ progress.cleanupWhenAborted(() => removeFolders([artifactsDir]));
const browserLogsCollector = new RecentLogsCollector();
const env = options.env ? envArrayToObject(options.env) : process.env;
@@ -233,8 +231,8 @@ export class Electron extends SdkObject {
// All waitForLines must be started immediately.
// Otherwise the lines might come before we are ready.
- const waitForXserverError = new Promise(async (resolve, reject) => {
- waitForLine(progress, launchedProcess, /Unable to open X display/).then(() => reject(new Error([
+ const waitForXserverError = waitForLine(progress, launchedProcess, /Unable to open X display/).then(() => {
+ throw new Error([
'Unable to open X display!',
`================================`,
'Most likely this is because there is no X server available.',
@@ -242,7 +240,7 @@ export class Electron extends SdkObject {
"For example: 'xvfb-run npm run test:e2e'",
`================================`,
progress.metadata.log
- ].join('\n')))).catch(() => {});
+ ].join('\n'));
});
const nodeMatchPromise = waitForLine(progress, launchedProcess, /^Debugger listening on (ws:\/\/.*)$/);
const chromeMatchPromise = waitForLine(progress, launchedProcess, /^DevTools listening on (ws:\/\/.*)$/);
@@ -250,6 +248,7 @@ export class Electron extends SdkObject {
const nodeMatch = await nodeMatchPromise;
const nodeTransport = await WebSocketTransport.connect(progress, nodeMatch[1]);
+ progress.cleanupWhenAborted(() => nodeTransport.close());
const nodeConnection = new CRConnection(this, nodeTransport, helper.debugProtocolLogger(), browserLogsCollector);
// Immediately release exiting process under debug.
@@ -261,6 +260,7 @@ export class Electron extends SdkObject {
waitForXserverError,
]) as RegExpMatchArray;
const chromeTransport = await WebSocketTransport.connect(progress, chromeMatch[1]);
+ progress.cleanupWhenAborted(() => chromeTransport.close());
const browserProcess: BrowserProcess = {
onclose: undefined,
process: launchedProcess,
@@ -285,16 +285,16 @@ export class Electron extends SdkObject {
originalLaunchOptions: { timeout: options.timeout },
};
validateBrowserContextOptions(contextOptions, browserOptions);
- const browser = await CRBrowser.connect(this.attribution.playwright, chromeTransport, browserOptions);
+ const browser = await progress.race(CRBrowser.connect(this.attribution.playwright, chromeTransport, browserOptions));
app = new ElectronApplication(this, browser, nodeConnection, launchedProcess);
- await app.initialize();
+ await progress.race(app.initialize());
return app;
}, options.timeout);
}
}
function waitForLine(progress: Progress, process: childProcess.ChildProcess, regex: RegExp): Promise<RegExpMatchArray> {
- return new Promise((resolve, reject) => {
+ return progress.race(new Promise((resolve, reject) => {
const rl = readline.createInterface({ input: process.stderr! });
const failError = new Error('Process failed to launch!');
const listeners = [
@@ -318,5 +318,5 @@ function waitForLine(progress: Progress, process: childProcess.ChildProcess, reg
function cleanup() {
eventsHelper.removeEventListeners(listeners);
}
- });
+ }));
}
diff --git a/packages/playwright-core/src/server/socksClientCertificatesInterceptor.ts b/packages/playwright-core/src/server/socksClientCertificatesInterceptor.ts
index 2cb5883782..896dd2f091 100644
--- a/packages/playwright-core/src/server/socksClientCertificatesInterceptor.ts
+++ b/packages/playwright-core/src/server/socksClientCertificatesInterceptor.ts
@@ -244,7 +244,7 @@ export class ClientCertificatesProxy {
alpnCache: ALPNCache;
proxyAgentFromOptions: ReturnType<typeof createProxyAgent>;
- constructor(
+ private constructor(
contextOptions: Pick<types.BrowserContextOptions, 'clientCertificates' | 'ignoreHTTPSErrors' | 'proxy'>
) {
verifyClientCertificates(contextOptions.clientCertificates);
@@ -294,9 +294,14 @@ export class ClientCertificatesProxy {
}
}
- public async listen() {
- const port = await this._socksProxy.listen(0, '127.0.0.1');
- return { server: `socks5://127.0.0.1:${port}` };
+ public static async create(contextOptions: Pick<types.BrowserContextOptions, 'clientCertificates' | 'ignoreHTTPSErrors' | 'proxy'>) {
+ const proxy = new ClientCertificatesProxy(contextOptions);
+ await proxy._socksProxy.listen(0, '127.0.0.1');
+ return proxy;
+ }
+
+ public proxySettings(): types.ProxySettings {
+ return { server: `socks5://127.0.0.1:${this._socksProxy.port()}` };
}
public async close() {
diff --git a/packages/playwright-core/src/server/transport.ts b/packages/playwright-core/src/server/transport.ts
index e95ec8eaee..30e87ae0c2 100644
--- a/packages/playwright-core/src/server/transport.ts
+++ b/packages/playwright-core/src/server/transport.ts
@@ -84,12 +84,8 @@ export class WebSocketTransport implements ConnectionTransport {
const logUrl = stripQueryParams(url);
progress?.log(`<ws connecting> ${logUrl}`);
const transport = new WebSocketTransport(progress, url, logUrl, { ...options, followRedirects: !!options.followRedirects && hadRedirects });
- let success = false;
- progress?.cleanupWhenAborted(async () => {
- if (!success)
- await transport.closeAndWait().catch(e => null);
- });
- const result = await new Promise<{ transport?: WebSocketTransport, redirect?: IncomingMessage }>((fulfill, reject) => {
+ progress?.cleanupWhenAborted(() => transport.closeAndWait());
+ const resultPromise = new Promise<{ transport?: WebSocketTransport, redirect?: IncomingMessage }>((fulfill, reject) => {
transport._ws.on('open', async () => {
progress?.log(`<ws connected> ${logUrl}`);
fulfill({ transport });
@@ -120,6 +116,7 @@ export class WebSocketTransport implements ConnectionTransport {
});
});
});
+ const result = progress ? await progress.race(resultPromise) : await resultPromise;
if (result.redirect) {
// Strip authorization headers from the redirected request.
@@ -128,8 +125,6 @@ export class WebSocketTransport implements ConnectionTransport {
}));
return WebSocketTransport._connect(progress, result.redirect.headers.location!, { ...options, headers: newHeaders }, true /* hadRedirects */);
}
-
- success = true;
return transport;
}
diff --git a/packages/playwright-core/src/server/utils/processLauncher.ts b/packages/playwright-core/src/server/utils/processLauncher.ts
index 90bc1507fc..2f204674ec 100644
--- a/packages/playwright-core/src/server/utils/processLauncher.ts
+++ b/packages/playwright-core/src/server/utils/processLauncher.ts
@@ -164,7 +164,7 @@ export async function launchProcess(options: LaunchProcessOptions): Promise<Laun
spawnedProcess.once('error', error => {
failed(new Error('Failed to launch: ' + error));
});
- return cleanup().then(() => failedPromise).then(e => Promise.reject(e));
+ return failedPromise.then(e => Promise.reject(e));
}
options.log(`<launched> pid=${spawnedProcess.pid}`);
diff --git a/tests/library/browser.spec.ts b/tests/library/browser.spec.ts
index 17bdc14213..19d47f871a 100644
--- a/tests/library/browser.spec.ts
+++ b/tests/library/browser.spec.ts
@@ -62,3 +62,11 @@ test('should dispatch page.on(close) upon browser.close and reject evaluate', as
const error = await promise;
expect(error.message).toContain(kTargetClosedErrorMessage);
});
+
+test('newContext should not leave a context upon failure', async ({ browser, toImpl }) => {
+ const error = await browser.newContext({
+ __testHookBeforeSetStorageState: () => Promise.reject(new Error('Oh my')),
+ } as any).catch(e => e);
+ expect(error.message).toContain('Oh my');
+ await expect.poll(() => toImpl(browser).contexts().length).toBe(0);
+});