selenium-webdriver 3.3.0 → 4.0.0-alpha.1

package/test/execute_script_test.js

@@ -17,226 +17,227 @@
 
 'use strict';
 
-var fail = require('assert').fail;
+const assert = require('assert');
+const {fail} = require('assert');
 
-var webdriver = require('..'),
-    Browser = webdriver.Browser,
-    By = webdriver.By,
-    assert = require('../testing/assert'),
-    test = require('../lib/test');
+const {Browser, By, WebElement} = require('..');
+const {Pages, ignore, suite} = require('../lib/test');
 
 
-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();
   });
 
-  test.beforeEach(function() {
-    return driver.get(test.Pages.echoPage);
+  beforeEach(function() {
+    return driver.get(Pages.echoPage);
   });
 
   describe('executeScript;', function() {
     var shouldHaveFailed = new Error('Should have failed');
 
-    test.it('fails if script throws', function() {
+    it('fails if script throws', function() {
       return execute('throw new Error("boom")')
           .then(function() { throw shouldHaveFailed; })
           .catch(function(e) {
             // The java WebDriver server adds a bunch of crap to error messages.
             // Error message will just be "JavaScript error" for IE.
-            assert(e.message).matches(/.*(JavaScript error|boom).*/);
+            assert.ok(
+                /.*(JavaScript error|boom).*/.test(e.message),
+                `Unexpected error: ${e.message}`);
           });
     });
 
-    test.it('fails if script does not parse', function() {
+    it('fails if script does not parse', function() {
       return execute('throw function\\*')
           .then(function() { throw shouldHaveFailed; })
           .catch(function(e) {
-            assert(e).notEqualTo(shouldHaveFailed);
+            assert.notEqual(e, shouldHaveFailed);
           });
     });
 
     describe('scripts;', function() {
-      test.it('do not pollute the global scope', function*() {
-        yield execute('var x = 1;');
-        yield assert(execute('return typeof x;')).equalTo('undefined');
+      it('do not pollute the global scope', async function() {
+        await execute('var x = 1;');
+        assert.equal(await execute('return typeof x;'), 'undefined');
       });
 
-      test.it('can set global variables', function*() {
-        yield execute('window.x = 1234;');
-        yield assert(execute('return x;')).equalTo(1234);
+      it('can set global variables', async function() {
+        await execute('window.x = 1234;');
+        assert.equal(await execute('return x;'), 1234);
       });
 
-      test.it('may be defined as a function expression', function*() {
-        let result = yield execute(function() {
+      it('may be defined as a function expression', async function() {
+        let result = await execute(function() {
           return 1234 + 'abc';
         });
-        assert(result).equalTo('1234abc');
+        assert.equal(result, '1234abc');
       });
     });
 
     describe('return values;', function() {
 
-      test.it('returns undefined as null', function() {
-        return assert(execute('var x; return x;')).isNull();
+      it('returns undefined as null', async function() {
+        assert.strictEqual(await execute('var x; return x;'), null);
       });
 
-      test.it('can return null', function() {
-        return assert(execute('return null;')).isNull();
+      it('can return null', async function() {
+        assert.strictEqual(await execute('return null;'), null);
       });
 
-      test.it('can return numbers', function*() {
-        yield assert(execute('return 1234')).equalTo(1234);
-        yield assert(execute('return 3.1456')).equalTo(3.1456);
+      it('can return numbers', async function() {
+        assert.equal(await execute('return 1234'), 1234);
+        assert.equal(await execute('return 3.1456'), 3.1456);
       });
 
-      test.it('can return strings', function() {
-        return assert(execute('return "hello"')).equalTo('hello');
+      it('can return strings', async function() {
+        assert.equal(await execute('return "hello"'), 'hello');
       });
 
-      test.it('can return booleans', function*() {
-        yield assert(execute('return true')).equalTo(true);
-        yield assert(execute('return false')).equalTo(false);
+      it('can return booleans', async function() {
+        assert.equal(await execute('return true'), true);
+        assert.equal(await execute('return false'), false);
       });
 
-      test.it('can return an array of primitives', function() {
+      it('can return an array of primitives', function() {
         return execute('var x; return [1, false, null, 3.14, x]')
             .then(verifyJson([1, false, null, 3.14, null]));
       });
 
-      test.it('can return nested arrays', function() {
+      it('can return nested arrays', function() {
         return execute('return [[1, 2, [3]]]').then(verifyJson([[1, 2, [3]]]));
       });
 
-      test.ignore(env.browsers(Browser.IE)).
+      ignore(env.browsers(Browser.IE)).
       it('can return empty object literal', function() {
         return execute('return {}').then(verifyJson({}));
       });
 
-      test.it('can return object literals', function() {
+      it('can return object literals', function() {
         return execute('return {a: 1, b: false, c: null}').then(result => {
           verifyJson(['a', 'b', 'c'])(Object.keys(result).sort());
-          assert(result.a).equalTo(1);
-          assert(result.b).equalTo(false);
-          assert(result.c).isNull();
+          assert.equal(result.a, 1);
+          assert.equal(result.b, false);
+          assert.strictEqual(result.c, null);
         });
       });
 
-      test.it('can return complex object literals', function() {
+      it('can return complex object literals', function() {
         return execute('return {a:{b: "hello"}}')
             .then(verifyJson({a:{b: 'hello'}}));
       });
 
-      test.it('can return dom elements as web elements', function*() {
+      it('can return dom elements as web elements', async function() {
         let result =
-            yield execute('return document.querySelector(".header.host")');
-        assert(result).instanceOf(webdriver.WebElement);
+            await execute('return document.querySelector(".header.host")');
+        assert.ok(result instanceof WebElement);
 
-        return assert(result.getText()).startsWith('host: ');
+        let text = await result.getText();
+        assert.ok(text.startsWith('host: '), `got: ${text}`);
       });
 
-      test.it('can return array of dom elements', function*() {
-        let result = yield execute(
+      it('can return array of dom elements', async function() {
+        let result = await execute(
             'var nodes = document.querySelectorAll(".request,.host");' +
             'return [nodes[0], nodes[1]];');
-        assert(result.length).equalTo(2);
+        assert.equal(result.length, 2);
 
-        assert(result[0]).instanceOf(webdriver.WebElement);
-        yield assert(result[0].getText()).startsWith('GET ');
+        assert.ok(result[0] instanceof WebElement);
+        assert.ok((await result[0].getText()).startsWith('GET '));;
 
-        assert(result[1]).instanceOf(webdriver.WebElement);
-        yield assert(result[1].getText()).startsWith('host: ');
+        assert.ok(result[1] instanceof WebElement);
+        assert.ok((await result[1].getText()).startsWith('host: '));;
       });
 
-      test.it('can return a NodeList as an array of web elements', function*() {
+      it('can return a NodeList as an array of web elements', async function() {
         let result =
-            yield execute('return document.querySelectorAll(".request,.host");')
+            await execute('return document.querySelectorAll(".request,.host");')
 
-        assert(result.length).equalTo(2);
+        assert.equal(result.length, 2);
 
-        assert(result[0]).instanceOf(webdriver.WebElement);
-        yield assert(result[0].getText()).startsWith('GET ');
+        assert.ok(result[0] instanceof WebElement);
+        assert.ok((await result[0].getText()).startsWith('GET '));;
 
-        assert(result[1]).instanceOf(webdriver.WebElement);
-        yield assert(result[1].getText()).startsWith('host: ');
+        assert.ok(result[1] instanceof WebElement);
+        assert.ok((await result[1].getText()).startsWith('host: '));;
       });
 
-      test.it('can return object literal with element property', function*() {
-        let result = yield execute('return {a: document.body}');
+      it('can return object literal with element property', async function() {
+        let result = await execute('return {a: document.body}');
 
-        assert(result.a).instanceOf(webdriver.WebElement);
-        yield assert(result.a.getTagName()).equalTo('body');
+        assert.ok(result.a instanceof WebElement);
+        assert.equal(await result.a.getTagName(), 'body');
       });
     });
 
     describe('parameters;', function() {
-      test.it('can pass numeric arguments', function*() {
-        yield assert(execute('return arguments[0]', 12)).equalTo(12);
-        yield assert(execute('return arguments[0]', 3.14)).equalTo(3.14);
+      it('can pass numeric arguments', async function() {
+        assert.equal(await execute('return arguments[0]', 12), 12);
+        assert.equal(await execute('return arguments[0]', 3.14), 3.14);
       });
 
-      test.it('can pass boolean arguments', function*() {
-        yield assert(execute('return arguments[0]', true)).equalTo(true);
-        yield assert(execute('return arguments[0]', false)).equalTo(false);
+      it('can pass boolean arguments', async function() {
+        assert.equal(await execute('return arguments[0]', true), true);
+        assert.equal(await execute('return arguments[0]', false), false);
       });
 
-      test.it('can pass string arguments', function*() {
-        yield assert(execute('return arguments[0]', 'hi')).equalTo('hi');
+      it('can pass string arguments', async function() {
+        assert.equal(await execute('return arguments[0]', 'hi'), 'hi');
       });
 
-      test.it('can pass null arguments', function*() {
-        yield assert(execute('return arguments[0] === null', null)).equalTo(true);
-        yield assert(execute('return arguments[0]', null)).equalTo(null);
+      it('can pass null arguments', async function() {
+        assert.equal(await execute('return arguments[0] === null', null), true);
+        assert.equal(await execute('return arguments[0]', null), null);
       });
 
-      test.it('passes undefined as a null argument', function*() {
+      it('passes undefined as a null argument', async function() {
         var x;
-        yield assert(execute('return arguments[0] === null', x)).equalTo(true);
-        yield assert(execute('return arguments[0]', x)).equalTo(null);
+        assert.equal(await execute('return arguments[0] === null', x), true);
+        assert.equal(await execute('return arguments[0]', x), null);
       });
 
-      test.it('can pass multiple arguments', function*() {
-        yield assert(execute('return arguments.length')).equalTo(0);
-        yield assert(execute('return arguments.length', 1, 'a', false)).equalTo(3);
+      it('can pass multiple arguments', async function() {
+        assert.equal(await execute('return arguments.length'), 0);
+        assert.equal(await execute('return arguments.length', 1, 'a', false), 3);
       });
 
-      test.ignore(env.browsers(Browser.FIREFOX, Browser.SAFARI)).
-      it('can return arguments object as array', function*() {
-        let val = yield execute('return arguments', 1, 'a', false);
+      ignore(env.browsers(Browser.FIREFOX, Browser.SAFARI)).
+      it('can return arguments object as array', async function() {
+        let val = await execute('return arguments', 1, 'a', false);
 
-        assert(val.length).equalTo(3);
-        assert(val[0]).equalTo(1);
-        assert(val[1]).equalTo('a');
-        assert(val[2]).equalTo(false);
+        assert.equal(val.length, 3);
+        assert.equal(val[0], 1);
+        assert.equal(val[1], 'a');
+        assert.equal(val[2], false);
       });
 
-      test.it('can pass object literal', function*() {
-        let result = yield execute(
+      it('can pass object literal', async function() {
+        let result = await execute(
             'return [typeof arguments[0], arguments[0].a]', {a: 'hello'})
-        assert(result[0]).equalTo('object');
-        assert(result[1]).equalTo('hello');
+        assert.equal(result[0], 'object');
+        assert.equal(result[1], 'hello');
       });
 
-      test.it('WebElement arguments are passed as DOM elements', function*() {
-        let el = yield driver.findElement(By.tagName('div'));
+      it('WebElement arguments are passed as DOM elements', async function() {
+        let el = await driver.findElement(By.tagName('div'));
         let result =
-            yield execute('return arguments[0].tagName.toLowerCase();', el);
-        assert(result).equalTo('div');
+            await execute('return arguments[0].tagName.toLowerCase();', el);
+        assert.equal(result, 'div');
       });
 
-      test.it('can pass array containing object literals', function*() {
-        let result = yield execute('return arguments[0]', [{color: "red"}]);
-        assert(result.length).equalTo(1);
-        assert(result[0].color).equalTo('red');
+      it('can pass array containing object literals', async function() {
+        let result = await execute('return arguments[0]', [{color: "red"}]);
+        assert.equal(result.length, 1);
+        assert.equal(result[0].color, 'red');
       });
 
-      test.it('does not modify object literal parameters', function() {
+      it('does not modify object literal parameters', function() {
         var input = {color: 'red'};
         return execute('return arguments[0];', input).then(verifyJson(input));
       });
@@ -245,7 +246,7 @@ test.suite(function(env) {
     // See https://code.google.com/p/selenium/issues/detail?id=8223.
     describe('issue 8223;', function() {
       describe('using for..in loops;', function() {
-        test.it('can return array built from for-loop index', function() {
+        it('can return array built from for-loop index', function() {
           return execute(function() {
             var ret = [];
             for (var i = 0; i < 3; i++) {
@@ -255,7 +256,7 @@ test.suite(function(env) {
           }).then(verifyJson[0, 1, 2]);
         });
 
-        test.it('can copy input array contents', function() {
+        it('can copy input array contents', function() {
           return execute(function(input) {
             var ret = [];
             for (var i in input) {
@@ -265,7 +266,7 @@ test.suite(function(env) {
           }, ['fa', 'fe', 'fi']).then(verifyJson(['fa', 'fe', 'fi']));
         });
 
-        test.it('can iterate over input object keys', function() {
+        it('can iterate over input object keys', function() {
           return execute(function(thing) {
             var ret = [];
             for (var w in thing.words) {
@@ -277,7 +278,7 @@ test.suite(function(env) {
         });
 
         describe('recursive functions;', function() {
-          test.it('can build array from input', function() {
+          it('can build array from input', function() {
             var input = ['fa', 'fe', 'fi'];
             return execute(function(thearray) {
               var ret = [];
@@ -290,7 +291,7 @@ test.suite(function(env) {
             }, input).then(verifyJson(input));
           });
 
-          test.it('can build array from elements in object', function() {
+          it('can build array from elements in object', function() {
             var input = {words: [{word: 'fa'}, {word: 'fe'}, {word: 'fi'}]};
             return execute(function(thing) {
               var ret = [];
@@ -313,19 +314,19 @@ test.suite(function(env) {
       var TOO_LONG_WAIT = TIMEOUT_IN_MS * 10;
 
       before(function() {
-        return driver.manage().timeouts().setScriptTimeout(TIMEOUT_IN_MS)
+        return driver.manage().setTimeouts({script: TIMEOUT_IN_MS});
       });
 
-      test.it('does not fail if script execute in time', function() {
+      it('does not fail if script execute in time', function() {
         return executeTimeOutScript(ACCEPTABLE_WAIT);
       });
 
-      test.it('fails if script took too long', function() {
+      it('fails if script took too long', function() {
         return executeTimeOutScript(TOO_LONG_WAIT)
           .then(function() {
             fail('it should have timed out');
           }).catch(function(e) {
-            assert(e.name).equalTo('ScriptTimeoutError');
+            assert.equal(e.name, 'ScriptTimeoutError');
           });
       });
 
@@ -340,7 +341,7 @@ test.suite(function(env) {
 
   function verifyJson(expected) {
     return function(actual) {
-      return assert(JSON.stringify(actual)).equalTo(JSON.stringify(expected));
+      assert.equal(JSON.stringify(actual), JSON.stringify(expected));
     };
   }
 

package/test/fingerprint_test.js

@@ -17,9 +17,10 @@
 
 'use strict';
 
-var assert = require('../testing/assert'),
-    test = require('../lib/test'),
-    Pages = test.Pages;
+const assert = require('assert');
+
+const test = require('../lib/test');
+const Pages = test.Pages;
 
 
 test.suite(function(env) {
@@ -35,26 +36,26 @@ test.suite(function(env) {
   });
 
   describe('fingerprinting', function() {
-    test.it('it should fingerprint the navigator object', function*() {
-      yield driver.get(Pages.simpleTestPage);
+    test.it('it should fingerprint the navigator object', async function() {
+      await driver.get(Pages.simpleTestPage);
 
-      let wd = yield driver.executeScript('return navigator.webdriver');
-      assert(wd).equalTo(true);
+      let wd = await driver.executeScript('return navigator.webdriver');
+      assert.strictEqual(wd, true);
     });
 
-    test.it('fingerprint must not be writable', function*() {
-      yield driver.get(Pages.simpleTestPage);
+    test.it('fingerprint must not be writable', async function() {
+      await driver.get(Pages.simpleTestPage);
 
-      let wd = yield driver.executeScript(
+      let wd = await driver.executeScript(
           'navigator.webdriver = "ohai"; return navigator.webdriver');
-      assert(wd).equalTo(true);
+      assert.strictEqual(wd, true);
     });
 
-    test.it('leaves fingerprint on svg pages', function*() {
-      yield driver.get(Pages.svgPage);
+    test.it('leaves fingerprint on svg pages', async function() {
+      await driver.get(Pages.svgPage);
 
-      let wd = yield driver.executeScript('return navigator.webdriver');
-      assert(wd).equalTo(true);
+      let wd = await driver.executeScript('return navigator.webdriver');
+      assert.strictEqual(wd, true);
     });
   });