selenium-webdriver 3.6.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/{session_test.js → builder_test.js}

@@ -17,51 +17,52 @@
 
 'use strict';
 
-const assert = require('../testing/assert');
+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 opera = require('../opera');
-const phantomjs = require('../phantomjs');
 const safari = require('../safari');
 const test = require('../lib/test');
 const {Browser} = require('../lib/capabilities');
 const {Pages} = require('../lib/test');
-const {WebDriver} = require('..');
+const {Builder, Capabilities, WebDriver} = require('..');
 
 
 test.suite(function(env) {
-  var browsers = env.browsers;
+  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.OPERA, opera.Driver],
-    [Browser.PHANTOM_JS, phantomjs.Driver],
     [Browser.SAFARI, safari.Driver],
   ]);
 
-  if (BROWSER_MAP.has(env.currentBrowser())) {
+  if (BROWSER_MAP.has(env.browser.name)) {
     describe('builder creates thenable driver instances', function() {
       let driver;
 
       after(() => driver && driver.quit());
 
-      it(env.currentBrowser(), function() {
+      it(env.browser.name, function() {
         driver = env.builder().build();
 
-        const want = BROWSER_MAP.get(env.currentBrowser());
-        assert(driver).instanceOf(want,
+        const want = BROWSER_MAP.get(env.browser.name);
+        assert.ok(
+            driver instanceof want,
             `want ${want.name}, but got ${driver.name}`);
-        assert(typeof driver.then).equalTo('function');
+        assert.equal(typeof driver.then, 'function');
 
         return driver
             .then(
-                d => assert(d)
-                    .instanceOf(want, `want ${want.name}, but got ${d.name}`))
+                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));
@@ -69,31 +70,37 @@ test.suite(function(env) {
     });
   }
 
-  describe('session management', function() {
-    var driver;
-    test.before(function*() {
-      driver = yield env.builder().build();
-    });
-
-    test.after(function() {
-      return driver.quit();
-    });
-
-    test.it('can connect to an existing session', function*() {
-      yield driver.get(Pages.simpleTestPage);
-      yield assert(driver.getTitle()).equalTo('Hello WebDriver');
+  class OptionsTest {
+    constructor(ctor, key) {
+      this.ctor = ctor;
+      this.key = key;
+    }
+  }
 
-      return driver.getSession().then(session1 => {
-        let driver2 = WebDriver.attachToSession(
-            driver.getExecutor(),
-            session1.getId());
+});
 
-        return assert(driver2.getTitle()).equalTo('Hello WebDriver')
-            .then(_ => {
-              let session2Id = driver2.getSession().then(s => s.getId());
-              return assert(session2Id).equalTo(session1.getId());
-            });
+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']});