selenium-webdriver 3.0.0-beta-1 → 3.0.1

package/test/remote_test.js

@@ -26,6 +26,8 @@ var promise = require('../').promise,
     cmd = require('../lib/command'),
     remote = require('../remote');
 
+const {enablePromiseManager} = require('../lib/test/promise');
+
 describe('DriverService', function() {
   describe('start()', function() {
     var service;
@@ -41,36 +43,34 @@ describe('DriverService', function() {
       return service.kill();
     });
 
-    it('fails if child-process dies', function(done) {
+    it('fails if child-process dies', function() {
       this.timeout(1000);
-      service.start(500)
-      .then(expectFailure.bind(null, done), verifyFailure.bind(null, done));
+      return service.start(500).then(expectFailure, verifyFailure);
     });
 
-    it('failures propagate through control flow if child-process dies',
-      function(done) {
-        this.timeout(1000);
+    enablePromiseManager(function() {
+      describe(
+          'failures propagate through control flow if child-process dies',
+          function() {
+            it('', function() {
+              this.timeout(1000);
 
-        promise.controlFlow().execute(function() {
-          promise.controlFlow().execute(function() {
-            return service.start(500);
+              return promise.controlFlow().execute(function() {
+                promise.controlFlow().execute(function() {
+                  return service.start(500);
+                });
+              }).then(expectFailure, verifyFailure);
+            });
           });
-        })
-        .then(expectFailure.bind(null, done), verifyFailure.bind(null, done));
-      });
+    });
 
-    function verifyFailure(done, e) {
-      try {
-        assert.ok(!(e instanceof promise.CancellationError));
-        assert.equal('Server terminated early with status 1', e.message);
-        done();
-      } catch (ex) {
-        done(ex);
-      }
+    function verifyFailure(e) {
+      assert.ok(!(e instanceof promise.CancellationError));
+      assert.equal('Server terminated early with status 1', e.message);
     }
 
-    function expectFailure(done) {
-      done(Error('expected to fail'));
+    function expectFailure() {
+      throw Error('expected to fail');
     }
   });
 });

package/test/safari_test.js

@@ -0,0 +1,108 @@
+// 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 webdriver = require('..'),
+  proxy = require('../proxy'),
+  safari = require('../safari'),
+  assert = require('../testing/assert'),
+  test = require('../lib/test');
+
+
+describe('safari.Options', function() {
+  describe('fromCapabilities', function() {
+    it('returns a new Options instance  if none were defined', function() {
+      let options = safari.Options.fromCapabilities(
+        new webdriver.Capabilities());
+      assert(options).instanceOf(safari.Options);
+    });
+
+    it('returns the options instance if present', function() {
+      let options = new safari.Options().setCleanSession(true),
+        caps = options.toCapabilities();
+      assert(safari.Options.fromCapabilities(caps)).equalTo(options);
+    });
+
+    it('extracts supported WebDriver capabilities', function() {
+      let proxyPrefs = proxy.direct(),
+        logPrefs = {},
+        caps = webdriver.Capabilities.chrome()
+          .set(webdriver.Capability.PROXY, proxyPrefs)
+          .set(webdriver.Capability.LOGGING_PREFS, logPrefs);
+
+      let options = safari.Options.fromCapabilities(caps);
+      assert(options.proxy_).equalTo(proxyPrefs);
+      assert(options.logPrefs_).equalTo(logPrefs);
+    });
+  });
+
+  describe('toCapabilities', function() {
+    let options;
+
+    before(function() {
+      options = new safari.Options()
+        .setCleanSession(true);
+    });
+
+    it('returns a new capabilities object if one is not provided', function() {
+      let caps = options.toCapabilities();
+      assert(caps).instanceOf(webdriver.Capabilities);
+      assert(caps.get('browserName')).equalTo('safari');
+      assert(caps.get('safari.options')).equalTo(options);
+    });
+
+    it('adds to input capabilities object', function() {
+      let caps = webdriver.Capabilities.safari();
+      assert(options.toCapabilities(caps)).equalTo(caps);
+      assert(caps.get('safari.options')).equalTo(options);
+    });
+
+    it('sets generic driver capabilities', function() {
+      let proxyPrefs = proxy.direct(),
+        loggingPrefs = {};
+
+      options
+        .setLoggingPrefs(loggingPrefs)
+        .setProxy(proxyPrefs);
+
+      let caps = options.toCapabilities();
+      assert(caps.get('proxy')).equalTo(proxyPrefs);
+      assert(caps.get('loggingPrefs')).equalTo(loggingPrefs);
+    });
+  });
+});
+
+test.suite(function(env) {
+  describe('safaridriver', function() {
+    let service;
+
+    afterEach(function() {
+      if (service) {
+        return service.kill();
+      }
+    });
+
+    it('can start safaridriver', function() {
+      service = new safari.ServiceBuilder().build();
+
+      return service.start().then(function(url) {
+        assert(url).matches(/127\.0\.0\.1/);
+      });
+    });
+  });
+}, {browsers: ['safari']});

package/test/session_test.js

@@ -27,27 +27,28 @@ test.suite(function(env) {
   var browsers = env.browsers;
 
   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.it('can connect to an existing session', function() {
-    driver.get(Pages.simpleTestPage);
-    assert(driver.getTitle()).equalTo('Hello WebDriver');
+  test.it('can connect to an existing session', function*() {
+    yield driver.get(Pages.simpleTestPage);
+    yield assert(driver.getTitle()).equalTo('Hello WebDriver');
 
     return driver.getSession().then(session1 => {
       let driver2 = WebDriver.attachToSession(
           driver.getExecutor(),
           session1.getId());
 
-      assert(driver2.getTitle()).equalTo('Hello WebDriver');
-
-      let session2Id = driver2.getSession().then(s => s.getId());
-      assert(session2Id).equalTo(session1.getId());
+      return assert(driver2.getTitle()).equalTo('Hello WebDriver')
+          .then(_ => {
+            let session2Id = driver2.getSession().then(s => s.getId());
+            return assert(session2Id).equalTo(session1.getId());
+          });
     });
   });
 });

package/test/stale_element_test.js

@@ -30,31 +30,33 @@ var Browser = require('..').Browser,
 
 test.suite(function(env) {
   var driver;
-  test.before(function() { driver = env.builder().build(); });
-  test.after(function() { driver.quit(); });
+  test.before(function*() { driver = yield env.builder().build(); });
+  test.after(function() { return driver.quit(); });
 
-  test.it(
+  // Element never goes stale in Safari.
+  test.ignore(env.browsers(Browser.SAFARI)).
+  it(
       'dynamically removing elements from the DOM trigger a ' +
           'StaleElementReferenceError',
-      function() {
-        driver.get(Pages.javascriptPage);
+      function*() {
+        yield driver.get(Pages.javascriptPage);
 
-        var toBeDeleted = driver.findElement(By.id('deleted'));
-        assert(toBeDeleted.isDisplayed()).isTrue();
+        var toBeDeleted = yield driver.findElement(By.id('deleted'));
+        yield assert(toBeDeleted.getTagName()).isEqualTo('p');
 
-        driver.findElement(By.id('delete')).click();
-        driver.wait(until.stalenessOf(toBeDeleted), 5000);
+        yield driver.findElement(By.id('delete')).click();
+        yield driver.wait(until.stalenessOf(toBeDeleted), 5000);
       });
 
-  test.it('an element found in a different frame is stale', function() {
-    driver.get(Pages.missedJsReferencePage);
+  test.it('an element found in a different frame is stale', function*() {
+    yield driver.get(Pages.missedJsReferencePage);
 
-    var frame = driver.findElement(By.css('iframe[name="inner"]'));
-    driver.switchTo().frame(frame);
+    var frame = yield driver.findElement(By.css('iframe[name="inner"]'));
+    yield driver.switchTo().frame(frame);
 
-    var el = driver.findElement(By.id('oneline'));
-    driver.switchTo().defaultContent();
-    el.getText().then(fail, function(e) {
+    var el = yield driver.findElement(By.id('oneline'));
+    yield driver.switchTo().defaultContent();
+    return el.getText().then(fail, function(e) {
       assert(e).instanceOf(error.StaleElementReferenceError);
     });
   });

package/test/tag_name_test.js

@@ -24,11 +24,13 @@ var By = require('..').By,
 
 test.suite(function(env) {
   var driver;
-  test.after(function() { driver.quit(); });
+  test.after(function() { return driver.quit(); });
 
-  test.it('should return lower case tag name', function() {
-    driver = env.builder().build();
-    driver.get(test.Pages.formPage);
-    assert(driver.findElement(By.id('cheese')).getTagName()).equalTo('input');
+  test.it('should return lower case tag name', function*() {
+    driver = yield env.builder().build();
+    yield driver.get(test.Pages.formPage);
+
+    let el = yield driver.findElement(By.id('cheese'));
+    return assert(el.getTagName()).equalTo('input');
   });
 });

package/test/testing/assert_test.js

@@ -178,9 +178,8 @@ describe('assert', function() {
     });
 
     it('waits for promised values', function() {
-      let d = Promise.defer();
-      setTimeout(() => d.resolve(123), 10);
-      return assert(d.promise).closeTo(124, 1);
+      let p = new Promise(resolve => setTimeout(() => resolve(123), 10));
+      return assert(p).closeTo(124, 1);
     });
   });
 

package/test/testing/index_test.js

@@ -17,8 +17,10 @@
 
 'use strict';
 
-var assert = require('assert');
-var promise = require('../..').promise;
+const assert = require('assert');
+const promise = require('../..').promise;
+const {enablePromiseManager} = require('../../lib/test/promise');
+
 
 var test = require('../../testing');
 
@@ -42,137 +44,181 @@ describe('Mocha Integration', function() {
     afterEach(function() { assert.equal(this.x, 2); });
   });
 
-  describe('timeout handling', function() {
-    describe('it does not reset the control flow on a non-timeout', function() {
-      var flowReset = false;
+  enablePromiseManager(function() {
+    describe('timeout handling', function() {
+      describe('it does not reset the control flow on a non-timeout', function() {
+        var flowReset = false;
 
-      beforeEach(function() {
-        flowReset = false;
-        test.controlFlow().once(promise.ControlFlow.EventType.RESET, onreset);
-      });
+        beforeEach(function() {
+          flowReset = false;
+          test.controlFlow().once(promise.ControlFlow.EventType.RESET, onreset);
+        });
 
-      test.it('', function() {
-        this.timeout(100);
-        return promise.delayed(50);
-      });
+        test.it('', function() {
+          this.timeout(100);
+          return promise.delayed(50);
+        });
 
-      afterEach(function() {
-        assert.ok(!flowReset);
-        test.controlFlow().removeListener(
-            promise.ControlFlow.EventType.RESET, onreset);
-      });
+        afterEach(function() {
+          assert.ok(!flowReset);
+          test.controlFlow().removeListener(
+              promise.ControlFlow.EventType.RESET, onreset);
+        });
 
-      function onreset() {
-        flowReset = true;
-      }
-    });
+        function onreset() {
+          flowReset = true;
+        }
+      });
 
-    describe('it resets the control flow after a timeout' ,function() {
-      var timeoutErr, flowReset;
+      describe('it resets the control flow after a timeout' ,function() {
+        var timeoutErr, flowReset;
 
-      beforeEach(function() {
-        flowReset = false;
-        test.controlFlow().once(promise.ControlFlow.EventType.RESET, onreset);
-      });
+        beforeEach(function() {
+          flowReset = false;
+          test.controlFlow().once(promise.ControlFlow.EventType.RESET, onreset);
+        });
 
-      test.it('', function() {
-        var callback = this.runnable().callback;
-        var test = this;
-        this.runnable().callback = function(err) {
-          timeoutErr = err;
-          // Reset our timeout to 0 so Mocha does not fail the test.
-          test.timeout(0);
-          // When we invoke the real callback, do not pass along the error so
-          // Mocha does not fail the test.
-          return callback.call(this);
-        };
-
-        test.timeout(50);
-        return promise.defer().promise;
-      });
+        test.it('', function() {
+          var callback = this.runnable().callback;
+          var test = this;
+          this.runnable().callback = function(err) {
+            timeoutErr = err;
+            // Reset our timeout to 0 so Mocha does not fail the test.
+            test.timeout(0);
+            // When we invoke the real callback, do not pass along the error so
+            // Mocha does not fail the test.
+            return callback.call(this);
+          };
+
+          test.timeout(50);
+          return promise.defer().promise;
+        });
 
-      afterEach(function() {
-        return Promise.resolve().then(function() {
-          test.controlFlow().removeListener(
-              promise.ControlFlow.EventType.RESET, onreset);
-          assert.ok(flowReset, 'control flow was not reset after a timeout');
+        afterEach(function() {
+          return Promise.resolve().then(function() {
+            test.controlFlow().removeListener(
+                promise.ControlFlow.EventType.RESET, onreset);
+            assert.ok(flowReset, 'control flow was not reset after a timeout');
+          });
         });
+
+        function onreset() {
+          flowReset = true;
+        }
       });
+    });
+
+    describe('async "done" support', function() {
+       this.timeout(2*1000);
+
+       var waited = false;
+       var DELAY = 100; // ms enough to notice
+
+       // Each test asynchronously sets waited to true, so clear/check waited
+       // before/after:
+       beforeEach(function() {
+          waited = false;
+       });
+
+       afterEach(function() {
+          assert.strictEqual(waited, true);
+       });
+
+       // --- First, vanilla mocha "it" should support the "done" callback correctly.
+
+       // This 'it' should block until 'done' is invoked
+       it('vanilla delayed', function(done) {
+          setTimeout(function delayedVanillaTimeout() {
+             waited = true;
+             done();
+          }, DELAY);
+       });
+
+       // --- Now with the webdriver wrappers for 'it' should support the "done" callback:
+
+       test.it('delayed', function(done) {
+          assert(done);
+          assert.strictEqual(typeof done, 'function');
+          setTimeout(function delayedTimeoutCallback() {
+             waited = true;
+             done();
+          }, DELAY);
+       });
+
+       // --- And test that the webdriver wrapper for 'it' works with a returned promise, too:
+
+       test.it('delayed by promise', function() {
+          var defer = promise.defer();
+          setTimeout(function delayedPromiseCallback() {
+             waited = true;
+             defer.fulfill('ignored');
+          });
+          return defer.promise;
+       });
+    });
 
-      function onreset() {
-        flowReset = true;
-      }
+    describe('ControlFlow and "done" work together', function() {
+       var flow, order;
+       before(function() {
+          order = [];
+          flow = test.controlFlow();
+          flow.execute(function() { order.push(1); });
+       });
+
+       test.it('control flow updates and async done', function(done) {
+          flow.execute(function() { order.push(2); });
+          flow.execute(function() { order.push(3); }).then(function() {
+             order.push(4);
+          });
+          done();
+       });
+
+       after(function() {
+          assert.deepEqual([1, 2, 3, 4], order);
+       });
     });
   });
-});
 
-describe('Mocha async "done" support', function() {
-   this.timeout(2*1000);
-
-   var waited = false;
-   var DELAY = 100; // ms enough to notice
-
-   // Each test asynchronously sets waited to true, so clear/check waited
-   // before/after:
-   beforeEach(function() {
-      waited = false;
-   });
-
-   afterEach(function() {
-      assert.strictEqual(waited, true);
-   });
-
-   // --- First, vanilla mocha "it" should support the "done" callback correctly.
-
-   // This 'it' should block until 'done' is invoked
-   it('vanilla delayed', function(done) {
-      setTimeout(function delayedVanillaTimeout() {
-         waited = true;
-         done();
-      }, DELAY);
-   });
-
-   // --- Now with the webdriver wrappers for 'it' should support the "done" callback:
-
-   test.it('delayed', function(done) {
-      assert(done);
-      assert.strictEqual(typeof done, 'function');
-      setTimeout(function delayedTimeoutCallback() {
-         waited = true;
-         done();
-      }, DELAY);
-   });
-
-   // --- And test that the webdriver wrapper for 'it' works with a returned promise, too:
-
-   test.it('delayed by promise', function() {
-      var defer = promise.defer();
-      setTimeout(function delayedPromiseCallback() {
-         waited = true;
-         defer.fulfill('ignored');
-      });
-      return defer.promise;
-   });
+  describe('generator support', function() {
+    let arr;
 
-});
+    beforeEach(() => arr = []);
+    afterEach(() => assert.deepEqual(arr, [0, 1, 2, 3]));
+
+    test.it('sync generator', function* () {
+      arr.push(yield arr.length);
+      arr.push(yield arr.length);
+      arr.push(yield arr.length);
+      arr.push(yield arr.length);
+    });
+
+    test.it('async generator', function* () {
+      arr.push(yield Promise.resolve(arr.length));
+      arr.push(yield Promise.resolve(arr.length));
+      arr.push(yield Promise.resolve(arr.length));
+      arr.push(yield Promise.resolve(arr.length));
+    });
+
+    test.it('generator returns promise', function*() {
+      arr.push(yield Promise.resolve(arr.length));
+      arr.push(yield Promise.resolve(arr.length));
+      arr.push(yield Promise.resolve(arr.length));
+      setTimeout(_ => arr.push(arr.length), 10);
+      return new Promise((resolve) => setTimeout(_ => resolve(), 25));
+    });
 
-describe('ControlFlow and "done" work together', function() {
-   var flow, order;
-   before(function() {
-      order = [];
-      flow = test.controlFlow();
-      flow.execute(function() { order.push(1); });
-   });
-
-   test.it('control flow updates and async done', function(done) {
-      flow.execute(function() { order.push(2); });
-      flow.execute(function() { order.push(3); }).then(function() {
-         order.push(4);
+    describe('generator runs with proper "this" context', () => {
+      before(function() { this.values = [0, 1, 2, 3]; });
+      test.it('', function*() {
+        arr = this.values;
       });
-      done();
-   })
+    });
 
-   after(function() {
-      assert.deepEqual([1, 2, 3, 4], order);
-   })
+    it('generator function must not take a callback', function() {
+      arr = [0, 1, 2, 3];  // For teardown hook.
+      assert.throws(_ => {
+        test.it('', function*(done){});
+      }, TypeError);
+    });
+  });
 });

package/test/upload_test.js

@@ -41,13 +41,13 @@ test.suite(function(env) {
   })
 
   var driver;
-  test.before(function() {
-    driver = env.builder().build();
+  test.before(function*() {
+    driver = yield env.builder().build();
   });
 
   test.after(function() {
     if (driver) {
-      driver.quit();
+      return driver.quit();
     }
   });
 
@@ -58,29 +58,29 @@ test.suite(function(env) {
       // See https://github.com/ariya/phantomjs/issues/12506
       Browser.PHANTOM_JS,
       Browser.SAFARI)).
-  it('can upload files', function() {
+  it('can upload files', function*() {
     driver.setFileDetector(new remote.FileDetector);
 
-    driver.get(Pages.uploadPage);
+    yield driver.get(Pages.uploadPage);
 
-    var fp = driver.call(function() {
+    var fp = yield driver.call(function() {
       return io.tmpFile().then(function(fp) {
         fs.writeFileSync(fp, FILE_HTML);
         return fp;
       });
     });
 
-    driver.findElement(By.id('upload')).sendKeys(fp);
-    driver.findElement(By.id('go')).click();
+    yield driver.findElement(By.id('upload')).sendKeys(fp);
+    yield driver.findElement(By.id('go')).click();
 
     // Uploading files across a network may take a while, even if they're small.
-    var label = driver.findElement(By.id('upload_label'));
-    driver.wait(until.elementIsNotVisible(label),
+    var label = yield driver.findElement(By.id('upload_label'));
+    yield driver.wait(until.elementIsNotVisible(label),
         10 * 1000, 'File took longer than 10 seconds to upload!');
 
-    var frame = driver.findElement(By.id('upload_target'));
-    driver.switchTo().frame(frame);
-    assert(driver.findElement(By.css('body')).getText())
+    var frame = yield driver.findElement(By.id('upload_target'));
+    yield driver.switchTo().frame(frame);
+    yield assert(driver.findElement(By.css('body')).getText())
         .equalTo(LOREM_IPSUM_TEXT);
   });
 });