WebDriver

Creates a new action sequence using this driver. The sequence will not be submitted for execution until Actions.perform() is called.

Injects a credential into the authenticator.

Adds a virtual authenticator with the given options.

Closes the current window.

Creates a new WebSocket connection.

Executes the provided command.Command using this driver's command.Executor.

Executes a snippet of asynchronous JavaScript in the context of the currently selected frame or window. The script fragment will be executed as the body of an anonymous function. If the script is provided as a function object, that function will be converted to a string for injection into the target window.

Any arguments provided in addition to the script will be included as script arguments and may be referenced using the arguments object. Arguments may be a boolean, number, string, or WebElement. Arrays and objects may also be used as script arguments as long as each item adheres to the types previously mentioned.

Unlike executing synchronous JavaScript with #executeScript, scripts executed with this function must explicitly signal they are finished by invoking the provided callback. This callback will always be injected into the executed function as the last argument, and thus may be referenced with arguments[arguments.length - 1]. The following steps will be taken for resolving this functions return value against the first argument to the script's callback function:

• For a HTML element, the value will resolve to a WebElement
• Null and undefined return values will resolve to null
• Booleans, numbers, and strings will resolve as is
• Functions will resolve to their string representation
• For arrays and objects, each member item will be converted according to the rules above

Example #1: Performing a sleep that is synchronized with the currently selected window:

var start = new Date().getTime();
driver.executeAsyncScript(
    'window.setTimeout(arguments[arguments.length - 1], 500);').
    then(function() {
      console.log(
          'Elapsed time: ' + (new Date().getTime() - start) + ' ms');
    });

Example #2: Synchronizing a test with an AJAX application:

var button = driver.findElement(By.id('compose-button'));
button.click();
driver.executeAsyncScript(
    'var callback = arguments[arguments.length - 1];' +
    'mailClient.getComposeWindowWidget().onload(callback);');
driver.switchTo().frame('composeWidget');
driver.findElement(By.id('to')).sendKeys('dog@example.com');

Example #3: Injecting a XMLHttpRequest and waiting for the result. In this example, the inject script is specified with a function literal. When using this format, the function is converted to a string for injection, so it should not reference any symbols not defined in the scope of the page under test.

driver.executeAsyncScript(function() {
  var callback = arguments[arguments.length - 1];
  var xhr = new XMLHttpRequest();
  xhr.open("GET", "/resource/data.json", true);
  xhr.onreadystatechange = function() {
    if (xhr.readyState == 4) {
      callback(xhr.responseText);
    }
  };
  xhr.send('');
}).then(function(str) {
  console.log(JSON.parse(str)['food']);
});

Executes a snippet of JavaScript in the context of the currently selected frame or window. The script fragment will be executed as the body of an anonymous function. If the script is provided as a function object, that function will be converted to a string for injection into the target window.

Any arguments provided in addition to the script will be included as script arguments and may be referenced using the arguments object. Arguments may be a boolean, number, string, or WebElement. Arrays and objects may also be used as script arguments as long as each item adheres to the types previously mentioned.

The script may refer to any variables accessible from the current window. Furthermore, the script will execute in the window's context, thus document may be used to refer to the current document. Any local variables will not be available once the script has finished executing, though global variables will persist.

If the script has a return value (i.e. if the script contains a return statement), then the following steps will be taken for resolving this functions return value:

• For a HTML element, the value will resolve to a WebElement
• Null and undefined return values will resolve to null
• Booleans, numbers, and strings will resolve as is
• Functions will resolve to their string representation
• For arrays and objects, each member item will be converted according to the rules above

Locates an element on the page. If the element cannot be found, a error.NoSuchElementError will be returned by the driver.

This function should not be used to test whether an element is present on the page. Rather, you should use #findElements:

driver.findElements(By.id('foo'))
    .then(found => console.log('Element found? %s', !!found.length));

The search criteria for an element may be defined using one of the factories in the webdriver.By namespace, or as a short-hand webdriver.By.Hash object. For example, the following two statements are equivalent:

var e1 = driver.findElement(By.id('foo'));
var e2 = driver.findElement({id:'foo'});

You may also provide a custom locator function, which takes as input this instance and returns a WebElement, or a promise that will resolve to a WebElement. If the returned promise resolves to an array of WebElements, WebDriver will use the first element. For example, to find the first visible link on a page, you could write:

var link = driver.findElement(firstVisibleLink);

function firstVisibleLink(driver) {
  var links = driver.findElements(By.tagName('a'));
  return promise.filter(links, function(link) {
    return link.isDisplayed();
  });
}

Search for multiple elements on the page. Refer to the documentation on #findElement(by) for information on element locator strategies.

Navigates to the given URL.

Retrieves a list of all available window handles.

Initiates bidi connection using 'webSocketUrl'

Retrieves the URL for the current page.

Retrieves the current page's source. The returned source is a representation of the underlying DOM: do not expect it to be formatted or escaped in the same way as the raw response sent from the web server.

Retrieves the current page title.

Retrieves the current window handle.

Retrieves 'webSocketDebuggerUrl' by sending a http request using debugger address

Handle Network interception requests

Takes a PDF of the current page. The driver makes a best effort to return a PDF based on the provided parameters.

Terminates the browser session. After calling quit, this instance will be invalidated and may no longer be used to issue commands against the browser.

Sets a listener for Fetch.authRequired event from CDP If event is triggered, it enters username and password and allows the test to move forward

Removes all the credentials from the authenticator.

Removes a credential from the authenticator.

Removes a previously added virtual authenticator. The authenticator is no longer valid after removal, so no methods may be called.

Sets the file detector that should be used with this instance.

Sets whether the authenticator will simulate success or fail on user verification.

Makes the driver sleep for the given amount of time.

Takes a screenshot of the current page. The driver makes the best effort to return a screenshot of the following, in order of preference:

1. Entire page
2. Current window
3. Visible portion of the current frame
4. The entire display containing the browser

Waits for a condition to evaluate to a "truthy" value. The condition may be specified by a Condition, as a custom function, or as any promise-like thenable.

For a Condition or function, the wait will repeatedly evaluate the condition until it returns a truthy value. If any errors occur while evaluating the condition, they will be allowed to propagate. In the event a condition returns a Promise, the polling loop will wait for it to be resolved and use the resolved value for whether the condition has been satisfied. The resolution time for a promise is always factored into whether a wait has timed out.

If the provided condition is a WebElementCondition, then the wait will return a WebElementPromise that will resolve to the element that satisfied the condition.

Example: waiting up to 10 seconds for an element to be present on the page.

async function example() {
  let button =
      await driver.wait(until.elementLocated(By.id('foo')), 10000);
  await button.click();
}

Creates a new WebDriver session.

This function will always return a WebDriver instance. If there is an error creating the session, such as the aforementioned SessionNotCreatedError, the driver will have a rejected session promise. This rejection will propagate through any subsequent commands scheduled on the returned WebDriver instance.

let required = Capabilities.firefox();
let driver = WebDriver.createSession(executor, {required});

// If the createSession operation failed, then this command will also
// also fail, propagating the creation failure.
driver.get('http://www.google.com').catch(e => console.log(e));