620 lines
24 KiB
TypeScript
Executable file
620 lines
24 KiB
TypeScript
Executable file
import { WebDriver } from 'selenium-webdriver';
|
|
import { PluginConfig } from './plugins';
|
|
export interface Config {
|
|
[key: string]: any;
|
|
/**
|
|
* The location of the standalone Selenium Server jar file, relative
|
|
* to the location of webdriver-manager. If no other method of starting
|
|
* Selenium Server is found, this will default to
|
|
* node_modules/protractor/node_modules/webdriver-manager/selenium/<jar file>
|
|
*/
|
|
seleniumServerJar?: string;
|
|
/**
|
|
* The timeout milliseconds waiting for a local standalone Selenium Server to start.
|
|
*
|
|
* default: 30000ms
|
|
*/
|
|
seleniumServerStartTimeout?: number;
|
|
/**
|
|
* Can be an object which will be passed to the SeleniumServer class as args.
|
|
* See a full list of options at
|
|
* https://github.com/SeleniumHQ/selenium/blob/master/javascript/node/selenium-webdriver/remote/index.js
|
|
* If you specify `args` or `port` in this object, it will overwrite the
|
|
* values set via the deprecated config values `seleniumPort` and
|
|
* `seleniumArgs`.
|
|
*/
|
|
localSeleniumStandaloneOpts?: {
|
|
/**
|
|
* The port to start the Selenium Server on, or null if the server should
|
|
* find its own unused port.
|
|
*/
|
|
port?: any;
|
|
/**
|
|
* Additional command line options to pass to selenium. For example,
|
|
* if you need to change the browser timeout, use
|
|
* seleniumArgs: ['-browserTimeout=60']
|
|
*/
|
|
args?: any;
|
|
/**
|
|
* Additional command line jvm options to pass to selenium. For example,
|
|
* if you need to change the browser driver, use
|
|
* jvmArgs: ['-Dwebdriver.ie.driver=IEDriverServer_Win32_2.53.1.exe']
|
|
*/
|
|
jvmArgs?: string[];
|
|
};
|
|
/**
|
|
* ChromeDriver location is used to help find the chromedriver binary. This will be passed to the
|
|
* Selenium jar as the system property webdriver.chrome.driver. If the value is not set when
|
|
* launching locally, it will use the default values downloaded from webdriver-manager.
|
|
*
|
|
* example:
|
|
* chromeDriver: './node_modules/webdriver-manager/selenium/chromedriver_2.20'
|
|
*/
|
|
chromeDriver?: string;
|
|
/**
|
|
* geckoDriver location is used to help find the gecko binary. This will be passed to the Selenium
|
|
* jar as the system property webdriver.gecko.driver. If the value is not set when launching
|
|
* locally, it will use the default values downloaded from webdriver-manager.
|
|
*/
|
|
geckoDriver?: string;
|
|
/**
|
|
* The address of a running Selenium Server. If specified, Protractor will
|
|
* connect to an already running instance of Selenium. This usually looks like
|
|
* seleniumAddress: 'http://localhost:4444/wd/hub'
|
|
*/
|
|
seleniumAddress?: string;
|
|
/**
|
|
* The selenium session id allows Protractor to attach to an existing selenium
|
|
* browser session. The selenium session is maintained after the test has
|
|
* completed. Ignored if seleniumAddress is null.
|
|
*/
|
|
seleniumSessionId?: string;
|
|
/**
|
|
* The address of a proxy server to use for communicating to Sauce Labs REST APIs via the
|
|
* saucelabs node module. For example, the Sauce Labs Proxy can be setup with: sauceProxy:
|
|
* 'http://localhost:3128'
|
|
*/
|
|
sauceProxy?: string;
|
|
/**
|
|
* The proxy address that WebDriver (e.g. Selenium commands) traffic will go through
|
|
* which is tied to the browser session.
|
|
*/
|
|
webDriverProxy?: string;
|
|
/**
|
|
* If specified, connect to webdriver through a proxy that manages client-side
|
|
* synchronization. Blocking Proxy is an experimental feature and may change
|
|
* without notice.
|
|
*/
|
|
useBlockingProxy?: boolean;
|
|
/**
|
|
* If specified, Protractor will connect to the Blocking Proxy at the given
|
|
* url instead of starting it's own.
|
|
*/
|
|
blockingProxyUrl?: string;
|
|
/**
|
|
* If the sauceUser and sauceKey are specified, seleniumServerJar will be
|
|
* ignored. The tests will be run remotely using Sauce Labs.
|
|
*/
|
|
sauceUser?: string;
|
|
/**
|
|
* If the sauceUser and sauceKey are specified, seleniumServerJar will be
|
|
* ignored. The tests will be run remotely using Sauce Labs.
|
|
*/
|
|
sauceKey?: string;
|
|
/**
|
|
* If you run your tests on SauceLabs you can specify the region you want to run your tests
|
|
* in via the `sauceRegion` property. Available short handles for regions are:
|
|
* us: us-west-1 (default)
|
|
* eu: eu-central-1
|
|
*/
|
|
sauceRegion?: string;
|
|
/**
|
|
* Use sauceAgent if you need custom HTTP agent to connect to saucelabs.com APIs.
|
|
* This is needed if your computer is behind a corporate proxy.
|
|
*
|
|
* To match sauce agent implementation, use
|
|
* [HttpProxyAgent](https://github.com/TooTallNate/node-http-proxy-agent)
|
|
* to generate the agent or use sauceProxy as an alternative. If a
|
|
* sauceProxy is provided, the sauceAgent will be overridden.
|
|
*/
|
|
sauceAgent?: any;
|
|
/**
|
|
* Use sauceBuild if you want to group test capabilites by a build ID
|
|
*/
|
|
sauceBuild?: string;
|
|
/**
|
|
* If true, Protractor will use http:// protocol instead of https:// to
|
|
* connect to Sauce Labs defined by sauceSeleniumAddress.
|
|
*
|
|
* default: false
|
|
*/
|
|
sauceSeleniumUseHttp?: boolean;
|
|
/**
|
|
* Use sauceSeleniumAddress if you need to customize the URL Protractor
|
|
* uses to connect to sauce labs (for example, if you are tunneling selenium
|
|
* traffic through a sauce connect tunnel). Default is
|
|
* ondemand.saucelabs.com:443/wd/hub
|
|
*/
|
|
sauceSeleniumAddress?: string;
|
|
/**
|
|
* If testobjectUser and testobjectKey are specified, kobitonUser, kobitonKey, browserstackUser,
|
|
* browserStackKey and seleniumServerJar will be ignored. The tests will be run remotely using
|
|
* TestObject.
|
|
*/
|
|
testobjectUser?: string;
|
|
/**
|
|
* If testobjectUser and testobjectKey are specified, kobitonUser, kobitonKey, browserStackUser,
|
|
* browserStackKey and seleniumServerJar will be ignored. The tests will be run remotely using
|
|
* TestObject.
|
|
*/
|
|
testobjectKey?: string;
|
|
/**
|
|
* If kobitonUser and kobitonKey are specified, testobjectUser, testojbectKey, browserstackUser,
|
|
* browserStackKey and seleniumServerJar will be ignored. The tests will be run remotely using
|
|
* TestObject.
|
|
*/
|
|
kobitonUser?: string;
|
|
/**
|
|
* If kobitonUser and kobitonKey are specified, testobjectUser, testojbectKey, browserStackUser,
|
|
* browserStackKey and seleniumServerJar will be ignored. The tests will be run remotely using
|
|
* TestObject.
|
|
*/
|
|
kobitonKey?: string;
|
|
/**
|
|
* If browserstackUser and browserstackKey are specified, seleniumServerJar
|
|
* will be ignored. The tests will be run remotely using BrowserStack.
|
|
*/
|
|
browserstackUser?: string;
|
|
/**
|
|
* If browserstackUser and browserstackKey are specified, seleniumServerJar
|
|
* will be ignored. The tests will be run remotely using BrowserStack.
|
|
*/
|
|
browserstackKey?: string;
|
|
/**
|
|
* Proxy server to be used for connecting to BrowserStack APIs
|
|
* e.g. "http://proxy.example.com:1234".
|
|
* This should be used when you are behind a proxy server.
|
|
*/
|
|
browserstackProxy?: string;
|
|
/**
|
|
* If true, Protractor will connect directly to the browser Drivers
|
|
* at the locations specified by chromeDriver and firefoxPath. Only Chrome
|
|
* and Firefox are supported for direct connect.
|
|
*
|
|
* default: false
|
|
*/
|
|
directConnect?: boolean;
|
|
/**
|
|
* Path to the firefox application binary. If null, will attempt to find
|
|
* firefox in the default locations.
|
|
*/
|
|
firefoxPath?: string;
|
|
seleniumWebDriver?: WebDriver;
|
|
/**
|
|
* Use default globals: 'protractor', 'browser', '$', '$$', 'element', 'by'.
|
|
* These also exist as properties of the protractor namespace:
|
|
* 'protractor.browser', 'protractor.$', 'protractor.$$',
|
|
* 'protractor.element', 'protractor.by', and 'protractor.By'.
|
|
*
|
|
* When no globals is set to true, the only available global variable will be
|
|
* 'protractor'.
|
|
*/
|
|
noGlobals?: boolean;
|
|
/**
|
|
* Required. Spec patterns are relative to the location of this config.
|
|
*
|
|
* Example:
|
|
* specs: [
|
|
* 'spec/*_spec.js'
|
|
* ]
|
|
*/
|
|
specs?: Array<string>;
|
|
/**
|
|
* Patterns to exclude specs.
|
|
*/
|
|
exclude?: Array<string> | string;
|
|
/**
|
|
* Alternatively, suites may be used. When run without a command line
|
|
* parameter, all suites will run. If run with --suite=smoke or
|
|
* --suite=smoke,full only the patterns matched by the specified suites will
|
|
* run.
|
|
*
|
|
* Example:
|
|
* suites: {
|
|
* smoke: 'spec/smoketests/*.js',
|
|
* full: 'spec/*.js'
|
|
* }
|
|
*/
|
|
suites?: any;
|
|
/**
|
|
* If you would like protractor to use a specific suite by default instead of
|
|
* all suites, you can put that in the config file as well.
|
|
*/
|
|
suite?: string;
|
|
/**
|
|
* Protractor can launch your tests on one or more browsers. If you are
|
|
* testing on a single browser, use the capabilities option. If you are
|
|
* testing on multiple browsers, use the multiCapabilities array.
|
|
*
|
|
* For a list of available capabilities, see
|
|
* https://github.com/SeleniumHQ/selenium/wiki/DesiredCapabilities
|
|
* In addition, you may specify count, shardTestFiles, and maxInstances.
|
|
*
|
|
* Example:
|
|
* capabilities: {
|
|
* browserName: 'chrome',
|
|
* name: 'Unnamed Job',
|
|
* logName: 'Chrome - English',
|
|
* count: 1,
|
|
* shardTestFiles: false,
|
|
* maxInstances: 1,
|
|
* specs: ['spec/chromeOnlySpec.js'],
|
|
* exclude: ['spec/doNotRunInChromeSpec.js'],
|
|
* seleniumAddress: 'http://localhost:4444/wd/hub'
|
|
* }
|
|
*/
|
|
capabilities?: {
|
|
[key: string]: any;
|
|
browserName?: string;
|
|
/**
|
|
* Name of the process executing this capability. Not used directly by
|
|
* protractor or the browser, but instead pass directly to third parties
|
|
* like BrowserStack and SauceLabs as the name of the job running this
|
|
* test
|
|
*/
|
|
name?: string;
|
|
/**
|
|
* User defined name for the capability that will display in the results
|
|
* log. Defaults to the browser name
|
|
*/
|
|
logName?: string;
|
|
/**
|
|
* Number of times to run this set of capabilities (in parallel, unless
|
|
* limited by maxSessions). Default is 1.
|
|
*/
|
|
count?: number;
|
|
/**
|
|
* If this is set to be true, specs will be sharded by file (i.e. all
|
|
* files to be run by this set of capabilities will run in parallel).
|
|
* Default is false.
|
|
*/
|
|
shardTestFiles?: boolean;
|
|
/**
|
|
* Maximum number of browser instances that can run in parallel for this
|
|
* set of capabilities. This is only needed if shardTestFiles is true.
|
|
* Default is 1.
|
|
*/
|
|
maxInstances?: number;
|
|
/**
|
|
* Additional spec files to be run on this capability only.
|
|
*/
|
|
specs?: string[];
|
|
/**
|
|
* Spec files to be excluded on this capability only.
|
|
*/
|
|
exclude?: string[];
|
|
/**
|
|
* Optional: override global seleniumAddress on this capability only.
|
|
*/
|
|
seleniumAddress?: string;
|
|
};
|
|
/**
|
|
* If you would like to run more than one instance of WebDriver on the same
|
|
* tests, use multiCapabilities, which takes an array of capabilities.
|
|
* If this is specified, capabilities will be ignored.
|
|
*/
|
|
multiCapabilities?: Array<any>;
|
|
/**
|
|
* If you need to resolve multiCapabilities asynchronously (i.e. wait for
|
|
* server/proxy, set firefox profile, etc), you can specify a function here
|
|
* which will return either `multiCapabilities` or a promise to
|
|
* `multiCapabilities`.
|
|
*
|
|
* If this returns a promise, it is resolved immediately after
|
|
* `beforeLaunch` is run, and before any driver is set up. If this is
|
|
* specified, both capabilities and multiCapabilities will be ignored.
|
|
*/
|
|
getMultiCapabilities?: any;
|
|
/**
|
|
* Maximum number of total browser sessions to run. Tests are queued in
|
|
* sequence if number of browser sessions is limited by this parameter.
|
|
* Use a number less than 1 to denote unlimited. Default is unlimited.
|
|
*/
|
|
maxSessions?: number;
|
|
/**
|
|
* Whether or not to buffer output when running tests on multiple browsers
|
|
* in parallel. By default, when running multiple browser sessions, the
|
|
* results are buffered and not logged until the test run finishes. If true,
|
|
* when running multiple sessions in parallel results will be logged when
|
|
* each test finishes.
|
|
*/
|
|
verboseMultiSessions?: boolean;
|
|
/**
|
|
* A base URL for your application under test. Calls to protractor.get()
|
|
* with relative paths will be resolved against this URL (via url.resolve)
|
|
*/
|
|
baseUrl?: string;
|
|
/**
|
|
* A CSS Selector for a DOM element within your Angular application.
|
|
* Protractor will attempt to automatically find your application, but it is
|
|
* necessary to set rootElement in certain cases.
|
|
*
|
|
* In Angular 1, Protractor will use the element your app bootstrapped to by
|
|
* default. If that doesn't work, it will then search for hooks in `body` or
|
|
* `ng-app` elements (details here: https://git.io/v1b2r).
|
|
*
|
|
* In later versions of Angular, Protractor will try to hook into all angular
|
|
* apps on the page. Use rootElement to limit the scope of which apps
|
|
* Protractor waits for and searches within.
|
|
*/
|
|
rootElement?: string;
|
|
/**
|
|
* The timeout in milliseconds for each script run on the browser. This
|
|
* should be longer than the maximum time your application needs to
|
|
* stabilize between tasks.
|
|
*/
|
|
allScriptsTimeout?: number;
|
|
/**
|
|
* How long to wait for a page to load.
|
|
*/
|
|
getPageTimeout?: number;
|
|
/**
|
|
* A callback function called once configs are read but before any
|
|
* environment setup. This will only run once, and before onPrepare.
|
|
*
|
|
* You can specify a file containing code to run by setting beforeLaunch to
|
|
* the filename string.
|
|
*
|
|
* At this point, global variable 'protractor' object will NOT be set up,
|
|
* and globals from the test framework will NOT be available. The main
|
|
* purpose of this function should be to bring up test dependencies.
|
|
*/
|
|
beforeLaunch?: () => void;
|
|
/**
|
|
* A callback function called once protractor is ready and available, and
|
|
* before the specs are executed. If multiple capabilities are being run,
|
|
* this will run once per capability.
|
|
*
|
|
* You can specify a file containing code to run by setting onPrepare to
|
|
* the filename string. onPrepare can optionally return a promise, which
|
|
* Protractor will wait for before continuing execution. This can be used if
|
|
* the preparation involves any asynchronous calls, e.g. interacting with
|
|
* the browser. Otherwise Protractor cannot guarantee order of execution
|
|
* and may start the tests before preparation finishes.
|
|
*
|
|
* At this point, global variable 'protractor' object will be set up, and
|
|
* globals from the test framework will be available. For example, if you
|
|
* are using Jasmine, you can add a reporter with:
|
|
*
|
|
* jasmine.getEnv().addReporter(new jasmine.JUnitXmlReporter(
|
|
* 'outputdir/', true, true));
|
|
*
|
|
* If you need access back to the current configuration object,
|
|
* use a pattern like the following:
|
|
*
|
|
* return browser.getProcessedConfig().then(function(config) {
|
|
* // config.capabilities is the CURRENT capability being run, if
|
|
* // you are using multiCapabilities.
|
|
* console.log('Executing capability', config.capabilities);
|
|
* });
|
|
*/
|
|
onPrepare?: () => void;
|
|
/**
|
|
* A callback function called once tests are finished. onComplete can
|
|
* optionally return a promise, which Protractor will wait for before
|
|
* shutting down webdriver.
|
|
*
|
|
* At this point, tests will be done but global objects will still be
|
|
* available.
|
|
*/
|
|
onComplete?: () => void;
|
|
/**
|
|
* A callback function called once the tests have finished running and
|
|
* the WebDriver instance has been shut down. It is passed the exit code
|
|
* (0 if the tests passed). This is called once per capability.
|
|
*/
|
|
onCleanUp?: (exitCode: number) => void;
|
|
/**
|
|
* A callback function called once all tests have finished running and
|
|
* the WebDriver instance has been shut down. It is passed the exit code
|
|
* (0 if the tests passed). afterLaunch must return a promise if you want
|
|
* asynchronous code to be executed before the program exits.
|
|
* This is called only once before the program exits (after onCleanUp).
|
|
*/
|
|
afterLaunch?: (exitCode: number) => void;
|
|
/**
|
|
* The params object will be passed directly to the Protractor instance,
|
|
* and can be accessed from your test as browser.params. It is an arbitrary
|
|
* object and can contain anything you may need in your test.
|
|
* This can be changed via the command line as:
|
|
* --params.login.user "Joe"
|
|
*
|
|
* Example:
|
|
* params: {
|
|
* login: {
|
|
* user: 'Jane',
|
|
* password: '1234'
|
|
* }
|
|
* }
|
|
*/
|
|
params?: any;
|
|
/**
|
|
* If set, protractor will save the test output in json format at this path.
|
|
* The path is relative to the location of this config.
|
|
*/
|
|
resultJsonOutputFile?: any;
|
|
/**
|
|
* If true, protractor will restart the browser between each test. Default
|
|
* value is false.
|
|
*
|
|
* CAUTION: This will cause your tests to slow down drastically.
|
|
*/
|
|
restartBrowserBetweenTests?: boolean;
|
|
/**
|
|
* Protractor will track outstanding $timeouts by default, and report them
|
|
* in the error message if Protractor fails to synchronize with Angular in
|
|
* time. In order to do this Protractor needs to decorate $timeout.
|
|
*
|
|
* CAUTION: If your app decorates $timeout, you must turn on this flag. This
|
|
* is false by default.
|
|
*/
|
|
untrackOutstandingTimeouts?: boolean;
|
|
/**
|
|
* If set, Protractor will ignore uncaught exceptions instead of exiting
|
|
* without an error code. The exceptions will still be logged as warnings.
|
|
*/
|
|
ignoreUncaughtExceptions?: boolean;
|
|
/**
|
|
* If set, will create a log file in the given directory with a readable log of
|
|
* the webdriver commands it executes.
|
|
*
|
|
* This is an experimental feature. Enabling this will also turn on Blocking Proxy
|
|
* synchronization, which is also experimental.
|
|
*/
|
|
webDriverLogDir?: string;
|
|
/**
|
|
* If set, Protractor will pause the specified amount of time (in milliseconds)
|
|
* before interactions with browser elements (ie, sending keys, clicking). It will
|
|
* also highlight the element it's about to interact with.
|
|
*
|
|
* This is an experimental feature. Enabling this will also turn on Blocking Proxy
|
|
* synchronization, which is also experimental.
|
|
*/
|
|
highlightDelay?: number;
|
|
/**
|
|
* Protractor log level
|
|
*
|
|
* default: INFO
|
|
*/
|
|
logLevel?: 'ERROR' | 'WARN' | 'INFO' | 'DEBUG';
|
|
/**
|
|
* Test framework to use. This may be one of: jasmine, mocha or custom.
|
|
* Default value is 'jasmine'
|
|
*
|
|
* When the framework is set to "custom" you'll need to additionally
|
|
* set frameworkPath with the path relative to the config file or absolute:
|
|
*
|
|
* framework: 'custom',
|
|
* frameworkPath: './frameworks/my_custom_jasmine.js',
|
|
*
|
|
* See github.com/angular/protractor/blob/master/lib/frameworks/README.md
|
|
* to comply with the interface details of your custom implementation.
|
|
*
|
|
* Jasmine is fully supported as test and assertion frameworks.
|
|
* Mocha has limited support. You will need to include your
|
|
* own assertion framework (such as Chai) if working with Mocha.
|
|
*/
|
|
framework?: string;
|
|
/**
|
|
* Options to be passed to jasmine.
|
|
*
|
|
* See https://github.com/jasmine/jasmine-npm/blob/master/lib/jasmine.js
|
|
* for the exact options available.
|
|
*/
|
|
jasmineNodeOpts?: {
|
|
[key: string]: any;
|
|
/**
|
|
* If true, print colors to the terminal.
|
|
*/
|
|
showColors?: boolean;
|
|
/**
|
|
* Default time to wait in ms before a test fails.
|
|
*/
|
|
defaultTimeoutInterval?: number;
|
|
/**
|
|
* Function called to print jasmine results.
|
|
*/
|
|
print?: () => void;
|
|
/**
|
|
* If set, only execute specs whose names match the pattern, which is
|
|
* internally compiled to a RegExp.
|
|
*/
|
|
grep?: string;
|
|
/**
|
|
* Inverts 'grep' matches
|
|
*/
|
|
invertGrep?: boolean;
|
|
/**
|
|
* If true, run specs in semi-random order
|
|
*/
|
|
random?: boolean;
|
|
/**
|
|
* Set the randomization seed if randomization is turned on
|
|
*/
|
|
seed?: string;
|
|
};
|
|
/**
|
|
* Options to be passed to Mocha.
|
|
*
|
|
* See the full list at http://mochajs.org/
|
|
*/
|
|
mochaOpts?: {
|
|
[key: string]: any;
|
|
ui?: string;
|
|
reporter?: string;
|
|
};
|
|
/**
|
|
* See docs/plugins.md
|
|
*/
|
|
plugins?: PluginConfig[];
|
|
/**
|
|
* Turns off source map support. Stops protractor from registering global
|
|
* variable `source-map-support`. Defaults to `false`
|
|
*/
|
|
skipSourceMapSupport?: boolean;
|
|
/**
|
|
* Turns off WebDriver's environment variables overrides to ignore any
|
|
* environment variable and to only use the configuration in this file.
|
|
* Defaults to `false`
|
|
*/
|
|
disableEnvironmentOverrides?: boolean;
|
|
/**
|
|
* Tells Protractor to interpret any angular apps it comes across as hybrid
|
|
* angular1/angular2 apps (i.e. apps using ngUpgrade)
|
|
* Defaults to `false`
|
|
*
|
|
* @type {boolean}
|
|
*/
|
|
ng12Hybrid?: boolean;
|
|
/**
|
|
* Protractor will exit with an error if it sees any command line flags it doesn't
|
|
* recognize. Set disableChecks true to disable this check.
|
|
*/
|
|
disableChecks?: boolean;
|
|
/**
|
|
* Enable/disable the WebDriver Control Flow.
|
|
*
|
|
* WebDriverJS (and by extention, Protractor) uses a Control Flow to manage the order in which
|
|
* commands are executed and promises are resolved (see docs/control-flow.md for details).
|
|
* However, as syntax like `async`/`await` are being introduced, WebDriverJS has decided to
|
|
* deprecate the control flow, and have users manage the asynchronous activity themselves
|
|
* (details here: https://github.com/SeleniumHQ/selenium/issues/2969).
|
|
*
|
|
* At the moment, the WebDriver Control Flow is still enabled by default. You can disable it by
|
|
* setting the environment variable `SELENIUM_PROMISE_MANAGER` to `0`. In a webdriver release in
|
|
* Q4 2017, the Control Flow will be disabled by default, but you will be able to re-enable it by
|
|
* setting `SELENIUM_PROMISE_MANAGER` to `1`. At a later point, the control flow will be removed
|
|
* for good.
|
|
*
|
|
* If you don't like managing environment variables, you can set this option in your config file,
|
|
* and Protractor will handle enabling/disabling the control flow for you. Setting this option
|
|
* is higher priority than the `SELENIUM_PROMISE_MANAGER` environment variable.
|
|
*
|
|
* @type {boolean=}
|
|
*/
|
|
SELENIUM_PROMISE_MANAGER?: boolean;
|
|
seleniumArgs?: any[];
|
|
jvmArgs?: string[];
|
|
configDir?: string;
|
|
troubleshoot?: boolean;
|
|
seleniumPort?: number;
|
|
mockSelenium?: boolean;
|
|
v8Debug?: any;
|
|
nodeDebug?: boolean;
|
|
debuggerServerPort?: number;
|
|
frameworkPath?: string;
|
|
elementExplorer?: any;
|
|
debug?: boolean;
|
|
unknownFlags_?: string[];
|
|
}
|