Skip to content

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

chore(browserType): merge connectOverCDP and connectOverCDPTransport (#41014)

Pavel Feldman4afdd64a3c96
diff --git a/packages/isomorphic/protocolMetainfo.ts b/packages/isomorphic/protocolMetainfo.ts
index e99ac29133..b0e779d1b0 100644
--- a/packages/isomorphic/protocolMetainfo.ts
+++ b/packages/isomorphic/protocolMetainfo.ts
@@ -115,7 +115,6 @@ export const methodMetainfo = new Map<string, MethodMetainfo>([
['BrowserType.launch', { title: 'Launch browser', }],
['BrowserType.launchPersistentContext', { title: 'Launch persistent context', }],
['BrowserType.connectOverCDP', { title: 'Connect over CDP', }],
- ['BrowserType.connectOverCDPTransport', { title: 'Connect over CDP transport', }],
['BrowserType.connectToWorker', { title: 'Connect to worker', }],
['Disposable.dispose', { internal: true, potentiallyClosesScope: true, }],
['Electron.launch', { title: 'Launch electron', }],
diff --git a/packages/playwright-client/types/types.d.ts b/packages/playwright-client/types/types.d.ts
index d15884b399..185bb6dce2 100644
--- a/packages/playwright-client/types/types.d.ts
+++ b/packages/playwright-client/types/types.d.ts
@@ -15439,7 +15439,8 @@ export interface BrowserType<Unused = {}> {
* `ws://127.0.0.1:9222/devtools/browser/387adf4c-243f-4051-a181-46798f4a46f4`.
* @param options
*/
- connectOverCDP(transport: ConnectionTransport): Promise<Browser>;
+ connectOverCDP(transport: ConnectionTransport, options?: ConnectOverCDPOptions): Promise<Browser>;
+
/**
* This method attaches Playwright to an existing browser instance created via `BrowserType.launchServer` in Node.js.
*
diff --git a/packages/playwright-core/src/client/browserType.ts b/packages/playwright-core/src/client/browserType.ts
index f78b9d2714..036dd702a9 100644
--- a/packages/playwright-core/src/client/browserType.ts
+++ b/packages/playwright-core/src/client/browserType.ts
@@ -138,24 +138,33 @@ export class BrowserType extends ChannelOwner<channels.BrowserTypeChannel> imple
async connectOverCDP(options: api.ConnectOverCDPOptions & { wsEndpoint?: string }): Promise<api.Browser>;
async connectOverCDP(endpointURL: string, options?: api.ConnectOverCDPOptions): Promise<api.Browser>;
- async connectOverCDP(transport: api.ConnectionTransport): Promise<api.Browser>;
- async connectOverCDP(endpointURLOrOptions: (api.ConnectOverCDPOptions & { wsEndpoint?: string })|string|api.ConnectionTransport, options?: api.ConnectOverCDPOptions) {
- if (typeof endpointURLOrOptions === 'string')
- return await this._connectOverCDP(endpointURLOrOptions, options);
- if (isConnectionTransport(endpointURLOrOptions))
- return await this._connectOverCDPTransport(endpointURLOrOptions);
- const endpointURL = 'endpointURL' in endpointURLOrOptions ? endpointURLOrOptions.endpointURL : endpointURLOrOptions.wsEndpoint;
- assert(endpointURL, 'Cannot connect over CDP without wsEndpoint.');
- return await this._connectOverCDP(endpointURL, endpointURLOrOptions);
- }
-
- async _connectOverCDP(endpointURL: string, params: api.ConnectOverCDPOptions = {}): Promise<Browser> {
- if (this.name() !== 'chromium' && this.name() !== 'webkit')
+ async connectOverCDP(transport: api.ConnectionTransport, options?: api.ConnectOverCDPOptions): Promise<api.Browser>;
+ async connectOverCDP(overloaded: (api.ConnectOverCDPOptions & { wsEndpoint?: string }) | string | api.ConnectionTransport, options?: api.ConnectOverCDPOptions): Promise<Browser> {
+ let endpointURL: string | undefined;
+ let transport: api.ConnectionTransport | undefined;
+ let params: api.ConnectOverCDPOptions;
+ if (typeof overloaded === 'string') {
+ endpointURL = overloaded;
+ params = options ?? {};
+ } else if (isConnectionTransport(overloaded)) {
+ if (this.name() !== 'chromium' && this.name() !== 'webkit')
+ throw new Error('Connecting over CDP is only supported in Chromium and WebKit.');
+ if (this._connection.isRemote())
+ throw new Error('Passing a ConnectionTransport to connectOverCDP is not supported when connecting remotely.');
+ transport = overloaded;
+ params = options ?? {};
+ } else {
+ endpointURL = 'endpointURL' in overloaded ? (overloaded as any).endpointURL : overloaded.wsEndpoint;
+ assert(endpointURL, 'Cannot connect over CDP without wsEndpoint.');
+ params = overloaded;
+ }
+ if (endpointURL && this.name() !== 'chromium' && this.name() !== 'webkit')
throw new Error('Connecting over CDP is only supported in Chromium and WebKit.');
- const headers = params.headers ? headersObjectToArray(params.headers) : undefined;
+
const result = await this._channel.connectOverCDP({
endpointURL,
- headers,
+ transport: transport as any,
+ headers: params.headers ? headersObjectToArray(params.headers) : undefined,
slowMo: params.slowMo,
timeout: new TimeoutSettings(this._platform).timeout(params),
isLocal: params.isLocal,
@@ -165,15 +174,6 @@ export class BrowserType extends ChannelOwner<channels.BrowserTypeChannel> imple
return await this._browserFromConnectResult(result);
}
- async _connectOverCDPTransport(transport: api.ConnectionTransport): Promise<Browser> {
- if (this.name() !== 'chromium')
- throw new Error('Connecting over CDP is only supported in Chromium.');
- if (this._connection.isRemote())
- throw new Error('Passing a ConnectionTransport to connectOverCDP is not supported when connecting remotely.');
- const result = await this._channel.connectOverCDPTransport({ transport: transport as any });
- return await this._browserFromConnectResult(result);
- }
-
private async _browserFromConnectResult(result: { browser: channels.BrowserChannel, defaultContext?: channels.BrowserContextChannel }): Promise<Browser> {
const browser = Browser.from(result.browser);
browser._connectToBrowserType(this, {}, undefined);
diff --git a/packages/playwright-core/src/protocol/validator.ts b/packages/playwright-core/src/protocol/validator.ts
index 1e39b28725..656817e780 100644
--- a/packages/playwright-core/src/protocol/validator.ts
+++ b/packages/playwright-core/src/protocol/validator.ts
@@ -1087,25 +1087,19 @@ scheme.BrowserTypeLaunchPersistentContextResult = tObject({
context: tChannel(['BrowserContext']),
});
scheme.BrowserTypeConnectOverCDPParams = tObject({
- endpointURL: tString,
+ endpointURL: tOptional(tString),
headers: tOptional(tArray(tType('NameValue'))),
slowMo: tOptional(tFloat),
timeout: tFloat,
isLocal: tOptional(tBoolean),
noDefaults: tOptional(tBoolean),
artifactsDir: tOptional(tString),
+ transport: tOptional(tBinary),
});
scheme.BrowserTypeConnectOverCDPResult = tObject({
browser: tChannel(['Browser']),
defaultContext: tOptional(tChannel(['BrowserContext'])),
});
-scheme.BrowserTypeConnectOverCDPTransportParams = tObject({
- transport: tBinary,
-});
-scheme.BrowserTypeConnectOverCDPTransportResult = tObject({
- browser: tChannel(['Browser']),
- defaultContext: tOptional(tChannel(['BrowserContext'])),
-});
scheme.BrowserTypeConnectToWorkerParams = tObject({
endpoint: tString,
timeout: tFloat,
diff --git a/packages/playwright-core/src/server/browserType.ts b/packages/playwright-core/src/server/browserType.ts
index d9a1e34f52..5631142825 100644
--- a/packages/playwright-core/src/server/browserType.ts
+++ b/packages/playwright-core/src/server/browserType.ts
@@ -286,11 +286,7 @@ export abstract class BrowserType extends SdkObject {
}
}
- async connectOverCDP(progress: Progress, endpointURL: string, options: { slowMo?: number, timeout?: number, headers?: types.HeadersArray, isLocal?: boolean, noDefaults?: boolean, artifactsDir?: string }): Promise<Browser> {
- throw new Error('CDP connections are only supported by Chromium');
- }
-
- async connectOverCDPTransport(progress: Progress, transport: ConnectionTransport): Promise<Browser> {
+ async connectOverCDP(progress: Progress, params: channels.BrowserTypeConnectOverCDPParams): Promise<Browser> {
throw new Error('CDP connections are only supported by Chromium');
}
diff --git a/packages/playwright-core/src/server/chromium/chromium.ts b/packages/playwright-core/src/server/chromium/chromium.ts
index 063701c82b..7766548d19 100644
--- a/packages/playwright-core/src/server/chromium/chromium.ts
+++ b/packages/playwright-core/src/server/chromium/chromium.ts
@@ -81,8 +81,10 @@ export class Chromium extends BrowserType {
return super.launchPersistentContext(progress, userDataDir, options);
}
- override async connectOverCDP(progress: Progress, endpointURL: string, options: { slowMo?: number, headers?: types.HeadersArray, isLocal?: boolean, noDefaults?: boolean, artifactsDir?: string }) {
- return await this._connectOverCDPInternal(progress, endpointURL, options);
+ override async connectOverCDP(progress: Progress, params: channels.BrowserTypeConnectOverCDPParams) {
+ if (params.transport)
+ return this._connectOverCDPImpl(progress, params.transport as any, async () => (params.transport as any).close(), { ...params, isLocal: true });
+ return await this._connectOverCDPInternal(progress, params.endpointURL!, params);
}
async _connectOverCDPInternal(progress: Progress, endpointURL: string, options: types.LaunchOptions & { headers?: types.HeadersArray, isLocal?: boolean, noDefaults?: boolean, artifactsDir?: string }, onClose?: () => Promise<void>) {
@@ -166,11 +168,6 @@ export class Chromium extends BrowserType {
}
}
- override async connectOverCDPTransport(progress: Progress, transport: ConnectionTransport) {
- const closeAndWait = async () => transport.close();
- return this._connectOverCDPImpl(progress, transport, closeAndWait, { isLocal: true });
- }
-
override async connectToWorker(progress: Progress, endpoint: string) {
const wsEndpoint = await urlToWSEndpoint(progress, endpoint, {});
const transport = await WebSocketTransport.connect(progress, wsEndpoint);
diff --git a/packages/playwright-core/src/server/dispatchers/browserTypeDispatcher.ts b/packages/playwright-core/src/server/dispatchers/browserTypeDispatcher.ts
index 40633088d5..dc0d005c10 100644
--- a/packages/playwright-core/src/server/dispatchers/browserTypeDispatcher.ts
+++ b/packages/playwright-core/src/server/dispatchers/browserTypeDispatcher.ts
@@ -57,7 +57,7 @@ export class BrowserTypeDispatcher extends Dispatcher<BrowserType, channels.Brow
if (this._denyLaunch)
throw new Error(`Launching more browsers is not allowed.`);
- const browser = await this._object.connectOverCDP(progress, params.endpointURL, params);
+ const browser = await this._object.connectOverCDP(progress, params);
const browserDispatcher = new BrowserDispatcher(this, browser);
return {
browser: browserDispatcher,
@@ -65,15 +65,6 @@ export class BrowserTypeDispatcher extends Dispatcher<BrowserType, channels.Brow
};
}
- async connectOverCDPTransport(params: channels.BrowserTypeConnectOverCDPTransportParams, progress: Progress): Promise<channels.BrowserTypeConnectOverCDPTransportResult> {
- if (this._denyLaunch)
- throw new Error(`Launching more browsers is not allowed.`);
-
- const browser = await this._object.connectOverCDPTransport(progress, params.transport as any);
- const browserDispatcher = new BrowserDispatcher(this, browser);
- return { browser: browserDispatcher, defaultContext: browser._defaultContext ? BrowserContextDispatcher.from(browserDispatcher, browser._defaultContext) : undefined };
- }
-
async connectToWorker(params: channels.BrowserTypeConnectToWorkerParams, progress: Progress): Promise<channels.BrowserTypeConnectToWorkerResult> {
if (this._denyLaunch)
throw new Error(`Launching more browsers is not allowed.`);
diff --git a/packages/playwright-core/src/server/webkit/webkit.ts b/packages/playwright-core/src/server/webkit/webkit.ts
index d5f8eb1ce4..994bc25d27 100644
--- a/packages/playwright-core/src/server/webkit/webkit.ts
+++ b/packages/playwright-core/src/server/webkit/webkit.ts
@@ -30,6 +30,7 @@ import type { SdkObject } from '../instrumentation';
import type { Progress } from '../progress';
import type { ConnectionTransport } from '../transport';
import type * as types from '../types';
+import type * as channels from '@protocol/channels';
export class WebKit extends BrowserType {
constructor(parent: SdkObject) {
@@ -40,8 +41,8 @@ export class WebKit extends BrowserType {
return WKBrowser.connect(this.attribution.playwright, transport, options);
}
- override async connectOverCDP(progress: Progress, endpointURL: string, options: { slowMo?: number, headers?: types.HeadersArray, isLocal?: boolean, noDefaults?: boolean }): Promise<Browser> {
- return connectOverRDP(progress, this, endpointURL, options);
+ override async connectOverCDP(progress: Progress, params: channels.BrowserTypeConnectOverCDPParams): Promise<Browser> {
+ return connectOverRDP(progress, this, params.endpointURL!, params);
}
override amendEnvironment(env: NodeJS.ProcessEnv, userDataDir: string, isPersistent: boolean, options: types.LaunchOptions): NodeJS.ProcessEnv {
diff --git a/packages/playwright-core/types/types.d.ts b/packages/playwright-core/types/types.d.ts
index d15884b399..185bb6dce2 100644
--- a/packages/playwright-core/types/types.d.ts
+++ b/packages/playwright-core/types/types.d.ts
@@ -15439,7 +15439,8 @@ export interface BrowserType<Unused = {}> {
* `ws://127.0.0.1:9222/devtools/browser/387adf4c-243f-4051-a181-46798f4a46f4`.
* @param options
*/
- connectOverCDP(transport: ConnectionTransport): Promise<Browser>;
+ connectOverCDP(transport: ConnectionTransport, options?: ConnectOverCDPOptions): Promise<Browser>;
+
/**
* This method attaches Playwright to an existing browser instance created via `BrowserType.launchServer` in Node.js.
*
diff --git a/packages/protocol/spec/browserType.yml b/packages/protocol/spec/browserType.yml
index 022ed15aa3..7c4247a884 100644
--- a/packages/protocol/spec/browserType.yml
+++ b/packages/protocol/spec/browserType.yml
@@ -43,7 +43,7 @@ BrowserType:
connectOverCDP:
title: Connect over CDP
parameters:
- endpointURL: string
+ endpointURL: string?
headers:
type: array?
items: NameValue
@@ -52,14 +52,7 @@ BrowserType:
isLocal: boolean?
noDefaults: boolean?
artifactsDir: string?
- returns:
- browser: Browser
- defaultContext: BrowserContext?
-
- connectOverCDPTransport:
- title: Connect over CDP transport
- parameters:
- transport: binary
+ transport: binary?
returns:
browser: Browser
defaultContext: BrowserContext?
diff --git a/packages/protocol/src/channels.d.ts b/packages/protocol/src/channels.d.ts
index a4dd1e2bd4..02409015ca 100644
--- a/packages/protocol/src/channels.d.ts
+++ b/packages/protocol/src/channels.d.ts
@@ -1822,7 +1822,6 @@ export interface BrowserTypeChannel extends BrowserTypeEventTarget, Channel {
launch(params: BrowserTypeLaunchParams, progress?: Progress): Promise<BrowserTypeLaunchResult>;
launchPersistentContext(params: BrowserTypeLaunchPersistentContextParams, progress?: Progress): Promise<BrowserTypeLaunchPersistentContextResult>;
connectOverCDP(params: BrowserTypeConnectOverCDPParams, progress?: Progress): Promise<BrowserTypeConnectOverCDPResult>;
- connectOverCDPTransport(params: BrowserTypeConnectOverCDPTransportParams, progress?: Progress): Promise<BrowserTypeConnectOverCDPTransportResult>;
connectToWorker(params: BrowserTypeConnectToWorkerParams, progress?: Progress): Promise<BrowserTypeConnectToWorkerResult>;
}
export type BrowserTypeLaunchParams = {
@@ -2060,35 +2059,28 @@ export type BrowserTypeLaunchPersistentContextResult = {
context: BrowserContextChannel,
};
export type BrowserTypeConnectOverCDPParams = {
- endpointURL: string,
+ endpointURL?: string,
headers?: NameValue[],
slowMo?: number,
timeout: number,
isLocal?: boolean,
noDefaults?: boolean,
artifactsDir?: string,
+ transport?: Binary,
};
export type BrowserTypeConnectOverCDPOptions = {
+ endpointURL?: string,
headers?: NameValue[],
slowMo?: number,
isLocal?: boolean,
noDefaults?: boolean,
artifactsDir?: string,
+ transport?: Binary,
};
export type BrowserTypeConnectOverCDPResult = {
browser: BrowserChannel,
defaultContext?: BrowserContextChannel,
};
-export type BrowserTypeConnectOverCDPTransportParams = {
- transport: Binary,
-};
-export type BrowserTypeConnectOverCDPTransportOptions = {
-
-};
-export type BrowserTypeConnectOverCDPTransportResult = {
- browser: BrowserChannel,
- defaultContext?: BrowserContextChannel,
-};
export type BrowserTypeConnectToWorkerParams = {
endpoint: string,
timeout: number,
diff --git a/tests/library/browsertype-basic.spec.ts b/tests/library/browsertype-basic.spec.ts
index b0bc16f328..39bac27969 100644
--- a/tests/library/browsertype-basic.spec.ts
+++ b/tests/library/browsertype-basic.spec.ts
@@ -32,8 +32,8 @@ test('browserType.name should work', async ({ browserType, browserName }) => {
});
test('should throw when trying to connect with not-chromium', async ({ browserType, browserName }) => {
- test.skip(browserName === 'chromium');
+ test.skip(browserName === 'chromium' || browserName === 'webkit');
const error = await browserType.connectOverCDP({ endpointURL: 'ws://foo' }).catch(e => e);
- expect(error.message).toBe('Connecting over CDP is only supported in Chromium.');
+ expect(error.message).toBe('Connecting over CDP is only supported in Chromium and WebKit.');
});
diff --git a/utils/generate_types/overrides.d.ts b/utils/generate_types/overrides.d.ts
index 687f620e36..ea7d6a03d5 100644
--- a/utils/generate_types/overrides.d.ts
+++ b/utils/generate_types/overrides.d.ts
@@ -216,7 +216,8 @@ export interface BrowserType<Unused = {}> {
* @deprecated
*/
connectOverCDP(options: ConnectOverCDPOptions & { wsEndpoint?: string }): Promise<Browser>;
- connectOverCDP(transport: ConnectionTransport): Promise<Browser>;
+ connectOverCDP(transport: ConnectionTransport, options?: ConnectOverCDPOptions): Promise<Browser>;
+
connect(wsEndpoint: string, options?: ConnectOptions): Promise<Browser>;
/**
* wsEndpoint in options is deprecated. Instead use `wsEndpoint`.