Playwright is a framework for Web Testing and Automation. It allows testing Chromium, Firefox and WebKit with a single API.
TypeScript automationchromechromiume2e-testingelectronend-to-end-testingfirefoxjavascriptplaywrighttesttest-automationtestingtesting-toolswebwebkit
/**
* 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 { monotonicTime } from '@isomorphic/time';
import { raceAgainstDeadline } from '@isomorphic/timeoutRunner';
import { Browser } from './browser';
import { ChannelOwner } from './channelOwner';
import { Connection } from './connection';
import { Events } from './events';
import { kNoTimeout } from './timeoutSettings';
import type { Playwright } from './playwright';
import type { ConnectOptions, HeadersArray } from './types';
import type * as channels from './channels';
export async function connectToBrowser(playwright: Playwright, params: ConnectOptions): Promise<Browser> {
const deadline = params.timeout ? monotonicTime() + params.timeout : 0;
const nameParam = params.browserName ? { 'x-playwright-browser': params.browserName } : {};
const headers = { ...nameParam, ...params.headers };
const connectParams: channels.LocalUtilsConnectParams = {
endpoint: params.endpoint!,
headers,
exposeNetwork: params.exposeNetwork,
slowMo: params.slowMo,
};
if ((params as any).__testHookRedirectPortForwarding)
connectParams.socksProxyRedirectPortForTest = (params as any).__testHookRedirectPortForwarding;
const connection = await connectToEndpoint(playwright._connection, connectParams, { signal: undefined, timeout: params.timeout || 0 });
let browser: Browser;
connection.on('close', () => {
// Emulate all pages, contexts and the browser closing upon disconnect.
for (const context of browser?.contexts() || []) {
for (const page of context.pages())
page._onClose();
context._onClose();
}
setTimeout(() => browser?._didClose(), 0);
});
const result = await raceAgainstDeadline(async () => {
// For tests.
if ((params as any).__testHookBeforeCreateBrowser)
await (params as any).__testHookBeforeCreateBrowser();
const playwright = await connection!.initializePlaywright();
if (!playwright._initializer.preLaunchedBrowser) {
connection.close();
throw new Error('Malformed endpoint. Did you use BrowserType.launchServer method?');
}
playwright.selectors = playwright.selectors;
browser = Browser.from(playwright._initializer.preLaunchedBrowser!);
browser._shouldCloseConnectionOnClose = true;
browser.on(Events.Browser.Disconnected, () => connection.close());
return browser;
}, deadline);
if (!result.timedOut) {
return result.result;
} else {
connection.close();
throw new Error(`Timeout ${params.timeout}ms exceeded`);
}
}
export async function connectToEndpoint(parentConnection: Connection, params: channels.LocalUtilsConnectParams, timeout: channels.TimeoutOptions): Promise<Connection> {
const localUtils = parentConnection.localUtils();
const transport = localUtils ? new JsonPipeTransport(localUtils) : new WebSocketTransport();
const connectHeaders = await transport.connect(params, timeout);
const connection = new Connection(localUtils, parentConnection._instrumentation, connectHeaders);
connection.markAsRemote();
connection.on('close', () => transport.close());
let closeError: string | undefined;
const onTransportClosed = (reason?: string) => {
connection.close(reason || closeError);
};
transport.onClose(reason => onTransportClosed(reason));
connection.onmessage = message => transport.send(message).catch(() => onTransportClosed());
transport.onMessage(message => {
try {
connection!.dispatch(message);
} catch (e) {
closeError = String(e);
transport.close().catch(() => {});
}
});
return connection;
}
interface Transport {
connect(params: channels.LocalUtilsConnectParams, timeout: channels.TimeoutOptions): Promise<HeadersArray>;
send(message: any): Promise<void>;
onMessage(callback: (message: object) => void): void;
onClose(callback: (reason?: string) => void): void;
close(): Promise<void>;
}
class JsonPipeTransport implements Transport {
private _pipe: channels.JsonPipeChannel | undefined;
private _owner: ChannelOwner<channels.LocalUtilsChannel>;
constructor(owner: ChannelOwner<channels.LocalUtilsChannel>) {
this._owner = owner;
}
async connect(params: channels.LocalUtilsConnectParams, timeout: channels.TimeoutOptions) {
const { pipe, headers: connectHeaders } = await this._owner._channel.connect(params, timeout);
this._pipe = pipe;
return connectHeaders;
}
async send(message: object) {
await this._pipe!.send({ message }, kNoTimeout);
}
onMessage(callback: (message: object) => void) {
this._pipe!.on('message', ({ message }) => callback(message));
}
onClose(callback: (reason?: string) => void) {
this._pipe!.on('closed', ({ reason }) => callback(reason));
}
async close() {
await this._pipe!.close({}, kNoTimeout).catch(() => {});
}
}
class WebSocketTransport implements Transport {
private _ws: WebSocket | undefined;
async connect(params: channels.LocalUtilsConnectParams, timeout: channels.TimeoutOptions) {
this._ws = new window.WebSocket(params.endpoint);
return [];
}
async send(message: object) {
this._ws!.send(JSON.stringify(message));
}
onMessage(callback: (message: object) => void) {
this._ws!.addEventListener('message', event => callback(JSON.parse(event.data)));
}
onClose(callback: (reason?: string) => void) {
this._ws!.addEventListener('close', () => callback());
}
async close() {
this._ws!.close();
}
}