microsoft/playwright
1
1
Fork 0
mirror of https://github.com/microsoft/playwright.git synced 2024-12-17 16:21:55 +03:00
Code Issues Projects Releases Wiki Activity

feat(rpc): switch Env to use an array, split ignoreDefaultArgs (#2984)

Browse Source
This commit is contained in:
Dmitry Gozman 2020-07-17 09:32:27 -07:00 committed by GitHub
parent df8b27069e
commit 5cf3e4f0f2
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 74 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
src/rpc/channels.ts
View File

@ -37,6 +37,24 @@ export type BrowserContextOptions = {
colorScheme?: types.ColorScheme,
acceptDownloads?: boolean,
};
type LaunchOptionsBase = {
executablePath?: string,
args?: string[],
ignoreAllDefaultArgs?: boolean,
ignoreDefaultArgs?: string[],
handleSIGINT?: boolean,
handleSIGTERM?: boolean,
handleSIGHUP?: boolean,
timeout?: number,
env?: types.EnvArray,
headless?: boolean,
devtools?: boolean,
proxy?: types.ProxySettings,
downloadsPath?: string,
};
export type LaunchOptions = LaunchOptionsBase & { slowMo?: number };
export type LaunchServerOptions = LaunchOptionsBase & { port?: number };
export type LaunchPersistentContextOptions = { userDataDir: string } & LaunchOptions & BrowserContextOptions;
export interface Channel extends EventEmitter {
}
@ -60,11 +78,10 @@ export interface SelectorsChannel extends Channel {
export type SelectorsInitializer = {};
export type LaunchPersistentContextOptions = { userDataDir: string } & types.LaunchOptions & BrowserContextOptions;
export interface BrowserTypeChannel extends Channel {
connect(params: types.ConnectOptions): Promise<{ browser: BrowserChannel }>;
launch(params: types.LaunchOptions): Promise<{ browser: BrowserChannel }>;
launchServer(params: types.LaunchServerOptions): Promise<{ server: BrowserServerChannel }>;
launch(params: LaunchOptions): Promise<{ browser: BrowserChannel }>;
launchServer(params: LaunchServerOptions): Promise<{ server: BrowserServerChannel }>;
launchPersistentContext(params: LaunchPersistentContextOptions): Promise<{ context: BrowserContextChannel }>;
}
export type BrowserTypeInitializer = {

23
src/rpc/client/browserType.ts
View File

@ -15,13 +15,13 @@
*/
import * as types from '../../types';
import { BrowserTypeChannel, BrowserTypeInitializer, LaunchPersistentContextOptions } from '../channels';
import { BrowserTypeChannel, BrowserTypeInitializer, LaunchPersistentContextOptions, LaunchOptions, LaunchServerOptions } from '../channels';
import { Browser } from './browser';
import { BrowserContext } from './browserContext';
import { ChannelOwner } from './channelOwner';
import { BrowserServer } from './browserServer';
import { LoggerSink } from '../../loggerSink';
import { headersObjectToArray } from '../serializers';
import { headersObjectToArray, envObjectToArray } from '../serializers';
export class BrowserType extends ChannelOwner<BrowserTypeChannel, BrowserTypeInitializer> {
@ -45,7 +45,13 @@ export class BrowserType extends ChannelOwner<BrowserTypeChannel, BrowserTypeIni
const logger = options.logger;
options = { ...options, logger: undefined };
return this._wrapApiCall('browserType.launch', async () => {
const browser = Browser.from((await this._channel.launch(options)).browser);
const launchOptions: LaunchOptions = {
...options,
ignoreDefaultArgs: Array.isArray(options.ignoreDefaultArgs) ? options.ignoreDefaultArgs : undefined,
ignoreAllDefaultArgs: !!options.ignoreDefaultArgs && !Array.isArray(options.ignoreDefaultArgs),
env: options.env ? envObjectToArray(options.env) : undefined,
};
const browser = Browser.from((await this._channel.launch(launchOptions)).browser);
browser._logger = logger;
return browser;
}, logger);
@ -55,7 +61,13 @@ export class BrowserType extends ChannelOwner<BrowserTypeChannel, BrowserTypeIni
const logger = options.logger;
options = { ...options, logger: undefined };
return this._wrapApiCall('browserType.launchServer', async () => {
return BrowserServer.from((await this._channel.launchServer(options)).server);
const launchServerOptions: LaunchServerOptions = {
...options,
ignoreDefaultArgs: Array.isArray(options.ignoreDefaultArgs) ? options.ignoreDefaultArgs : undefined,
ignoreAllDefaultArgs: !!options.ignoreDefaultArgs && !Array.isArray(options.ignoreDefaultArgs),
env: options.env ? envObjectToArray(options.env) : undefined,
};
return BrowserServer.from((await this._channel.launchServer(launchServerOptions)).server);
}, logger);
}
@ -65,6 +77,9 @@ export class BrowserType extends ChannelOwner<BrowserTypeChannel, BrowserTypeIni
return this._wrapApiCall('browserType.launchPersistentContext', async () => {
const persistentOptions: LaunchPersistentContextOptions = {
...options,
ignoreDefaultArgs: Array.isArray(options.ignoreDefaultArgs) ? options.ignoreDefaultArgs : undefined,
ignoreAllDefaultArgs: !!options.ignoreDefaultArgs && !Array.isArray(options.ignoreDefaultArgs),
env: options.env ? envObjectToArray(options.env) : undefined,
extraHTTPHeaders: options.extraHTTPHeaders ? headersObjectToArray(options.extraHTTPHeaders) : undefined,
userDataDir,
};

16
src/rpc/serializers.ts
View File

@ -126,3 +126,19 @@ export function headersArrayToObject(headers: types.HeadersArray): types.Headers
result[name] = value;
return result;
}
export function envObjectToArray(env: types.Env): types.EnvArray {
const result: types.EnvArray = [];
for (const name in env) {
if (!Object.is(env[name], undefined))
result.push({ name, value: String(env[name]) });
}
return result;
}
export function envArrayToObject(env: types.EnvArray): types.Env {
const result: types.Env = {};
for (const { name, value } of env)
result[name] = value;
return result;
}

24
src/rpc/server/browserTypeDispatcher.ts
View File

@ -18,12 +18,12 @@ import { BrowserBase } from '../../browser';
import { BrowserTypeBase, BrowserType } from '../../server/browserType';
import * as types from '../../types';
import { BrowserDispatcher } from './browserDispatcher';
import { BrowserChannel, BrowserTypeChannel, BrowserContextChannel, BrowserTypeInitializer, BrowserServerChannel, LaunchPersistentContextOptions } from '../channels';
import { BrowserChannel, BrowserTypeChannel, BrowserContextChannel, BrowserTypeInitializer, BrowserServerChannel, LaunchPersistentContextOptions, LaunchOptions, LaunchServerOptions } from '../channels';
import { Dispatcher, DispatcherScope } from './dispatcher';
import { BrowserContextBase } from '../../browserContext';
import { BrowserContextDispatcher } from './browserContextDispatcher';
import { BrowserServerDispatcher } from './browserServerDispatcher';
import { headersArrayToObject } from '../serializers';
import { headersArrayToObject, envArrayToObject } from '../serializers';
export class BrowserTypeDispatcher extends Dispatcher<BrowserType, BrowserTypeInitializer> implements BrowserTypeChannel {
constructor(scope: DispatcherScope, browserType: BrowserTypeBase) {
@ -33,22 +33,34 @@ export class BrowserTypeDispatcher extends Dispatcher<BrowserType, BrowserTypeIn
}, true, browserType.name());
}
async launch(params: types.LaunchOptions): Promise<{ browser: BrowserChannel }> {
const browser = await this._object.launch(params);
async launch(params: LaunchOptions): Promise<{ browser: BrowserChannel }> {
const options = {
...params,
ignoreDefaultArgs: params.ignoreAllDefaultArgs ? true : params.ignoreDefaultArgs,
env: params.env ? envArrayToObject(params.env) : undefined,
};
const browser = await this._object.launch(options);
return { browser: new BrowserDispatcher(this._scope, browser as BrowserBase) };
}
async launchPersistentContext(params: LaunchPersistentContextOptions): Promise<{ context: BrowserContextChannel }> {
const options = {
...params,
ignoreDefaultArgs: params.ignoreAllDefaultArgs ? true : params.ignoreDefaultArgs,
env: params.env ? envArrayToObject(params.env) : undefined,
extraHTTPHeaders: params.extraHTTPHeaders ? headersArrayToObject(params.extraHTTPHeaders) : undefined,
};
const browserContext = await this._object.launchPersistentContext(params.userDataDir, options);
return { context: new BrowserContextDispatcher(this._scope, browserContext as BrowserContextBase) };
}
async launchServer(params: types.LaunchServerOptions): Promise<{ server: BrowserServerChannel }> {
return { server: new BrowserServerDispatcher(this._scope, await this._object.launchServer(params)) };
async launchServer(params: LaunchServerOptions): Promise<{ server: BrowserServerChannel }> {
const options = {
...params,
ignoreDefaultArgs: params.ignoreAllDefaultArgs ? true : params.ignoreDefaultArgs,
env: params.env ? envArrayToObject(params.env) : undefined,
};
return { server: new BrowserServerDispatcher(this._scope, await this._object.launchServer(options)) };
}
async connect(params: types.ConnectOptions): Promise<{ browser: BrowserChannel }> {

1
src/types.ts
View File

@ -280,6 +280,7 @@ export type BrowserContextOptions = {
};
export type Env = {[key: string]: string | number | boolean | undefined};
export type EnvArray = { name: string, value: string }[];
export type LaunchOptionsBase = {
executablePath?: string,