selenium-webdriver 3.3.0 → 4.0.0-alpha.1

package/test/firefox_test.js

@@ -0,0 +1,251 @@
+// 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 path = require('path');
+
+const error = require('../lib/error');
+const firefox = require('../firefox');
+const io = require('../io');
+const {Browser} = require('../');
+const {Context} = require('../firefox');
+const {Pages, suite, ignore} = require('../lib/test');
+
+
+const WEBEXTENSION_EXTENSION =
+    path.join(__dirname, '../lib/test/data/firefox/webextension.xpi');
+
+const WEBEXTENSION_EXTENSION_ID =
+    'webextensions-selenium-example@example.com.xpi';
+
+
+suite(function(env) {
+  describe('firefox', function() {
+    let driver;
+
+    beforeEach(function() {
+      driver = null;
+    });
+
+    afterEach(function() {
+      return driver && driver.quit();
+    });
+
+    /**
+     * 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) {
+      return firefox.Channel.AURORA.locate().then(async (exe) => {
+        options = options || new firefox.Options();
+        options.setBinary(exe);
+        driver = await env.builder()
+            .setFirefoxOptions(options)
+            .build();
+        return testFn();
+      }, err => {
+        console.warn(
+            'Skipping test: could not find Firefox Dev Edition: ' + err);
+      });
+    }
+
+    describe('Options', function() {
+      let profileWithWebExtension;
+      let profileWithUserPrefs;
+
+      before(async function createProfileWithWebExtension() {
+        profileWithWebExtension = await io.tmpDir();
+        let extensionsDir = path.join(profileWithWebExtension, 'extensions');
+        await io.mkdir(extensionsDir);
+        await io.write(
+            path.join(extensionsDir, WEBEXTENSION_EXTENSION_ID),
+            await io.read(WEBEXTENSION_EXTENSION));
+      });
+
+      before(async function createProfileWithUserPrefs() {
+        profileWithUserPrefs = await io.tmpDir();
+        await io.write(
+            path.join(profileWithUserPrefs, 'user.js'),
+            'user_pref("general.useragent.override", "foo;bar");\n');
+      });
+
+      describe('setProfile', function() {
+        it('use profile with custom prefs', async function() {
+          let options = new firefox.Options;
+          options.setProfile(profileWithUserPrefs);
+
+          driver = env.builder().setFirefoxOptions(options).build();
+
+          await driver.get(Pages.echoPage);
+          await verifyUserAgentWasChanged();
+        });
+
+        it('use profile with extension', function() {
+          let options = new firefox.Options;
+          options.setProfile(profileWithWebExtension);
+
+          return runWithFirefoxDev(options, async function() {
+            await driver.get(Pages.echoPage);
+            await verifyWebExtensionWasInstalled();
+          });
+        });
+      });
+
+      describe('setPreference', function() {
+        it('throws if key is not a string', function() {
+          let options = new firefox.Options;
+          assert.throws(() => options.setPreference(1, 2), TypeError);
+          options.setPreference('1', 2);  // OK if no throw.
+        });
+
+        it('throws if value is an invalid type', function() {
+          let options = new firefox.Options;
+          options.setPreference('a', 1);
+          options.setPreference('b', '2');
+          options.setPreference('c', true);
+
+          assert.throws(() => options.setPreference('d', null), TypeError);
+          assert.throws(() => options.setPreference('d', undefined), TypeError);
+          assert.throws(() => options.setPreference('d', {}), TypeError);
+        });
+
+        it('can start Firefox with custom preferences', async function() {
+          let options = new firefox.Options();
+          options.setPreference('general.useragent.override', 'foo;bar');
+
+          driver = env.builder().setFirefoxOptions(options).build();
+
+          await driver.get(Pages.echoPage);
+          await verifyUserAgentWasChanged();
+        });
+
+        it('can add extra prefs on top of an existing profile', async function() {
+          let options = new firefox.Options()
+              .setPreference('general.useragent.override', 'foo;bar')
+              .setProfile(profileWithWebExtension);
+
+          return runWithFirefoxDev(options, async function() {
+            await driver.get(Pages.echoPage);
+            await verifyWebExtensionWasInstalled();
+            await verifyUserAgentWasChanged();
+          });
+        });
+      });
+
+      describe('addExtensions', function() {
+        it('can add extension to brand new profile', async function() {
+          let options = new firefox.Options();
+          options.addExtensions(WEBEXTENSION_EXTENSION);
+
+          return runWithFirefoxDev(options, async function() {
+            await driver.get(Pages.echoPage);
+            await verifyWebExtensionWasInstalled();
+          });
+        });
+
+        it('can add extension to custom profile', function() {
+          let options = new firefox.Options()
+              .addExtensions(WEBEXTENSION_EXTENSION)
+              .setProfile(profileWithUserPrefs);
+
+          return runWithFirefoxDev(options, async function() {
+            await driver.get(Pages.echoPage);
+            await verifyWebExtensionWasInstalled();
+            await verifyUserAgentWasChanged();
+          });
+        });
+
+        it('can addExtensions and setPreference', function() {
+          let options = new firefox.Options()
+              .addExtensions(WEBEXTENSION_EXTENSION)
+              .setPreference('general.useragent.override', 'foo;bar')
+
+          return runWithFirefoxDev(options, async function() {
+            await driver.get(Pages.echoPage);
+            await verifyWebExtensionWasInstalled();
+            await verifyUserAgentWasChanged();
+          });
+        });
+      });
+    });
+
+    describe('context switching', function() {
+      beforeEach(async function() {
+        driver = await env.builder().build();
+      });
+
+      it('can get context', async function() {
+        assert.equal(await driver.getContext(), Context.CONTENT);
+      });
+
+      it('can set context', async function() {
+        await driver.setContext(Context.CHROME);
+        let ctxt = await driver.getContext();
+        assert.equal(ctxt, Context.CHROME);
+
+        await driver.setContext(Context.CONTENT);
+        ctxt = await driver.getContext();
+        assert.equal(ctxt, Context.CONTENT);
+      });
+
+      it('throws on unknown context', function() {
+        return driver.setContext("foo").then(assert.fail, function(e) {
+          assert(e instanceof error.InvalidArgumentError);
+        });
+      });
+    });
+
+    it('addons can be installed and uninstalled at runtime', function() {
+      return runWithFirefoxDev(null, async function() {
+        await driver.get(Pages.echoPage);
+        await verifyWebExtensionNotInstalled();
+
+        let id = await driver.installAddon(WEBEXTENSION_EXTENSION);
+        await driver.sleep(1000);  // Give extension time to install (yuck).
+
+        await driver.get(Pages.echoPage);
+        await verifyWebExtensionWasInstalled();
+
+        await driver.uninstallAddon(id);
+        await driver.get(Pages.echoPage);
+        await verifyWebExtensionNotInstalled();
+      });
+    });
+
+    async function verifyUserAgentWasChanged() {
+      let userAgent =
+          await driver.executeScript('return window.navigator.userAgent');
+      assert.equal(userAgent, 'foo;bar');
+    }
+
+    async function verifyWebExtensionNotInstalled() {
+      let found =
+          await driver.findElements({id: 'webextensions-selenium-example'});
+      assert.equal(found.length, 0);
+    }
+
+    async function verifyWebExtensionWasInstalled() {
+      let footer =
+          await driver.findElement({id: 'webextensions-selenium-example'});
+      let text = await footer.getText();
+      assert.equal(
+          text, 'Content injected by webextensions-selenium-example');
+    }
+  });
+}, {browsers: [Browser.FIREFOX]});

package/test/http/http_test.js

@@ -27,7 +27,6 @@ var HttpClient = require('../../http').HttpClient,
     Server = require('../../lib/test/httpserver').Server;
 
 describe('HttpClient', function() {
-  this.timeout(4 * 1000);
 
   var server = new Server(function(req, res) {
     let parsedUrl = url.parse(req.url);
@@ -44,6 +43,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 +128,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/http/util_test.js

@@ -132,7 +132,7 @@ describe('selenium-webdriver/http/util', function() {
       return util.waitForServer(baseUrl, 200, cancel)
           .then(
               () => { throw Error('Did not expect to succeed!'); },
-              (e) => assert.ok(e instanceof promise.CancellationError));
+              (e) => assert.ok(e instanceof util.CancellationError));
     });
   });
 
@@ -172,7 +172,7 @@ describe('selenium-webdriver/http/util', function() {
       return util.waitForUrl(baseUrl, 200, cancel)
           .then(
               () => { throw Error('Did not expect to succeed!'); },
-              (e) => assert.ok(e instanceof promise.CancellationError));
+              (e) => assert.ok(e instanceof util.CancellationError));
     });
   });
 });

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,127 @@
+// 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 XPI_PATH =
+    path.join(__dirname, '../../lib/test/data/firefox/webextension.xpi');
+
+describe('io/zip', function() {
+  describe('unzip', function() {
+    it('creates destination dir if necessary', function() {
+      return io.tmpDir()
+          .then(dir => zip.unzip(XPI_PATH, dir))
+          .then(dir => {
+            assertExists(path.join(dir, 'inject.js'));
+            assertExists(path.join(dir, 'manifest.json'));
+            assertExists(path.join(dir, 'META-INF/manifest.mf'));
+          });
+    });
+  });
+
+  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,17 +38,19 @@ 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('insecure certificate', error.InsecureCertificateError);
     test('invalid argument', error.InvalidArgumentError);
     test('invalid cookie domain', error.InvalidCookieDomainError);
-    test('invalid element coordinates', error.InvalidElementCoordinatesError);
+    test('invalid coordinates', error.InvalidCoordinatesError);
     test('invalid element state', error.InvalidElementStateError);
     test('invalid selector', error.InvalidSelectorError);
     test('invalid session id', error.NoSuchSessionError);
     test('javascript error', error.JavascriptError);
     test('move target out of bounds', error.MoveTargetOutOfBoundsError);
     test('no such alert', error.NoSuchAlertError);
+    test('no such cookie', error.NoSuchCookieError);
     test('no such element', error.NoSuchElementError);
     test('no such frame', error.NoSuchFrameError);
     test('no such window', error.NoSuchWindowError);
@@ -91,8 +93,9 @@ describe('error', function() {
     });
 
     test(error.WebDriverError, 'unknown error');
+    test(error.ElementClickInterceptedError, 'element click intercepted');
     test(error.ElementNotSelectableError, 'element not selectable');
-    test(error.ElementNotVisibleError, 'element not visible');
+    test(error.InsecureCertificateError, 'insecure certificate');
     test(error.InvalidArgumentError, 'invalid argument');
     test(error.InvalidCookieDomainError, 'invalid cookie domain');
     test(error.InvalidElementStateError, 'invalid element state');
@@ -101,6 +104,7 @@ describe('error', function() {
     test(error.JavascriptError, 'javascript error');
     test(error.MoveTargetOutOfBoundsError, 'move target out of bounds');
     test(error.NoSuchAlertError, 'no such alert');
+    test(error.NoSuchCookieError, 'no such cookie');
     test(error.NoSuchElementError, 'no such element');
     test(error.NoSuchFrameError, 'no such frame');
     test(error.NoSuchWindowError, 'no such window');
@@ -162,17 +166,19 @@ describe('error', function() {
     });
 
     test('unknown error', error.WebDriverError);
+    test('element click intercepted', error.ElementClickInterceptedError);
     test('element not selectable', error.ElementNotSelectableError);
-    test('element not visible', error.ElementNotVisibleError);
+    test('insecure certificate', error.InsecureCertificateError);
     test('invalid argument', error.InvalidArgumentError);
     test('invalid cookie domain', error.InvalidCookieDomainError);
-    test('invalid element coordinates', error.InvalidElementCoordinatesError);
+    test('invalid coordinates', error.InvalidCoordinatesError);
     test('invalid element state', error.InvalidElementStateError);
     test('invalid selector', error.InvalidSelectorError);
     test('invalid session id', error.NoSuchSessionError);
     test('javascript error', error.JavascriptError);
     test('move target out of bounds', error.MoveTargetOutOfBoundsError);
     test('no such alert', error.NoSuchAlertError);
+    test('no such cookie', error.NoSuchCookieError);
     test('no such element', error.NoSuchElementError);
     test('no such frame', error.NoSuchFrameError);
     test('no such window', error.NoSuchWindowError);
@@ -187,17 +193,54 @@ 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;
             });
       });
     }
+
+    describe('remote stack trace decoding', function() {
+      test('stacktrace');
+      test('stackTrace');
+
+      function test(key) {
+        it(`encoded as "${key}"`, function() {
+          let data = {error: 'unknown command', message: 'oops'};
+          data[key] = 'some-stacktrace';
+          assert.throws(
+              () => error.throwDecodedError(data),
+              (e) => {
+                assert.strictEqual(e.remoteStacktrace, 'some-stacktrace');
+                return true;
+              });
+        });
+      }
+    });
   });
 
   describe('checkLegacyResponse', function() {
@@ -206,12 +249,12 @@ describe('error', function() {
       assert.strictEqual(resp, error.checkLegacyResponse(resp));
     });
 
+    test('NO_SUCH_SESSION', error.NoSuchSessionError);
     test('NO_SUCH_ELEMENT', error.NoSuchElementError);
     test('NO_SUCH_FRAME', error.NoSuchFrameError);
     test('UNKNOWN_COMMAND', error.UnsupportedOperationError);
     test('UNSUPPORTED_OPERATION', error.UnsupportedOperationError);
     test('STALE_ELEMENT_REFERENCE', error.StaleElementReferenceError);
-    test('ELEMENT_NOT_VISIBLE', error.ElementNotVisibleError);
     test('INVALID_ELEMENT_STATE', error.InvalidElementStateError);
     test('UNKNOWN_ERROR', error.WebDriverError);
     test('ELEMENT_NOT_SELECTABLE', error.ElementNotSelectableError);
@@ -224,12 +267,16 @@ describe('error', function() {
     test('UNEXPECTED_ALERT_OPEN', error.UnexpectedAlertOpenError);
     test('NO_SUCH_ALERT', error.NoSuchAlertError);
     test('SCRIPT_TIMEOUT', error.ScriptTimeoutError);
-    test('INVALID_ELEMENT_COORDINATES', error.InvalidElementCoordinatesError);
+    test('INVALID_ELEMENT_COORDINATES', error.InvalidCoordinatesError);
     test('INVALID_SELECTOR_ERROR', error.InvalidSelectorError);
     test('SESSION_NOT_CREATED', error.SessionNotCreatedError);
     test('MOVE_TARGET_OUT_OF_BOUNDS', error.MoveTargetOutOfBoundsError);
     test('INVALID_XPATH_SELECTOR', error.InvalidSelectorError);
     test('INVALID_XPATH_SELECTOR_RETURN_TYPE', error.InvalidSelectorError);
+    test('ELEMENT_NOT_INTERACTABLE', error.ElementNotInteractableError);
+    test('INVALID_ARGUMENT', error.InvalidArgumentError);
+    test('UNABLE_TO_CAPTURE_SCREEN', error.UnableToCaptureScreenError);
+    test('ELEMENT_CLICK_INTERCEPTED', error.ElementClickInterceptedError);
     test('METHOD_NOT_ALLOWED', error.UnsupportedOperationError);
 
     describe('UnexpectedAlertOpenError', function() {