selenium-webdriver 3.0.0-beta-1 → 3.0.1

package/index.js

@@ -22,7 +22,11 @@
 
 'use strict';
 
-const builder = require('./builder');
+const chrome = require('./chrome');
+const edge = require('./edge');
+const firefox = require('./firefox');
+const _http = require('./http');
+const ie = require('./ie');
 const actions = require('./lib/actions');
 const by = require('./lib/by');
 const capabilities = require('./lib/capabilities');
@@ -35,21 +39,651 @@ const promise = require('./lib/promise');
 const session = require('./lib/session');
 const until = require('./lib/until');
 const webdriver = require('./lib/webdriver');
+const opera = require('./opera');
+const phantomjs = require('./phantomjs');
+const remote = require('./remote');
+const safari = require('./safari');
+
+const Browser = capabilities.Browser;
+const Capabilities = capabilities.Capabilities;
+const Capability = capabilities.Capability;
+const Session = session.Session;
+const WebDriver = webdriver.WebDriver;
+
+
+
+var seleniumServer;
+
+/**
+ * Starts an instance of the Selenium server if not yet running.
+ * @param {string} jar Path to the server jar to use.
+ * @return {!Promise<string>} A promise for the server's
+ *     addrss once started.
+ */
+function startSeleniumServer(jar) {
+  if (!seleniumServer) {
+    seleniumServer = new remote.SeleniumServer(jar);
+  }
+  return seleniumServer.start();
+}
+
+
+/**
+ * {@linkplain webdriver.WebDriver#setFileDetector WebDriver's setFileDetector}
+ * method uses a non-standard command to transfer files from the local client
+ * to the remote end hosting the browser. Many of the WebDriver sub-types, like
+ * the {@link chrome.Driver} and {@link firefox.Driver}, do not support this
+ * command. Thus, these classes override the `setFileDetector` to no-op.
+ *
+ * This function uses a mixin to re-enable `setFileDetector` by calling the
+ * original method on the WebDriver prototype directly. This is used only when
+ * the builder creates a Chrome or Firefox instance that communicates with a
+ * remote end (and thus, support for remote file detectors is unknown).
+ *
+ * @param {function(new: webdriver.WebDriver, ...?)} ctor
+ * @return {function(new: webdriver.WebDriver, ...?)}
+ */
+function ensureFileDetectorsAreEnabled(ctor) {
+  const mixin = class extends ctor {
+    /** @param {input.FileDetector} detector */
+    setFileDetector(detector) {
+      webdriver.WebDriver.prototype.setFileDetector.call(this, detector);
+    }
+  };
+  return mixin;
+}
+
+
+/**
+ * A thenable wrapper around a {@linkplain webdriver.IWebDriver IWebDriver}
+ * instance that allows commands to be issued directly instead of having to
+ * repeatedly call `then`:
+ *
+ *     let driver = new Builder().build();
+ *     driver.then(d => d.get(url));  // You can do this...
+ *     driver.get(url);               // ...or this
+ *
+ * If the driver instance fails to resolve (e.g. the session cannot be created),
+ * every issued command will fail.
+ *
+ * @extends {webdriver.IWebDriver}
+ * @extends {promise.CancellableThenable<!webdriver.IWebDriver>}
+ * @interface
+ */
+class ThenableWebDriver {
+  /** @param {...?} args */
+  static createSession(...args) {}
+}
+
+
+/**
+ * @const {!Map<function(new: WebDriver, !IThenable<!Session>, ...?),
+ *              function(new: ThenableWebDriver, !IThenable<!Session>, ...?)>}
+ */
+const THENABLE_DRIVERS = new Map;
+
+
+/**
+ * @param {function(new: WebDriver, !IThenable<!Session>, ...?)} ctor
+ * @param {...?} args
+ * @return {!ThenableWebDriver}
+ */
+function createDriver(ctor, ...args) {
+  let thenableWebDriverProxy = THENABLE_DRIVERS.get(ctor);
+  if (!thenableWebDriverProxy) {
+    /** @implements {ThenableWebDriver} */
+    thenableWebDriverProxy = class extends ctor {
+      /**
+       * @param {!IThenable<!Session>} session
+       * @param {...?} rest
+       */
+      constructor(session, ...rest) {
+        super(session, ...rest);
+
+        const pd = this.getSession().then(session => {
+          return new ctor(session, ...rest);
+        });
+
+        /**
+         * @param {(string|Error)=} opt_reason
+         * @override
+         */
+        this.cancel = function(opt_reason) {
+          if (promise.CancellableThenable.isImplementation(pd)) {
+            /** @type {!promise.CancellableThenable} */(pd).cancel(opt_reason);
+          }
+        };
+
+        /** @override */
+        this.then = pd.then.bind(pd);
+
+        /** @override */
+        this.catch = pd.then.bind(pd);
+      }
+    }
+    promise.CancellableThenable.addImplementation(thenableWebDriverProxy);
+    THENABLE_DRIVERS.set(ctor, thenableWebDriverProxy);
+  }
+  return thenableWebDriverProxy.createSession(...args);
+}
+
+
+/**
+ * Creates new {@link webdriver.WebDriver WebDriver} instances. The environment
+ * variables listed below may be used to override a builder's configuration,
+ * allowing quick runtime changes.
+ *
+ * - {@code SELENIUM_BROWSER}: defines the target browser in the form
+ *   {@code browser[:version][:platform]}.
+ *
+ * - {@code SELENIUM_REMOTE_URL}: defines the remote URL for all builder
+ *   instances. This environment variable should be set to a fully qualified
+ *   URL for a WebDriver server (e.g. http://localhost:4444/wd/hub). This
+ *   option always takes precedence over {@code SELENIUM_SERVER_JAR}.
+ *
+ * - {@code SELENIUM_SERVER_JAR}: defines the path to the
+ *   <a href="http://selenium-release.storage.googleapis.com/index.html">
+ *   standalone Selenium server</a> jar to use. The server will be started the
+ *   first time a WebDriver instance and be killed when the process exits.
+ *
+ * Suppose you had mytest.js that created WebDriver with
+ *
+ *     var driver = new webdriver.Builder()
+ *         .forBrowser('chrome')
+ *         .build();
+ *
+ * This test could be made to use Firefox on the local machine by running with
+ * `SELENIUM_BROWSER=firefox node mytest.js`. Rather than change the code to
+ * target Google Chrome on a remote machine, you can simply set the
+ * `SELENIUM_BROWSER` and `SELENIUM_REMOTE_URL` environment variables:
+ *
+ *     SELENIUM_BROWSER=chrome:36:LINUX \
+ *     SELENIUM_REMOTE_URL=http://www.example.com:4444/wd/hub \
+ *     node mytest.js
+ *
+ * You could also use a local copy of the standalone Selenium server:
+ *
+ *     SELENIUM_BROWSER=chrome:36:LINUX \
+ *     SELENIUM_SERVER_JAR=/path/to/selenium-server-standalone.jar \
+ *     node mytest.js
+ */
+class Builder {
+  constructor() {
+    /** @private @const */
+    this.log_ = logging.getLogger('webdriver.Builder');
+
+    /** @private {promise.ControlFlow} */
+    this.flow_ = null;
+
+    /** @private {string} */
+    this.url_ = '';
+
+    /** @private {?string} */
+    this.proxy_ = null;
+
+    /** @private {!Capabilities} */
+    this.capabilities_ = new Capabilities();
+
+    /** @private {chrome.Options} */
+    this.chromeOptions_ = null;
+
+    /** @private {firefox.Options} */
+    this.firefoxOptions_ = null;
+
+    /** @private {opera.Options} */
+    this.operaOptions_ = null;
+
+    /** @private {ie.Options} */
+    this.ieOptions_ = null;
+
+    /** @private {safari.Options} */
+    this.safariOptions_ = null;
+
+    /** @private {edge.Options} */
+    this.edgeOptions_ = null;
+
+    /** @private {boolean} */
+    this.ignoreEnv_ = false;
+
+    /** @private {http.Agent} */
+    this.agent_ = null;
+  }
+
+  /**
+   * Configures this builder to ignore any environment variable overrides and to
+   * only use the configuration specified through this instance's API.
+   *
+   * @return {!Builder} A self reference.
+   */
+  disableEnvironmentOverrides() {
+    this.ignoreEnv_ = true;
+    return this;
+  }
+
+  /**
+   * Sets the URL of a remote WebDriver server to use. Once a remote URL has
+   * been specified, the builder direct all new clients to that server. If this
+   * method is never called, the Builder will attempt to create all clients
+   * locally.
+   *
+   * As an alternative to this method, you may also set the
+   * `SELENIUM_REMOTE_URL` environment variable.
+   *
+   * @param {string} url The URL of a remote server to use.
+   * @return {!Builder} A self reference.
+   */
+  usingServer(url) {
+    this.url_ = url;
+    return this;
+  }
+
+  /**
+   * @return {string} The URL of the WebDriver server this instance is
+   *     configured to use.
+   */
+  getServerUrl() {
+    return this.url_;
+  }
+
+  /**
+   * Sets the URL of the proxy to use for the WebDriver's HTTP connections.
+   * If this method is never called, the Builder will create a connection
+   * without a proxy.
+   *
+   * @param {string} proxy The URL of a proxy to use.
+   * @return {!Builder} A self reference.
+   */
+  usingWebDriverProxy(proxy) {
+    this.proxy_ = proxy;
+    return this;
+  }
+
+  /**
+   * @return {?string} The URL of the proxy server to use for the WebDriver's
+   *    HTTP connections, or `null` if not set.
+   */
+  getWebDriverProxy() {
+    return this.proxy_;
+  }
+
+  /**
+   * Sets the http agent to use for each request.
+   * If this method is not called, the Builder will use http.globalAgent by default.
+   *
+   * @param {http.Agent} agent The agent to use for each request.
+   * @return {!Builder} A self reference.
+   */
+  usingHttpAgent(agent) {
+    this.agent_ = agent;
+    return this;
+  }
+
+  /**
+   * @return {http.Agent} The http agent used for each request
+   */
+  getHttpAgent() {
+    return this.agent_;
+  }
+
+  /**
+   * Sets the desired capabilities when requesting a new session. This will
+   * overwrite any previously set capabilities.
+   * @param {!(Object|Capabilities)} capabilities The desired capabilities for
+   *     a new session.
+   * @return {!Builder} A self reference.
+   */
+  withCapabilities(capabilities) {
+    this.capabilities_ = new Capabilities(capabilities);
+    return this;
+  }
+
+  /**
+   * Returns the base set of capabilities this instance is currently configured
+   * to use.
+   * @return {!Capabilities} The current capabilities for this builder.
+   */
+  getCapabilities() {
+    return this.capabilities_;
+  }
+
+  /**
+   * Configures the target browser for clients created by this instance.
+   * Any calls to {@link #withCapabilities} after this function will
+   * overwrite these settings.
+   *
+   * You may also define the target browser using the {@code SELENIUM_BROWSER}
+   * environment variable. If set, this environment variable should be of the
+   * form `browser[:[version][:platform]]`.
+   *
+   * @param {(string|Browser)} name The name of the target browser;
+   *     common defaults are available on the {@link webdriver.Browser} enum.
+   * @param {string=} opt_version A desired version; may be omitted if any
+   *     version should be used.
+   * @param {string=} opt_platform The desired platform; may be omitted if any
+   *     version may be used.
+   * @return {!Builder} A self reference.
+   */
+  forBrowser(name, opt_version, opt_platform) {
+    this.capabilities_.set(Capability.BROWSER_NAME, name);
+    this.capabilities_.set(Capability.VERSION, opt_version || null);
+    this.capabilities_.set(Capability.PLATFORM, opt_platform || null);
+    return this;
+  }
+
+  /**
+   * Sets the proxy configuration for the target browser.
+   * Any calls to {@link #withCapabilities} after this function will
+   * overwrite these settings.
+   *
+   * @param {!capabilities.ProxyConfig} config The configuration to use.
+   * @return {!Builder} A self reference.
+   */
+  setProxy(config) {
+    this.capabilities_.setProxy(config);
+    return this;
+  }
+
+  /**
+   * Sets the logging preferences for the created session. Preferences may be
+   * changed by repeated calls, or by calling {@link #withCapabilities}.
+   * @param {!(./lib/logging.Preferences|Object<string, string>)} prefs The
+   *     desired logging preferences.
+   * @return {!Builder} A self reference.
+   */
+  setLoggingPrefs(prefs) {
+    this.capabilities_.setLoggingPrefs(prefs);
+    return this;
+  }
+
+  /**
+   * Sets whether native events should be used.
+   * @param {boolean} enabled Whether to enable native events.
+   * @return {!Builder} A self reference.
+   */
+  setEnableNativeEvents(enabled) {
+    this.capabilities_.setEnableNativeEvents(enabled);
+    return this;
+  }
+
+  /**
+   * Sets how elements should be scrolled into view for interaction.
+   * @param {number} behavior The desired scroll behavior: either 0 to align
+   *     with the top of the viewport or 1 to align with the bottom.
+   * @return {!Builder} A self reference.
+   */
+  setScrollBehavior(behavior) {
+    this.capabilities_.setScrollBehavior(behavior);
+    return this;
+  }
+
+  /**
+   * Sets the default action to take with an unexpected alert before returning
+   * an error.
+   * @param {string} behavior The desired behavior; should be "accept",
+   *     "dismiss", or "ignore". Defaults to "dismiss".
+   * @return {!Builder} A self reference.
+   */
+  setAlertBehavior(behavior) {
+    this.capabilities_.setAlertBehavior(behavior);
+    return this;
+  }
+
+  /**
+   * Sets Chrome specific {@linkplain chrome.Options options} for drivers
+   * created by this builder. Any logging or proxy settings defined on the given
+   * options will take precedence over those set through
+   * {@link #setLoggingPrefs} and {@link #setProxy}, respectively.
+   *
+   * @param {!chrome.Options} options The ChromeDriver options to use.
+   * @return {!Builder} A self reference.
+   */
+  setChromeOptions(options) {
+    this.chromeOptions_ = options;
+    return this;
+  }
+
+  /**
+   * Sets Firefox specific {@linkplain firefox.Options options} for drivers
+   * created by this builder. Any logging or proxy settings defined on the given
+   * options will take precedence over those set through
+   * {@link #setLoggingPrefs} and {@link #setProxy}, respectively.
+   *
+   * @param {!firefox.Options} options The FirefoxDriver options to use.
+   * @return {!Builder} A self reference.
+   */
+  setFirefoxOptions(options) {
+    this.firefoxOptions_ = options;
+    return this;
+  }
+
+  /**
+   * @return {firefox.Options} the Firefox specific options currently configured
+   *     for this instance.
+   */
+  getFirefoxOptions() {
+    return this.firefoxOptions_;
+  }
+
+  /**
+   * Sets Opera specific {@linkplain opera.Options options} for drivers created
+   * by this builder. Any logging or proxy settings defined on the given options
+   * will take precedence over those set through {@link #setLoggingPrefs} and
+   * {@link #setProxy}, respectively.
+   *
+   * @param {!opera.Options} options The OperaDriver options to use.
+   * @return {!Builder} A self reference.
+   */
+  setOperaOptions(options) {
+    this.operaOptions_ = options;
+    return this;
+  }
+
+  /**
+   * Set Internet Explorer specific {@linkplain ie.Options options} for drivers
+   * created by this builder. Any proxy settings defined on the given options
+   * will take precedence over those set through {@link #setProxy}.
+   *
+   * @param {!ie.Options} options The IEDriver options to use.
+   * @return {!Builder} A self reference.
+   */
+  setIeOptions(options) {
+    this.ieOptions_ = options;
+    return this;
+  }
+
+  /**
+   * Set {@linkplain edge.Options options} specific to Microsoft's Edge browser
+   * for drivers created by this builder. Any proxy settings defined on the
+   * given options will take precedence over those set through
+   * {@link #setProxy}.
+   *
+   * @param {!edge.Options} options The MicrosoftEdgeDriver options to use.
+   * @return {!Builder} A self reference.
+   */
+  setEdgeOptions(options) {
+    this.edgeOptions_ = options;
+    return this;
+  }
+
+  /**
+   * Sets Safari specific {@linkplain safari.Options options} for drivers
+   * created by this builder. Any logging settings defined on the given options
+   * will take precedence over those set through {@link #setLoggingPrefs}.
+   *
+   * @param {!safari.Options} options The Safari options to use.
+   * @return {!Builder} A self reference.
+   */
+  setSafariOptions(options) {
+    this.safariOptions_ = options;
+    return this;
+  }
+
+  /**
+   * @return {safari.Options} the Safari specific options currently configured
+   *     for this instance.
+   */
+  getSafariOptions() {
+    return this.safariOptions_;
+  }
+
+  /**
+   * Sets the control flow that created drivers should execute actions in. If
+   * the flow is never set, or is set to {@code null}, it will use the active
+   * flow at the time {@link #build()} is called.
+   * @param {promise.ControlFlow} flow The control flow to use, or
+   *     {@code null} to
+   * @return {!Builder} A self reference.
+   */
+  setControlFlow(flow) {
+    this.flow_ = flow;
+    return this;
+  }
+
+  /**
+   * Creates a new WebDriver client based on this builder's current
+   * configuration.
+   *
+   * This method will return a {@linkplain ThenableWebDriver} instance, allowing
+   * users to issue commands directly without calling `then()`. The returned
+   * thenable wraps a promise that will resolve to a concrete
+   * {@linkplain webdriver.WebDriver WebDriver} instance. The promise will be
+   * rejected if the remote end fails to create a new session.
+   *
+   * @return {!ThenableWebDriver} A new WebDriver instance.
+   * @throws {Error} If the current configuration is invalid.
+   */
+  build() {
+    // Create a copy for any changes we may need to make based on the current
+    // environment.
+    var capabilities = new Capabilities(this.capabilities_);
+
+    var browser;
+    if (!this.ignoreEnv_ && process.env.SELENIUM_BROWSER) {
+      this.log_.fine(`SELENIUM_BROWSER=${process.env.SELENIUM_BROWSER}`);
+      browser = process.env.SELENIUM_BROWSER.split(/:/, 3);
+      capabilities.set(Capability.BROWSER_NAME, browser[0]);
+      capabilities.set(Capability.VERSION, browser[1] || null);
+      capabilities.set(Capability.PLATFORM, browser[2] || null);
+    }
+
+    browser = capabilities.get(Capability.BROWSER_NAME);
+
+    if (typeof browser !== 'string') {
+      throw TypeError(
+          `Target browser must be a string, but is <${typeof browser}>;` +
+          ' did you forget to call forBrowser()?');
+    }
+
+    if (browser === 'ie') {
+      browser = Browser.INTERNET_EXPLORER;
+    }
+
+    // Apply browser specific overrides.
+    if (browser === Browser.CHROME && this.chromeOptions_) {
+      capabilities.merge(this.chromeOptions_.toCapabilities());
+
+    } else if (browser === Browser.FIREFOX && this.firefoxOptions_) {
+      capabilities.merge(this.firefoxOptions_.toCapabilities());
+
+    } else if (browser === Browser.INTERNET_EXPLORER && this.ieOptions_) {
+      capabilities.merge(this.ieOptions_.toCapabilities());
+
+    } else if (browser === Browser.OPERA && this.operaOptions_) {
+      capabilities.merge(this.operaOptions_.toCapabilities());
+
+    } else if (browser === Browser.SAFARI && this.safariOptions_) {
+      capabilities.merge(this.safariOptions_.toCapabilities());
+
+    } else if (browser === Browser.EDGE && this.edgeOptions_) {
+      capabilities.merge(this.edgeOptions_.toCapabilities());
+    }
+
+    // Check for a remote browser.
+    let url = this.url_;
+    if (!this.ignoreEnv_) {
+      if (process.env.SELENIUM_REMOTE_URL) {
+        this.log_.fine(
+            `SELENIUM_REMOTE_URL=${process.env.SELENIUM_REMOTE_URL}`);
+        url = process.env.SELENIUM_REMOTE_URL;
+      } else if (process.env.SELENIUM_SERVER_JAR) {
+        this.log_.fine(
+            `SELENIUM_SERVER_JAR=${process.env.SELENIUM_SERVER_JAR}`);
+        url = startSeleniumServer(process.env.SELENIUM_SERVER_JAR);
+      }
+    }
+
+    if (url) {
+      this.log_.fine('Creating session on remote server');
+      let client = Promise.resolve(url)
+          .then(url => new _http.HttpClient(url, this.agent_, this.proxy_));
+      let executor = new _http.Executor(client);
+
+      if (browser === Browser.CHROME) {
+        const driver = ensureFileDetectorsAreEnabled(chrome.Driver);
+        return createDriver(
+            driver, capabilities, executor, this.flow_);
+      }
+
+      if (browser === Browser.FIREFOX) {
+        const driver = ensureFileDetectorsAreEnabled(firefox.Driver);
+        return createDriver(
+            driver, capabilities, executor, this.flow_);
+      }
+      return createDriver(
+          WebDriver, executor, capabilities, this.flow_);
+    }
+
+    // Check for a native browser.
+    switch (browser) {
+      case Browser.CHROME:
+        return createDriver(chrome.Driver, capabilities, null, this.flow_);
+
+      case Browser.FIREFOX:
+        return createDriver(firefox.Driver, capabilities, null, this.flow_);
+
+      case Browser.INTERNET_EXPLORER:
+        return createDriver(ie.Driver, capabilities, this.flow_);
+
+      case Browser.EDGE:
+        return createDriver(edge.Driver, capabilities, null, this.flow_);
+
+      case Browser.OPERA:
+        return createDriver(opera.Driver, capabilities, null, this.flow_);
+
+      case Browser.PHANTOM_JS:
+        return createDriver(phantomjs.Driver, capabilities, this.flow_);
+
+      case Browser.SAFARI:
+        return createDriver(safari.Driver, capabilities, this.flow_);
+
+      default:
+        throw new Error('Do not know how to build driver: ' + browser
+            + '; did you forget to call usingServer(url)?');
+    }
+  }
+}
+
+
+// PUBLIC API
 
 
 exports.ActionSequence = actions.ActionSequence;
 exports.Browser = capabilities.Browser;
-exports.Builder = builder.Builder;
+exports.Builder = Builder;
 exports.Button = input.Button;
 exports.By = by.By;
 exports.Capabilities = capabilities.Capabilities;
 exports.Capability = capabilities.Capability;
+exports.Condition = webdriver.Condition;
 exports.EventEmitter = events.EventEmitter;
 exports.FileDetector = input.FileDetector;
 exports.Key = input.Key;
 exports.Session = session.Session;
+exports.ThenableWebDriver = ThenableWebDriver;
+exports.TouchSequence = actions.TouchSequence;
 exports.WebDriver = webdriver.WebDriver;
 exports.WebElement = webdriver.WebElement;
+exports.WebElementCondition = webdriver.WebElementCondition;
 exports.WebElementPromise = webdriver.WebElementPromise;
 exports.error = error;
 exports.logging = logging;