forked from annv/MinigameTest
946 lines
30 KiB
JavaScript
946 lines
30 KiB
JavaScript
// Licensed to the Software Freedom Conservancy (SFC) under one
|
|
// or more contributor license agreements. See the NOTICE file
|
|
// distributed with this work for additional information
|
|
// regarding copyright ownership. The SFC licenses this file
|
|
// to you 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.
|
|
|
|
/**
|
|
* @fileoverview Defines an abstract {@linkplain Driver WebDriver} client for
|
|
* Chromium-based web browsers. These classes should not be instantiated
|
|
* directly.
|
|
*
|
|
* There are three primary classes exported by this module:
|
|
*
|
|
* 1. {@linkplain ServiceBuilder}: configures the
|
|
* {@link selenium-webdriver/remote.DriverService remote.DriverService}
|
|
* that manages a WebDriver server child process.
|
|
*
|
|
* 2. {@linkplain Options}: defines configuration options for each new Chromium
|
|
* session, such as which {@linkplain Options#setProxy proxy} to use,
|
|
* what {@linkplain Options#addExtensions extensions} to install, or
|
|
* what {@linkplain Options#addArguments command-line switches} to use when
|
|
* starting the browser.
|
|
*
|
|
* 3. {@linkplain Driver}: the WebDriver client; each new instance will control
|
|
* a unique browser session with a clean user profile (unless otherwise
|
|
* configured through the {@link Options} class).
|
|
*
|
|
* __Headless Chromium__ <a id="headless"></a>
|
|
*
|
|
* To start the browser in headless mode, simply call
|
|
* {@linkplain Options#headless Options.headless()}.
|
|
*
|
|
* let chrome = require('selenium-webdriver/chrome');
|
|
* let {Builder} = require('selenium-webdriver');
|
|
*
|
|
* let driver = new Builder()
|
|
* .forBrowser('chrome')
|
|
* .setChromeOptions(new chrome.Options().headless())
|
|
* .build();
|
|
*
|
|
* __Customizing the Chromium WebDriver Server__ <a id="custom-server"></a>
|
|
*
|
|
* Subclasses of {@link Driver} are expected to provide a static
|
|
* getDefaultService method. By default, this method will be called every time
|
|
* a {@link Driver} instance is created to obtain the default driver service
|
|
* for that specific browser (e.g. Chrome or Chromium Edge). Subclasses are
|
|
* responsible for managing the lifetime of the default service.
|
|
*
|
|
* You may also create a {@link Driver} with its own driver service. This is
|
|
* useful if you need to capture the server's log output for a specific session:
|
|
*
|
|
* let chrome = require('selenium-webdriver/chrome');
|
|
*
|
|
* let service = new chrome.ServiceBuilder()
|
|
* .loggingTo('/my/log/file.txt')
|
|
* .enableVerboseLogging()
|
|
* .build();
|
|
*
|
|
* let options = new chrome.Options();
|
|
* // configure browser options ...
|
|
*
|
|
* let driver = chrome.Driver.createSession(options, service);
|
|
*/
|
|
|
|
'use strict'
|
|
|
|
const http = require('./http')
|
|
const io = require('./io')
|
|
const { Capabilities, Capability } = require('./lib/capabilities')
|
|
const command = require('./lib/command')
|
|
const error = require('./lib/error')
|
|
const Symbols = require('./lib/symbols')
|
|
const webdriver = require('./lib/webdriver')
|
|
const remote = require('./remote')
|
|
|
|
/**
|
|
* Custom command names supported by Chromium WebDriver.
|
|
* @enum {string}
|
|
*/
|
|
const Command = {
|
|
LAUNCH_APP: 'launchApp',
|
|
GET_NETWORK_CONDITIONS: 'getNetworkConditions',
|
|
SET_NETWORK_CONDITIONS: 'setNetworkConditions',
|
|
DELETE_NETWORK_CONDITIONS: 'deleteNetworkConditions',
|
|
SEND_DEVTOOLS_COMMAND: 'sendDevToolsCommand',
|
|
SEND_AND_GET_DEVTOOLS_COMMAND: 'sendAndGetDevToolsCommand',
|
|
SET_PERMISSION: 'setPermission',
|
|
GET_CAST_SINKS: 'getCastSinks',
|
|
SET_CAST_SINK_TO_USE: 'setCastSinkToUse',
|
|
START_CAST_DESKTOP_MIRRORING: 'startDesktopMirroring',
|
|
START_CAST_TAB_MIRRORING: 'setCastTabMirroring',
|
|
GET_CAST_ISSUE_MESSAGE: 'getCastIssueMessage',
|
|
STOP_CASTING: 'stopCasting',
|
|
}
|
|
|
|
/**
|
|
* Creates a command executor with support for Chromium's custom commands.
|
|
* @param {!Promise<string>} url The server's URL.
|
|
* @param vendorPrefix
|
|
* @return {!command.Executor} The new command executor.
|
|
*/
|
|
function createExecutor(url, vendorPrefix) {
|
|
const agent = new http.Agent({ keepAlive: true })
|
|
const client = url.then((url) => new http.HttpClient(url, agent))
|
|
const executor = new http.Executor(client)
|
|
configureExecutor(executor, vendorPrefix)
|
|
return executor
|
|
}
|
|
|
|
/**
|
|
* Configures the given executor with Chromium-specific commands.
|
|
* @param {!http.Executor} executor the executor to configure.
|
|
*/
|
|
function configureExecutor(executor, vendorPrefix) {
|
|
executor.defineCommand(
|
|
Command.LAUNCH_APP,
|
|
'POST',
|
|
'/session/:sessionId/chromium/launch_app'
|
|
)
|
|
executor.defineCommand(
|
|
Command.GET_NETWORK_CONDITIONS,
|
|
'GET',
|
|
'/session/:sessionId/chromium/network_conditions'
|
|
)
|
|
executor.defineCommand(
|
|
Command.SET_NETWORK_CONDITIONS,
|
|
'POST',
|
|
'/session/:sessionId/chromium/network_conditions'
|
|
)
|
|
executor.defineCommand(
|
|
Command.DELETE_NETWORK_CONDITIONS,
|
|
'DELETE',
|
|
'/session/:sessionId/chromium/network_conditions'
|
|
)
|
|
executor.defineCommand(
|
|
Command.SEND_DEVTOOLS_COMMAND,
|
|
'POST',
|
|
'/session/:sessionId/chromium/send_command'
|
|
)
|
|
executor.defineCommand(
|
|
Command.SEND_AND_GET_DEVTOOLS_COMMAND,
|
|
'POST',
|
|
'/session/:sessionId/chromium/send_command_and_get_result'
|
|
)
|
|
executor.defineCommand(
|
|
Command.SET_PERMISSION,
|
|
'POST',
|
|
'/session/:sessionId/permissions'
|
|
)
|
|
executor.defineCommand(
|
|
Command.GET_CAST_SINKS,
|
|
'GET',
|
|
`/session/:sessionId/${vendorPrefix}/cast/get_sinks`
|
|
)
|
|
executor.defineCommand(
|
|
Command.SET_CAST_SINK_TO_USE,
|
|
'POST',
|
|
`/session/:sessionId/${vendorPrefix}/cast/set_sink_to_use`
|
|
)
|
|
executor.defineCommand(
|
|
Command.START_CAST_DESKTOP_MIRRORING,
|
|
'POST',
|
|
`/session/:sessionId/${vendorPrefix}/cast/start_desktop_mirroring`
|
|
)
|
|
executor.defineCommand(
|
|
Command.START_CAST_TAB_MIRRORING,
|
|
'POST',
|
|
`/session/:sessionId/${vendorPrefix}/cast/start_tab_mirroring`
|
|
)
|
|
executor.defineCommand(
|
|
Command.GET_CAST_ISSUE_MESSAGE,
|
|
'GET',
|
|
`/session/:sessionId/${vendorPrefix}/cast/get_issue_message`
|
|
)
|
|
executor.defineCommand(
|
|
Command.STOP_CASTING,
|
|
'POST',
|
|
`/session/:sessionId/${vendorPrefix}/cast/stop_casting`
|
|
)
|
|
}
|
|
|
|
/**
|
|
* Creates {@link selenium-webdriver/remote.DriverService} instances that manage
|
|
* a WebDriver server in a child process.
|
|
*/
|
|
class ServiceBuilder extends remote.DriverService.Builder {
|
|
/**
|
|
* @param {string=} exe Path to the server executable to use. Subclasses
|
|
* should ensure a valid path to the appropriate exe is provided.
|
|
*/
|
|
constructor(exe) {
|
|
super(exe)
|
|
this.setLoopback(true) // Required
|
|
}
|
|
|
|
/**
|
|
* Sets which port adb is listening to. _The driver will connect to adb
|
|
* if an {@linkplain Options#androidPackage Android session} is requested, but
|
|
* adb **must** be started beforehand._
|
|
*
|
|
* @param {number} port Which port adb is running on.
|
|
* @return {!ServiceBuilder} A self reference.
|
|
*/
|
|
setAdbPort(port) {
|
|
return this.addArguments('--adb-port=' + port)
|
|
}
|
|
|
|
/**
|
|
* Sets the path of the log file the driver should log to. If a log file is
|
|
* not specified, the driver will log to stderr.
|
|
* @param {string} path Path of the log file to use.
|
|
* @return {!ServiceBuilder} A self reference.
|
|
*/
|
|
loggingTo(path) {
|
|
return this.addArguments('--log-path=' + path)
|
|
}
|
|
|
|
/**
|
|
* Enables Chrome logging.
|
|
* @returns {!ServiceBuilder} A self reference.
|
|
*/
|
|
enableChromeLogging() {
|
|
return this.addArguments('--enable-chrome-logs')
|
|
}
|
|
|
|
/**
|
|
* Enables verbose logging.
|
|
* @return {!ServiceBuilder} A self reference.
|
|
*/
|
|
enableVerboseLogging() {
|
|
return this.addArguments('--verbose')
|
|
}
|
|
|
|
/**
|
|
* Sets the number of threads the driver should use to manage HTTP requests.
|
|
* By default, the driver will use 4 threads.
|
|
* @param {number} n The number of threads to use.
|
|
* @return {!ServiceBuilder} A self reference.
|
|
*/
|
|
setNumHttpThreads(n) {
|
|
return this.addArguments('--http-threads=' + n)
|
|
}
|
|
|
|
/**
|
|
* @override
|
|
*/
|
|
setPath(path) {
|
|
super.setPath(path)
|
|
return this.addArguments('--url-base=' + path)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Class for managing WebDriver options specific to a Chromium-based browser.
|
|
*/
|
|
class Options extends Capabilities {
|
|
/**
|
|
* @param {(Capabilities|Map<string, ?>|Object)=} other Another set of
|
|
* capabilities to initialize this instance from.
|
|
*/
|
|
constructor(other = undefined) {
|
|
super(other)
|
|
|
|
/** @private {!Object} */
|
|
this.options_ = this.get(this.CAPABILITY_KEY) || {}
|
|
|
|
this.setBrowserName(this.BROWSER_NAME_VALUE)
|
|
this.set(this.CAPABILITY_KEY, this.options_)
|
|
}
|
|
|
|
/**
|
|
* Add additional command line arguments to use when launching the browser.
|
|
* Each argument may be specified with or without the "--" prefix
|
|
* (e.g. "--foo" and "foo"). Arguments with an associated value should be
|
|
* delimited by an "=": "foo=bar".
|
|
*
|
|
* @param {...(string|!Array<string>)} args The arguments to add.
|
|
* @return {!Options} A self reference.
|
|
*/
|
|
addArguments(...args) {
|
|
let newArgs = (this.options_.args || []).concat(...args)
|
|
if (newArgs.length) {
|
|
this.options_.args = newArgs
|
|
}
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Sets the address of a Chromium remote debugging server to connect to.
|
|
* Address should be of the form "{hostname|IP address}:port"
|
|
* (e.g. "localhost:9222").
|
|
*
|
|
* @param {string} address The address to connect to.
|
|
* @return {!Options} A self reference.
|
|
*/
|
|
debuggerAddress(address) {
|
|
this.options_.debuggerAddress = address
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* @deprecated Use {@link Options#addArguments} instead.
|
|
* @example
|
|
* options.addArguments('--headless=chrome'); (or)
|
|
* options.addArguments('--headless');
|
|
* @example
|
|
*
|
|
* Recommended to use '--headless=chrome' as argument for browsers v94-108.
|
|
* Recommended to use '--headless=new' as argument for browsers v109+.
|
|
*
|
|
* Configures the driver to start the browser in headless mode.
|
|
*
|
|
* > __NOTE:__ Resizing the browser window in headless mode is only supported
|
|
* > in Chromium 60+. Users are encouraged to set an initial window size with
|
|
* > the {@link #windowSize windowSize({width, height})} option.
|
|
*
|
|
* > __NOTE__: For security, Chromium disables downloads by default when
|
|
* > in headless mode (to prevent sites from silently downloading files to
|
|
* > your machine). After creating a session, you may call
|
|
* > {@link ./chrome.Driver#setDownloadPath setDownloadPath} to re-enable
|
|
* > downloads, saving files in the specified directory.
|
|
*
|
|
* @return {!Options} A self reference.
|
|
*/
|
|
headless() {
|
|
return this.addArguments('headless')
|
|
}
|
|
|
|
/**
|
|
* Sets the initial window size.
|
|
*
|
|
* @param {{width: number, height: number}} size The desired window size.
|
|
* @return {!Options} A self reference.
|
|
* @throws {TypeError} if width or height is unspecified, not a number, or
|
|
* less than or equal to 0.
|
|
*/
|
|
windowSize({ width, height }) {
|
|
function checkArg(arg) {
|
|
if (typeof arg !== 'number' || arg <= 0) {
|
|
throw TypeError('Arguments must be {width, height} with numbers > 0')
|
|
}
|
|
}
|
|
checkArg(width)
|
|
checkArg(height)
|
|
return this.addArguments(`window-size=${width},${height}`)
|
|
}
|
|
|
|
/**
|
|
* List of Chrome command line switches to exclude that ChromeDriver by default
|
|
* passes when starting Chrome. Do not prefix switches with "--".
|
|
*
|
|
* @param {...(string|!Array<string>)} args The switches to exclude.
|
|
* @return {!Options} A self reference.
|
|
*/
|
|
excludeSwitches(...args) {
|
|
let switches = (this.options_.excludeSwitches || []).concat(...args)
|
|
if (switches.length) {
|
|
this.options_.excludeSwitches = switches
|
|
}
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Add additional extensions to install when launching the browser. Each extension
|
|
* should be specified as the path to the packed CRX file, or a Buffer for an
|
|
* extension.
|
|
* @param {...(string|!Buffer|!Array<(string|!Buffer)>)} args The
|
|
* extensions to add.
|
|
* @return {!Options} A self reference.
|
|
*/
|
|
addExtensions(...args) {
|
|
let extensions = this.options_.extensions || new Extensions()
|
|
extensions.add(...args)
|
|
if (extensions.length) {
|
|
this.options_.extensions = extensions
|
|
}
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Sets the path to the browser binary to use. On Mac OS X, this path should
|
|
* reference the actual Chromium executable, not just the application binary
|
|
* (e.g. "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome").
|
|
*
|
|
* The binary path can be absolute or relative to the WebDriver server
|
|
* executable, but it must exist on the machine that will launch the browser.
|
|
*
|
|
* @param {string} path The path to the browser binary to use.
|
|
* @return {!Options} A self reference.
|
|
*/
|
|
setBinaryPath(path) {
|
|
this.options_.binary = path
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Sets whether to leave the started browser process running if the controlling
|
|
* driver service is killed before {@link webdriver.WebDriver#quit()} is
|
|
* called.
|
|
* @param {boolean} detach Whether to leave the browser running if the
|
|
* driver service is killed before the session.
|
|
* @return {!Options} A self reference.
|
|
*/
|
|
detachDriver(detach) {
|
|
this.options_.detach = detach
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Sets the user preferences for Chrome's user profile. See the "Preferences"
|
|
* file in Chrome's user data directory for examples.
|
|
* @param {!Object} prefs Dictionary of user preferences to use.
|
|
* @return {!Options} A self reference.
|
|
*/
|
|
setUserPreferences(prefs) {
|
|
this.options_.prefs = prefs
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Sets the performance logging preferences. Options include:
|
|
*
|
|
* - `enableNetwork`: Whether or not to collect events from Network domain.
|
|
* - `enablePage`: Whether or not to collect events from Page domain.
|
|
* - `enableTimeline`: Whether or not to collect events from Timeline domain.
|
|
* Note: when tracing is enabled, Timeline domain is implicitly disabled,
|
|
* unless `enableTimeline` is explicitly set to true.
|
|
* - `traceCategories`: A comma-separated string of Chromium tracing
|
|
* categories for which trace events should be collected. An unspecified
|
|
* or empty string disables tracing.
|
|
* - `bufferUsageReportingInterval`: The requested number of milliseconds
|
|
* between DevTools trace buffer usage events. For example, if 1000, then
|
|
* once per second, DevTools will report how full the trace buffer is. If
|
|
* a report indicates the buffer usage is 100%, a warning will be issued.
|
|
*
|
|
* @param {{enableNetwork: boolean,
|
|
* enablePage: boolean,
|
|
* enableTimeline: boolean,
|
|
* traceCategories: string,
|
|
* bufferUsageReportingInterval: number}} prefs The performance
|
|
* logging preferences.
|
|
* @return {!Options} A self reference.
|
|
*/
|
|
setPerfLoggingPrefs(prefs) {
|
|
this.options_.perfLoggingPrefs = prefs
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Sets preferences for the "Local State" file in Chrome's user data
|
|
* directory.
|
|
* @param {!Object} state Dictionary of local state preferences.
|
|
* @return {!Options} A self reference.
|
|
*/
|
|
setLocalState(state) {
|
|
this.options_.localState = state
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Sets the name of the activity hosting a Chrome-based Android WebView. This
|
|
* option must be set to connect to an [Android WebView](
|
|
* https://chromedriver.chromium.org/getting-started/getting-started---android)
|
|
*
|
|
* @param {string} name The activity name.
|
|
* @return {!Options} A self reference.
|
|
*/
|
|
androidActivity(name) {
|
|
this.options_.androidActivity = name
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Sets the device serial number to connect to via ADB. If not specified, the
|
|
* WebDriver server will select an unused device at random. An error will be
|
|
* returned if all devices already have active sessions.
|
|
*
|
|
* @param {string} serial The device serial number to connect to.
|
|
* @return {!Options} A self reference.
|
|
*/
|
|
androidDeviceSerial(serial) {
|
|
this.options_.androidDeviceSerial = serial
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Sets the package name of the Chrome or WebView app.
|
|
*
|
|
* @param {?string} pkg The package to connect to, or `null` to disable Android
|
|
* and switch back to using desktop browser.
|
|
* @return {!Options} A self reference.
|
|
*/
|
|
androidPackage(pkg) {
|
|
this.options_.androidPackage = pkg
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Sets the process name of the Activity hosting the WebView (as given by
|
|
* `ps`). If not specified, the process name is assumed to be the same as
|
|
* {@link #androidPackage}.
|
|
*
|
|
* @param {string} processName The main activity name.
|
|
* @return {!Options} A self reference.
|
|
*/
|
|
androidProcess(processName) {
|
|
this.options_.androidProcess = processName
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Sets whether to connect to an already-running instead of the specified
|
|
* {@linkplain #androidProcess app} instead of launching the app with a clean
|
|
* data directory.
|
|
*
|
|
* @param {boolean} useRunning Whether to connect to a running instance.
|
|
* @return {!Options} A self reference.
|
|
*/
|
|
androidUseRunningApp(useRunning) {
|
|
this.options_.androidUseRunningApp = useRunning
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Sets the path to the browser's log file. This path should exist on the machine
|
|
* that will launch the browser.
|
|
* @param {string} path Path to the log file to use.
|
|
* @return {!Options} A self reference.
|
|
*/
|
|
setBrowserLogFile(path) {
|
|
this.options_.logPath = path
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Sets the directory to store browser minidumps in. This option is only
|
|
* supported when the driver is running on Linux.
|
|
* @param {string} path The directory path.
|
|
* @return {!Options} A self reference.
|
|
*/
|
|
setBrowserMinidumpPath(path) {
|
|
this.options_.minidumpPath = path
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Configures the browser to emulate a mobile device. For more information, refer
|
|
* to the ChromeDriver project page on [mobile emulation][em]. Configuration
|
|
* options include:
|
|
*
|
|
* - `deviceName`: The name of a pre-configured [emulated device][devem]
|
|
* - `width`: screen width, in pixels
|
|
* - `height`: screen height, in pixels
|
|
* - `pixelRatio`: screen pixel ratio
|
|
*
|
|
* __Example 1: Using a Pre-configured Device__
|
|
*
|
|
* let options = new chrome.Options().setMobileEmulation(
|
|
* {deviceName: 'Google Nexus 5'});
|
|
*
|
|
* let driver = chrome.Driver.createSession(options);
|
|
*
|
|
* __Example 2: Using Custom Screen Configuration__
|
|
*
|
|
* let options = new chrome.Options().setMobileEmulation({deviceMetrics: {
|
|
* width: 360,
|
|
* height: 640,
|
|
* pixelRatio: 3.0
|
|
* }});
|
|
*
|
|
* let driver = chrome.Driver.createSession(options);
|
|
*
|
|
*
|
|
* [em]: https://chromedriver.chromium.org/mobile-emulation
|
|
* [devem]: https://developer.chrome.com/devtools/docs/device-mode
|
|
*
|
|
* @param {?({deviceName: string}|
|
|
* {width: number, height: number, pixelRatio: number})} config The
|
|
* mobile emulation configuration, or `null` to disable emulation.
|
|
* @return {!Options} A self reference.
|
|
*/
|
|
setMobileEmulation(config) {
|
|
this.options_.mobileEmulation = config
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Sets a list of the window types that will appear when getting window
|
|
* handles. For access to <webview> elements, include "webview" in the list.
|
|
* @param {...(string|!Array<string>)} args The window types that will appear
|
|
* when getting window handles.
|
|
* @return {!Options} A self reference.
|
|
*/
|
|
windowTypes(...args) {
|
|
let windowTypes = (this.options_.windowTypes || []).concat(...args)
|
|
if (windowTypes.length) {
|
|
this.options_.windowTypes = windowTypes
|
|
}
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Enable bidi connection
|
|
* @returns {!Capabilities}
|
|
*/
|
|
enableBidi() {
|
|
return this.set('webSocketUrl', true)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A list of extensions to install when launching the browser.
|
|
*/
|
|
class Extensions {
|
|
constructor() {
|
|
this.extensions = []
|
|
}
|
|
|
|
/**
|
|
* @return {number} The length of the extensions list.
|
|
*/
|
|
get length() {
|
|
return this.extensions.length
|
|
}
|
|
|
|
/**
|
|
* Add additional extensions to install when launching the browser. Each
|
|
* extension should be specified as the path to the packed CRX file, or a
|
|
* Buffer for an extension.
|
|
*
|
|
* @param {...(string|!Buffer|!Array<(string|!Buffer)>)} args The
|
|
* extensions to add.
|
|
*/
|
|
add(...args) {
|
|
this.extensions = this.extensions.concat(...args)
|
|
}
|
|
|
|
/**
|
|
* @return {!Object} A serialized representation of this Extensions object.
|
|
*/
|
|
[Symbols.serialize]() {
|
|
return this.extensions.map(function (extension) {
|
|
if (Buffer.isBuffer(extension)) {
|
|
return extension.toString('base64')
|
|
}
|
|
return io
|
|
.read(/** @type {string} */ (extension))
|
|
.then((buffer) => buffer.toString('base64'))
|
|
})
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates a new WebDriver client for Chromium-based browsers.
|
|
*/
|
|
class Driver extends webdriver.WebDriver {
|
|
/**
|
|
* Creates a new session with the WebDriver server.
|
|
*
|
|
* @param {(Capabilities|Options)=} opt_config The configuration options.
|
|
* @param {(remote.DriverService|http.Executor)=} opt_serviceExecutor Either
|
|
* a DriverService to use for the remote end, or a preconfigured executor
|
|
* for an externally managed endpoint. If neither is provided, the
|
|
* {@linkplain ##getDefaultService default service} will be used by
|
|
* default.
|
|
* @return {!Driver} A new driver instance.
|
|
*/
|
|
static createSession(caps, opt_serviceExecutor) {
|
|
let executor
|
|
let onQuit
|
|
if (opt_serviceExecutor instanceof http.Executor) {
|
|
executor = opt_serviceExecutor
|
|
configureExecutor(executor, this.VENDOR_COMMAND_PREFIX)
|
|
} else {
|
|
let service = opt_serviceExecutor || this.getDefaultService()
|
|
onQuit = () => service.kill()
|
|
executor = createExecutor(service.start(), this.VENDOR_COMMAND_PREFIX)
|
|
}
|
|
|
|
// W3C spec requires noProxy value to be an array of strings, but Chromium
|
|
// expects a single host as a string.
|
|
let proxy = caps.get(Capability.PROXY)
|
|
if (proxy && Array.isArray(proxy.noProxy)) {
|
|
proxy.noProxy = proxy.noProxy[0]
|
|
if (!proxy.noProxy) {
|
|
proxy.noProxy = undefined
|
|
}
|
|
}
|
|
|
|
return /** @type {!Driver} */ (super.createSession(executor, caps, onQuit))
|
|
}
|
|
|
|
/**
|
|
* This function is a no-op as file detectors are not supported by this
|
|
* implementation.
|
|
* @override
|
|
*/
|
|
setFileDetector() {}
|
|
|
|
/**
|
|
* Schedules a command to launch Chrome App with given ID.
|
|
* @param {string} id ID of the App to launch.
|
|
* @return {!Promise<void>} A promise that will be resolved
|
|
* when app is launched.
|
|
*/
|
|
launchApp(id) {
|
|
return this.execute(
|
|
new command.Command(Command.LAUNCH_APP).setParameter('id', id)
|
|
)
|
|
}
|
|
|
|
/**
|
|
* Schedules a command to get Chromium network emulation settings.
|
|
* @return {!Promise} A promise that will be resolved when network
|
|
* emulation settings are retrieved.
|
|
*/
|
|
getNetworkConditions() {
|
|
return this.execute(new command.Command(Command.GET_NETWORK_CONDITIONS))
|
|
}
|
|
|
|
/**
|
|
* Schedules a command to delete Chromium network emulation settings.
|
|
* @return {!Promise} A promise that will be resolved when network
|
|
* emulation settings have been deleted.
|
|
*/
|
|
deleteNetworkConditions() {
|
|
return this.execute(new command.Command(Command.DELETE_NETWORK_CONDITIONS))
|
|
}
|
|
|
|
/**
|
|
* Schedules a command to set Chromium network emulation settings.
|
|
*
|
|
* __Sample Usage:__
|
|
*
|
|
* driver.setNetworkConditions({
|
|
* offline: false,
|
|
* latency: 5, // Additional latency (ms).
|
|
* download_throughput: 500 * 1024, // Maximal aggregated download throughput.
|
|
* upload_throughput: 500 * 1024 // Maximal aggregated upload throughput.
|
|
* });
|
|
*
|
|
* @param {Object} spec Defines the network conditions to set
|
|
* @return {!Promise<void>} A promise that will be resolved when network
|
|
* emulation settings are set.
|
|
*/
|
|
setNetworkConditions(spec) {
|
|
if (!spec || typeof spec !== 'object') {
|
|
throw TypeError(
|
|
'setNetworkConditions called with non-network-conditions parameter'
|
|
)
|
|
}
|
|
return this.execute(
|
|
new command.Command(Command.SET_NETWORK_CONDITIONS).setParameter(
|
|
'network_conditions',
|
|
spec
|
|
)
|
|
)
|
|
}
|
|
|
|
/**
|
|
* Sends an arbitrary devtools command to the browser.
|
|
*
|
|
* @param {string} cmd The name of the command to send.
|
|
* @param {Object=} params The command parameters.
|
|
* @return {!Promise<void>} A promise that will be resolved when the command
|
|
* has finished.
|
|
* @see <https://chromedevtools.github.io/devtools-protocol/>
|
|
*/
|
|
sendDevToolsCommand(cmd, params = {}) {
|
|
return this.execute(
|
|
new command.Command(Command.SEND_DEVTOOLS_COMMAND)
|
|
.setParameter('cmd', cmd)
|
|
.setParameter('params', params)
|
|
)
|
|
}
|
|
|
|
/**
|
|
* Sends an arbitrary devtools command to the browser and get the result.
|
|
*
|
|
* @param {string} cmd The name of the command to send.
|
|
* @param {Object=} params The command parameters.
|
|
* @return {!Promise<string>} A promise that will be resolved when the command
|
|
* has finished.
|
|
* @see <https://chromedevtools.github.io/devtools-protocol/>
|
|
*/
|
|
sendAndGetDevToolsCommand(cmd, params = {}) {
|
|
return this.execute(
|
|
new command.Command(Command.SEND_AND_GET_DEVTOOLS_COMMAND)
|
|
.setParameter('cmd', cmd)
|
|
.setParameter('params', params)
|
|
)
|
|
}
|
|
|
|
/**
|
|
* Set a permission state to the given value.
|
|
*
|
|
* @param {string} name A name of the permission to update.
|
|
* @param {('granted'|'denied'|'prompt')} state State to set permission to.
|
|
* @returns {!Promise<Object>} A promise that will be resolved when the
|
|
* command has finished.
|
|
* @see <https://w3c.github.io/permissions/#permission-registry> for valid
|
|
* names
|
|
*/
|
|
setPermission(name, state) {
|
|
return this.execute(
|
|
new command.Command(Command.SET_PERMISSION)
|
|
.setParameter('descriptor', { name })
|
|
.setParameter('state', state)
|
|
)
|
|
}
|
|
|
|
/**
|
|
* Sends a DevTools command to change the browser's download directory.
|
|
*
|
|
* @param {string} path The desired download directory.
|
|
* @return {!Promise<void>} A promise that will be resolved when the command
|
|
* has finished.
|
|
* @see #sendDevToolsCommand
|
|
*/
|
|
async setDownloadPath(path) {
|
|
if (!path || typeof path !== 'string') {
|
|
throw new error.InvalidArgumentError('invalid download path')
|
|
}
|
|
const stat = await io.stat(path)
|
|
if (!stat.isDirectory()) {
|
|
throw new error.InvalidArgumentError('not a directory: ' + path)
|
|
}
|
|
return this.sendDevToolsCommand('Page.setDownloadBehavior', {
|
|
behavior: 'allow',
|
|
downloadPath: path,
|
|
})
|
|
}
|
|
|
|
/**
|
|
* Returns the list of cast sinks (Cast devices) available to the Chrome media router.
|
|
*
|
|
* @return {!promise.Thenable<void>} A promise that will be resolved with an array of Strings
|
|
* containing the friendly device names of available cast sink targets.
|
|
*/
|
|
getCastSinks() {
|
|
return this.schedule(
|
|
new command.Command(Command.GET_CAST_SINKS),
|
|
'Driver.getCastSinks()'
|
|
)
|
|
}
|
|
|
|
/**
|
|
* Selects a cast sink (Cast device) as the recipient of media router intents (connect or play).
|
|
*
|
|
* @param {String} deviceName name of the target device.
|
|
* @return {!promise.Thenable<void>} A promise that will be resolved
|
|
* when the target device has been selected to respond further webdriver commands.
|
|
*/
|
|
setCastSinkToUse(deviceName) {
|
|
return this.schedule(
|
|
new command.Command(Command.SET_CAST_SINK_TO_USE).setParameter(
|
|
'sinkName',
|
|
deviceName
|
|
),
|
|
'Driver.setCastSinkToUse(' + deviceName + ')'
|
|
)
|
|
}
|
|
|
|
/**
|
|
* Initiates desktop mirroring for the current browser tab on the specified device.
|
|
*
|
|
* @param {String} deviceName name of the target device.
|
|
* @return {!promise.Thenable<void>} A promise that will be resolved
|
|
* when the mirror command has been issued to the device.
|
|
*/
|
|
startDesktopMirroring(deviceName) {
|
|
return this.schedule(
|
|
new command.Command(Command.START_CAST_DESKTOP_MIRRORING).setParameter(
|
|
'sinkName',
|
|
deviceName
|
|
),
|
|
'Driver.startDesktopMirroring(' + deviceName + ')'
|
|
)
|
|
}
|
|
|
|
/**
|
|
* Initiates tab mirroring for the current browser tab on the specified device.
|
|
*
|
|
* @param {String} deviceName name of the target device.
|
|
* @return {!promise.Thenable<void>} A promise that will be resolved
|
|
* when the mirror command has been issued to the device.
|
|
*/
|
|
startCastTabMirroring(deviceName) {
|
|
return this.schedule(
|
|
new command.Command(Command.START_CAST_TAB_MIRRORING).setParameter(
|
|
'sinkName',
|
|
deviceName
|
|
),
|
|
'Driver.startCastTabMirroring(' + deviceName + ')'
|
|
)
|
|
}
|
|
|
|
/**
|
|
* Returns an error message when there is any issue in a Cast session.
|
|
* @return {!promise.Thenable<void>} A promise that will be resolved
|
|
* when the mirror command has been issued to the device.
|
|
*/
|
|
getCastIssueMessage() {
|
|
return this.schedule(
|
|
new command.Command(Command.GET_CAST_ISSUE_MESSAGE),
|
|
'Driver.getCastIssueMessage()'
|
|
)
|
|
}
|
|
|
|
/**
|
|
* Stops casting from media router to the specified device, if connected.
|
|
*
|
|
* @param {String} deviceName name of the target device.
|
|
* @return {!promise.Thenable<void>} A promise that will be resolved
|
|
* when the stop command has been issued to the device.
|
|
*/
|
|
stopCasting(deviceName) {
|
|
return this.schedule(
|
|
new command.Command(Command.STOP_CASTING).setParameter(
|
|
'sinkName',
|
|
deviceName
|
|
),
|
|
'Driver.stopCasting(' + deviceName + ')'
|
|
)
|
|
}
|
|
}
|
|
|
|
// PUBLIC API
|
|
|
|
module.exports = {
|
|
Driver,
|
|
Options,
|
|
ServiceBuilder,
|
|
}
|