support mobileextension

Author: licanhua

package.json

@@ -1,6 +1,6 @@
 {
   "name": "selenium-appium",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "A selenium-webdriver extension to support native app testing by Mobile JSON Wire Protocol which appium supports, also provides easy wait for element for pages or navigation among pages, and supports PageObject pattern",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

src/index.ts

@@ -4,6 +4,6 @@
  */
 
 export { By2 } from './by2';
-export { IWebDriver2, createWebDriver2 } from './webdriver2'
+export { WebDriver2, createWebDriver2 } from './webdriver2'
 export { windowsNativeAppCapabilities } from './webdriver2.windows'
 export { IPageObject, PageObject, waitForPage, clickAndWaitForPage } from './pageobject'

src/mobileextension.ts

@@ -1,6 +1,6 @@
 import { Executor } from "selenium-webdriver/lib/command";
 
-export const MobileExtensionCommand = {
+export const MobileJSONWireCommand = {
   GET_NETWORK_CONDITION: 'getNetworkConnection',
   SET_NETWORK_CONDITION: 'setNetworkConnection',
 };
@@ -13,14 +13,18 @@ export enum NetworkConnectionType {
   None = 0
 }
 
-export function configureExecutor(executor: Executor) {
+export type NetworkConnectionParam = {
+  type: NetworkConnectionType
+}
+
+export function configureMobileJSONWireExtension(executor: Executor) {
   executor.defineCommand(
-    MobileExtensionCommand.GET_NETWORK_CONDITION,
+    MobileJSONWireCommand.GET_NETWORK_CONDITION,
     'GET',
-    '/session/:sessionid/network_connection');
+    '/session/:sessionId/network_connection');
 
   executor.defineCommand(
-    MobileExtensionCommand.SET_NETWORK_CONDITION,
+    MobileJSONWireCommand.SET_NETWORK_CONDITION,
     'POST',
-    '/session/:sessionid/network_connection');
+    '/session/:sessionId/network_connection');
 }

src/pageobject.ts

@@ -3,12 +3,13 @@
  * Licensed under the MIT License.
  */
 
-import { WebDriver, WebElementCondition, By } from "selenium-webdriver";
+import { WebDriver, WebElementCondition, Locator } from "selenium-webdriver";
 import { IWebDriver2 } from './webdriver2';
 
 export interface IPageObject {
-  elementExists(by: By): Promise<boolean>;
-  clickAndWaitForPage<T extends IPageObject>(type: (new (...args: any[]) => T), by: By, timeout?: number): Promise<T>;
+  clickOn(locator: Locator): Promise<void>;
+  elementExists(locator: Locator): Promise<boolean>;
+  clickAndWaitForPage<T extends IPageObject>(type: (new (...args: any[]) => T), locator: Locator, timeout?: number): Promise<T>;
   waitForPage<T extends IPageObject>(type: (new (...args: any[]) => T), timeout?: number): Promise<T>;
   isReadyConditions(): WebElementCondition[];
   waitUntilReady(timeout?: number): Promise<void>;
@@ -25,16 +26,20 @@ export function waitForPage<T extends IPageObject>(type: (new (...args: any[]) =
   });
 }
 
-export function clickAndWaitForPage<T extends IPageObject>(type: (new (...args: any[]) => T), driver: IWebDriver2, by: By, timeout?: number): Promise<T> {
+export function clickAndWaitForPage<T extends IPageObject>(type: (new (...args: any[]) => T), driver: IWebDriver2, locator: Locator, timeout?: number): Promise<T> {
   return new Promise<T>((resolve) => {
-    driver.getBy(by, timeout)
+    driver.getBy(locator, timeout)
       .then(el => { return el.click(); })
       .then(() => { return waitForPage(type, driver, timeout); })
       .then(page => resolve(page));
   });
 }
 
 export class PageObject implements IPageObject {
+  clickOn(locator: Locator): Promise<void> {
+    return this.webDriver2.getBy(locator).click();
+  }
+
   private static defaultTimeout: number = 20000; //ms
   private timeout?: number;
   private getTimeout(timeout?: number): number {
@@ -49,16 +54,16 @@ export class PageObject implements IPageObject {
     this.defaultTimeout = ms;
   }
 
-  protected appiumDriver: IWebDriver2;
+  protected webDriver2: IWebDriver2;
 
   constructor(driver: IWebDriver2, timeout?: number) {
     this.timeout = timeout;
-    this.appiumDriver = driver;
+    this.webDriver2 = driver;
   }
 
-  elementExists(by: By): Promise<boolean> {
+  elementExists(locator: Locator): Promise<boolean> {
     return new Promise<boolean>(resolve =>
-      this.appiumDriver.seleniumDriver().findElement(by)
+      this.webDriver2.seleniumDriver().findElement(locator)
         .then(() => resolve(true))
         .catch(() => resolve(false))
     );
@@ -69,20 +74,20 @@ export class PageObject implements IPageObject {
   }
 
   waitUntilReady(timeout?: number): Promise<void> {
-    const webDriver = this.appiumDriver.seleniumDriver();
+    const webDriver = this.webDriver2.seleniumDriver();
     if (webDriver) {
       return PageObject.waitForConditions(webDriver, this.isReadyConditions(), this.getTimeout(timeout));
     } else {
       return Promise.reject("no driver found");
     }
   }
 
-  clickAndWaitForPage<T extends IPageObject>(type: (new (...args: any[]) => T), by: By, timeout?: number): Promise<T> {
-    return clickAndWaitForPage(type, this.appiumDriver, by, this.getTimeout(timeout));
+  clickAndWaitForPage<T extends IPageObject>(type: (new (...args: any[]) => T), locator: Locator, timeout?: number): Promise<T> {
+    return clickAndWaitForPage(type, this.webDriver2, locator, this.getTimeout(timeout));
   }
 
   waitForPage<T extends IPageObject>(type: (new (...args: any[]) => T), timeout?: number): Promise<T> {
-    return waitForPage(type, this.appiumDriver, this.getTimeout(timeout));
+    return waitForPage(type, this.webDriver2, this.getTimeout(timeout));
   }
 
   private static async  waitForConditions(driver: WebDriver, conditions: WebElementCondition[], timeout?: number) {

src/webdriver2.ts

@@ -7,21 +7,49 @@
 import { Locator, WebDriver, Builder, until, Capabilities, WebElement, WebElementPromise, ThenableWebDriver, FileDetector, Session, Actions, WebElementCondition, Condition, Options, Navigation, TargetLocator } from 'selenium-webdriver'
 import { Command, Executor } from 'selenium-webdriver/lib/command'
 import { By2 } from './by2';
-import { MobileExtensionCommand, NetworkConnectionType } from './mobileextension';
+import { MobileJSONWireCommand, NetworkConnectionParam, configureMobileJSONWireExtension } from './mobileextension';
 
 interface INativeWaitAndGet {
+  /**
+ * wait until element by accessibility id exists or timeout
+ */
   getByNativeAccessibilityId(id: string, timeout?: number, message?: string): WebElementPromise;
+  /**
+ * wait until element by name exists or timeout
+ */
   getByNativeName(name: string, timeout?: number, message?: string): WebElementPromise;
+  /**
+ * wait until element by id exists or timeout
+ */
   getByNativeId(id: string, timeout?: number, message?: string): WebElementPromise;
+  /**
+ * wait until element by class name exists or timeout
+ */
   getByNativeclassName(className: string, timeout?: number, message?: string): WebElementPromise;
 }
 
 interface IWaitAndGet extends INativeWaitAndGet {
+  /**
+   * wait until element by locator exists or timeout
+   */
   getBy(locator: Locator, timeout?: number, message?: string): WebElementPromise;
 }
 
-export interface IWebDriver2 extends IWaitAndGet {
-  // internal WebDriver is created by user
+/**
+ * @see https://github.com/SeleniumHQ/mobile-spec/blob/master/spec-draft.md
+ */
+export interface IMobileJSONWireExtension {
+  /**
+   * A workaround before WebDriver supports Mobile JSONWire
+   */
+  enableMobileJSONWire(): void;
+ 
+  getNetworkCondition(): Promise<NetworkConnectionParam>;
+  setNetworkCondition(params: NetworkConnectionParam): Promise<NetworkConnectionParam>;
+}
+
+export interface IWebDriver2 extends IWaitAndGet, IMobileJSONWireExtension {
+  // For user who want to customize the WebDriver create process
   attach(webDriver: WebDriver): void;
   detach(): void;
 
@@ -33,117 +61,195 @@ export interface IWebDriver2 extends IWaitAndGet {
   isActive(): Promise<boolean>;
   seleniumDriver(): WebDriver;
   lastError(): any;
-  
+
 }
 
 export class WebDriver2 implements IWebDriver2 {
-  /**
-   * Schedules a command to get Chrome network emulation settings.
-   * @return {!Promise} A promise that will be resolved when network
-   *     emulation settings are retrievied.
-   */
-  getNetworkCondition(): Promise<{type: NetworkConnectionType}> {
-    return this.execute(new Command(MobileExtensionCommand.GET_NETWORK_CONDITION));
+  enableMobileJSONWire() {
+    configureMobileJSONWireExtension(this.getExecutor());
   }
 
-  setNetworkCondition(type: NetworkConnectionType) {    
-    return this.execute(
-        new Command(MobileExtensionCommand.SET_NETWORK_CONDITION)
-            .setParameter('network_conditions', {type: type}));
+  getNetworkCondition(): Promise<NetworkConnectionParam> {
+    return this.execute<NetworkConnectionParam>(new Command(MobileJSONWireCommand.GET_NETWORK_CONDITION));
   }
 
+  setNetworkCondition(params: NetworkConnectionParam) {
+    return this.execute<NetworkConnectionParam>(
+      new Command(MobileJSONWireCommand.SET_NETWORK_CONDITION)
+        .setParameter('type', params.type));
+  }
+
+  /**
+  *   @see WebDriver.wait
+  */
   wait(condition: WebElementCondition, opt_timeout?: number | undefined, opt_message?: string | undefined): WebElementPromise {
     return this.seleniumDriver().wait(condition, opt_timeout, opt_message);
   }
 
+  /**
+*   @see WebDriver.wait
+*/
   wait2<T>(condition: Function | PromiseLike<T> | Condition<T> | ((driver: WebDriver) => T | PromiseLike<T>), opt_timeout?: number | undefined, opt_message?: string | undefined): Promise<T> {
     return this.seleniumDriver().wait<T>(condition, opt_timeout, opt_message);
   }
 
+  /**
+*   @see WebDriver.sleep
+*/
   sleep(ms: number): Promise<void> {
     return this.seleniumDriver().sleep(ms);
   }
 
-  [Symbol.toStringTag]: string;
+  /**
+*   @see WebDriver.execute
+*/
   execute<T>(command: Command, description?: string | undefined): Promise<T> {
     return this.seleniumDriver().execute<T>(command, description);
   }
 
+  /**
+*   @see WebDriver.setFileDetector
+*/
   setFileDetector(detector: FileDetector): void {
     return this.seleniumDriver().setFileDetector(detector);
   }
 
+  /**
+*   @see WebDriver.getExecutor
+*/
   getExecutor(): Executor {
     return this.seleniumDriver().getExecutor();
   }
 
+  /**
+*   @see WebDriver.getSession
+*/
   getSession(): Promise<Session> {
     return this.seleniumDriver().getSession();
   }
 
+  /**
+*   @see WebDriver.getCapabilities
+*/
   getCapabilities(): Promise<Capabilities> {
     return this.seleniumDriver().getCapabilities();
   }
 
+  /**
+*   @see WebDriver.quit
+*/
   quit(): Promise<void> {
     return this.stop();
   }
 
+  /**
+*   @see WebDriver.actions
+*/
   actions(options?: { async: boolean; bridge: boolean; } | { async: boolean; } | { bridge: boolean; } | undefined): Actions {
     return this.seleniumDriver().actions(options);
   }
 
+  /**
+*   @see WebDriver.executeScript
+*/
   executeScript<T>(script: string | Function, ...var_args: any[]): Promise<T> {
     return this.seleniumDriver().executeScript(script, var_args);
   }
 
+  /**
+*   @see WebDriver.executeAsyncScript
+*/
   executeAsyncScript<T>(script: string | Function, ...var_args: any[]): Promise<T> {
     return this.seleniumDriver().executeAsyncScript<T>(script, var_args);
   }
 
+  /**
+*   @see WebDriver.getWindowHandle
+*/
   getWindowHandle(): Promise<string> {
     return this.seleniumDriver().getWindowHandle();
   }
 
+  /**
+  *   @see WebDriver.getAllWindowHandles
+  */
   getAllWindowHandles(): Promise<string[]> {
     return this.seleniumDriver().getAllWindowHandles();
   }
 
+  /**
+  *   @see WebDriver.getPageSource
+  */
   getPageSource(): Promise<string> {
     return this.seleniumDriver().getPageSource();
   }
 
+  /**
+  *   @see WebDriver.close
+  */
   close(): Promise<void> {
     return this.seleniumDriver().close();
   }
 
+  /**
+  *   @see WebDriver.get
+  */
   get(url: string): Promise<void> {
     return this.seleniumDriver().get(url);
   }
 
+  /**
+  *   @see WebDriver.getCurrentUrl
+  */
   getCurrentUrl(): Promise<string> {
     return this.seleniumDriver().getCurrentUrl();
   }
 
+  /**
+  *   @see WebDriver.getTitle
+  */
   getTitle(): Promise<string> {
     return this.seleniumDriver().getTitle();
   }
 
+  /**
+  *   @see WebDriver.findElement
+  */
   findElement(locator: Locator): WebElementPromise {
     return this.seleniumDriver().findElement(locator);
   }
+
+  /**
+  *   @see WebDriver.findElements
+  */
   findElements(locator: Locator): Promise<WebElement[]> {
     return this.seleniumDriver().findElements(locator);
   }
+
+  /**
+  *   @see WebDriver.takeScreenshot
+  */
   takeScreenshot(): Promise<string> {
     return this.seleniumDriver().takeScreenshot();
   }
+
+  /**
+  *   @see WebDriver.manage
+  */
   manage(): Options {
     return this.seleniumDriver().manage();
   }
+
+  /**
+  *   @see WebDriver.navigate
+  */
   navigate(): Navigation {
     return this.seleniumDriver().navigate();
   }
+
+  /**
+  *   @see WebDriver.switchTo
+  */
   switchTo(): TargetLocator {
     return this.seleniumDriver().switchTo();
   }