selenium-webdriver 3.1.0 → 3.6.0

package/test/firefox/extension_test.js

@@ -17,24 +17,27 @@
 
 'use strict';
 
-var AdmZip = require('adm-zip'),
-    assert = require('assert'),
+var assert = require('assert'),
     crypto = require('crypto'),
     fs = require('fs'),
     path = require('path');
 
 var extension = require('../../firefox/extension'),
     io = require('../../io'),
+    zip = require('../../io/zip'),
     it = require('../../testing').it;
 
 
 var JETPACK_EXTENSION = path.join(__dirname,
     '../../lib/test/data/firefox/jetpack-sample.xpi');
 var NORMAL_EXTENSION = path.join(__dirname,
-    '../../lib/test/data/firefox/sample.xpi');
+  '../../lib/test/data/firefox/sample.xpi');
+var WEBEXTENSION_EXTENSION = path.join(__dirname,
+  '../../lib/test/data/firefox/webextension.xpi');
 
 var JETPACK_EXTENSION_ID = 'jid1-EaXX7k0wwiZR7w@jetpack';
 var NORMAL_EXTENSION_ID = 'sample@seleniumhq.org';
+var WEBEXTENSION_EXTENSION_ID = 'webextensions-selenium-example@example.com';
 
 
 describe('extension', function() {
@@ -75,22 +78,43 @@ describe('extension', function() {
     });
   });
 
+  it('can install a webextension xpi file', function() {
+    return io.tmpDir().then(function(dir) {
+      return extension.install(WEBEXTENSION_EXTENSION, dir).then(function(id) {
+        assert.equal(WEBEXTENSION_EXTENSION_ID, id);
+        var file = path.join(dir, id + '.xpi');
+        assert.ok(fs.existsSync(file), 'no such file: ' + file);
+        assert.ok(!fs.statSync(file).isDirectory());
+
+        var copiedSha1 = crypto.createHash('sha1')
+          .update(fs.readFileSync(file))
+          .digest('hex');
+
+        var goldenSha1 = crypto.createHash('sha1')
+          .update(fs.readFileSync(WEBEXTENSION_EXTENSION))
+          .digest('hex');
+
+        assert.equal(copiedSha1, goldenSha1);
+      });
+    });
+  });
+
   it('can install an extension from a directory', function() {
     return io.tmpDir().then(function(srcDir) {
-      var buf = fs.readFileSync(NORMAL_EXTENSION);
-      new AdmZip(buf).extractAllTo(srcDir, true);
-      return io.tmpDir().then(function(dstDir) {
-        return extension.install(srcDir, dstDir).then(function(id) {
-          assert.equal(NORMAL_EXTENSION_ID, id);
-
-          var dir = path.join(dstDir, NORMAL_EXTENSION_ID);
-
-          assert.ok(fs.existsSync(path.join(dir, 'chrome.manifest')));
-          assert.ok(fs.existsSync(path.join(dir, 'content/overlay.xul')));
-          assert.ok(fs.existsSync(path.join(dir, 'content/overlay.js')));
-          assert.ok(fs.existsSync(path.join(dir, 'install.rdf')));
-        });
-      });
+      return zip.unzip(NORMAL_EXTENSION, srcDir)
+          .then(() => io.tmpDir())
+          .then(dstDir => {
+            return extension.install(srcDir, dstDir).then(function(id) {
+              assert.equal(NORMAL_EXTENSION_ID, id);
+
+              var dir = path.join(dstDir, NORMAL_EXTENSION_ID);
+
+              assert.ok(fs.existsSync(path.join(dir, 'chrome.manifest')));
+              assert.ok(fs.existsSync(path.join(dir, 'content/overlay.xul')));
+              assert.ok(fs.existsSync(path.join(dir, 'content/overlay.js')));
+              assert.ok(fs.existsSync(path.join(dir, 'install.rdf')));
+            });
+          });
     });
   });
 });

package/test/firefox/firefox_test.js

@@ -33,23 +33,36 @@ var JETPACK_EXTENSION = path.join(__dirname,
     '../../lib/test/data/firefox/jetpack-sample.xpi');
 var NORMAL_EXTENSION = path.join(__dirname,
     '../../lib/test/data/firefox/sample.xpi');
+var WEBEXTENSION_EXTENSION = path.join(__dirname,
+  '../../lib/test/data/firefox/webextension.xpi');
 
 
 test.suite(function(env) {
   describe('firefox', function() {
     describe('Options', function() {
-      var driver;
+      let driver;
 
-      test.beforeEach(function() {
+      beforeEach(function() {
         driver = null;
       });
 
-      test.afterEach(function() {
+      afterEach(function() {
         if (driver) {
           return driver.quit();
         }
       });
 
+      /**
+       * @param {...string} extensions the extensions to install.
+       * @return {!firefox.Profile} a new profile.
+       */
+      function profileWithExtensions(...extensions) {
+        let profile = new firefox.Profile();
+        profile.setPreference('xpinstall.signatures.required', false);
+        extensions.forEach(ext => profile.addExtension(ext));
+        return profile;
+      }
+
       /**
        * Runs a test that requires Firefox Developer Edition. The test will be
        * skipped if dev cannot be found on the current system.
@@ -97,9 +110,7 @@ test.suite(function(env) {
       });
 
       test.it('can start Firefox with a jetpack extension', function() {
-        let profile = new firefox.Profile();
-        profile.addExtension(JETPACK_EXTENSION);
-
+        let profile = profileWithExtensions(JETPACK_EXTENSION);
         let options = new firefox.Options().setProfile(profile);
 
         return runWithFirefoxDev(options, function*() {
@@ -113,9 +124,7 @@ test.suite(function(env) {
       });
 
       test.it('can start Firefox with a normal extension', function() {
-        let profile = new firefox.Profile();
-        profile.addExtension(NORMAL_EXTENSION);
-
+        let profile = profileWithExtensions(NORMAL_EXTENSION);
         let options = new firefox.Options().setProfile(profile);
 
         return runWithFirefoxDev(options, function*() {
@@ -128,11 +137,23 @@ test.suite(function(env) {
         });
       });
 
-      test.it('can start Firefox with multiple extensions', function() {
-        let profile = new firefox.Profile();
-        profile.addExtension(JETPACK_EXTENSION);
-        profile.addExtension(NORMAL_EXTENSION);
+      test.it('can start Firefox with a webextension extension', function() {
+        let profile = profileWithExtensions(WEBEXTENSION_EXTENSION);
+        let options = new firefox.Options().setProfile(profile);
 
+        return runWithFirefoxDev(options, function*() {
+          yield driver.get(test.Pages.echoPage);
+
+          let footer =
+            yield driver.findElement({id: 'webextensions-selenium-example'});
+          let text = yield footer.getText();
+          assert(text).equalTo('Content injected by webextensions-selenium-example');
+        });
+      });
+
+      test.it('can start Firefox with multiple extensions', function() {
+        let profile =
+            profileWithExtensions(JETPACK_EXTENSION, NORMAL_EXTENSION);
         let options = new firefox.Options().setProfile(profile);
 
         return runWithFirefoxDev(options, function*() {
@@ -198,13 +219,11 @@ test.suite(function(env) {
         }
       });
 
-      test.ignore(() => !env.isMarionette).
-      it('can get context', function() {
+      test.it('can get context', function() {
         return assert(driver.getContext()).equalTo(Context.CONTENT);
       });
 
-      test.ignore(() => !env.isMarionette).
-      it('can set context', function*() {
+      test.it('can set context', function*() {
         yield driver.setContext(Context.CHROME);
         let ctxt = yield driver.getContext();
         assert(ctxt).equalTo(Context.CHROME);
@@ -214,8 +233,7 @@ test.suite(function(env) {
         assert(ctxt).equalTo(Context.CONTENT);
       });
 
-      test.ignore(() => !env.isMarionette).
-      it('throws on unknown context', function() {
+      test.it('throws on unknown context', function() {
         return driver.setContext("foo").then(assert.fail, function(e) {
           assert(e).instanceOf(error.InvalidArgumentError);
         });

package/test/firefox/profile_test.js

@@ -17,8 +17,7 @@
 
 'use strict';
 
-var AdmZip = require('adm-zip'),
-    assert = require('assert'),
+var assert = require('assert'),
     fs = require('fs'),
     path = require('path');
 
@@ -33,10 +32,12 @@ var JETPACK_EXTENSION = path.join(__dirname,
     '../../lib/test/data/firefox/jetpack-sample.xpi');
 var NORMAL_EXTENSION = path.join(__dirname,
     '../../lib/test/data/firefox/sample.xpi');
+var WEBEXTENSION_EXTENSION = path.join(__dirname,
+  '../../lib/test/data/firefox/webextension.xpi');
 
 var JETPACK_EXTENSION_ID = 'jid1-EaXX7k0wwiZR7w@jetpack.xpi';
 var NORMAL_EXTENSION_ID = 'sample@seleniumhq.org';
-var WEBDRIVER_EXTENSION_ID = 'fxdriver@googlecode.com';
+var WEBEXTENSION_EXTENSION_ID = 'webextensions-selenium-example@example.com';
 
 
 
@@ -57,13 +58,6 @@ describe('Profile', function() {
       assert.equal('http://www.example.com',
           profile.getPreference('browser.newtab.url'));
     });
-
-    it('throws if setting a frozen preference', function() {
-      var profile = new Profile();
-      assert.throws(function() {
-        profile.setPreference('app.update.auto', true);
-      });
-    });
   });
 
   describe('writeToDisk', function() {
@@ -104,20 +98,6 @@ describe('Profile', function() {
     });
 
     describe('user.js', function() {
-
-      it('writes defaults', function() {
-        return new Profile().writeToDisk().then(function(dir) {
-          return loadUserPrefs(path.join(dir, 'user.js'));
-        }).then(function(prefs) {
-          // Just check a few.
-          assert.equal(false, prefs['app.update.auto']);
-          assert.equal(true, prefs['browser.EULA.override']);
-          assert.equal(false, prefs['extensions.update.enabled']);
-          assert.equal('about:blank', prefs['browser.newtab.url']);
-          assert.equal(30, prefs['dom.max_script_run_time']);
-        });
-      });
-
       it('merges template user.js into preferences', function() {
         return io.tmpDir().then(function(dir) {
           fs.writeFileSync(path.join(dir, 'user.js'), [
@@ -133,19 +113,6 @@ describe('Profile', function() {
           assert.equal(1234, prefs['dom.max_script_run_time']);
         });
       });
-
-      it('ignores frozen preferences when merging template user.js',
-        function() {
-          return io.tmpDir().then(function(dir) {
-            fs.writeFileSync(path.join(dir, 'user.js'),
-                'user_pref("app.update.auto", true)');
-            return new Profile(dir).writeToDisk();
-          }).then(function(profile) {
-            return loadUserPrefs(path.join(profile, 'user.js'));
-          }).then(function(prefs) {
-            assert.equal(false, prefs['app.update.auto']);
-          });
-        });
     });
 
     describe('extensions', function() {
@@ -153,33 +120,21 @@ describe('Profile', function() {
         var profile = new Profile();
         profile.addExtension(JETPACK_EXTENSION);
         profile.addExtension(NORMAL_EXTENSION);
+        profile.addExtension(WEBEXTENSION_EXTENSION);
 
         return profile.writeToDisk().then(function(dir) {
           dir = path.join(dir, 'extensions');
-          assert.ok(fs.existsSync(path.join(dir, JETPACK_EXTENSION_ID)));
-          assert.ok(fs.existsSync(path.join(dir, NORMAL_EXTENSION_ID)));
-          assert.ok(fs.existsSync(path.join(dir, WEBDRIVER_EXTENSION_ID)));
+          assertExists(JETPACK_EXTENSION_ID);
+          assertExists(NORMAL_EXTENSION_ID);
+          assertExists(WEBEXTENSION_EXTENSION_ID + '.xpi');
+
+          function assertExists(file) {
+            assert.ok(
+                fs.existsSync(path.join(dir, file)),
+                `expected ${file} to exist`);
+          }
         });
       });
     });
   });
-
-  describe('encode', function() {
-    it('excludes the bundled WebDriver extension', function() {
-      return new Profile().encode().then(function(data) {
-        return decode(data);
-      }).then(function(dir) {
-        assert.ok(fs.existsSync(path.join(dir, 'user.js')));
-        assert.ok(fs.existsSync(path.join(dir, 'extensions')));
-        return loadUserPrefs(path.join(dir, 'user.js'));
-      }).then(function(prefs) {
-        // Just check a few.
-        assert.equal(false, prefs['app.update.auto']);
-        assert.equal(true, prefs['browser.EULA.override']);
-        assert.equal(false, prefs['extensions.update.enabled']);
-        assert.equal('about:blank', prefs['browser.newtab.url']);
-        assert.equal(30, prefs['dom.max_script_run_time']);
-      });
-    });
-  });
 });

package/test/http/http_test.js

@@ -44,6 +44,14 @@ describe('HttpClient', function() {
       res.writeHead(200, {'content-type': 'text/plain'});
       res.end('hello, world!');
 
+    } else if (req.method == 'GET' && req.url == '/chunked') {
+      res.writeHead(200, {
+        'content-type': 'text/html; charset=utf-8',
+        'transfer-encoding': 'chunked'
+      });
+      res.write('<!DOCTYPE html>');
+      setTimeout(() => res.end('<h1>Hello, world!</h1>'), 20);
+
     } else if (req.method == 'GET' && req.url == '/badredirect') {
       res.writeHead(303, {});
       res.end();
@@ -121,6 +129,16 @@ describe('HttpClient', function() {
     });
   });
 
+  it('handles chunked responses', function() {
+    let request = new HttpRequest('GET', '/chunked');
+
+    let client = new HttpClient(server.url());
+    return client.send(request).then(response => {
+      assert.equal(200, response.status);
+      assert.equal(response.body, '<!DOCTYPE html><h1>Hello, world!</h1>');
+    });
+  });
+
   it('can use basic auth', function() {
     var parsed = url.parse(server.url());
     parsed.auth = 'genie:bottle';

package/test/{io_test.js → io/io_test.js}

@@ -22,7 +22,7 @@ var assert = require('assert'),
     path = require('path'),
     tmp = require('tmp');
 
-var io = require('../io');
+var io = require('../../io');
 
 
 describe('io', function() {
@@ -318,4 +318,43 @@ describe('io', function() {
                 (e) => assert.equal('ENOENT', e.code));
     });
   });
+
+  describe('mkdirp', function() {
+    it('recursively creates entire directory path', function() {
+      return io.tmpDir().then(root => {
+        let dst = path.join(root, 'foo/bar/baz');
+        return io.mkdirp(dst).then(d => {
+          assert.strictEqual(d, dst);
+          return io.stat(d).then(stats => {
+            assert.ok(stats.isDirectory());
+          });
+        });
+      });
+    });
+
+    it('does nothing if the directory already exists', function() {
+      return io.tmpDir()
+          .then(dir => io.mkdirp(dir).then(d => assert.strictEqual(d, dir)));
+    });
+  });
+
+  describe('walkDir', function() {
+    it('walk directory', function() {
+      return io.tmpDir().then(dir => {
+        fs.writeFileSync(path.join(dir, 'file1'), 'hello');
+        fs.mkdirSync(path.join(dir, 'sub'));
+        fs.mkdirSync(path.join(dir, 'sub/folder'));
+        fs.writeFileSync(path.join(dir, 'sub/folder/file2'), 'goodbye');
+
+        return io.walkDir(dir).then(seen => {
+          assert.deepStrictEqual(
+              seen,
+              [{path: 'file1', dir: false},
+               {path: 'sub', dir: true},
+               {path: 'sub/folder', dir: true},
+               {path: 'sub/folder/file2', dir: false}]);
+        });
+      });
+    });
+  })
 });

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

@@ -38,6 +38,7 @@ describe('error', function() {
     });
 
     test('unknown error', error.WebDriverError);
+    test('element not interactable', error.ElementNotInteractableError);
     test('element not selectable', error.ElementNotSelectableError);
     test('element not visible', error.ElementNotVisibleError);
     test('invalid argument', error.InvalidArgumentError);
@@ -187,13 +188,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))));
@@ -344,7 +351,8 @@ describe('http', function() {
         });
 
         it('handles w3c new session failures', function() {
-          let rawResponse = {error: 'no such element', message: 'oops'};
+          let rawResponse =
+              {value: {error: 'no such element', message: 'oops'}};
 
           send.returns(Promise.resolve(
               new http.Response(500, {}, JSON.stringify(rawResponse))));
@@ -429,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))));