fix(types): update for selenium-webdriver types creating transpile er…

…rors (#3848)

- pin package.json to a specific version of @types/selenium-webdriver

lib/browser.ts

@@ -562,7 +562,7 @@ export class ProtractorBrowser extends Webdriver {
    * @returns {!webdriver.promise.Promise} A promise that will be resolved to an
    *     array of the located {@link webdriver.WebElement}s.
    */
-  findElements(locator: Locator): webdriver.promise.Promise<any> {
+  findElements(locator: Locator): wdpromise.Promise<any> {
     return this.element.all(locator).getWebElements();
   }
 
@@ -572,8 +572,7 @@ export class ProtractorBrowser extends Webdriver {
    * @returns {!webdriver.promise.Promise} A promise that will resolve to whether
    *     the element is present on the page.
    */
-  isElementPresent(locatorOrElement: ProtractorBy|
-                   webdriver.WebElement): webdriver.promise.Promise<any> {
+  isElementPresent(locatorOrElement: ProtractorBy|WebElement): wdpromise.Promise<any> {
     let element =
         ((locatorOrElement as any).isPresent) ? locatorOrElement : this.element(locatorOrElement);
     return (element as any).isPresent();
@@ -823,7 +822,7 @@ export class ProtractorBrowser extends Webdriver {
    * @returns {!webdriver.promise.Promise} A promise that will resolve once
    *    page has been changed.
    */
-  setLocation(url: string): webdriver.promise.Promise<any> {
+  setLocation(url: string): wdpromise.Promise<any> {
     this.waitForAngular();
     return this
         .executeScriptWithDescription(
@@ -845,7 +844,7 @@ export class ProtractorBrowser extends Webdriver {
    * @returns {webdriver.promise.Promise<string>} The current absolute url from
    * AngularJS.
    */
-  getLocationAbsUrl(): webdriver.promise.Promise<any> {
+  getLocationAbsUrl(): wdpromise.Promise<any> {
     this.waitForAngular();
     return this.executeScriptWithDescription(
         clientSideScripts.getLocationAbsUrl, 'Protractor.getLocationAbsUrl()', this.rootEl);
@@ -930,7 +929,7 @@ export class ProtractorBrowser extends Webdriver {
    * @param {number=} opt_debugPort Optional port to use for the debugging
    * process
    */
-  pause(opt_debugPort?: number): webdriver.promise.Promise<any> {
+  pause(opt_debugPort?: number): wdpromise.Promise<any> {
     if (this.debugHelper.isAttached()) {
       logger.info('Encountered browser.pause(), but debugger already attached.');
       return wdpromise.fulfilled(true);

lib/debugger.ts

@@ -1,4 +1,5 @@
 import * as net from 'net';
+import {promise as wdpromise, WebElement} from 'selenium-webdriver';
 import * as util from 'util'
 
 import {ProtractorBrowser} from './browser';
@@ -11,7 +12,7 @@ declare var global: any;
 declare var process: any;
 
 let logger = new Logger('protractor');
-let webdriver = require('selenium-webdriver');
+const webdriver = require('selenium-webdriver');
 
 export class DebugHelper {
   /**
@@ -60,17 +61,15 @@ export class DebugHelper {
     }
     let context: Context = {require: require};
     global.list = (locator: Locator) => {
-      return (<Ptor>global.protractor)
-          .browser.findElements(locator)
-          .then((arr: webdriver.WebElement[]) => {
-            let found: string[] = [];
-            for (let i = 0; i < arr.length; ++i) {
-              arr[i].getText().then((text: string) => {
-                found.push(text);
-              });
-            }
-            return found;
+      return (<Ptor>global.protractor).browser.findElements(locator).then((arr: WebElement[]) => {
+        let found: string[] = [];
+        for (let i = 0; i < arr.length; ++i) {
+          arr[i].getText().then((text: string) => {
+            found.push(text);
           });
+        }
+        return found;
+      });
     };
     for (let key in global) {
       context[key] = global[key];
@@ -230,9 +229,9 @@ export class DebugHelper {
    *     is done. The promise will resolve to a boolean which represents whether
    *     this is the first time that the debugger is called.
    */
-  private validatePortAvailability_(port: number): webdriver.promise.Promise<any> {
+  private validatePortAvailability_(port: number): wdpromise.Promise<any> {
     if (this.debuggerValidated_) {
-      return webdriver.promise.fulfilled(false);
+      return wdpromise.fulfilled(false);
     }
 
     let doneDeferred = webdriver.promise.defer();

lib/driverProviders/attachSession.ts

@@ -4,15 +4,14 @@
  *  it down, and setting up the driver correctly.
  */
 import * as q from 'q';
+import {WebDriver} from 'selenium-webdriver';
+import * as executors from 'selenium-webdriver/executors';
 
 import {Config} from '../config';
 import {Logger} from '../logger';
 
 import {DriverProvider} from './driverProvider';
 
-let webdriver = require('selenium-webdriver');
-let executors = require('selenium-webdriver/executors');
-
 let logger = new Logger('attachSession');
 
 export class AttachSession extends DriverProvider {
@@ -38,9 +37,9 @@ export class AttachSession extends DriverProvider {
    * @public
    * @return {WebDriver} webdriver instance
    */
-  getNewDriver(): webdriver.WebDriver {
+  getNewDriver(): WebDriver {
     var executor = executors.createExecutor(this.config_.seleniumAddress);
-    var newDriver = webdriver.WebDriver.attachToSession(executor, this.config_.seleniumSessionId);
+    var newDriver = WebDriver.attachToSession(executor, this.config_.seleniumSessionId);
     this.drivers_.push(newDriver);
     return newDriver;
   }
@@ -50,8 +49,8 @@ export class AttachSession extends DriverProvider {
    *
    * @public
    */
-  quitDriver(): q.Promise<webdriver.WebDriver> {
-    let defer = q.defer<webdriver.WebDriver>();
+  quitDriver(): q.Promise<WebDriver> {
+    let defer = q.defer<WebDriver>();
     defer.resolve(null);
     return defer.promise;
   }

lib/driverProviders/browserStack.ts

@@ -5,6 +5,7 @@
  */
 import * as https from 'https';
 import * as q from 'q';
+import {Session, WebDriver} from 'selenium-webdriver';
 import * as util from 'util';
 
 import {Config} from '../config';
@@ -27,9 +28,9 @@ export class BrowserStack extends DriverProvider {
    * @return {q.promise} A promise that will resolve when the update is complete.
    */
   updateJob(update: any): q.Promise<any> {
-    let deferredArray = this.drivers_.map((driver: webdriver.WebDriver) => {
+    let deferredArray = this.drivers_.map((driver: WebDriver) => {
       let deferred = q.defer();
-      driver.getSession().then((session: webdriver.Session) => {
+      driver.getSession().then((session: Session) => {
         let headers: Object = {
           'Content-Type': 'application/json',
           'Authorization': 'Basic ' +

lib/driverProviders/direct.ts

@@ -6,19 +6,18 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import * as q from 'q';
+import {Capabilities, WebDriver} from 'selenium-webdriver';
+import {Driver as ChromeDriver, ServiceBuilder as ChromeServiceBuilder} from 'selenium-webdriver/chrome';
+import {Driver as FirefoxDriver} from 'selenium-webdriver/firefox';
 
 import {Config} from '../config';
 import {BrowserError} from '../exitCodes';
 import {Logger} from '../logger';
 
 import {DriverProvider} from './driverProvider';
 
-let webdriver = require('selenium-webdriver'), chrome = require('selenium-webdriver/chrome'),
-    firefox = require('selenium-webdriver/firefox');
-let SeleniumConfig = require('webdriver-manager/built/lib/config').Config;
-let SeleniumChrome = require('webdriver-manager/built/lib/binaries/chrome_driver').ChromeDriver;
-let SeleniumStandAlone = require('webdriver-manager/built/lib/binaries/stand_alone').StandAlone;
-
+const SeleniumConfig = require('webdriver-manager/built/lib/config').Config;
+const SeleniumChrome = require('webdriver-manager/built/lib/binaries/chrome_driver').ChromeDriver;
 
 let logger = new Logger('direct');
 export class Direct extends DriverProvider {
@@ -56,8 +55,8 @@ export class Direct extends DriverProvider {
    * @override
    * @return webdriver instance
    */
-  getNewDriver(): webdriver.WebDriver {
-    let driver: webdriver.WebDriver;
+  getNewDriver(): WebDriver {
+    let driver: WebDriver;
     switch (this.config_.capabilities.browserName) {
       case 'chrome':
         let defaultChromeDriverPath = path.resolve(
@@ -73,14 +72,14 @@ export class Direct extends DriverProvider {
           throw new BrowserError(logger, 'Could not find chromedriver at ' + chromeDriverFile);
         }
 
-        let service = new chrome.ServiceBuilder(chromeDriverFile).build();
-        driver = new chrome.Driver(new webdriver.Capabilities(this.config_.capabilities), service);
+        let service = new ChromeServiceBuilder(chromeDriverFile).build();
+        driver = new ChromeDriver(new Capabilities(this.config_.capabilities), service);
         break;
       case 'firefox':
         if (this.config_.firefoxPath) {
           this.config_.capabilities['firefox_binary'] = this.config_.firefoxPath;
         }
-        driver = new firefox.Driver(this.config_.capabilities);
+        driver = new FirefoxDriver(this.config_.capabilities);
         break;
       default:
         throw new BrowserError(

lib/driverProviders/driverProvider.ts

@@ -4,13 +4,12 @@
  *  it down, and setting up the driver correctly.
  */
 import * as q from 'q';
+import {Builder, Session, WebDriver} from 'selenium-webdriver';
 
 import {Config} from '../config';
 
-let webdriver = require('selenium-webdriver');
-
 export class DriverProvider {
-  drivers_: webdriver.WebDriver[];
+  drivers_: WebDriver[];
   config_: Config;
 
   constructor(config: Config) {
@@ -35,7 +34,7 @@ export class DriverProvider {
    * @return webdriver instance
    */
   getNewDriver() {
-    let builder = new webdriver.Builder()
+    let builder = new Builder()
                       .usingServer(this.config_.seleniumAddress)
                       .usingWebDriverProxy(this.config_.webDriverProxy)
                       .withCapabilities(this.config_.capabilities);
@@ -53,18 +52,18 @@ export class DriverProvider {
    * @public
    * @param webdriver instance
    */
-  quitDriver(driver: webdriver.WebDriver): q.Promise<webdriver.WebDriver> {
+  quitDriver(driver: WebDriver): q.Promise<WebDriver> {
     let driverIndex = this.drivers_.indexOf(driver);
     if (driverIndex >= 0) {
       this.drivers_.splice(driverIndex, 1);
     }
 
-    let deferred = q.defer<webdriver.WebDriver>();
+    let deferred = q.defer<WebDriver>();
     if (driver.getSession() === undefined) {
       deferred.resolve();
     } else {
       driver.getSession()
-          .then((session_) => {
+          .then((session_: Session) => {
             if (session_) {
               driver.quit().then(function() {
                 deferred.resolve();
@@ -104,8 +103,8 @@ export class DriverProvider {
    * @return {q.promise} A promise which will resolve when the environment
    *     is down.
    */
-  teardownEnv(): q.Promise<q.Promise<webdriver.WebDriver>[]> {
-    return q.all<any>(this.drivers_.map((driver: webdriver.WebDriver) => {
+  teardownEnv(): q.Promise<q.Promise<WebDriver>[]> {
+    return q.all<any>(this.drivers_.map((driver: WebDriver) => {
       return this.quitDriver(driver);
     }));
   }

lib/driverProviders/local.ts

@@ -16,12 +16,13 @@ import {Logger} from '../logger';
 
 import {DriverProvider} from './driverProvider';
 
-let SeleniumConfig = require('webdriver-manager/built/lib/config').Config;
-let SeleniumChrome = require('webdriver-manager/built/lib/binaries/chrome_driver').ChromeDriver;
-let SeleniumStandAlone = require('webdriver-manager/built/lib/binaries/stand_alone').StandAlone;
-let remote = require('selenium-webdriver/remote');
+const SeleniumConfig = require('webdriver-manager/built/lib/config').Config;
+const SeleniumChrome = require('webdriver-manager/built/lib/binaries/chrome_driver').ChromeDriver;
+const SeleniumStandAlone = require('webdriver-manager/built/lib/binaries/stand_alone').StandAlone;
+const remote = require('selenium-webdriver/remote');
 
 let logger = new Logger('local');
+
 export class Local extends DriverProvider {
   server_: any;
   constructor(config: Config) {

lib/driverProviders/mock.ts

@@ -4,10 +4,15 @@
  * server.
  */
 import * as q from 'q';
+import {Session, WebDriver} from 'selenium-webdriver';
+import * as executors from 'selenium-webdriver/executors';
+
 import {Config} from '../config';
 import {DriverProvider} from './driverProvider';
 
-let webdriver = require('selenium-webdriver');
+export class MockExecutor {
+  execute(command: any): any {}
+}
 
 export class Mock extends DriverProvider {
   constructor(config?: Config) {
@@ -39,9 +44,9 @@ export class Mock extends DriverProvider {
    * @override
    * @return webdriver instance
    */
-  getNewDriver(): webdriver.WebDriver {
-    let mockSession = new webdriver.Session('test_session_id', {});
-    let newDriver = new webdriver.WebDriver(mockSession, new Mock());
+  getNewDriver(): WebDriver {
+    let mockSession = new Session('test_session_id', {});
+    let newDriver = new WebDriver(mockSession, new MockExecutor());
     this.drivers_.push(newDriver);
     return newDriver;
   }

lib/driverProviders/sauce.ts

@@ -5,14 +5,15 @@
  */
 
 import * as q from 'q';
+import {Session, WebDriver} from 'selenium-webdriver';
 import * as util from 'util';
 
 import {Config} from '../config';
 import {Logger} from '../logger';
 
 import {DriverProvider} from './driverProvider';
 
-let SauceLabs = require('saucelabs');
+const SauceLabs = require('saucelabs');
 
 let logger = new Logger('sauce');
 export class Sauce extends DriverProvider {
@@ -29,9 +30,9 @@ export class Sauce extends DriverProvider {
    * @return {q.promise} A promise that will resolve when the update is complete.
    */
   updateJob(update: any): q.Promise<any> {
-    var deferredArray = this.drivers_.map((driver: webdriver.WebDriver) => {
+    var deferredArray = this.drivers_.map((driver: WebDriver) => {
       var deferred = q.defer();
-      driver.getSession().then((session: webdriver.Session) => {
+      driver.getSession().then((session: Session) => {
         logger.info('SauceLabs results available at http://saucelabs.com/jobs/' + session.getId());
         this.sauceServer_.updateJob(session.getId(), update, (err: Error) => {
           if (err) {