selenium-webdriver 3.6.0 → 4.0.0-alpha.1

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']});

package/test/chrome/service_test.js

@@ -17,28 +17,28 @@
 
 'use strict';
 
-var webdriver = require('../..'),
-    chrome = require('../../chrome'),
-    assert = require('../../testing/assert');
+const assert = require('assert');
 
-var test = require('../../lib/test');
+const chrome = require('../../chrome');
+const test = require('../../lib/test');
+const webdriver = require('../..');
 
 
 test.suite(function(env) {
   describe('chromedriver', function() {
     var service;
-    test.afterEach(function() {
+    afterEach(function() {
       if (service) {
         return service.kill();
       }
     });
 
-    test.it('can be started on a custom path', function() {
+    it('can be started on a custom path', function() {
       service = new chrome.ServiceBuilder()
           .setPath('/foo/bar/baz')
           .build();
       return service.start().then(function(url) {
-        assert(url).endsWith('/foo/bar/baz');
+        assert.ok(url.endsWith('/foo/bar/baz'), 'unexpected url: ' + url);
       });
     });
   });

package/test/cookie_test.js

@@ -20,157 +20,171 @@
 var assert = require('assert'),
     url = require('url');
 
-var test = require('../lib/test'),
+var {Pages, ignore, suite} = require('../lib/test'),
     fileserver = require('../lib/test/fileserver'),
-    Browser = require('..').Browser,
-    Pages = test.Pages;
+    {Browser} = require('..');
 
 
-test.suite(function(env) {
+suite(function(env) {
   var driver;
 
-  test.before(function*() {
-    driver = yield env.builder().build();
+  before(async function() {
+    driver = await env.builder().build();
   });
 
-  test.after(function() {
+  after(function() {
     return driver.quit();
   });
 
-  // Cookie handling is broken.
-  test.ignore(env.browsers(Browser.PHANTOM_JS, Browser.SAFARI)).
   describe('Cookie Management;', function() {
 
-    test.beforeEach(function*() {
-      yield driver.get(fileserver.Pages.ajaxyPage);
-      yield driver.manage().deleteAllCookies();
+    beforeEach(async function() {
+      await driver.get(fileserver.Pages.ajaxyPage);
+      await driver.manage().deleteAllCookies();
       return assertHasCookies();
     });
 
-    test.it('can add new cookies', function*() {
+    it('can add new cookies', async function() {
       var cookie = createCookieSpec();
 
-      yield driver.manage().addCookie(cookie);
-      yield driver.manage().getCookie(cookie.name).then(function(actual) {
+      await driver.manage().addCookie(cookie);
+      await driver.manage().getCookie(cookie.name).then(function(actual) {
         assert.equal(actual.value, cookie.value);
       });
     });
 
-    test.it('can get all cookies', function*() {
+    it('can get all cookies', async function() {
       var cookie1 = createCookieSpec();
       var cookie2 = createCookieSpec();
 
-      yield driver.manage().addCookie(cookie1);
-      yield driver.manage().addCookie(cookie2);
+      await driver.manage().addCookie(cookie1);
+      await driver.manage().addCookie(cookie2);
 
       return assertHasCookies(cookie1, cookie2);
     });
 
-    test.ignore(env.browsers(Browser.IE)).
-    it('only returns cookies visible to the current page', function*() {
+    ignore(env.browsers(Browser.IE)).
+    it('only returns cookies visible to the current page', async function() {
       var cookie1 = createCookieSpec();
 
-      yield driver.manage().addCookie(cookie1);
+      await driver.manage().addCookie(cookie1);
 
       var pageUrl = fileserver.whereIs('page/1');
       var cookie2 = createCookieSpec({
         path: url.parse(pageUrl).pathname
       });
-      yield driver.get(pageUrl);
-      yield driver.manage().addCookie(cookie2);
-      yield assertHasCookies(cookie1, cookie2);
+      await driver.get(pageUrl);
+      await driver.manage().addCookie(cookie2);
+      await assertHasCookies(cookie1, cookie2);
 
-      yield driver.get(fileserver.Pages.ajaxyPage);
-      yield assertHasCookies(cookie1);
+      await driver.get(fileserver.Pages.ajaxyPage);
+      await assertHasCookies(cookie1);
 
-      yield driver.get(pageUrl);
-      yield assertHasCookies(cookie1, cookie2);
+      await driver.get(pageUrl);
+      await assertHasCookies(cookie1, cookie2);
     });
 
-    test.it('can delete all cookies', function*() {
+    it('can delete all cookies', async function() {
       var cookie1 = createCookieSpec();
       var cookie2 = createCookieSpec();
 
-      yield driver.executeScript(
+      await driver.executeScript(
           'document.cookie = arguments[0] + "=" + arguments[1];' +
           'document.cookie = arguments[2] + "=" + arguments[3];',
           cookie1.name, cookie1.value, cookie2.name, cookie2.value);
-      yield assertHasCookies(cookie1, cookie2);
+      await assertHasCookies(cookie1, cookie2);
 
-      yield driver.manage().deleteAllCookies();
-      yield assertHasCookies();
+      await driver.manage().deleteAllCookies();
+      await assertHasCookies();
     });
 
-    test.it('can delete cookies by name', function*() {
+    it('can delete cookies by name', async function() {
       var cookie1 = createCookieSpec();
       var cookie2 = createCookieSpec();
 
-      yield driver.executeScript(
+      await driver.executeScript(
           'document.cookie = arguments[0] + "=" + arguments[1];' +
           'document.cookie = arguments[2] + "=" + arguments[3];',
           cookie1.name, cookie1.value, cookie2.name, cookie2.value);
-      yield assertHasCookies(cookie1, cookie2);
+      await assertHasCookies(cookie1, cookie2);
 
-      yield driver.manage().deleteCookie(cookie1.name);
-      yield assertHasCookies(cookie2);
+      await driver.manage().deleteCookie(cookie1.name);
+      await assertHasCookies(cookie2);
     });
 
-    test.it('should only delete cookie with exact name', function*() {
+    it('should only delete cookie with exact name', async function() {
       var cookie1 = createCookieSpec();
       var cookie2 = createCookieSpec();
       var cookie3 = {name: cookie1.name + 'xx', value: cookie1.value};
 
-      yield driver.executeScript(
+      await driver.executeScript(
           'document.cookie = arguments[0] + "=" + arguments[1];' +
           'document.cookie = arguments[2] + "=" + arguments[3];' +
           'document.cookie = arguments[4] + "=" + arguments[5];',
           cookie1.name, cookie1.value, cookie2.name, cookie2.value,
           cookie3.name, cookie3.value);
-      yield assertHasCookies(cookie1, cookie2, cookie3);
+      await assertHasCookies(cookie1, cookie2, cookie3);
 
-      yield driver.manage().deleteCookie(cookie1.name);
-      yield assertHasCookies(cookie2, cookie3);
+      await driver.manage().deleteCookie(cookie1.name);
+      await assertHasCookies(cookie2, cookie3);
     });
 
-    test.it('can delete cookies set higher in the path', function*() {
+    it('can delete cookies set higher in the path', async function() {
       var cookie = createCookieSpec();
       var childUrl = fileserver.whereIs('child/childPage.html');
       var grandchildUrl = fileserver.whereIs(
           'child/grandchild/grandchildPage.html');
 
-      yield driver.get(childUrl);
-      yield driver.manage().addCookie(cookie);
-      yield assertHasCookies(cookie);
+      await driver.get(childUrl);
+      await driver.manage().addCookie(cookie);
+      await assertHasCookies(cookie);
 
-      yield driver.get(grandchildUrl);
-      yield assertHasCookies(cookie);
+      await driver.get(grandchildUrl);
+      await assertHasCookies(cookie);
 
-      yield driver.manage().deleteCookie(cookie.name);
-      yield assertHasCookies();
+      await driver.manage().deleteCookie(cookie.name);
+      await assertHasCookies();
 
-      yield driver.get(childUrl);
-      yield assertHasCookies();
+      await driver.get(childUrl);
+      await assertHasCookies();
     });
 
-    test.ignore(env.browsers(
-        Browser.ANDROID,
+    ignore(env.browsers(
         Browser.FIREFOX,
-        'legacy-' + Browser.FIREFOX,
         Browser.IE)).
-    it('should retain cookie expiry', function*() {
+    it('should retain cookie expiry', async function() {
       let expirationDelay = 5 * 1000;
       let expiry = new Date(Date.now() + expirationDelay);
       let cookie = createCookieSpec({expiry});
 
-      yield driver.manage().addCookie(cookie);
-      yield driver.manage().getCookie(cookie.name).then(function(actual) {
+      await driver.manage().addCookie(cookie);
+      await driver.manage().getCookie(cookie.name).then(function(actual) {
         assert.equal(actual.value, cookie.value);
-        // expiry times are exchanged in seconds since January 1, 1970 UTC.
-        assert.equal(actual.expiry, Math.floor(expiry.getTime() / 1000));
+
+        // expiry times should be in seconds since January 1, 1970 UTC
+        try {
+          assert.equal(actual.expiry, Math.floor(expiry.getTime() / 1000));
+          assert.notEqual(
+              env.browser.name, Browser.SAFARI,
+              'Safari cookie expiry fixed; update test');
+        } catch (ex) {
+          if (env.browser.name !== Browser.SAFARI
+              || !(ex instanceof assert.AssertionError)) {
+            throw ex;
+          }
+
+          // Safari returns milliseconds (and is off by a few seconds...)
+          let diff = Math.abs(actual.expiry - expiry.getTime());
+          if (diff > 2000) {
+            assert.fail(
+                actual.expiry, expiry.getTime(),
+                'Expect Safari to return expiry in millis since epoch ± 2s');
+          }
+        }
       });
 
-      yield driver.sleep(expirationDelay);
-      yield assertHasCookies();
+      await driver.sleep(expirationDelay);
+      await assertHasCookies();
     });
   });