selenium-webdriver 3.0.0-beta-1 → 3.0.1

package/test/execute_script_test.js

@@ -17,7 +17,6 @@
 
 'use strict';
 
-var path = require('path');
 var fail = require('assert').fail;
 
 var webdriver = require('..'),
@@ -30,24 +29,24 @@ var webdriver = require('..'),
 test.suite(function(env) {
   var driver;
 
-  test.before(function() {
-    driver = env.builder().build();
+  test.before(function*() {
+    driver = yield env.builder().build();
   });
 
   test.after(function() {
-    driver.quit();
+    return driver.quit();
   });
 
   test.beforeEach(function() {
-    driver.get(test.Pages.echoPage);
+    return driver.get(test.Pages.echoPage);
   });
 
   describe('executeScript;', function() {
     var shouldHaveFailed = new Error('Should have failed');
 
     test.it('fails if script throws', function() {
-      execute('throw new Error("boom")')
-          .then(function() { throw shoudlHaveFailed; })
+      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.
@@ -56,72 +55,72 @@ test.suite(function(env) {
     });
 
     test.it('fails if script does not parse', function() {
-      execute('throw function\\*')
-          .then(function() { throw shoudlHaveFailed; })
+      return execute('throw function\\*')
+          .then(function() { throw shouldHaveFailed; })
           .catch(function(e) {
             assert(e).notEqualTo(shouldHaveFailed);
           });
     });
 
     describe('scripts;', function() {
-      test.it('do not pollute the global scope', function() {
-        execute('var x = 1;');
-        assert(execute('return typeof x;')).equalTo('undefined');
+      test.it('do not pollute the global scope', function*() {
+        yield execute('var x = 1;');
+        yield assert(execute('return typeof x;')).equalTo('undefined');
       });
 
-      test.it('can set global variables', function() {
-        execute('window.x = 1234;');
-        assert(execute('return x;')).equalTo(1234);
+      test.it('can set global variables', function*() {
+        yield execute('window.x = 1234;');
+        yield assert(execute('return x;')).equalTo(1234);
       });
 
-      test.it('may be defined as a function expression', function() {
-        assert(execute(function() {
+      test.it('may be defined as a function expression', function*() {
+        let result = yield execute(function() {
           return 1234 + 'abc';
-        })).equalTo('1234abc');
+        });
+        assert(result).equalTo('1234abc');
       });
     });
 
     describe('return values;', function() {
 
       test.it('returns undefined as null', function() {
-        assert(execute('var x; return x;')).isNull();
+        return assert(execute('var x; return x;')).isNull();
       });
 
       test.it('can return null', function() {
-        assert(execute('return null;')).isNull();
+        return assert(execute('return null;')).isNull();
       });
 
-      test.it('can return numbers', function() {
-        assert(execute('return 1234')).equalTo(1234);
-        assert(execute('return 3.1456')).equalTo(3.1456);
+      test.it('can return numbers', function*() {
+        yield assert(execute('return 1234')).equalTo(1234);
+        yield assert(execute('return 3.1456')).equalTo(3.1456);
       });
 
       test.it('can return strings', function() {
-        assert(execute('return "hello"')).equalTo('hello');
+        return assert(execute('return "hello"')).equalTo('hello');
       });
 
-      test.it('can return booleans', function() {
-        assert(execute('return true')).equalTo(true);
-        assert(execute('return false')).equalTo(false);
+      test.it('can return booleans', function*() {
+        yield assert(execute('return true')).equalTo(true);
+        yield assert(execute('return false')).equalTo(false);
       });
 
       test.it('can return an array of primitives', function() {
-        execute('var x; return [1, false, null, 3.14, x]')
+        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() {
-        execute('return [[1, 2, [3]]]')
-            .then(verifyJson([[1, 2, [3]]]));
+        return execute('return [[1, 2, [3]]]').then(verifyJson([[1, 2, [3]]]));
       });
 
-      test.ignore(env.browsers(Browser.IE, Browser.SAFARI)).
+      test.ignore(env.browsers(Browser.IE)).
       it('can return empty object literal', function() {
-        execute('return {}').then(verifyJson({}));
+        return execute('return {}').then(verifyJson({}));
       });
 
       test.it('can return object literals', function() {
-        execute('return {a: 1, b: false, c: null}').then(function(result) {
+        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);
@@ -130,118 +129,116 @@ test.suite(function(env) {
       });
 
       test.it('can return complex object literals', function() {
-        execute('return {a:{b: "hello"}}').then(verifyJson({a:{b: 'hello'}}));
+        return execute('return {a:{b: "hello"}}')
+            .then(verifyJson({a:{b: 'hello'}}));
       });
 
-      test.it('can return dom elements as web elements', function() {
-        execute('return document.querySelector(".header.host")')
-            .then(function(result) {
-              assert(result).instanceOf(webdriver.WebElement);
-              assert(result.getText()).startsWith('host: ');
-            });
+      test.it('can return dom elements as web elements', function*() {
+        let result =
+            yield execute('return document.querySelector(".header.host")');
+        assert(result).instanceOf(webdriver.WebElement);
+
+        return assert(result.getText()).startsWith('host: ');
       });
 
-      test.it('can return array of dom elements', function() {
-        execute('var nodes = document.querySelectorAll(".request,.host");' +
-                'return [nodes[0], nodes[1]];')
-            .then(function(result) {
-              assert(result.length).equalTo(2);
+      test.it('can return array of dom elements', function*() {
+        let result = yield execute(
+            'var nodes = document.querySelectorAll(".request,.host");' +
+            'return [nodes[0], nodes[1]];');
+        assert(result.length).equalTo(2);
 
-              assert(result[0]).instanceOf(webdriver.WebElement);
-              assert(result[0].getText()).startsWith('GET ');
+        assert(result[0]).instanceOf(webdriver.WebElement);
+        yield assert(result[0].getText()).startsWith('GET ');
 
-              assert(result[1]).instanceOf(webdriver.WebElement);
-              assert(result[1].getText()).startsWith('host: ');
-            });
+        assert(result[1]).instanceOf(webdriver.WebElement);
+        yield assert(result[1].getText()).startsWith('host: ');
       });
 
-      test.it('can return a NodeList as an array of web elements', function() {
-        execute('return document.querySelectorAll(".request,.host");')
-            .then(function(result) {
-              assert(result.length).equalTo(2);
+      test.it('can return a NodeList as an array of web elements', function*() {
+        let result =
+            yield execute('return document.querySelectorAll(".request,.host");')
 
-              assert(result[0]).instanceOf(webdriver.WebElement);
-              assert(result[0].getText()).startsWith('GET ');
+        assert(result.length).equalTo(2);
 
-              assert(result[1]).instanceOf(webdriver.WebElement);
-              assert(result[1].getText()).startsWith('host: ');
-            });
+        assert(result[0]).instanceOf(webdriver.WebElement);
+        yield assert(result[0].getText()).startsWith('GET ');
+
+        assert(result[1]).instanceOf(webdriver.WebElement);
+        yield assert(result[1].getText()).startsWith('host: ');
       });
 
-      test.it('can return object literal with element property', function() {
-        execute('return {a: document.body}').then(function(result) {
-          assert(result.a).instanceOf(webdriver.WebElement);
-          assert(result.a.getTagName()).equalTo('body');
-        });
+      test.it('can return object literal with element property', function*() {
+        let result = yield execute('return {a: document.body}');
+
+        assert(result.a).instanceOf(webdriver.WebElement);
+        yield assert(result.a.getTagName()).equalTo('body');
       });
     });
 
     describe('parameters;', function() {
-      test.it('can pass numeric arguments', function() {
-        assert(execute('return arguments[0]', 12)).equalTo(12);
-        assert(execute('return arguments[0]', 3.14)).equalTo(3.14);
+      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);
       });
 
-      test.it('can pass boolean arguments', function() {
-        assert(execute('return arguments[0]', true)).equalTo(true);
-        assert(execute('return arguments[0]', false)).equalTo(false);
+      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);
       });
 
-      test.it('can pass string arguments', function() {
-        assert(execute('return arguments[0]', 'hi')).equalTo('hi');
+      test.it('can pass string arguments', function*() {
+        yield assert(execute('return arguments[0]', 'hi')).equalTo('hi');
       });
 
-      test.it('can pass null arguments', function() {
-        assert(execute('return arguments[0] === null', null)).equalTo(true);
-        assert(execute('return arguments[0]', null)).equalTo(null);
+      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);
       });
 
-      test.it('passes undefined as a null argument', function() {
+      test.it('passes undefined as a null argument', function*() {
         var x;
-        assert(execute('return arguments[0] === null', x)).equalTo(true);
-        assert(execute('return arguments[0]', x)).equalTo(null);
+        yield assert(execute('return arguments[0] === null', x)).equalTo(true);
+        yield assert(execute('return arguments[0]', x)).equalTo(null);
       });
 
-      test.it('can pass multiple arguments', function() {
-        assert(execute('return arguments.length')).equalTo(0);
-        assert(execute('return arguments.length', 1, 'a', false)).equalTo(3);
+      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);
       });
 
-      test.ignore(env.browsers(Browser.FIREFOX)).
-      it('can return arguments object as array', function() {
-        execute('return arguments', 1, 'a', false).then(function(val) {
-          assert(val.length).equalTo(3);
-          assert(val[0]).equalTo(1);
-          assert(val[1]).equalTo('a');
-          assert(val[2]).equalTo(false);
-        });
+      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);
+
+        assert(val.length).equalTo(3);
+        assert(val[0]).equalTo(1);
+        assert(val[1]).equalTo('a');
+        assert(val[2]).equalTo(false);
       });
 
-      test.it('can pass object literal', function() {
-        execute(
+      test.it('can pass object literal', function*() {
+        let result = yield execute(
             'return [typeof arguments[0], arguments[0].a]', {a: 'hello'})
-            .then(function(result) {
-              assert(result[0]).equalTo('object');
-              assert(result[1]).equalTo('hello');
-            });
+        assert(result[0]).equalTo('object');
+        assert(result[1]).equalTo('hello');
       });
 
-      test.it('WebElement arguments are passed as DOM elements', function() {
-        var el = driver.findElement(By.tagName('div'));
-        assert(execute('return arguments[0].tagName.toLowerCase();', el))
-            .equalTo('div');
+      test.it('WebElement arguments are passed as DOM elements', function*() {
+        let el = yield driver.findElement(By.tagName('div'));
+        let result =
+            yield execute('return arguments[0].tagName.toLowerCase();', el);
+        assert(result).equalTo('div');
       });
 
-      test.it('can pass array containing object literals', function() {
-        execute('return arguments[0]', [{color: "red"}]).then(function(result) {
-          assert(result.length).equalTo(1);
-          assert(result[0].color).equalTo('red');
-        });
+      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');
       });
 
       test.it('does not modify object literal parameters', function() {
         var input = {color: 'red'};
-        execute('return arguments[0];', input).then(verifyJson(input));
+        return execute('return arguments[0];', input).then(verifyJson(input));
       });
     });
 
@@ -249,7 +246,7 @@ test.suite(function(env) {
     describe('issue 8223;', function() {
       describe('using for..in loops;', function() {
         test.it('can return array built from for-loop index', function() {
-          execute(function() {
+          return execute(function() {
             var ret = [];
             for (var i = 0; i < 3; i++) {
               ret.push(i);
@@ -259,7 +256,7 @@ test.suite(function(env) {
         });
 
         test.it('can copy input array contents', function() {
-          execute(function(input) {
+          return execute(function(input) {
             var ret = [];
             for (var i in input) {
               ret.push(input[i]);
@@ -269,7 +266,7 @@ test.suite(function(env) {
         });
 
         test.it('can iterate over input object keys', function() {
-          execute(function(thing) {
+          return execute(function(thing) {
             var ret = [];
             for (var w in thing.words) {
               ret.push(thing.words[w].word);
@@ -282,7 +279,7 @@ test.suite(function(env) {
         describe('recursive functions;', function() {
           test.it('can build array from input', function() {
             var input = ['fa', 'fe', 'fi'];
-            execute(function(thearray) {
+            return execute(function(thearray) {
               var ret = [];
               function build_response(thearray, ret) {
                 ret.push(thearray.shift());
@@ -295,7 +292,7 @@ test.suite(function(env) {
 
           test.it('can build array from elements in object', function() {
             var input = {words: [{word: 'fa'}, {word: 'fe'}, {word: 'fi'}]};
-            execute(function(thing) {
+            return execute(function(thing) {
               var ret = [];
               function build_response(thing, ret) {
                 var item = thing.words.shift();
@@ -343,7 +340,7 @@ test.suite(function(env) {
 
   function verifyJson(expected) {
     return function(actual) {
-      assert(JSON.stringify(actual)).equalTo(JSON.stringify(expected));
+      return assert(JSON.stringify(actual)).equalTo(JSON.stringify(expected));
     };
   }
 

package/test/fingerprint_test.js

@@ -35,21 +35,26 @@ test.suite(function(env) {
   });
 
   describe('fingerprinting', function() {
-    test.it('it should fingerprint the navigator object', function() {
-      driver.get(Pages.simpleTestPage);
-      assert(driver.executeScript('return navigator.webdriver')).equalTo(true);
+    test.it('it should fingerprint the navigator object', function*() {
+      yield driver.get(Pages.simpleTestPage);
+
+      let wd = yield driver.executeScript('return navigator.webdriver');
+      assert(wd).equalTo(true);
     });
 
-    test.it('fingerprint must not be writable', function() {
-      driver.get(Pages.simpleTestPage);
-      assert(driver.executeScript(
-          'navigator.webdriver = "ohai"; return navigator.webdriver'))
-          .equalTo(true);
+    test.it('fingerprint must not be writable', function*() {
+      yield driver.get(Pages.simpleTestPage);
+
+      let wd = yield driver.executeScript(
+          'navigator.webdriver = "ohai"; return navigator.webdriver');
+      assert(wd).equalTo(true);
     });
 
-    test.it('leaves fingerprint on svg pages', function() {
-      driver.get(Pages.svgPage);
-      assert(driver.executeScript('return navigator.webdriver')).equalTo(true);
+    test.it('leaves fingerprint on svg pages', function*() {
+      yield driver.get(Pages.svgPage);
+
+      let wd = yield driver.executeScript('return navigator.webdriver');
+      assert(wd).equalTo(true);
     });
   });
 

package/test/firefox/firefox_test.js

@@ -44,11 +44,30 @@ test.suite(function(env) {
 
       test.afterEach(function() {
         if (driver) {
-          driver.quit();
+          return driver.quit();
         }
       });
 
-      test.it('can start Firefox with custom preferences', function() {
+      /**
+       * Runs a test that requires Firefox Developer Edition. The test will be
+       * skipped if dev cannot be found on the current system.
+       */
+      function runWithFirefoxDev(options, testFn) {
+        let binary = new firefox.Binary();
+        binary.useDevEdition();
+        return binary.locate().then(exe => {
+          options.setBinary(exe);
+          driver = env.builder()
+              .setFirefoxOptions(options)
+              .build();
+          return driver.call(testFn);
+        }, err => {
+          console.warn(
+              'Skipping test: could not find Firefox Dev Edition: ' + err);
+        });
+      }
+
+      test.it('can start Firefox with custom preferences', function*() {
         var profile = new firefox.Profile();
         profile.setPreference('general.useragent.override', 'foo;bar');
 
@@ -58,68 +77,72 @@ test.suite(function(env) {
             setFirefoxOptions(options).
             build();
 
-        driver.get('data:text/html,<html><div>content</div></html>');
+        yield driver.get('data:text/html,<html><div>content</div></html>');
 
-        var userAgent = driver.executeScript(
+        var userAgent = yield driver.executeScript(
             'return window.navigator.userAgent');
         assert(userAgent).equalTo('foo;bar');
       });
 
       test.it('can start Firefox with a jetpack extension', function() {
-        var profile = new firefox.Profile();
+        let profile = new firefox.Profile();
         profile.addExtension(JETPACK_EXTENSION);
 
-        var options = new firefox.Options().setProfile(profile);
+        let options = new firefox.Options().setProfile(profile);
 
-        driver = env.builder().
-            setFirefoxOptions(options).
-            build();
+        return runWithFirefoxDev(options, function*() {
+          yield loadJetpackPage(driver,
+              'data:text/html;charset=UTF-8,<html><div>content</div></html>');
 
-        loadJetpackPage(driver,
-            'data:text/html;charset=UTF-8,<html><div>content</div></html>');
-        assert(driver.findElement({id: 'jetpack-sample-banner'}).getText())
-            .equalTo('Hello, world!');
+          let text =
+              yield driver.findElement({id: 'jetpack-sample-banner'}).getText();
+          assert(text).equalTo('Hello, world!');
+        });
       });
 
       test.it('can start Firefox with a normal extension', function() {
-        var profile = new firefox.Profile();
+        let profile = new firefox.Profile();
         profile.addExtension(NORMAL_EXTENSION);
 
-        var options = new firefox.Options().setProfile(profile);
+        let options = new firefox.Options().setProfile(profile);
 
-        driver = env.builder().
-            setFirefoxOptions(options).
-            build();
+        return runWithFirefoxDev(options, function*() {
+          yield driver.get('data:text/html,<html><div>content</div></html>');
 
-        driver.get('data:text/html,<html><div>content</div></html>');
-        assert(driver.findElement({id: 'sample-extension-footer'}).getText())
-            .equalTo('Goodbye');
+          let footer =
+              yield driver.findElement({id: 'sample-extension-footer'});
+          let text = yield footer.getText();
+          assert(text).equalTo('Goodbye');
+        });
       });
 
       test.it('can start Firefox with multiple extensions', function() {
-        var profile = new firefox.Profile();
+        let profile = new firefox.Profile();
         profile.addExtension(JETPACK_EXTENSION);
         profile.addExtension(NORMAL_EXTENSION);
 
-        var options = new firefox.Options().setProfile(profile);
+        let options = new firefox.Options().setProfile(profile);
 
-        driver = env.builder().
-            setFirefoxOptions(options).
-            build();
+        return runWithFirefoxDev(options, function*() {
+          yield loadJetpackPage(driver,
+              'data:text/html;charset=UTF-8,<html><div>content</div></html>');
+
+          let banner =
+              yield driver.findElement({id: 'jetpack-sample-banner'}).getText();
+          assert(banner).equalTo('Hello, world!');
 
-        loadJetpackPage(driver,
-            'data:text/html;charset=UTF-8,<html><div>content</div></html>');
-        assert(driver.findElement({id: 'jetpack-sample-banner'}).getText())
-            .equalTo('Hello, world!');
-        assert(driver.findElement({id: 'sample-extension-footer'}).getText())
-            .equalTo('Goodbye');
+          let footer =
+              yield driver.findElement({id: 'sample-extension-footer'})
+                  .getText();
+          assert(footer).equalTo('Goodbye');
+        });
       });
 
       function loadJetpackPage(driver, url) {
         // On linux the jetpack extension does not always run the first time
         // we load a page. If this happens, just reload the page (a simple
         // refresh doesn't appear to work).
-        driver.wait(function() {
+        return driver.wait(function() {
           driver.get(url);
           return driver.findElements({id: 'jetpack-sample-banner'})
               .then(found => found.length > 0);
@@ -131,21 +154,21 @@ test.suite(function(env) {
       var driver1, driver2;
 
       test.ignore(env.isRemote).
-      it('can start multiple sessions with single binary instance', function() {
+      it('can start multiple sessions with single binary instance', function*() {
         var options = new firefox.Options().setBinary(new firefox.Binary);
         env.builder().setFirefoxOptions(options);
-        driver1 = env.builder().build();
-        driver2 = env.builder().build();
+        driver1 = yield env.builder().build();
+        driver2 = yield env.builder().build();
         // Ok if this doesn't fail.
       });
 
-      test.afterEach(function() {
+      test.afterEach(function*() {
         if (driver1) {
-          driver1.quit();
+          yield driver1.quit();
         }
 
         if (driver2) {
-          driver2.quit();
+          yield driver2.quit();
         }
       });
     });
@@ -153,32 +176,35 @@ test.suite(function(env) {
     describe('context switching', function() {
       var driver;
 
-      test.beforeEach(function() {
-        driver = env.builder().build();
+      test.beforeEach(function*() {
+        driver = yield env.builder().build();
       });
 
       test.afterEach(function() {
         if (driver) {
-          driver.quit();
+          return driver.quit();
         }
       });
 
       test.ignore(() => !env.isMarionette).
       it('can get context', function() {
-        assert(driver.getContext()).equalTo(Context.CONTENT);
+        return assert(driver.getContext()).equalTo(Context.CONTENT);
       });
 
       test.ignore(() => !env.isMarionette).
-      it('can set context', function() {
-        driver.setContext(Context.CHROME);
-        assert(driver.getContext()).equalTo(Context.CHROME);
-        driver.setContext(Context.CONTENT);
-        assert(driver.getContext()).equalTo(Context.CONTENT);
+      it('can set context', function*() {
+        yield driver.setContext(Context.CHROME);
+        let ctxt = yield driver.getContext();
+        assert(ctxt).equalTo(Context.CHROME);
+
+        yield driver.setContext(Context.CONTENT);
+        ctxt = yield driver.getContext();
+        assert(ctxt).equalTo(Context.CONTENT);
       });
 
       test.ignore(() => !env.isMarionette).
       it('throws on unknown context', function() {
-        driver.setContext("foo").then(assert.fail, function(e) {
+        return driver.setContext("foo").then(assert.fail, function(e) {
           assert(e).instanceOf(error.InvalidArgumentError);
         });
       });

package/test/firefox/profile_test.js

@@ -26,8 +26,7 @@ var promise = require('../..').promise,
     Profile = require('../../firefox/profile').Profile,
     decode = require('../../firefox/profile').decode,
     loadUserPrefs = require('../../firefox/profile').loadUserPrefs,
-    io = require('../../io'),
-    it = require('../../testing').it;
+    io = require('../../io');
 
 
 var JETPACK_EXTENSION = path.join(__dirname,
@@ -53,7 +52,6 @@ describe('Profile', function() {
 
     it('allows overriding mutable properties', function() {
       var profile = new Profile();
-      assert.equal('about:blank', profile.getPreference('browser.newtab.url'));
 
       profile.setPreference('browser.newtab.url', 'http://www.example.com');
       assert.equal('http://www.example.com',