selenium-webdriver 3.0.1 → 3.5.0

package/lib/error.js

@@ -28,6 +28,14 @@ class WebDriverError extends Error {
 
     /** @override */
     this.name = this.constructor.name;
+
+    /**
+     * A stacktrace reported by the remote webdriver endpoint that initially
+     * reported this error. This property will be an empty string if the remote
+     * end did not provide a stacktrace.
+     * @type {string}
+     */
+    this.remoteStacktrace = '';
   }
 }
 
@@ -311,7 +319,7 @@ class UnknownMethodError extends WebDriverError {
 
 
 /**
- * Reports an unsupport operation.
+ * Reports an unsupported operation.
  */
 class UnsupportedOperationError extends WebDriverError {
   /** @param {string=} opt_error the error message, if any. */
@@ -462,19 +470,35 @@ function checkResponse(data) {
   return data;
 }
 
+/**
+ * Tests if the given value is a valid error response object according to the
+ * W3C WebDriver spec.
+ *
+ * @param {?} data The value to test.
+ * @return {boolean} Whether the given value data object is a valid error
+ *     response.
+ * @see https://w3c.github.io/webdriver/webdriver-spec.html#protocol
+ */
+function isErrorResponse(data) {
+  return data && typeof data === 'object' && typeof data.error === 'string';
+}
 
 /**
  * Throws an error coded from the W3C protocol. A generic error will be thrown
- * if the privded `data` is not a valid encoded error.
+ * if the provided `data` is not a valid encoded error.
  *
  * @param {{error: string, message: string}} data The error data to decode.
  * @throws {WebDriverError} the decoded error.
  * @see https://w3c.github.io/webdriver/webdriver-spec.html#protocol
  */
 function throwDecodedError(data) {
-  if (data && typeof data === 'object' && typeof data.error === 'string') {
+  if (isErrorResponse(data)) {
     let ctor = ERROR_CODE_TO_TYPE.get(data.error) || WebDriverError;
-    throw new ctor(data.message);
+    let err = new ctor(data.message);
+    if (typeof data.stacktrace === 'string') {
+      err.remoteStacktrace = data.stacktrace;
+    }
+    throw err;
   }
   throw new WebDriverError('Unknown error: ' + JSON.stringify(data));
 }
@@ -551,5 +575,6 @@ module.exports = {
   checkResponse: checkResponse,
   checkLegacyResponse: checkLegacyResponse,
   encodeError: encodeError,
+  isErrorResponse: isErrorResponse,
   throwDecodedError: throwDecodedError,
 };

package/lib/events.js

@@ -22,7 +22,7 @@
  */
 class Listener {
   /**
-   * @param {!Function} fn The acutal listener function.
+   * @param {!Function} fn The actual listener function.
    * @param {(Object|undefined)} scope The object in whose scope to invoke the
    *     listener.
    * @param {boolean} oneshot Whether this listener should only be used once.

package/lib/firefox/webdriver.json

@@ -37,7 +37,6 @@
     "network.http.phishy-userpass-length": 255,
     "offline-apps.allow_by_default": true,
     "prompts.tab_modal.enabled": false,
-    "security.csp.enable": false,
     "security.fileuri.origin_policy": 3,
     "security.fileuri.strict_origin_policy": false,
     "signon.rememberSignons": false,
@@ -61,6 +60,8 @@
     "dom.max_script_run_time": 30,
     "dom.report_all_js_exceptions": true,
     "javascript.options.showInConsole": true,
+    "network.captive-portal-service.enabled": false,
+    "security.csp.enable": false,
     "startup.homepage_welcome_url": "about:blank",
     "startup.homepage_welcome_url.additional": "about:blank",
     "webdriver_accept_untrusted_certs": true,

package/lib/http.js

@@ -25,17 +25,26 @@
 
 'use strict';
 
-const fs = require('fs');
-const path = require('path');
-
 const cmd = require('./command');
-const devmode = require('./devmode');
 const error = require('./error');
 const logging = require('./logging');
 const promise = require('./promise');
 const Session = require('./session').Session;
 const WebElement = require('./webdriver').WebElement;
 
+const {getAttribute, isDisplayed} = /** @suppress {undefinedVars|uselessCode} */(function() {
+  try {
+    return {
+      getAttribute: require('./atoms/getAttribute.js'),
+      isDisplayed: require('./atoms/is-displayed.js')
+    };
+  } catch (ex) {
+    throw Error(
+        'Failed to import atoms modules. If running in devmode, you need to run'
+            + ' `./go node:atoms` from the project root: ' + ex);
+  }
+})();
+
 
 /**
  * Converts a headers map to a HTTP header block string.
@@ -116,43 +125,15 @@ class Response {
 
 const DEV_ROOT = '../../../../buck-out/gen/javascript/';
 
-/** @enum {string} */
+/** @enum {!Function} */
 const Atom = {
-  GET_ATTRIBUTE: devmode
-      ? path.join(__dirname, DEV_ROOT, 'webdriver/atoms/getAttribute.js')
-      : path.join(__dirname, 'atoms/getAttribute.js'),
-  IS_DISPLAYED: devmode
-      ? path.join(__dirname, DEV_ROOT, 'atoms/fragments/is-displayed.js')
-      : path.join(__dirname, 'atoms/isDisplayed.js'),
+  GET_ATTRIBUTE: getAttribute,
+  IS_DISPLAYED: isDisplayed
 };
 
 
-const ATOMS = /** !Map<string, !Promise<string>> */new Map();
 const LOG = logging.getLogger('webdriver.http');
 
-/**
- * @param {Atom} file The atom file to load.
- * @return {!Promise<string>} A promise that will resolve to the contents of the
- *     file.
- */
-function loadAtom(file) {
-  if (ATOMS.has(file)) {
-    return ATOMS.get(file);
-  }
-  let contents = /** !Promise<string> */new Promise((resolve, reject) => {
-    LOG.finest(() => `Loading atom ${file}`);
-    fs.readFile(file, 'utf8', function(err, data) {
-      if (err) {
-        reject(err);
-      } else {
-        resolve(data);
-      }
-    });
-  });
-  ATOMS.set(file, contents);
-  return contents;
-}
-
 
 function post(path) { return resource('POST', path); }
 function del(path)  { return resource('DELETE', path); }
@@ -168,17 +149,26 @@ var CommandSpec;
 var CommandTransformer;
 
 
+class InternalTypeError extends TypeError {}
+
+
 /**
  * @param {!cmd.Command} command The initial command.
  * @param {Atom} atom The name of the atom to execute.
  * @return {!Promise<!cmd.Command>} The transformed command to execute.
  */
 function toExecuteAtomCommand(command, atom, ...params) {
-  return loadAtom(atom).then(atom => {
-    return new cmd.Command(cmd.Name.EXECUTE_SCRIPT)
+  return new Promise((resolve, reject) => {
+    if (typeof atom !== 'function') {
+      reject(new InternalTypeError('atom is not a function: ' + typeof atom));
+      return;
+    }
+
+    let newCmd = new cmd.Command(cmd.Name.EXECUTE_SCRIPT)
         .setParameter('sessionId', command.getParameter('sessionId'))
         .setParameter('script', `return (${atom}).apply(null, arguments)`)
         .setParameter('args', params.map(param => command.getParameter(param)));
+    resolve(newCmd);
   });
 }
 
@@ -235,6 +225,7 @@ const COMMAND_MAP = new Map([
     [cmd.Name.EXECUTE_SCRIPT, post('/session/:sessionId/execute')],
     [cmd.Name.EXECUTE_ASYNC_SCRIPT, post('/session/:sessionId/execute_async')],
     [cmd.Name.SCREENSHOT, get('/session/:sessionId/screenshot')],
+    [cmd.Name.GET_TIMEOUT, get('/session/:sessionId/timeouts')],
     [cmd.Name.SET_TIMEOUT, post('/session/:sessionId/timeouts')],
     [cmd.Name.MOVE_TO, post('/session/:sessionId/moveto')],
     [cmd.Name.CLICK, post('/session/:sessionId/click')],
@@ -266,17 +257,27 @@ const COMMAND_MAP = new Map([
 /** @const {!Map<string, (CommandSpec|CommandTransformer)>} */
 const W3C_COMMAND_MAP = new Map([
   [cmd.Name.GET_ACTIVE_ELEMENT, get('/session/:sessionId/element/active')],
+  [cmd.Name.GET_ALERT_TEXT, get('/session/:sessionId/alert/text')],
+  [cmd.Name.SET_ALERT_TEXT, post('/session/:sessionId/alert/text')],
+  [cmd.Name.ACCEPT_ALERT, post('/session/:sessionId/alert/accept')],
+  [cmd.Name.DISMISS_ALERT, post('/session/:sessionId/alert/dismiss')],
   [cmd.Name.GET_ELEMENT_ATTRIBUTE, (cmd) => {
     return toExecuteAtomCommand(cmd, Atom.GET_ATTRIBUTE, 'id', 'name');
   }],
+  [cmd.Name.GET_ELEMENT_LOCATION, get('/session/:sessionId/element/:id/rect')],
+  [cmd.Name.GET_ELEMENT_SIZE, get('/session/:sessionId/element/:id/rect')],
   [cmd.Name.IS_ELEMENT_DISPLAYED, (cmd) => {
     return toExecuteAtomCommand(cmd, Atom.IS_DISPLAYED, 'id');
   }],
+  [cmd.Name.EXECUTE_SCRIPT, post('/session/:sessionId/execute/sync')],
+  [cmd.Name.EXECUTE_ASYNC_SCRIPT, post('/session/:sessionId/execute/async')],
   [cmd.Name.MAXIMIZE_WINDOW, post('/session/:sessionId/window/maximize')],
   [cmd.Name.GET_WINDOW_POSITION, get('/session/:sessionId/window/position')],
   [cmd.Name.SET_WINDOW_POSITION, post('/session/:sessionId/window/position')],
   [cmd.Name.GET_WINDOW_SIZE, get('/session/:sessionId/window/size')],
   [cmd.Name.SET_WINDOW_SIZE, post('/session/:sessionId/window/size')],
+  [cmd.Name.GET_CURRENT_WINDOW_HANDLE, get('/session/:sessionId/window')],
+  [cmd.Name.GET_WINDOW_HANDLES, get('/session/:sessionId/window/handles')],
 ]);
 
 
@@ -436,33 +437,29 @@ class Executor {
       return doSend(this, request).then(response => {
         this.log_.finer(() => `>>>\n${request}\n<<<\n${response}`);
 
-        let parsed =
-            parseHttpResponse(/** @type {!Response} */ (response), this.w3c);
+        let httpResponse = /** @type {!Response} */(response);
+        let {isW3C, value} = parseHttpResponse(command, httpResponse);
 
         if (command.getName() === cmd.Name.NEW_SESSION
             || command.getName() === cmd.Name.DESCRIBE_SESSION) {
-          if (!parsed || !parsed['sessionId']) {
+          if (!value || !value.sessionId) {
             throw new error.WebDriverError(
-                'Unable to parse new session response: ' + response.body);
+                `Unable to parse new session response: ${response.body}`);
           }
 
           // The remote end is a W3C compliant server if there is no `status`
-          // field in the response. This is not appliable for the DESCRIBE_SESSION
+          // field in the response. This is not applicable for the DESCRIBE_SESSION
           // command, which is not defined in the W3C spec.
           if (command.getName() === cmd.Name.NEW_SESSION) {
-            this.w3c = this.w3c || !('status' in parsed);
+            this.w3c = this.w3c || isW3C;
           }
 
-          return new Session(parsed['sessionId'], parsed['value']);
+          // No implementations use the `capabilities` key yet...
+          let capabilities = value.capabilities || value.value;
+          return new Session(value.sessionId, capabilities);
         }
 
-        if (parsed
-            && typeof parsed === 'object'
-            && 'value' in parsed) {
-          let value = parsed['value'];
-          return typeof value === 'undefined' ? null : value;
-        }
-        return parsed;
+        return typeof value === 'undefined' ? null : value;
       });
     });
   }
@@ -485,30 +482,48 @@ function tryParse(str) {
 /**
  * Callback used to parse {@link Response} objects from a
  * {@link HttpClient}.
+ *
+ * @param {!cmd.Command} command The command the response is for.
  * @param {!Response} httpResponse The HTTP response to parse.
- * @param {boolean} w3c Whether the response should be processed using the
- *     W3C wire protocol.
- * @return {?} The parsed response.
+ * @return {{isW3C: boolean, value: ?}} An object describing the parsed
+ *     response. This object will have two fields: `isW3C` indicates whether
+ *     the response looks like it came from a remote end that conforms with the
+ *     W3C WebDriver spec, and `value`, the actual response value.
  * @throws {WebDriverError} If the HTTP response is an error.
  */
-function parseHttpResponse(httpResponse, w3c) {
+function parseHttpResponse(command, httpResponse) {
+  if (httpResponse.status < 200) {
+    // This should never happen, but throw the raw response so users report it.
+    throw new error.WebDriverError(
+        `Unexpected HTTP response:\n${httpResponse}`);
+  }
+
   let parsed = tryParse(httpResponse.body);
-  if (parsed !== undefined) {
-    if (w3c) {
-      if (httpResponse.status > 399) {
-        error.throwDecodedError(parsed);
-      }
+  if (parsed && typeof parsed === 'object') {
+    let value = parsed.value;
+    let isW3C =
+        value !== null && typeof value === 'object'
+            && typeof parsed.status === 'undefined';
 
-      if (httpResponse.status < 200) {
-        // This should never happen, but throw the raw response so
-        // users report it.
-        throw new error.WebDriverError(
-            `Unexpected HTTP response:\n${httpResponse}`);
-      }
-    } else {
+    if (!isW3C) {
       error.checkLegacyResponse(parsed);
+
+      // Adjust legacy new session responses to look like W3C to simplify
+      // later processing.
+      if (command.getName() === cmd.Name.NEW_SESSION
+          || command.getName() == cmd.Name.DESCRIBE_SESSION) {
+        value = parsed;
+      }
+
+    } else if (httpResponse.status > 399) {
+      error.throwDecodedError(value);
     }
-    return parsed;
+
+    return {isW3C, value};
+  }
+
+  if (parsed !== undefined) {
+    return {isW3C: false, value: parsed};
   }
 
   let value = httpResponse.body.replace(/\r\n/g, '\n');
@@ -521,7 +536,7 @@ function parseHttpResponse(httpResponse, w3c) {
     throw new error.WebDriverError(value);
   }
 
-  return value || null;
+  return {isW3C: false, value: value || null};
 }
 
 

package/lib/input.js

@@ -144,7 +144,7 @@ class FileDetector {
   /**
    * Handles the file specified by the given path, preparing it for use with
    * the current browser. If the path does not refer to a valid file, it will
-   * be returned unchanged, otherwisee a path suitable for use with the current
+   * be returned unchanged, otherwise a path suitable for use with the current
    * browser will be returned.
    *
    * This default implementation is a no-op. Subtypes may override this function