selenium-webdriver 3.0.1 → 3.5.0

package/test/io/zip_test.js

@@ -0,0 +1,128 @@
+// 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 io = require('../../io');
+const devmode = require('../../lib/devmode');
+const zip = require('../../io/zip');
+const {InvalidArgumentError} = require('../../lib/error');
+
+
+const SAMPLE_XPI_PATH =
+    path.join(__dirname, '../../lib/test/data/firefox/sample.xpi');
+
+describe('io/zip', function() {
+  describe('unzip', function() {
+    it('creates destination dir if necessary', function() {
+      return io.tmpDir()
+          .then(dir => zip.unzip(SAMPLE_XPI_PATH, dir))
+          .then(dir => {
+            assertExists(path.join(dir, 'chrome.manifest'));
+            assertExists(path.join(dir, 'content/overlay.js'));
+            assertExists(path.join(dir, 'content/overlay.xul'));
+            assertExists(path.join(dir, 'install.rdf'));
+          });
+    });
+  });
+
+  describe('Zip', function() {
+    let dir;
+
+    beforeEach(function() {
+      return io.tmpDir().then(d => dir = d);
+    });
+
+    it('can convert an archive to a buffer', function() {
+      let z = new zip.Zip;
+      return io.mkdirp(path.join(dir, 'a/b/c/d/e')).then(() => {
+        return Promise.all([
+          io.write(path.join(dir, 'foo'), 'a file'),
+          io.write(path.join(dir, 'a/b/c/carrot'), 'an orange carrot'),
+          io.write(path.join(dir, 'a/b/c/d/e/elephant'), 'e is for elephant')
+        ]);
+      })
+      .then(() => z.addDir(dir))
+      .then(() => Promise.all([io.tmpDir(), z.toBuffer()]))
+      .then(([outDir, buf]) => {
+        let output = path.join(outDir, 'out.zip');
+        return io.write(output, buf)
+            .then(() => io.tmpDir())
+            .then(d => zip.unzip(output, d))
+            .then(d => {
+              assertContents(path.join(d, 'foo'), 'a file');
+              assertContents(path.join(d, 'a/b/c/carrot'), 'an orange carrot');
+              assertContents(
+                  path.join(d, 'a/b/c/d/e/elephant'),
+                  'e is for elephant');
+            });
+      });
+    });
+
+    describe('getFile', function() {
+      it('returns archive file contents as a buffer', function() {
+        let foo = path.join(dir, 'foo');
+        fs.writeFileSync(foo, 'hello, world!');
+
+        let z = new zip.Zip;
+        return z.addFile(foo).then(() => {
+          assert.ok(z.has('foo'));
+          return z.getFile('foo');
+        }).then(
+            buffer => assert.equal(buffer.toString('utf8'), 'hello, world!'));
+      });
+
+      it('returns an error if file is not in archive', function() {
+        let z = new zip.Zip;
+        assert.ok(!z.has('some-file'));
+        return z.getFile('some-file')
+            .then(() => assert.fail('should have failed'),
+                  e => assert.strictEqual(e.constructor, InvalidArgumentError));
+      });
+
+      it(
+          'returns a rejected promise if the requested path is a directory',
+          function() {
+            let file = path.join(dir, 'aFile');
+            fs.writeFileSync(file, 'hello, world!');
+
+            let z = new zip.Zip;
+            return z.addDir(dir, 'foo')
+                .then(() => z.getFile('foo'))
+                .then(
+                    () => assert.fail('should have failed'),
+                    e => assert.strictEqual(
+                        e.constructor, InvalidArgumentError))
+                .then(() => z.getFile('foo/aFile'))
+                .then(b => assert.equal(b.toString('utf8'), 'hello, world!'));
+          });
+    });
+  });
+
+  function assertExists(p) {
+    assert.ok(fs.existsSync(p), `expected ${p} to exist`);
+  }
+
+  function assertContents(p, c) {
+    assert.strictEqual(
+        fs.readFileSync(p, 'utf8'), c, `unexpected file contents for ${p}`);
+  }
+});

package/test/lib/by_test.js

@@ -88,6 +88,27 @@ describe('by', function() {
   });
 
   describe('checkedLocator', function() {
+    it('accepts a By instance', function() {
+      let original = by.By.name('foo');
+      let locator = by.checkedLocator(original);
+      assert.strictEqual(locator, original);
+    });
+
+    it('accepts custom locator functions', function() {
+      let original = function() {};
+      let locator = by.checkedLocator(original);
+      assert.strictEqual(locator, original);
+    });
+
+    // See https://github.com/SeleniumHQ/selenium/issues/3056
+    it('accepts By-like objects', function() {
+      let fakeBy = {using: 'id', value: 'foo'};
+      let locator = by.checkedLocator(fakeBy);
+      assert.strictEqual(locator.constructor, by.By);
+      assert.equal(locator.using, 'id');
+      assert.equal(locator.value, 'foo');
+    });
+
     it('accepts class name', function() {
       let locator = by.checkedLocator({className: 'foo'});
       assert.equal('css selector', locator.using);

package/test/lib/error_test.js

@@ -187,13 +187,32 @@ describe('error', function() {
     test('unknown method', error.UnknownMethodError);
     test('unsupported operation', error.UnsupportedOperationError);
 
+    it('leaves remoteStacktrace empty if not in encoding', function() {
+      assert.throws(
+          () => error.throwDecodedError({
+            error: 'session not created',
+            message: 'oops'
+          }),
+          (e) => {
+            assert.strictEqual(e.constructor, error.SessionNotCreatedError);
+            assert.strictEqual(e.message, 'oops');
+            assert.strictEqual(e.remoteStacktrace, '');
+            return true;
+          });
+    });
+
     function test(status, expectedType) {
       it(`"${status}" => ${expectedType.name}`, function() {
         assert.throws(
-            () => error.throwDecodedError({error: status, message: 'oops'}),
+            () => error.throwDecodedError({
+              error: status,
+              message: 'oops',
+              stacktrace: 'some-stacktrace'
+            }),
             (e) => {
               assert.strictEqual(e.constructor, expectedType);
               assert.strictEqual(e.message, 'oops');
+              assert.strictEqual(e.remoteStacktrace, 'some-stacktrace');
               return true;
             });
       });

package/test/lib/http_test.js

@@ -293,7 +293,14 @@ describe('http', function() {
         });
 
         it('auto-upgrades on W3C response', function() {
-          var rawResponse = {sessionId: 's123', value: {name: 'Bob'}};
+          let rawResponse = {
+            value: {
+              sessionId: 's123',
+              value: {
+                name: 'Bob'
+              }
+            }
+          };
 
           send.returns(Promise.resolve(
               new http.Response(200, {}, JSON.stringify(rawResponse))));
@@ -325,6 +332,38 @@ describe('http', function() {
             assert.ok(executor.w3c, 'should never downgrade');
           });
         });
+
+        it('handles legacy new session failures', function() {
+          let rawResponse = {
+            status: error.ErrorCode.NO_SUCH_ELEMENT,
+            value: {message: 'hi'}
+          };
+
+          send.returns(Promise.resolve(
+              new http.Response(500, {}, JSON.stringify(rawResponse))));
+
+          return executor.execute(command)
+              .then(() => assert.fail('should have failed'),
+                    e => {
+                      assert.ok(e instanceof error.NoSuchElementError);
+                      assert.equal(e.message, 'hi');
+                    });
+        });
+
+        it('handles w3c new session failures', function() {
+          let rawResponse =
+              {value: {error: 'no such element', message: 'oops'}};
+
+          send.returns(Promise.resolve(
+              new http.Response(500, {}, JSON.stringify(rawResponse))));
+
+          return executor.execute(command)
+              .then(() => assert.fail('should have failed'),
+                    e => {
+                      assert.ok(e instanceof error.NoSuchElementError);
+                      assert.equal(e.message, 'oops');
+                    });
+        });
       });
 
       describe('extracts Session from DESCRIBE_SESSION response', function() {
@@ -398,7 +437,7 @@ describe('http', function() {
         });
 
         it('does not auto-upgrade on W3C response', function() {
-          var rawResponse = {sessionId: 's123', value: {name: 'Bob'}};
+          var rawResponse = {value: {sessionId: 's123', value: {name: 'Bob'}}};
 
           send.returns(Promise.resolve(
               new http.Response(200, {}, JSON.stringify(rawResponse))));

package/test/lib/promise_test.js

@@ -301,6 +301,25 @@ describe('promise', function() {
   });
 
   promiseManagerSuite(() => {
+    describe('fulfilled', function() {
+      it('returns input value if it is already a valid promise', function() {
+        let p = promise.createPromise(function() {});
+        let r = promise.fulfilled(p);
+        assert.strictEqual(p, r);
+      });
+
+      it('creates a new promise fulfilled with input', function() {
+        return promise.fulfilled(1234).then(v => assert.equal(1234, v));
+      });
+
+      it('can convert thenables to valid promise', function() {
+        let thenable = {then: function(cb) {cb(1234)}};
+        let p = promise.fulfilled(thenable);
+        assert.notStrictEqual(thenable, p);
+        return p.then(v => assert.equal(1234, v));
+      });
+    });
+
     describe('when', function() {
       it('ReturnsAResolvedPromiseIfGivenANonPromiseValue', function() {
         var ret = promise.when('abc');

package/test/lib/until_test.js

@@ -70,39 +70,54 @@ describe('until', function() {
           .then(fail, (e2) => assert.strictEqual(e2, e));
     });
 
+    const ELEMENT_ID = 'some-element-id';
+    const ELEMENT_INDEX = 1234;
+
+    function onSwitchFrame(expectedId) {
+      if (typeof expectedId === 'string') {
+        expectedId = WebElement.buildId(expectedId);
+      } else {
+        assert.equal(typeof expectedId, 'number', 'must be string or number');
+      }
+      return cmd => {
+        assert.deepEqual(
+            cmd.getParameter('id'), expectedId, 'frame ID not specified');
+        return true;
+      };
+    }
+
     it('byIndex', function() {
-      executor.on(CommandName.SWITCH_TO_FRAME, () => true);
-      return driver.wait(until.ableToSwitchToFrame(0), 100);
+      executor.on(CommandName.SWITCH_TO_FRAME, onSwitchFrame(ELEMENT_INDEX));
+      return driver.wait(until.ableToSwitchToFrame(ELEMENT_INDEX), 100);
     });
 
     it('byWebElement', function() {
-      executor.on(CommandName.SWITCH_TO_FRAME, () => true);
-      var el = new webdriver.WebElement(driver, {ELEMENT: 1234});
+      executor.on(CommandName.SWITCH_TO_FRAME, onSwitchFrame(ELEMENT_ID));
+
+      var el = new webdriver.WebElement(driver, ELEMENT_ID);
       return driver.wait(until.ableToSwitchToFrame(el), 100);
     });
 
     it('byWebElementPromise', function() {
-      executor.on(CommandName.SWITCH_TO_FRAME, () => true);
+      executor.on(CommandName.SWITCH_TO_FRAME, onSwitchFrame(ELEMENT_ID));
       var el = new webdriver.WebElementPromise(driver,
-          Promise.resolve(new webdriver.WebElement(driver, {ELEMENT: 1234})));
+          Promise.resolve(new webdriver.WebElement(driver, ELEMENT_ID)));
       return driver.wait(until.ableToSwitchToFrame(el), 100);
     });
 
     it('byLocator', function() {
-      executor.on(CommandName.FIND_ELEMENTS, () => [WebElement.buildId(1234)]);
-      executor.on(CommandName.SWITCH_TO_FRAME, () => true);
+      executor.on(CommandName.FIND_ELEMENTS, () => [WebElement.buildId(ELEMENT_ID)]);
+      executor.on(CommandName.SWITCH_TO_FRAME, onSwitchFrame(ELEMENT_ID));
       return driver.wait(until.ableToSwitchToFrame(By.id('foo')), 100);
     });
 
     it('byLocator_elementNotInitiallyFound', function() {
-      var foundResponses = [[], [], [WebElement.buildId(1234)]];
+      let foundResponses = [[], [], [WebElement.buildId(ELEMENT_ID)]];
       executor.on(CommandName.FIND_ELEMENTS, () => foundResponses.shift());
-      executor.on(CommandName.SWITCH_TO_FRAME, () => true);
+      executor.on(CommandName.SWITCH_TO_FRAME, onSwitchFrame(ELEMENT_ID));
 
       return driver.wait(until.ableToSwitchToFrame(By.id('foo')), 2000)
-          .then(function() {
-            assert.equal(foundResponses.length, 0);
-          });
+          .then(() => assert.deepEqual(foundResponses, []));
     });
 
     it('timesOutIfNeverAbletoSwitchFrames', function() {

package/test/lib/webdriver_test.js

@@ -403,7 +403,7 @@ describe('WebDriver', function() {
 
       var driver =
           WebDriver.createSession(executor, {'browserName': 'firefox'},
-              null, null, () => called = true);
+              null, () => called = true);
       return driver.getSession().then(fail, err => {
         assert.ok(called);
         assertIsStubError(err);
@@ -464,8 +464,7 @@ describe('WebDriver', function() {
               .end();
 
           WebDriver.createSession(
-              executor, {'browserName': 'firefox'}, null, null,
-              () => {throw e});
+              executor, {'browserName': 'firefox'}, null, () => {throw e});
           return waitForAbort().then(err => assert.strictEqual(err, e));
         });
       });
@@ -1446,6 +1445,7 @@ describe('WebDriver', function() {
       let executor = new FakeExecutor().
           expect(CName.SEND_KEYS_TO_ELEMENT,
                  {'id': WebElement.buildId('one'),
+                  'text': '12abc3',
                   'value':'12abc3'.split('')}).
               andReturnSuccess().
           end();
@@ -1463,6 +1463,7 @@ describe('WebDriver', function() {
               andReturnSuccess(WebElement.buildId('one')).
           expect(CName.SEND_KEYS_TO_ELEMENT,
                  {'id':WebElement.buildId('one'),
+                  'text': 'abc123def',
                   'value':'abc123def'.split('')}).
               andReturnSuccess().
           end();
@@ -1482,6 +1483,7 @@ describe('WebDriver', function() {
               andReturnSuccess(WebElement.buildId('one')).
           expect(CName.SEND_KEYS_TO_ELEMENT,
                  {'id': WebElement.buildId('one'),
+                  'text': 'modified/path',
                   'value':'modified/path'.split('')}).
               andReturnSuccess().
           end();
@@ -1952,6 +1954,108 @@ describe('WebDriver', function() {
     });
   });
 
+  describe('manage()', function() {
+    describe('setTimeouts()', function() {
+      describe('throws if no timeouts are specified', function() {
+        let driver;
+        before(() => driver = new FakeExecutor().createDriver());
+
+        it('; no arguments', function() {
+          assert.throws(() => driver.manage().setTimeouts(), TypeError);
+        });
+
+        it('; ignores unrecognized timeout keys', function() {
+          assert.throws(
+              () => driver.manage().setTimeouts({foo: 123}), TypeError);
+        });
+
+        it('; ignores positional arguments', function() {
+          assert.throws(
+              () => driver.manage().setTimeouts(1234, 56), TypeError);
+        });
+      });
+
+      describe('throws timeout is not a number, null, or undefined', () => {
+        let driver;
+        before(() => driver = new FakeExecutor().createDriver());
+
+        function checkError(e) {
+          return e instanceof TypeError
+              && /expected "(script|pageLoad|implicit)" to be a number/.test(
+                  e.message);
+        }
+
+        it('script', function() {
+          assert.throws(
+              () => driver.manage().setTimeouts({script: 'abc'}),
+              checkError);
+        });
+
+        it('pageLoad', function() {
+          assert.throws(
+              () => driver.manage().setTimeouts({pageLoad: 'abc'}),
+              checkError);
+        });
+
+        it('implicit', function() {
+          assert.throws(
+              () => driver.manage().setTimeouts({implicit: 'abc'}),
+              checkError);
+        });
+      });
+
+      it('can set multiple timeouts', function() {
+        let executor = new FakeExecutor()
+            .expect(CName.SET_TIMEOUT, {script:1, pageLoad: 2, implicit: 3})
+            .andReturnSuccess()
+            .end();
+        let driver = executor.createDriver();
+        return driver.manage()
+            .setTimeouts({script: 1, pageLoad: 2, implicit: 3});
+      });
+
+      it('falls back to legacy wire format if W3C version fails', () => {
+        let executor = new FakeExecutor()
+            .expect(CName.SET_TIMEOUT, {implicit: 3})
+            .andReturnError(Error('oops'))
+            .expect(CName.SET_TIMEOUT, {type: 'implicit', ms: 3})
+            .andReturnSuccess()
+            .end();
+        let driver = executor.createDriver();
+        return driver.manage().setTimeouts({implicit: 3});
+      });
+
+      describe('deprecated API calls setTimeouts()', function() {
+        it('implicitlyWait()', function() {
+          let executor = new FakeExecutor()
+              .expect(CName.SET_TIMEOUT, {implicit: 3})
+              .andReturnSuccess()
+              .end();
+          let driver = executor.createDriver();
+          return driver.manage().timeouts().implicitlyWait(3);
+        });
+
+        it('setScriptTimeout()', function() {
+          let executor = new FakeExecutor()
+              .expect(CName.SET_TIMEOUT, {script: 3})
+              .andReturnSuccess()
+              .end();
+          let driver = executor.createDriver();
+          return driver.manage().timeouts().setScriptTimeout(3);
+        });
+
+        it('pageLoadTimeout()', function() {
+          let executor = new FakeExecutor()
+              .expect(CName.SET_TIMEOUT, {pageLoad: 3})
+              .andReturnSuccess()
+              .end();
+          let driver = executor.createDriver();
+          return driver.manage().timeouts().pageLoadTimeout(3);
+        });
+      });
+    });
+  });
+
   describe('generator support', function() {
     var driver;
 

package/test/page_loading_test.js

@@ -57,12 +57,6 @@ test.suite(function(env) {
     return assert(driver.getTitle()).equalTo('We Arrive Here');
   });
 
-  test.ignore(browsers(Browser.SAFARI)).
-  it('should follow meta redirects', function*() {
-    yield driver.get(Pages.metaRedirectPage);
-    return assert(driver.getTitle()).equalTo('We Arrive Here');
-  });
-
   // Skip Firefox; see https://bugzilla.mozilla.org/show_bug.cgi?id=1280300
   test.ignore(browsers(Browser.FIREFOX)).
   it('should be able to get a fragment on the current page', function*() {

package/test/rect_test.js

@@ -0,0 +1,60 @@
+// 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 {By} = require('..');
+const test = require('../lib/test');
+
+test.suite(function(env) {
+  describe('rect commands', function() {
+    let driver;
+    let el;
+
+    test.before(function*() {
+      driver = yield env.builder().build();
+      yield driver.get(
+            'data:text/html,<!DOCTYPE html><style>'
+                + '*{padding:0; margin:0}'
+                + 'div{position: absolute; top: 50px; left: 50px;'
+                + 'height: 50px;width:50px;background: green;}'
+                + '</style><div>Hello</div>');
+      el = yield driver.findElement(By.css('div'));
+    });
+
+    after(function() {
+      if (driver) {
+        return driver.quit();
+      }
+    });
+
+    test.it('WebElement.getLocation()', function*() {
+      let location = yield el.getLocation();
+      assert.equal(location.x, 50);
+      assert.equal(location.y, 50);
+    });
+
+    test.it('WebElement.getSize()', function*() {
+      let size = yield el.getSize();
+      assert.equal(size.width, 50);
+      assert.equal(size.height, 50);
+    });
+
+  });
+});

package/test/remote_test.js

@@ -83,7 +83,7 @@ describe('FileDetector', function() {
   }
 
   it('returns the original path if the file does not exist', function() {
-    return io.tmpDir(dir => {
+    return io.tmpDir().then(dir => {
       let theFile = path.join(dir, 'not-there');
       return (new remote.FileDetector)
           .handleFile(new ExplodingDriver, theFile)
@@ -92,7 +92,7 @@ describe('FileDetector', function() {
   });
 
   it('returns the original path if it is a directory', function() {
-    return io.tmpDir(dir => {
+    return io.tmpDir().then(dir => {
       return (new remote.FileDetector)
           .handleFile(new ExplodingDriver, dir)
           .then(f => assert.equal(f, dir));
@@ -100,7 +100,7 @@ describe('FileDetector', function() {
   });
 
   it('attempts to upload valid files', function() {
-    return io.tmpFile(theFile => {
+    return io.tmpFile().then(theFile => {
       return (new remote.FileDetector)
           .handleFile(
               new (class FakeDriver {