selenium-webdriver 3.3.0 → 4.0.0-alpha.1

package/test/actions_test.js

@@ -17,36 +17,191 @@
 
 'use strict';
 
-var Browser = require('..').Browser,
-    By = require('..').By,
-    until = require('..').until,
-    test = require('../lib/test'),
-    fileServer = require('../lib/test/fileserver');
+const assert = require('assert');
 
+const chrome = require('../chrome');
+const error = require('../lib/error');
+const fileServer = require('../lib/test/fileserver');
+const firefox = require('../firefox');
+const test = require('../lib/test');
+const {Key, Origin} = require('../lib/input');
+const {Browser, By, until} = require('..');
 
 test.suite(function(env) {
-  var driver;
-  test.beforeEach(function*() { driver = yield env.builder().build(); });
-  test.afterEach(function() { return driver.quit(); });
-
-  test.ignore(
-      env.browsers(Browser.FIREFOX, Browser.PHANTOM_JS, Browser.SAFARI)).
+  test.ignore(env.browsers(Browser.SAFARI)).
   describe('WebDriver.actions()', function() {
+    let driver;
 
-    test.it('can move to and click element in an iframe', function*() {
-      yield driver.get(fileServer.whereIs('click_tests/click_in_iframe.html'));
+    before(async function() {
+      driver = await env.builder().build();
+    });
 
-      yield driver.wait(until.elementLocated(By.id('ifr')), 5000)
-          .then(frame => driver.switchTo().frame(frame));
+    afterEach(async function() {
+      try {
+        await driver.actions().clear();
+      } catch (e) {
+        if (e instanceof error.UnsupportedOperationError
+            || e instanceof error.UnknownCommandError) {
+          return;
+        }
+        throw e;
+      }
+    });
+
+    after(function() {
+      return driver.quit();
+    });
+
+    it('click(element)', async function() {
+      await driver.get(fileServer.whereIs('/data/actions/click.html'));
+
+      let box = await driver.findElement(By.id('box'));
+      assert.equal(await box.getAttribute('class'), '');
+
+      await driver.actions({bridge: true}).click(box).perform();
+      assert.equal(await box.getAttribute('class'), 'green');
+    });
+
+    it('click(element) clicks in center of element', async function() {
+      await driver.get(fileServer.whereIs('/data/actions/record_click.html'));
+
+      const div = await driver.findElement(By.css('div'));
+      const rect = await div.getRect();
+      assert.deepEqual(rect, {width: 500, height: 500, x: 0, y: 0});
+
+      await driver.actions({bridge: true}).click(div).perform();
+
+      const clicks = await driver.executeScript('return clicks');
+      assert.deepEqual(clicks, [[250, 250]]);
+    });
+
+    it('can move relative to element center', async function() {
+      await driver.get(fileServer.whereIs('/data/actions/record_click.html'));
 
-      let link = yield driver.findElement(By.id('link'));
-      yield driver.actions()
-          .mouseMove(link)
+      const div = await driver.findElement(By.css('div'));
+      const rect = await div.getRect();
+      assert.deepEqual(rect, {width: 500, height: 500, x: 0, y: 0});
+
+      await driver.actions({bridge: true})
+          .move({x: 10, y: 10, origin: div})
           .click()
           .perform();
 
+      const clicks = await driver.executeScript('return clicks');
+      assert.deepEqual(clicks, [[260, 260]]);
+    });
+
+    it('doubleClick(element)', async function() {
+      // This test requires Firefox 59+.
+      if (env.browser.name === Browser.FIREFOX) {
+        await driver.quit();
+        driver = await env.builder()
+            .setFirefoxOptions(
+                new firefox.Options().setBinary(firefox.Channel.NIGHTLY))
+            .build();
+      }
+      await driver.get(fileServer.whereIs('/data/actions/click.html'));
+
+      let box = await driver.findElement(By.id('box'));
+      assert.equal(await box.getAttribute('class'), '');
+
+      await driver.actions({bridge: true}).doubleClick(box).perform();
+      assert.equal(await box.getAttribute('class'), 'blue');
+    });
+
+    it('dragAndDrop()', async function() {
+      await driver.get(fileServer.whereIs('/data/actions/drag.html'));
+
+      let slide = await driver.findElement(By.id('slide'));
+      assert.equal(await slide.getCssValue('left'), '0px');
+      assert.equal(await slide.getCssValue('top'), '0px');
+
+      let br = await driver.findElement(By.id('BR'));
+      await driver.actions({bridge: true}).dragAndDrop(slide, br).perform();
+      assert.equal(await slide.getCssValue('left'), '206px');
+      assert.equal(await slide.getCssValue('top'), '206px');
+
+      let tr = await driver.findElement(By.id('TR'));
+      await driver.actions({bridge: true}).dragAndDrop(slide, tr).perform();
+      assert.equal(await slide.getCssValue('left'), '206px');
+      assert.equal(await slide.getCssValue('top'), '1px');
+    });
+
+    it('move()', async function() {
+      await driver.get(fileServer.whereIs('/data/actions/drag.html'));
+
+      let slide = await driver.findElement(By.id('slide'));
+      assert.equal(await slide.getCssValue('left'), '0px');
+      assert.equal(await slide.getCssValue('top'), '0px');
+
+      await driver.actions({bridge: true})
+          .move({origin: slide})
+          .press()
+          .move({x: 100, y: 100, origin: Origin.POINTER})
+          .release()
+          .perform();
+      assert.equal(await slide.getCssValue('left'), '101px');
+      assert.equal(await slide.getCssValue('top'), '101px');
+    });
+
+    it('can move to and click element in an iframe', async function() {
+      await driver.get(fileServer.whereIs('click_tests/click_in_iframe.html'));
+
+      await driver.wait(until.elementLocated(By.id('ifr')), 5000)
+          .then(frame => driver.switchTo().frame(frame));
+
+      let link = await driver.findElement(By.id('link'));
+
+      await driver.actions({bridge: true}).click(link).perform();
+      await driver.switchTo().defaultContent();
       return driver.wait(until.titleIs('Submitted Successfully!'), 5000);
     });
 
+    it('can send keys to focused element', async function() {
+      await driver.get(test.Pages.formPage);
+
+      let el = await driver.findElement(By.id('email'));
+      assert.equal(await el.getAttribute('value'), '');
+
+      await driver.executeScript('arguments[0].focus()', el);
+
+      await driver.actions({bridge: true}).sendKeys('foobar').perform();
+
+      assert.equal(await el.getAttribute('value'), 'foobar');
+    });
+
+    it('can send keys to focused element (with modifiers)', async function() {
+      await driver.get(test.Pages.formPage);
+
+      let el = await driver.findElement(By.id('email'));
+      assert.equal(await el.getAttribute('value'), '');
+
+      await driver.executeScript('arguments[0].focus()', el);
+
+      await driver.actions({bridge: true})
+          .sendKeys('fo')
+          .keyDown(Key.SHIFT)
+          .sendKeys('OB')
+          .keyUp(Key.SHIFT)
+          .sendKeys('ar')
+          .perform();
+
+      assert.equal(await el.getAttribute('value'), 'foOBar');
+    });
+
+    it('can interact with simple form elements', async function() {
+      await driver.get(test.Pages.formPage);
+
+      let el = await driver.findElement(By.id('email'));
+      assert.equal(await el.getAttribute('value'), '');
+
+      await driver.actions({bridge: true})
+          .click(el)
+          .sendKeys('foobar')
+          .perform();
+
+      assert.equal(await el.getAttribute('value'), 'foobar');
+    });
   });
 });
+

package/test/builder_test.js

@@ -0,0 +1,106 @@
+// 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.
+
+'use strict';
+
+const assert = require('assert');
+
+const chrome = require('../chrome');
+const edge = require('../edge');
+const error = require('../lib/error');
+const firefox = require('../firefox');
+const ie = require('../ie');
+const safari = require('../safari');
+const test = require('../lib/test');
+const {Browser} = require('../lib/capabilities');
+const {Pages} = require('../lib/test');
+const {Builder, Capabilities, WebDriver} = require('..');
+
+
+test.suite(function(env) {
+  const browsers = (...args) => env.browsers(...args);
+
+  const BROWSER_MAP = new Map([
+    [Browser.CHROME, chrome.Driver],
+    [Browser.EDGE, edge.Driver],
+    [Browser.FIREFOX, firefox.Driver],
+    [Browser.INTERNET_EXPLORER, ie.Driver],
+    [Browser.SAFARI, safari.Driver],
+  ]);
+
+  if (BROWSER_MAP.has(env.browser.name)) {
+    describe('builder creates thenable driver instances', function() {
+      let driver;
+
+      after(() => driver && driver.quit());
+
+      it(env.browser.name, function() {
+        driver = env.builder().build();
+
+        const want = BROWSER_MAP.get(env.browser.name);
+        assert.ok(
+            driver instanceof want,
+            `want ${want.name}, but got ${driver.name}`);
+        assert.equal(typeof driver.then, 'function');
+
+        return driver
+            .then(
+                d =>
+                    assert.ok(
+                        d instanceof want,
+                        `want ${want.name}, but got ${d.name}`))
+            // Load something so the safari driver doesn't crash from starting and
+            // stopping in short time.
+            .then(() => driver.get(Pages.echoPage));
+      });
+    });
+  }
+
+  class OptionsTest {
+    constructor(ctor, key) {
+      this.ctor = ctor;
+      this.key = key;
+    }
+  }
+
+});
+
+describe('Builder', function() {
+  describe('catches incorrect use of browser options class', function() {
+    function test(key, options) {
+      it(key, async function() {
+        let builder = new Builder()
+            .withCapabilities(new Capabilities()
+                .set('browserName', 'fake-browser-should-not-try-to-start')
+                .set(key, new options()));
+        try {
+          let driver = await builder.build();
+          await driver.quit();
+          return Promise.reject(Error('should have failed'));
+        } catch (ex) {
+          if (!(ex instanceof error.InvalidArgumentError)) {
+            throw ex;
+          }
+        }
+      });
+    }
+
+    test('chromeOptions', chrome.Options);
+    test('moz:firefoxOptions', firefox.Options);
+    test('safari.options', safari.Options);
+  });
+});

package/test/chrome/devtools_test.js

@@ -0,0 +1,93 @@
+// 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.
+
+'use strict';
+
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+
+const chrome = require('../../chrome');
+const error = require('../../lib/error');
+const fileServer = require('../../lib/test/fileserver');
+const io = require('../../io');
+const test = require('../../lib/test');
+const webdriver = require('../..');
+
+test.suite(function(env) {
+  let driver;
+
+  before(async function() {
+    driver = await env.builder()
+        .setChromeOptions(new chrome.Options().headless())
+        .build();
+  });
+  after(() => driver.quit());
+
+  it('can send commands to devtools', async function() {
+    await driver.get(test.Pages.ajaxyPage);
+    assert.equal(await driver.getCurrentUrl(), test.Pages.ajaxyPage);
+
+    await driver.sendDevToolsCommand(
+        'Page.navigate', {url: test.Pages.echoPage});
+    assert.equal(await driver.getCurrentUrl(), test.Pages.echoPage);
+  });
+
+  describe('setDownloadPath', function() {
+    it('can enable downloads in headless mode', async function() {
+      const dir = await io.tmpDir();
+      await driver.setDownloadPath(dir);
+
+      const url = fileServer.whereIs('/data/chrome/download.html');
+      await driver.get(`data:text/html,<!DOCTYPE html>
+  <div><a download="" href="${url}">Go!</a></div>`);
+
+      await driver.findElement({css: 'a'}).click();
+
+      const downloadPath = path.join(dir, 'download.html');
+      await driver.wait(() => io.exists(downloadPath), 1000);
+
+      const goldenPath =
+          path.join(__dirname, '../../lib/test/data/chrome/download.html');
+      assert.equal(
+          fs.readFileSync(downloadPath, 'utf8'),
+          fs.readFileSync(goldenPath, 'utf8'));
+    });
+
+    it('throws if path is not a directory', async function() {
+      await assertInvalidArgumentError(() => driver.setDownloadPath());
+      await assertInvalidArgumentError(() => driver.setDownloadPath(null));
+      await assertInvalidArgumentError(() => driver.setDownloadPath(''));
+      await assertInvalidArgumentError(() => driver.setDownloadPath(1234));
+
+      const file = await io.tmpFile();
+      await assertInvalidArgumentError(() => driver.setDownloadPath(file));
+
+      async function assertInvalidArgumentError(fn) {
+        try {
+          await fn();
+          return Promise.reject(Error('should have failed'));
+        } catch (err) {
+          if (err instanceof error.InvalidArgumentError) {
+            return;
+          }
+          throw err;
+        }
+      }
+    });
+  });
+}, {browsers: ['chrome']});

package/test/chrome/options_test.js

@@ -17,186 +17,80 @@
 
 'use strict';
 
-var fs = require('fs');
+const assert = require('assert');
+const fs = require('fs');
 
-var webdriver = require('../..'),
-    chrome = require('../../chrome'),
-    symbols = require('../../lib/symbols'),
-    proxy = require('../../proxy'),
-    assert = require('../../testing/assert');
-
-var test = require('../../lib/test');
+const chrome = require('../../chrome');
+const proxy = require('../../proxy');
+const symbols = require('../../lib/symbols');
+const test = require('../../lib/test');
+const webdriver = require('../..');
 
 
 describe('chrome.Options', function() {
-  describe('fromCapabilities', function() {
-
-    it('should return a new Options instance if none were defined',
-       function() {
-         var options = chrome.Options.fromCapabilities(
-             new webdriver.Capabilities());
-         assert(options).instanceOf(chrome.Options);
-       });
-
-    it('should return options instance if present', function() {
-      var options = new chrome.Options();
-      var caps = options.toCapabilities();
-      assert(caps).instanceOf(webdriver.Capabilities);
-      assert(chrome.Options.fromCapabilities(caps)).equalTo(options);
-    });
-
-    it('should rebuild options from wire representation', function() {
-      var expectedExtension = fs.readFileSync(__filename, 'base64');
-      var caps = webdriver.Capabilities.chrome().set('chromeOptions', {
-        args: ['a', 'b'],
-        extensions: [__filename],
-        binary: 'binaryPath',
-        logPath: 'logFilePath',
-        detach: true,
-        localState: 'localStateValue',
-        prefs: 'prefsValue'
-      });
-
-      var options = chrome.Options.fromCapabilities(caps);
-      var json = options[symbols.serialize]();
-
-      assert(json.args.length).equalTo(2);
-      assert(json.args[0]).equalTo('a');
-      assert(json.args[1]).equalTo('b');
-      assert(json.extensions.length).equalTo(1);
-      assert(json.extensions[0]).equalTo(expectedExtension);
-      assert(json.binary).equalTo('binaryPath');
-      assert(json.logPath).equalTo('logFilePath');
-      assert(json.detach).equalTo(true);
-      assert(json.localState).equalTo('localStateValue');
-      assert(json.prefs).equalTo('prefsValue');
-    });
-
-    it('should rebuild options from incomplete wire representation',
-        function() {
-          var caps = webdriver.Capabilities.chrome().set('chromeOptions', {
-            logPath: 'logFilePath'
-          });
-
-          var options = chrome.Options.fromCapabilities(caps);
-          var json = options[symbols.serialize]();
-          assert(json.args).isUndefined();
-          assert(json.binary).isUndefined();
-          assert(json.detach).isUndefined();
-          assert(json.excludeSwitches).isUndefined();
-          assert(json.extensions).isUndefined();
-          assert(json.localState).isUndefined();
-          assert(json.logPath).equalTo('logFilePath');
-          assert(json.prefs).isUndefined();
-          assert(json.minidumpPath).isUndefined();
-          assert(json.mobileEmulation).isUndefined();
-          assert(json.perfLoggingPrefs).isUndefined();
-        });
-
-    it('should extract supported WebDriver capabilities', function() {
-      var proxyPrefs = proxy.direct();
-      var logPrefs = {};
-      var caps = webdriver.Capabilities.chrome().
-          set(webdriver.Capability.PROXY, proxyPrefs).
-          set(webdriver.Capability.LOGGING_PREFS, logPrefs);
-
-      var options = chrome.Options.fromCapabilities(caps);
-      assert(options.proxy_).equalTo(proxyPrefs);
-      assert(options.logPrefs_).equalTo(logPrefs);
-    });
-  });
-
   describe('addArguments', function() {
     it('takes var_args', function() {
-      var options = new chrome.Options();
-      assert(options[symbols.serialize]().args).isUndefined();
+      let options = new chrome.Options();
+      assert.deepEqual(
+          options[symbols.serialize](),
+          {browserName: 'chrome', chromeOptions: {}});
 
       options.addArguments('a', 'b');
-      var json = options[symbols.serialize]();
-      assert(json.args.length).equalTo(2);
-      assert(json.args[0]).equalTo('a');
-      assert(json.args[1]).equalTo('b');
+      assert.deepEqual(
+          options[symbols.serialize](),
+          {
+            browserName: 'chrome',
+            chromeOptions: {
+              args: ['a', 'b']
+            }
+          });
     });
 
     it('flattens input arrays', function() {
-      var options = new chrome.Options();
-      assert(options[symbols.serialize]().args).isUndefined();
+      let options = new chrome.Options();
+      assert.deepEqual(
+          options[symbols.serialize](),
+          {browserName: 'chrome', chromeOptions: {}});
 
       options.addArguments(['a', 'b'], 'c', [1, 2], 3);
-      var json = options[symbols.serialize]();
-      assert(json.args.length).equalTo(6);
-      assert(json.args[0]).equalTo('a');
-      assert(json.args[1]).equalTo('b');
-      assert(json.args[2]).equalTo('c');
-      assert(json.args[3]).equalTo(1);
-      assert(json.args[4]).equalTo(2);
-      assert(json.args[5]).equalTo(3);
+      assert.deepEqual(
+          options[symbols.serialize](),
+          {
+            browserName: 'chrome',
+            chromeOptions: {
+              args: ['a', 'b', 'c', 1, 2, 3]
+            }
+          });
     });
   });
 
   describe('addExtensions', function() {
     it('takes var_args', function() {
-      var options = new chrome.Options();
-      assert(options.extensions_.length).equalTo(0);
+      let options = new chrome.Options();
+      assert.strictEqual(options.options_.extensions, undefined);
 
       options.addExtensions('a', 'b');
-      assert(options.extensions_.length).equalTo(2);
-      assert(options.extensions_[0]).equalTo('a');
-      assert(options.extensions_[1]).equalTo('b');
+      assert.deepEqual(options.options_.extensions, ['a', 'b']);
     });
 
     it('flattens input arrays', function() {
-      var options = new chrome.Options();
-      assert(options.extensions_.length).equalTo(0);
+      let options = new chrome.Options();
+      assert.strictEqual(options.options_.extensions, undefined);
 
       options.addExtensions(['a', 'b'], 'c', [1, 2], 3);
-      assert(options.extensions_.length).equalTo(6);
-      assert(options.extensions_[0]).equalTo('a');
-      assert(options.extensions_[1]).equalTo('b');
-      assert(options.extensions_[2]).equalTo('c');
-      assert(options.extensions_[3]).equalTo(1);
-      assert(options.extensions_[4]).equalTo(2);
-      assert(options.extensions_[5]).equalTo(3);
+      assert.deepEqual(options.options_.extensions, ['a', 'b', 'c', 1, 2, 3]);
     });
   });
 
   describe('serialize', function() {
-    it('base64 encodes extensions', function() {
-      var expected = fs.readFileSync(__filename, 'base64');
-      var wire = new chrome.Options()
+    it('base64 encodes extensions', async function() {
+      let expected = fs.readFileSync(__filename, 'base64');
+      let wire = new chrome.Options()
           .addExtensions(__filename)
           [symbols.serialize]();
-      assert(wire.extensions.length).equalTo(1);
-      assert(wire.extensions[0]).equalTo(expected);
-    });
-  });
-
-  describe('toCapabilities', function() {
-    it('returns a new capabilities object if one is not provided', function() {
-      var options = new chrome.Options();
-      var caps = options.toCapabilities();
-      assert(caps.get('browserName')).equalTo('chrome');
-      assert(caps.get('chromeOptions')).equalTo(options);
-    });
-
-    it('adds to input capabilities object', function() {
-      var caps = webdriver.Capabilities.firefox();
-      var options = new chrome.Options();
-      assert(options.toCapabilities(caps)).equalTo(caps);
-      assert(caps.get('browserName')).equalTo('firefox');
-      assert(caps.get('chromeOptions')).equalTo(options);
-    });
-
-    it('sets generic driver capabilities', function() {
-      var proxyPrefs = {};
-      var loggingPrefs = {};
-      var options = new chrome.Options().
-          setLoggingPrefs(loggingPrefs).
-          setProxy(proxyPrefs);
 
-      var caps = options.toCapabilities();
-      assert(caps.get('proxy')).equalTo(proxyPrefs);
-      assert(caps.get('loggingPrefs')).equalTo(loggingPrefs);
+      assert.equal(wire.chromeOptions.extensions.length, 1);
+      assert.equal(await wire.chromeOptions.extensions[0], expected);
     });
   });
 });
@@ -204,24 +98,24 @@ describe('chrome.Options', function() {
 test.suite(function(env) {
   var driver;
 
-  test.afterEach(function() {
+  afterEach(function() {
     return driver.quit();
   });
 
   describe('Chrome options', function() {
-    test.it('can start Chrome with custom args', function*() {
+    it('can start Chrome with custom args', async function() {
       var options = new chrome.Options().
           addArguments('user-agent=foo;bar');
 
-      driver = yield env.builder()
+      driver = await env.builder()
           .setChromeOptions(options)
           .build();
 
-      yield driver.get(test.Pages.ajaxyPage);
+      await driver.get(test.Pages.ajaxyPage);
 
       var userAgent =
-          yield driver.executeScript('return window.navigator.userAgent');
-      assert(userAgent).equalTo('foo;bar');
+          await driver.executeScript('return window.navigator.userAgent');
+      assert.equal(userAgent, 'foo;bar');
     });
   });
 }, {browsers: ['chrome']});