@serenity-js/protractor 2.32.2 → 3.0.0-rc.0

package/src/screenplay/abilities/{BrowseTheWeb.ts → BrowseTheWebWithProtractor.ts}

@@ -1,8 +1,10 @@
-import { Ability, ConfigurationError, LogicError, UsesAbilities } from '@serenity-js/core';
-import { ActionSequence, ElementArrayFinder, ElementFinder, Locator, ProtractorBrowser } from 'protractor';
-import { AlertPromise, Capabilities, Navigation, Options, WebElement, WebElementPromise } from 'selenium-webdriver';
+import { ConfigurationError, Duration, LogicError, UsesAbilities } from '@serenity-js/core';
+import { BrowserCapabilities, BrowseTheWeb, Cookie, CookieData, Key, ModalDialog, Page, PageElement, PageElements } from '@serenity-js/web';
+import { by, ElementArrayFinder, ElementFinder, ProtractorBrowser, WebElementPromise } from 'protractor';
+import { Capabilities } from 'selenium-webdriver';
 
-import { promiseOf } from '../../promiseOf';
+import { ProtractorCookie, ProtractorModalDialog, ProtractorNativeElementRoot, ProtractorPage, ProtractorPageElement, ProtractorPageElements } from '../models';
+import { promised } from '../promised';
 
 /**
  * @desc
@@ -33,288 +35,269 @@ import { promiseOf } from '../../promiseOf';
  * @implements {@serenity-js/core/lib/screenplay~Ability}
  * @see {@link @serenity-js/core/lib/screenplay/actor~Actor}
  */
-export class BrowseTheWeb implements Ability {
-
-    /**
-     * @private
-     */
-    private lastScriptExecutionSummary: LastScriptExecutionSummary;
-
-    /**
-     * @private
-     */
-    private originalWindowHandle: string;
+export class BrowseTheWebWithProtractor extends BrowseTheWeb {
 
     /**
      * @desc
      *  Ability to interact with web front-ends using a given protractor browser instance.
      *
      * @param {ProtractorBrowser} browser
-     * @returns {BrowseTheWeb}
+     * @returns {BrowseTheWebWithProtractor}
      */
-    static using(browser: ProtractorBrowser): BrowseTheWeb {
-        return new BrowseTheWeb(browser);
+    static using(browser: ProtractorBrowser): BrowseTheWebWithProtractor {
+        return new BrowseTheWebWithProtractor(browser);
     }
 
     /**
      * @desc
-     *  Used to access the Actor's ability to {@link BrowseTheWeb} from within the {@link Interaction} classes,
+     *  Used to access the Actor's ability to {@link BrowseTheWebWithProtractor} from within the {@link Interaction} classes,
      *  such as {@link Navigate}.
      *
      * @param {UsesAbilities} actor
-     * @return {BrowseTheWeb}
+     * @return {BrowseTheWebWithProtractor}
      */
-    static as(actor: UsesAbilities): BrowseTheWeb {
-        return actor.abilityTo(BrowseTheWeb);
+    static as(actor: UsesAbilities): BrowseTheWebWithProtractor {
+        return actor.abilityTo(BrowseTheWebWithProtractor);
     }
 
+    /**
+     * @private
+     */
+    private lastScriptExecutionSummary: LastScriptExecutionSummary;
+
     /**
      * @param {ProtractorBrowser} browser
      *  An instance of a protractor browser
      */
     constructor(protected browser: ProtractorBrowser) {
+        super();
     }
 
-    /**
-     * @desc
-     *  Navigate to the given destination and loads mock modules before Angular.
-     *  Assumes that the page being loaded uses Angular.
-     *
-     * @param {string} destination
-     * @param {number?} timeoutInMillis
-     *
-     * @returns {Promise<void>}
-     */
-    get(destination: string, timeoutInMillis?: number): Promise<void> {
-        return promiseOf(this.browser.get(destination, timeoutInMillis)
-            .then(() => this.browser.getWindowHandle())
-            .then(handle => {
-                this.originalWindowHandle = handle;
-            }),
-        );
+    async browserCapabilities(): Promise<BrowserCapabilities> {
+        const capabilities = await promised(this.browser.getCapabilities());
+
+        return {
+            platformName:   capabilities.get('platform'),
+            browserName:    capabilities.get('browserName'),
+            browserVersion: capabilities.get('version'),
+        };
     }
 
-    /**
-     * @desc
-     *  Interface for navigating back and forth in the browser history.
-     *
-     *  @returns {Navigation}
-     */
-    navigate(): Navigation {
-        return this.browser.navigate();
+    async cookie(name: string): Promise<Cookie> {
+        return new ProtractorCookie(this.browser, name);
     }
 
-    /**
-     * @desc
-     *  Interface for defining sequences of complex user interactions.
-     *  Each sequence will not be executed until `perform` is called.
-     *
-     * @returns {ActionSequence}
-     *
-     * @see https://www.selenium.dev/selenium/docs/api/javascript/module/selenium-webdriver/lib/actions.html
-     */
-    actions(): ActionSequence {
-        return this.browser.actions();
+    async setCookie(cookieData: CookieData): Promise<void> {
+        return promised(this.browser.manage().addCookie({
+            name:       cookieData.name,
+            value:      cookieData.value,
+            path:       cookieData.path,
+            domain:     cookieData.domain,
+            secure:     cookieData.secure,
+            httpOnly:   cookieData.httpOnly,
+            expiry:     cookieData.expiry
+                ? cookieData.expiry.toSeconds()
+                : undefined,
+        }));
     }
 
-    /**
-     * @desc
-     *  Interface for managing browser and driver state.
-     *
-     * @returns {Options}
-     *
-     * @see https://www.selenium.dev/selenium/docs/api/javascript/module/selenium-webdriver/lib/webdriver_exports_WebDriver.html#manage
-     */
-    manage(): Options {
-        /*
-        this.browser.manage().deleteCookie();
-        this.browser.manage().deleteAllCookies();
-        return this.browser.manage().getCookie('asd');
-         */
+    deleteAllCookies(): Promise<void> {
+        return promised(this.browser.manage().deleteAllCookies());
+    }
 
-        return this.browser.manage();
+    findByCss(selector: string): PageElement<any, any> {
+        return this.find(root => root.element(by.css(selector)));
     }
 
-    /**
-     * @desc
-     *  Changes focus to the active modal dialog,
-     *  such as those opened by
-     *  [`Window.alert()`](https://developer.mozilla.org/en-US/docs/Web/API/Window/alert),
-     *  [`Window.prompt()`](https://developer.mozilla.org/en-US/docs/Web/API/Window/prompt), or
-     *  [`Window.confirm()`](https://developer.mozilla.org/en-US/docs/Web/API/Window/confirm).
-     *
-     * The returned promise will be rejected with an [`error.NoSuchAlertError`](https://www.selenium.dev/selenium/docs/api/javascript/module/selenium-webdriver/lib/error_exports_NoSuchAlertError.html)
-     * if there are no open alerts.
-     *
-     * @returns {AlertPromise}
-     *
-     * @see https://www.selenium.dev/selenium/docs/api/javascript/module/selenium-webdriver/lib/webdriver_exports_TargetLocator.html#alert
-     */
-    alert(): AlertPromise {
-        return this.browser.switchTo().alert();
+    findByCssContainingText(selector: string, text: string): PageElement<any, any> {
+        return this.find(root => root.element(by.cssContainingText(selector, text)));
     }
 
-    /**
-     * @desc
-     *  Switches the focus to a [`frame`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/frame) or
-     *  [`iframe`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe) identified by `elementOrIndexOrName`,
-     *  which can be specified either as {@link selenium-webdriver~WebElement}, the name of the frame, or its index.
-     *
-     * @param {number | string | WebElement} elementOrIndexOrName
-     *
-     * @returns {Promise<void>}
-     */
-    switchToFrame(elementOrIndexOrName: number | string | WebElement | WebElementPromise): Promise<void> {
-        // incorrect type definition in selenium-webdriver prevents us from providing a string arg
-        return promiseOf(this.browser.switchTo().frame(elementOrIndexOrName as any));
+    findById(selector: string): PageElement<any, any> {
+        return this.find(root => root.element(by.id(selector)));
     }
 
-    /**
-     * @desc
-     *  Switches the focus from any [`frame`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/frame) or
-     *  [`iframe`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe) back to its parent iframe.
-     *
-     * @returns {Promise<void>}
-     */
-    switchToParentFrame(): Promise<void> {
-        return promiseOf(this.browser.driver.switchToParentFrame());
+    findByTagName(selector: string): PageElement<any, any> {
+        return this.find(root => root.element(by.tagName(selector)));
     }
 
-    /**
-     * @desc
-     *  Switches the focus from any [`frame`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/frame)
-     *  or [`iframe`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe) back to default content,
-     *  a.k.a. "the main window".
-     *
-     * @returns {Promise<void>}
-     */
-    switchToDefaultContent(): Promise<void> {
-        return promiseOf(this.browser.switchTo().defaultContent());
+    findByXPath(selector: string): PageElement<any, any> {
+        return this.find(root => root.element(by.xpath(selector)));
     }
 
-    /**
-     * @desc
-     *  Switches browser window/tab to the one identified by `nameOrHandleOrIndex`,
-     *  which can be specified as the name of the window to switch to, its handle, or numeric index.
-     *
-     * @param {string | number} nameOrHandleOrIndex
-     *
-     * @returns {Promise<void>}
-     */
-    switchToWindow(nameOrHandleOrIndex: string | number): Promise<void> {
-        return typeof nameOrHandleOrIndex === 'string'
-            ? this.switchToWindowByNameOrHandle(nameOrHandleOrIndex)
-            : this.switchToWindowByIndex(nameOrHandleOrIndex);
+    findAllByCss(selector: string): PageElements<any, any, any> {
+        return this.findAll(root => root.all(by.css(selector)));
     }
 
-    /**
-     * @param {string} nameOrHandle
-     * @private
-     */
-    private switchToWindowByNameOrHandle(nameOrHandle: string): Promise<void> {
-        return promiseOf(this.browser.switchTo().window(nameOrHandle));
+    findAllByTagName(selector: string): PageElements<any, any, any> {
+        return this.findAll(root => root.all(by.tagName(selector)));
     }
 
-    /**
-     * @param {number} index
-     * @private
-     */
-    private switchToWindowByIndex(index: number): Promise<void> {
-        return promiseOf(this.browser.getAllWindowHandles().then(handles => {
-            const handle = handles[index];
+    findAllByXPath(selector: string): PageElements<any, any, any> {
+        return this.findAll(root => root.all(by.xpath(selector)));
+    }
 
-            if (! handle) {
-                throw new LogicError(`Window ${ index } doesn't exist`)
+    private find(locator: (root: ProtractorNativeElementRoot) => Promise<ElementFinder> | ElementFinder): ProtractorPageElement {
+        return new ProtractorPageElement(
+            () => ({
+                element: this.browser.element.bind(this.browser),
+                all: this.browser.element.all.bind(this.browser),
+            }),
+            locator,
+        );
+    }
+
+    private findAll(locator: (root: ProtractorNativeElementRoot) => Promise<ElementArrayFinder> | ElementArrayFinder): ProtractorPageElements {
+        return new ProtractorPageElements(
+            () => ({
+                element: this.browser.element.bind(this.browser),
+                all: this.browser.element.all.bind(this.browser),
+            }),
+            locator,
+        );
+    }
+
+    navigateTo(destination: string): Promise<void> {
+        return promised(this.browser.get(destination));
+    }
+
+    navigateBack(): Promise<void> {
+        return promised(this.browser.navigate().back());
+    }
+
+    navigateForward(): Promise<void> {
+        return promised(this.browser.navigate().forward());
+    }
+
+    reloadPage(): Promise<void> {
+        return promised(this.browser.navigate().refresh());
+    }
+
+    waitFor(duration: Duration): Promise<void> {
+        return promised(this.browser.sleep(duration.inMilliseconds()));
+    }
+
+    waitUntil(condition: () => boolean | Promise<boolean>, timeout: Duration): Promise<void> {
+        return promised(this.browser.wait(condition, timeout.inMilliseconds())) as unknown as Promise<void>;
+    }
+
+    async sendKeys(keys: (string | Key)[]): Promise<void> {
+        function isModifier(maybeKey: string | Key): boolean {
+            return Key.isKey(maybeKey) && maybeKey.isModifier;
+        }
+
+        function asCodePoint(maybeKey: string | Key): string {
+            if (! Key.isKey(maybeKey)) {
+                return maybeKey;
             }
 
-            return this.browser.switchTo().window(handle);
-        }));
+            return maybeKey.utf16codePoint;
+        }
+
+        // keyDown for any modifier keys and sendKeys otherwise
+        const keyDownActions = keys.reduce((actions, key) => {
+            return isModifier(key)
+                ? actions.keyDown(asCodePoint(key))
+                : actions.sendKeys(asCodePoint(key))
+        }, this.browser.actions());
+
+        // keyUp for any modifier keys, ignore for regular keys
+        const keyUpActions = keys.reduce((actions, key) => {
+            return isModifier(key)
+                ? actions.keyUp(asCodePoint(key))
+                : actions;
+        }, keyDownActions);
+
+        return promised(keyUpActions.perform());
     }
 
-    /**
-     * @desc
-     *  Switches the window back to the original one that was used to call {@link get}.
-     *
-     * @returns {Promise<void>}
-     */
-    switchToOriginalWindow(): Promise<void> {
-        return this.originalWindowHandle
-            ? promiseOf(this.browser.switchTo().window(this.originalWindowHandle))
-            : Promise.resolve();
+    async modalDialog(): Promise<ModalDialog> {
+        return new ProtractorModalDialog(this.browser);
     }
 
     /**
      * @desc
-     *  Returns the handle of the browser window last used to navigate to a URL.
+     *  Navigate to the given destination and loads mock modules before Angular.
+     *  Assumes that the page being loaded uses Angular.
      *
-     * @returns {Promise<string>}
-     *  A window handle
+     * @param {string} destination
+     * @param {number?} timeoutInMillis
      *
-     * @see {@link get}
+     * @returns {Promise<void>}
      */
-    getOriginalWindowHandle(): Promise<string> {
-        return Promise.resolve(this.originalWindowHandle);
+    get(destination: string, timeoutInMillis?: number): Promise<void> {
+        return promised(this.browser.get(destination, timeoutInMillis));
     }
 
     /**
      * @desc
-     *  Returns the current window handle.
-     *  Please note that the current handle changes with each browser window you {@link Switch} to.
+     *  Switches the focus to a [`frame`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/frame) or
+     *  [`iframe`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe) identified by `elementOrIndexOrName`,
+     *  which can be specified either as {@link selenium-webdriver~WebElement}, the name of the frame, or its index.
      *
-     * @returns {Promise<string>}
-     *  A window handle
+     * @param {number | string | WebElement} elementOrIndexOrName
      *
-     * @see {@link get}
+     * @returns {Promise<void>}
      */
-    getCurrentWindowHandle(): Promise<string> {
-        return promiseOf(this.browser.getWindowHandle());
+    async switchToFrame(elementOrIndexOrName: number | string | PageElement): Promise<void> {
+        if (elementOrIndexOrName instanceof ProtractorPageElement) {
+            const nativeElement = await elementOrIndexOrName.nativeElement();
+            const webElement = await nativeElement.getWebElement() as unknown as WebElementPromise // https://github.com/angular/protractor/issues/1846#issuecomment-82634739;
+
+            return this.browser.switchTo().frame(webElement);
+        }
+
+        // incorrect type definition in selenium-webdriver prevents us from providing a string argument
+        return this.browser.switchTo().frame(elementOrIndexOrName as any);
     }
 
     /**
      * @desc
-     *  Returns the handles of all the available windows.
-     *
-     *  Please note that while some browsers organise entries of this list in the same order
-     *  new windows have been spawned, other browsers order it alphabetically.
-     *  For this reason, you should not make any assumptions about how this list is ordered.
+     *  Switches the focus from any [`frame`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/frame) or
+     *  [`iframe`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe) back to its parent iframe.
      *
-     * @returns {Promise<string[]>}
-     *  A list of window handles
+     * @returns {Promise<void>}
      */
-    getAllWindowHandles(): Promise<string[]> {
-        return promiseOf(this.browser.getAllWindowHandles());
+    switchToParentFrame(): Promise<void> {
+        return promised(this.browser.driver.switchToParentFrame());
     }
 
     /**
      * @desc
-     *  Closes the currently active browser window/tab.
+     *  Switches the focus from any [`frame`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/frame)
+     *  or [`iframe`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe) back to default content,
+     *  a.k.a. "the main window".
      *
      * @returns {Promise<void>}
      */
-    closeCurrentWindow(): Promise<void> {
-        return promiseOf(this.browser.close());
+    switchToDefaultContent(): Promise<void> {
+        return promised(this.browser.switchTo().defaultContent());
     }
 
     /**
      * @desc
-     *  Locates a single element identified by the locator
+     *  Returns a {@link Page} representing the currently active top-level browsing context.
      *
-     * @param {Locator} locator
-     * @returns {ElementFinder}
+     * @returns {Promise<Page>}
      */
-    locate(locator: Locator): ElementFinder {
-        return this.browser.element(locator);
+    async currentPage(): Promise<Page> {
+
+        const windowHandle = await this.browser.getWindowHandle();
+
+        return new ProtractorPage(this.browser, windowHandle);
     }
 
     /**
      * @desc
-     *  Locates all elements identified by the locator
+     *  Returns an array of {@link Page} objects representing all the available
+     *  top-level browsing context, e.g. all the open browser tabs.
      *
-     * @param {Locator} locator
-     * @returns {ElementArrayFinder}
+     * @returns {Promise<Array<Page>>}
      */
-    locateAll(locator: Locator): ElementArrayFinder {
-        return this.browser.element.all(locator);
+    async allPages(): Promise<Array<Page>> {
+        const windowHandles = await this.browser.getAllWindowHandles();
+
+        return windowHandles.map(windowHandle => new ProtractorPage(this.browser, windowHandle));
     }
 
     /**
@@ -343,7 +326,7 @@ export class BrowseTheWeb implements Ability {
      * @returns {Promise<boolean>}
      */
     enableAngularSynchronisation(enable: boolean): Promise<boolean> {
-        return promiseOf(this.browser.waitForAngularEnabled(enable));
+        return promised(this.browser.waitForAngularEnabled(enable));
     }
 
     /**
@@ -380,7 +363,6 @@ export class BrowseTheWeb implements Ability {
      * @see https://www.protractortest.org/#/api?view=webdriver.WebDriver.prototype.executeScript
      * @see https://seleniumhq.github.io/selenium/docs/api/java/org/openqa/selenium/JavascriptExecutor.html#executeScript-java.lang.String-java.lang.Object...-
      *
-     * @param {string} description  - useful for debugging
      * @param {string | Function} script
      * @param {any[]} args
      *
@@ -388,27 +370,34 @@ export class BrowseTheWeb implements Ability {
      *
      * @see {@link BrowseTheWeb#getLastScriptExecutionResult}
      */
-    executeScript(description: string, script: string | Function, ...args: any[]): Promise<any> {   // eslint-disable-line @typescript-eslint/ban-types
-        return promiseOf(this.browser.executeScriptWithDescription(script, description, ...args))
+    async executeScript<Result, InnerArguments extends any[]>(
+        script: string | ((...parameters: InnerArguments) => Result),
+        ...args: InnerArguments
+    ): Promise<Result> {
+        const nativeArguments = await Promise.all(args.map(arg => arg instanceof ProtractorPageElement ? arg.nativeElement() : arg)) as InnerArguments;
+
+        return promised(this.browser.executeScript(script, ...nativeArguments))
             .then(result => {
                 this.lastScriptExecutionSummary = new LastScriptExecutionSummary(
                     result,
                 );
                 return result;
-            });
+            }) as Promise<Result>;
     }
 
     /**
      * @desc
-     *  A simplified version of {@link BrowseTheWeb#executeScript} that doesn't affect {@link LastScriptExecution.result()}.
+     *  A simplified version of {@link BrowseTheWebWithProtractor#executeScript} that doesn't affect {@link LastScriptExecution.result()}.
      *
      * @param {Function} fn
      * @param {Parameters<fn>} args
      *
      * @returns {Promise<ReturnType<fn>>}
      */
-    executeFunction<F extends (...args: any[]) => any>(fn: F, ...args: Parameters<F>): Promise<ReturnType<F>> {
-        return promiseOf(this.browser.executeScriptWithDescription(fn, fn.name, ...args));
+    async executeFunction<F extends (...args: any[]) => any>(fn: F, ...args: Parameters<F>): Promise<ReturnType<F>> {
+        const nativeArguments = await Promise.all(args.map(arg => arg instanceof ProtractorPageElement ? arg.nativeElement() : arg)) as Parameters<F>;
+
+        return promised(this.browser.executeScriptWithDescription(fn, fn.name, ...nativeArguments));
     }
 
     /**
@@ -423,7 +412,7 @@ export class BrowseTheWeb implements Ability {
      *  Arrays and objects may also be used as script arguments as long as each item adheres
      *  to the types previously mentioned.
      *
-     *  Unlike executing synchronous JavaScript with {@link BrowseTheWeb#executeScript},
+     *  Unlike executing synchronous JavaScript with {@link BrowseTheWebWithProtractor#executeScript},
      *  scripts executed with this function must explicitly signal they are finished by invoking the provided callback.
      *
      *  This callback will always be injected into the executed function as the last argument,
@@ -463,15 +452,19 @@ export class BrowseTheWeb implements Ability {
      *
      * @see {@link BrowseTheWeb#getLastScriptExecutionResult}
      */
-    executeAsyncScript(script: string | Function, ...args: any[]): Promise<any> {   // eslint-disable-line @typescript-eslint/ban-types
-        return promiseOf(this.browser.executeAsyncScript(script, ...args))
+    async executeAsyncScript<Result, Parameters extends any[]>(
+        script: string | ((...args: [...parameters: Parameters, callback: (result: Result) => void]) => void),
+        ...args: Parameters
+    ): Promise<Result> {
+        const nativeArguments = await Promise.all(args.map(arg => arg instanceof ProtractorPageElement ? arg.nativeElement() : arg)) as Parameters;
+
+        return promised(this.browser.executeAsyncScript(script, ...nativeArguments))
             .then(result => {
                 this.lastScriptExecutionSummary = new LastScriptExecutionSummary(
                     result,
                 );
                 return result;
-            });
-        // todo: should I wrap this an provide additional diagnostic information? execution time? error handling?
+            }) as Promise<Result>;
     }
 
     /**
@@ -487,29 +480,7 @@ export class BrowseTheWeb implements Ability {
      * @return {Promise<string>} A promise that will be resolved to a base64-encoded screenshot PNG
      */
     takeScreenshot(): Promise<string> {
-        return promiseOf(this.browser.takeScreenshot());
-    }
-
-    /**
-     * @desc
-     *  Returns the title of the current page.
-     *
-     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/title
-     *
-     * @returns {Promise<string>}
-     */
-    getTitle(): Promise<string> {
-        return promiseOf(this.browser.getTitle());
-    }
-
-    /**
-     * @desc
-     *  Returns the url of the current page.
-     *
-     * @returns {Promise<string>}
-     */
-    getCurrentUrl(): Promise<string> {
-        return promiseOf(this.browser.getCurrentUrl());
+        return promised(this.browser.takeScreenshot());
     }
 
     /**
@@ -522,8 +493,8 @@ export class BrowseTheWeb implements Ability {
      *
      * @returns {Promise<Capabilities>} The actual capabilities of this browser.
      */
-    getCapabilities(): Promise<Capabilities> {
-        return promiseOf(this.browser.getCapabilities());
+    capabilities(): Promise<Capabilities> {
+        return promised(this.browser.getCapabilities());
     }
 
     /**
@@ -534,7 +505,7 @@ export class BrowseTheWeb implements Ability {
      * @returns {Promise<void>}
      */
     sleep(millis: number): Promise<void> {
-        return promiseOf(this.browser.sleep(millis));
+        return promised(this.browser.sleep(millis));
     }
 
     /**
@@ -546,22 +517,26 @@ export class BrowseTheWeb implements Ability {
      * @returns {Promise<boolean>}
      */
     wait(condition: () => Promise<boolean>, timeoutInMillis: number): Promise<boolean> {
-        return promiseOf(this.browser.wait(condition, timeoutInMillis));
+        return promised(this.browser.wait(condition, timeoutInMillis));
     }
 
     /**
      * @desc
-     *  Returns the last result of calling {@link BrowseTheWeb#executeAsyncScript}
-     *  or {@link BrowseTheWeb#executeScript}
+     *  Returns the last result of calling {@link BrowseTheWebWithProtractor#executeAsyncScript}
+     *  or {@link BrowseTheWebWithProtractor#executeScript}
      *
      * @returns {any}
      */
-    getLastScriptExecutionResult(): any {
+    lastScriptExecutionResult(): any {
         if (! this.lastScriptExecutionSummary) {
             throw new LogicError(`Make sure to execute a script before checking on the result`);
         }
 
-        return this.lastScriptExecutionSummary.result;
+        // Selenium 3 returns `null` when the script it executed returns `undefined`
+        // so we're mapping the result back.
+        return this.lastScriptExecutionSummary.result !== null
+            ? this.lastScriptExecutionSummary.result
+            : undefined;
     }
 
     /**

package/src/screenplay/abilities/index.ts

@@ -1 +1 @@
-export * from './BrowseTheWeb';
+export * from './BrowseTheWebWithProtractor';

package/src/screenplay/index.ts

@@ -1,3 +1,4 @@
 export * from './abilities';
 export * from './interactions';
+export * from './models';
 export * from './questions';