attempt to fix angular-protractor tests

protractor-helpers/index.d.ts

@@ -0,0 +1,111 @@
+// Type definitions for protractor-helpers v1.0.0
+// Project: https://github.com/wix/protractor-helpers
+// Definitions by: John Cant <https://github.com/johncant/>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+
+/// <reference types="jasmine" />
+/// <reference types="selenium-webdriver" />
+
+// ElementArrayFinder
+
+declare namespace protractor {
+  interface ElementArrayFinder {
+    getByText(text: string) : protractor.ElementFinder;
+    $$data(hook: string) : protractor.ElementArrayFinder;
+  }
+
+  interface ElementFinder {
+    $data(hook: string) : protractor.ElementFinder;
+  }
+}
+
+// Globals
+
+declare function $data(hook: string) : protractor.ElementFinder;
+declare function $$data(hook: string) : protractor.ElementArrayFinder;
+
+
+// Locators
+
+// TODO - find out about result of querySelector and querySelector all.
+//        Are they Locator s?
+declare namespace protractor {
+	interface IProtractorLocatorStrategy {
+		dataHook(hook: string, optParentElement?: protractor.ElementFinder, optRootSelector?: string) : webdriver.Locator;
+		dataHookAll(hook: string, optParentElement?: protractor.ElementFinder, optRootSelector?: string) : webdriver.Locator;
+	}
+}
+
+// Matchers
+// TODO - Typescript doesn't really help much here
+//        we don't know what type is being tested.
+//        Fixing this would require modifying the
+//        jasmine d.ts.
+
+declare namespace jasmine {
+  interface Matchers {
+    toBePresent() : boolean;
+    toBeDisplayed() : boolean;
+    toHaveCountOf(expectedCount : number) : boolean;
+    toHaveText(expectedText : string) : boolean;
+    toMatchRegex(regex : RegExp) : boolean;
+    toMatchMoney(expectedValue : number, currencySymbol? : string) : boolean;
+    toMatchMoneyWithFraction(expectedValue : number, currencySymbol?: string) : boolean;
+    toHaveValue(actual: string | number) : boolean;
+    toHaveClass(className : string) : boolean;
+    toHaveUrl(url : string) : boolean;
+    toBeDisabled() : boolean;
+    toBeChecked() : boolean;
+    toBeValid() : boolean;
+    toBeInvalid() : boolean;
+    toBeInvalidRequired() : boolean;
+    // Copied definitions from angular-translate.
+    toMatchTranslated(translationId : string, interpolateParams? : any) : boolean;
+    toMatchTranslated(translationId : string[], interpolateParams? : any) : boolean;
+  }
+}
+
+
+declare module "protractor-helpers" {
+
+  function not(arg: webdriver.promise.IThenable<any>) : webdriver.promise.IThenable<boolean>;
+
+  // Copied definitions from angular-translate.
+  function translate(translationId: string, interpolateParams?: any): webdriver.promise.IThenable<string>;
+  function translate(translationId: string[], interpolateParams?: any): webdriver.promise.IThenable<{ [key: string]: string }>;
+
+  function safeGet(url: string) : void;
+
+  function maximizeWindow(width?: number, height?: number) : void; // TODO
+  function resetPosition() : void;
+  function moveToElement(hook: string) : void;
+  function displayHover(element: protractor.ElementFinder) : void;
+
+  function waitForElement(element: protractor.ElementFinder, timeout?: number) : void;
+  function waitForElementToDisappear(element: protractor.ElementFinder, timeout?: number) : void;
+
+  function selectOptionByText(select: protractor.ElementFinder, text: string) : void;
+  function selectOptionByIndex(select: protractor.ElementFinder, index: number) : void;
+
+  function selectOption(option: protractor.ElementFinder) : void
+
+  function isFirefox() : boolean;
+  function isIE() : boolean;
+
+  function createMessage(actual : string, message : string, isNot : any) : string; // isNot : boolean too inflexible
+  function createMessage(actual : protractor.ElementFinder, message : string, isNot : any) : string; // isNot : boolean too inflexible
+  function createMessage(actual : protractor.ElementArrayFinder, message : string, isNot : any) : string; // isNot : boolean too inflexible
+
+  function clearAndSetValue(input : protractor.ElementFinder, value : string) : void; // TODO - sendKeys(value)
+
+  function hasClass(element: protractor.ElementFinder, className: string) : webdriver.promise.IThenable<boolean>;
+  function hasValue(element: protractor.ElementFinder, expectedValue: string) : webdriver.promise.IThenable<boolean>;
+  function hasValue(element: protractor.ElementFinder, expectedValue: number) : webdriver.promise.IThenable<boolean>;
+  function hasLink(element: protractor.ElementFinder, url: string) : webdriver.promise.IThenable<boolean>;
+  function isDisabled(element: protractor.ElementFinder) : webdriver.promise.IThenable<boolean>;
+  function isChecked(element: protractor.ElementFinder) : webdriver.promise.IThenable<boolean>;
+  function getFilteredConsoleErrors() : webdriver.promise.IThenable<string[]>; // TODO - discuss handling in IE
+
+}
+

protractor-helpers/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "protractor-helpers",
+  "version": "1.0.0",
+  "description": "protractor helpers",
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@types/jasmine": "^2.2.34",
+    "@types/selenium-webdriver": "~2.44.28"
+  }
+}

protractor-helpers/protractor-helpers-tests.ts

@@ -0,0 +1,116 @@
+
+
+import helpers = require('protractor-helpers');
+
+declare var $$: any, $: any, by: any, element: any; // ??
+
+function testElementArrayFinder() {
+
+  var single1 : protractor.ElementFinder = $$('.foo').getByText('Hello');
+  var multiple : protractor.ElementArrayFinder = $$('.foo').$$data('Hello');
+
+}
+
+function testElementFinder () {
+  var single2 : protractor.ElementFinder = $('.foo').$data('Hello');
+}
+
+function testGlobals() {
+
+  var single : protractor.ElementFinder = $data('Hello');
+  var multiple : protractor.ElementArrayFinder = $$data('Hello');
+
+}
+
+function testHelpers() {
+
+  var q0 : webdriver.promise.IThenable<boolean> = helpers.not($('.foo').isDisplayed());
+  // TODO - Check impl
+  var q1 : webdriver.promise.IThenable<{[key: string]:string}> = helpers.translate(["foo", "bar"]);
+  var q2 : webdriver.promise.IThenable<{[key: string]:string}> = helpers.translate(["foo", "bar"], {name: 'foo'});
+  var q3 : webdriver.promise.IThenable<string> = helpers.translate("foo");
+  var q4 : webdriver.promise.IThenable<string> = helpers.translate("foo", {name: 'foo'});
+
+  helpers.safeGet('https://foo/');
+
+  helpers.maximizeWindow(500, 500);
+  helpers.maximizeWindow(500);
+  helpers.maximizeWindow(undefined, 500);
+  helpers.maximizeWindow();
+
+  helpers.resetPosition();
+  helpers.moveToElement(".foo"); // TODO - ?
+
+  helpers.displayHover($('.foo'));
+
+  helpers.waitForElement($('.foo'));
+  helpers.waitForElement($('.foo'), 1000);
+  helpers.waitForElementToDisappear($('.foo'));;
+  helpers.waitForElementToDisappear($('.foo'), 1000);
+
+  helpers.selectOptionByText($('select'), "GB");
+  helpers.selectOptionByIndex($('select'), 1);
+
+  helpers.selectOption($$('select option').first());
+
+  var ff : boolean = helpers.isFirefox();
+  var ie : boolean = helpers.isIE();
+
+  var msg : string = helpers.createMessage("actual", "message", true);
+  var msg : string = helpers.createMessage($('.foo'), "message", true);
+  var msg : string = helpers.createMessage($$('.foo'), "message", true);
+
+  helpers.clearAndSetValue($('input'), 'Foo');
+
+  var hc : webdriver.promise.IThenable<boolean> = helpers.hasClass($('.foo'), 'foo');
+
+  var hv : webdriver.promise.IThenable<boolean> = helpers.hasValue($('input[type=text]'), 'foo');
+  var hv1 : webdriver.promise.IThenable<boolean> = helpers.hasValue($('input[type=numeric]'), 12);
+  var hl : webdriver.promise.IThenable<boolean> = helpers.hasLink($('div'), 'http://foo.com');
+  var disabled : webdriver.promise.IThenable<boolean> = helpers.isDisabled($('foo'));
+  var checked : webdriver.promise.IThenable<boolean> = helpers.isChecked($('foo'));
+
+  var q5 : webdriver.promise.IThenable<string[]> = helpers.getFilteredConsoleErrors();
+
+}
+
+function testLocators() {
+
+	element(by.dataHook("foo"));
+	element(by.dataHook("foo", $('.parentfoo')));
+	element(by.dataHook("foo", undefined          , ".foo"));
+	element(by.dataHook("foo", $('.parentfoo'), ".foo")); // TODO - This might not make much sense, but can technically be used in working code. Opinions welcome
+
+	element.all(by.dataHook("foo"));
+	element.all(by.dataHook("foo", $('parentfoo')));
+	element.all(by.dataHook("foo", undefined          , ".foo"));
+	element.all(by.dataHook("foo", $('parentfoo'), ".foo")); // TODO - This might not make much sense, but can technically be used in working code. Opinions welcome
+
+}
+
+function testMatchers() {
+
+  var expectResult : boolean;
+	expectResult = expect($('.foo')).toBePresent();
+	expectResult = expect($('.foo')).toBeDisplayed();
+	expectResult = expect($$('.foo').count()).toHaveCountOf(1);
+	expectResult = expect($('.foo')).toHaveText("bla");
+	expectResult = expect($('.foo')).toMatchRegex(/bla/);
+	expectResult = expect($('.foo').getText()).toMatchMoney(123, "£");
+	expectResult = expect($('.foo').getText()).toMatchMoneyWithFraction(123.45, "£");
+	expectResult = expect($('input')).toHaveValue(12);
+	expectResult = expect($('input')).toHaveValue("bla");
+	expectResult = expect($('.foo')).toHaveClass("foo");
+	expectResult = expect($('.foo')).toHaveUrl('https://foo.com');
+	expectResult = expect($('.foo')).toBeDisabled();
+	expectResult = expect($('.foo')).toBeChecked();
+	expectResult = expect($('.foo')).toBeValid();
+	expectResult = expect($('.foo')).toBeInvalid();
+	expectResult = expect($('.foo')).toBeInvalidRequired();
+	expectResult = expect($('.foo')).toMatchTranslated("foo");
+	expectResult = expect($('.foo')).toMatchTranslated("foo", {foo: "bar"});
+	expectResult = expect($('.foo')).toMatchTranslated(["foo"]);
+	expectResult = expect($('.foo')).toMatchTranslated(["foo", "bla"], {foo: "bar"});
+
+}
+

protractor-helpers/tsconfig.json

@@ -0,0 +1,16 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "strictNullChecks": false,
+        "baseUrl": "../",
+        "types": ["jasmine", "selenium-webdriver"],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "protractor-helpers-tests.ts"
+    ]
+}

protractor-http-mock/index.d.ts

@@ -0,0 +1,284 @@
+// Type definitions for protractor-http-mock
+// Project: https://github.com/atecarlos/protractor-http-mock
+// Definitions by: Crevil <https://github.com/Crevil>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference types="selenium-webdriver" />
+
+declare namespace mock {
+    interface ProtractorHttpMock {
+        /**
+         * Instantiate mock module. This must be done before the browser connects.
+         *
+         * @param mocks An array of mock modules to load into the application.
+         * @param plugins An array of Plugin objects.
+         * @param skipDefaults Set true to skip loading of default mocks.
+         */
+        <TResponse, TPayload>(mocks?: Array<requests.AllRequests<TResponse, TPayload>>, plugins?: Array<Plugin>, skipDefaults?: boolean): ProtractorHttpMock;
+
+        /**
+         * Instantiate mock module. This must be done before the browser connects.
+         *
+         * @param mocks An array of mock modules to load into the application.
+         * @param plugins An array of NPM modules as strings.
+         * @param skipDefaults Set true to skip loading of default mocks.
+         */
+        <TResponse, TPayload>(mocks?: Array<requests.AllRequests<TResponse, TPayload>>, plugins?: Array<string>, skipDefaults?: boolean): ProtractorHttpMock;
+
+        /**
+         * Instantiate mock modules from files. This must be done before the browser connects.
+         *
+         * @param mocks An array of mock module names relative to the rootDirectory configuration.
+         * @param plugins An array of Plugin objects.
+         * @param skipDefaults Set true to skip loading of default mocks.
+         */
+        (mocks: Array<string>, plugins?: Array<Plugin>, skipDefaults?: boolean): ProtractorHttpMock;
+
+        /**
+         * Instantiate mock modules from files. This must be done before the browser connects.
+         *
+         * @param mocks An array of mock module names relative to the rootDirectory configuration.
+         * @param plugins An array of NPM modules as strings.
+         * @param skipDefaults Set true to skip loading of default mocks.
+         */
+        (mocks: Array<string>, plugins?: Array<string>, skipDefaults?: boolean): ProtractorHttpMock;
+
+        /**
+         * Clean up.
+         * Typically done in the afterEach call to ensure the teardown
+         * is executed regardless of what happens in the test execution.
+         */
+        teardown(): void;
+
+        /**
+         * Returns a promise that will be resolved with an array of
+         * all matched HTTP requests.
+         */
+        requestsMade(): webdriver.promise.Promise<Array<ReceivedRequest>>;
+
+        /**
+         * Returns a promise that will be resolved with a true boolean
+         * when all matched HTTP requests are cleared.
+         */
+        clearRequests(): webdriver.promise.Promise<boolean>;
+
+        /**
+         * Module configuration to setup
+         */
+        config: {
+            /**
+             * Mocks directory where mock files are located.
+             * Default: process.cwd()
+             */
+            rootDirectory?: string;
+
+            /**
+             * Path to protractor configuration file.
+             * Default: protractor.conf
+             */
+            protractorConfig?: string;
+        };
+
+        /**
+         * Add mocks during test execution.
+         * Returns a promise that will be resolved with a true boolean
+         * when mocks are added.
+         *
+         * @param mocks An array of mock modules to load into the application.
+         */
+        add<T1, T2>(mocks: Array<requests.AllRequests<T1, T2>>): webdriver.promise.Promise<boolean>;
+
+        /**
+         * Remove mocks during test execution.
+         * Returns a promise that will be resolved with a true boolean
+         * when the supplied mocks are removed.
+         *
+         * @param mocks An array of mock modules to remove from the application.
+         */
+        remove<T1, T2>(mocks: Array<requests.AllRequests<T1, T2>>): webdriver.promise.Promise<boolean>;
+    }
+
+    /**
+     * Matched request.
+     */
+    interface ReceivedRequest {
+        url: string;
+        method: requests.Method;
+    }
+
+    /**
+     * Plugin for custom matching logic.
+     */
+    interface Plugin {
+        /**
+         * Match function.
+         * Return a truthy value to indicate successfull match.
+         *
+         * @param mockRequest The mock to compare request with.
+         * @param requestConfig The request object to compare mock with.
+         */
+        match<T1, T2>(mockRequest: requests.AllRequests<T1, T2>, requestConfig: requests.AllRequests<T1, T2>): boolean;
+    }
+
+    /**
+     * Plugin for custom matching logic.
+     */
+    interface Plugin {
+        /**
+         * Match function.
+         * Return a truthy value to indicate successfull match.
+         *
+         * @param mockRequest The mock to compare request with.
+         * @param requestConfig The request object to compare mock with.
+         */
+        match<T1, T2>(mockRequest: requests.AllRequests<T1, T2>, requestConfig: requests.AllRequests<T1, T2>): boolean;
+    }
+
+    namespace requests {
+        /**
+         * Request methods type
+         */
+        type Method = "GET" | "POST" | "DELETE" | "PUT" | "HEAD" | "PATCH" | "JSONP";
+
+        /**
+         * All available request types.
+         */
+        type AllRequests<T1, T2> = Get<T1> |
+            PostData<T1, T2> |
+            Post<T1> |
+            Head<T1> |
+            Delete<T1> |
+            Put<T1> |
+            Patch<T1> |
+            Jsonp<T1>;
+
+        /**
+         * GET request mock.
+         */
+        interface Get<TResponse> {
+            request: {
+                method: Method;
+                path: string;
+                regex?: boolean;
+                params?: Object;
+                queryString?: Object;
+                headers?: Object;
+                interceptedRequest?: boolean;
+                interceptedAnonymousRequest?: boolean;
+            };
+            response: {
+                status?: number;
+                data: TResponse;
+            };
+        }
+
+        /**
+         * POST request mock with payload.
+         */
+        interface PostData<TResponse, TPayload> {
+            request: {
+                method: Method;
+                path: string;
+                regex?: boolean;
+                data: TPayload;
+            };
+            response: {
+                status?: number;
+                data: TResponse;
+            };
+        }
+
+        /**
+         * POST request mock.
+         */
+        interface Post<TResponse> {
+            request: {
+                method: Method;
+                path: string;
+                regex?: boolean;
+            };
+            response: {
+                status?: number;
+                data: TResponse;
+            };
+        }
+
+        /**
+         * HEAD request mock.
+         */
+        interface Head<TResponse> {
+            request: {
+                method: Method;
+                path: string;
+                regex?: boolean;
+            };
+            response: {
+                status?: number;
+                data: TResponse;
+            };
+        }
+
+        /**
+         * HTTP Delete request mock.
+         */
+        interface Delete<TResponse> {
+            request: {
+                method: Method;
+                path: string;
+                regex?: boolean;
+            };
+            response: {
+                status?: number;
+                data: TResponse;
+            };
+        }
+
+        /**
+         * PUT request mock.
+         */
+        interface Put<TResponse> {
+            request: {
+                method: Method;
+                path: string;
+                regex?: boolean;
+            };
+            response: {
+                status?: number;
+                data: TResponse;
+            };
+        }
+
+        /**
+         * PATCH request mock.
+         */
+        interface Patch<TResponse> {
+            request: {
+                method: Method;
+                path: string;
+                regex?: boolean;
+            };
+            response: {
+                status?: number;
+                data: TResponse;
+            };
+        }
+
+        /**
+         * JSONP request mock.
+         */
+        interface Jsonp<TResponse> {
+            request: {
+                method: Method;
+                path: string;
+                regex?: boolean;
+            };
+            response: {
+                status?: number;
+                data: TResponse;
+            };
+        }
+    }
+}
+
+declare var mock: mock.ProtractorHttpMock;
+export = mock;

protractor-http-mock/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "protractor-http-mock",
+  "version": "1.0.0",
+  "description": "protractor http mock",
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@types/selenium-webdriver": "~2.44.28"
+  }
+}

protractor-http-mock/protractor-http-mock-tests.ts

@@ -0,0 +1,302 @@
+import mock = require("protractor-http-mock");
+
+function TestConfig() {
+    mock.config = {
+        rootDirectory: "root",
+        protractorConfig: "protractor.conf.js"
+    };
+}
+
+function TestCtorOverloads() {
+    let del: mock.requests.Delete<number> = {
+        request: {
+            path: 'path',
+            method: 'DELETE'
+        },
+        response: {
+            status: 400,
+            data: 1
+        }
+    };
+    let put: mock.requests.Put<number> = {
+        request: {
+            path: 'path',
+            method: 'PUT'
+        },
+        response: {
+            status: 400,
+            data: 1
+        }
+    };
+    let plugin: mock.Plugin = {
+        match: (mockRequest: mock.requests.Delete<number>, requestConfig: mock.requests.AllRequests<number, number>) => {
+            if (requestConfig.request.method && mockRequest.request.method) {
+                return true;
+            }
+
+            return false;
+        }
+    };
+
+    let noParam: mock.ProtractorHttpMock = mock();
+    let emptyArray: mock.ProtractorHttpMock = mock([]);
+    let mockFiles: mock.ProtractorHttpMock = mock(['mock1', 'mock2']);
+    let mocks: mock.ProtractorHttpMock = mock([del, put]);
+
+    let mockFilesNpmPlugins: mock.ProtractorHttpMock = mock(['mock1'], ['plugin']);
+    let mocksWithNpmPlugins: mock.ProtractorHttpMock = mock([del, put], ['plugin']);
+
+    let pluginMocks: mock.ProtractorHttpMock = mock([del, put], [plugin]);
+
+    let mockFilesNpmPluginsSkipDefaults: mock.ProtractorHttpMock = mock(['mock1'], ['plugin'], true);
+    let skipDefaults: mock.ProtractorHttpMock = mock([del, put], [plugin], true);
+}
+
+function TestTeardown() {
+    mock.teardown();
+}
+
+function TestRequestsMade() {
+    let values: Array<mock.ReceivedRequest>;
+    mock.requestsMade().then(v => values = v);
+}
+
+function TestClearRequests() {
+    let promiseValue: boolean;
+    mock.clearRequests().then(value => {
+        promiseValue = value;
+    });
+}
+
+function TestDynamicAdd() {
+    let put: mock.requests.Put<number> = {
+        request: {
+            path: "path",
+            method: "PUT"
+        },
+        response: {
+            status: 400,
+            data: 1
+        }
+    };
+    let resolved: boolean;
+    mock.add([put]).then(r => resolved = r);
+}
+
+function TestDyanmicRemove() {
+    let put: mock.requests.Put<number> = {
+        request: {
+            path: "path",
+            method: "PUT"
+        },
+        response: {
+            status: 400,
+            data: 1
+        }
+    };
+    let resolved: boolean;
+    mock.remove([put]).then(r => resolved = r);
+}
+
+function TestGetRequestDefinitions() {
+    let getMinium: mock.requests.Get<number> = {
+        request: {
+            path: 'path',
+            method: 'GET',
+            regex: true
+        },
+        response: {
+            data: 1,
+            status: 500
+        }
+    };
+
+    let getParams: mock.requests.Get<number> = {
+        request: {
+            path: 'path',
+            method: 'GET',
+            regex: true,
+            params: {
+                param1: 'param1',
+                param2: 2
+            }
+        },
+        response: {
+            data: 1,
+            status: 500
+        }
+    };
+
+    let post: mock.requests.Post<number> = {
+        request: {
+            path: 'path',
+            method: 'POST',
+            regex: true
+        },
+        response: {
+            data: 1,
+            status: 500
+        }
+    };
+
+    let getQueryString: mock.requests.Get<number> = {
+        request: {
+            path: 'path',
+            method: 'GET',
+            regex: true,
+            queryString: {
+                query1: 'query1',
+                query2: 2
+            }
+        },
+        response: {
+            data: 1,
+            status: 500
+        }
+    };
+
+    let getHeaders: mock.requests.Get<number> = {
+        request: {
+            path: 'path',
+            method: 'GET',
+            regex: true,
+            headers: {
+                head1: 'head1',
+                head2: 'head2'
+            }
+        },
+        response: {
+            data: 1,
+            status: 500
+        }
+    };
+}
+
+function TestPostRequestDefinitions() {
+    let post: mock.requests.Post<number> = {
+        request: {
+            path: 'path',
+            method: 'POST',
+            regex: true
+        },
+        response: {
+            data: 1,
+            status: 500
+        }
+    };
+
+    let postData: mock.requests.PostData<number, string> = {
+        request: {
+            path: 'path',
+            method: 'POST',
+            data: 'data',
+            regex: true
+        },
+        response: {
+            data: 1,
+            status: 500
+        }
+    };
+}
+
+function TestHeadRequestDefinitions() {
+    let head: mock.requests.Head<number> = {
+        request: {
+            path: 'path',
+            method: 'HEAD',
+            regex: true
+        },
+        response: {
+            status: 500,
+            data: 1
+        }
+    };
+}
+
+function TestDeleteRequestDefinitions() {
+    let del: mock.requests.Delete<number> = {
+        request: {
+            path: 'path',
+            method: 'DELETE',
+            regex: true
+        },
+        response: {
+            status: 500,
+            data: 1
+        }
+    };
+}
+
+function TestPutRequestDefinitions() {
+    let put: mock.requests.Put<number> = {
+        request: {
+            path: 'path',
+            method: 'PUT',
+            regex: true
+        },
+        response: {
+            status: 500,
+            data: 1
+        }
+    };
+}
+
+function TestPatchRequestDefinitions() {
+    let patch: mock.requests.Patch<number> = {
+        request: {
+            path: 'path',
+            method: 'PATCH',
+            regex: true
+        },
+        response: {
+            status: 500,
+            data: 1
+        }
+    };
+}
+
+function TestJsonpRequestDefinitions() {
+    let jsonp: mock.requests.Jsonp<number> = {
+        request: {
+            path: 'path',
+            method: 'JSONP',
+            regex: true
+        },
+        response: {
+            status: 500,
+            data: 1
+        }
+    };
+}
+
+function TestRuntimeMocks() {
+    mock.add([{
+        request: {
+            path: '/users',
+            method: 'GET',
+            params: {
+                name: 'Charlie'
+            }
+        },
+        response: {
+            data: {
+                name: 'Override'
+            }
+        }
+    }]);
+
+    mock.remove([{
+        request: {
+            path: '/users',
+            method: 'GET',
+            params: {
+                name: 'Charlie'
+            }
+        },
+        response: {
+            data: {
+                name: 'Override'
+            }
+        }
+    }]);
+}

protractor-http-mock/tsconfig.json

@@ -0,0 +1,16 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "strictNullChecks": false,
+        "baseUrl": "../",
+        "types": ["selenium-webdriver"],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "protractor-http-mock-tests.ts"
+    ]
+}

protractor/angular-protractor-tests.ts

@@ -0,0 +1,483 @@
+
+
+function TestWebDriverExports() {
+    var button: number = protractor.Button.LEFT;
+
+    var key: string = protractor.Key.ADD;
+    var chord: string = protractor.Key.chord(protractor.Key.NUMPAD0, protractor.Key.NUMPAD1);
+
+    var driver: protractor.WebDriver = new protractor.Builder().
+        withCapabilities(protractor.Capabilities.chrome()).
+        build();
+    var baseDriver: webdriver.WebDriver = driver;
+
+    var action: protractor.ActionSequence = new protractor.ActionSequence(driver);
+    var baseAction: webdriver.ActionSequence = action;
+
+    var browser: string = protractor.Browser.ANDROID;
+
+    var builder: protractor.Builder = new protractor.Builder();
+    var baseBuilder: webdriver.Builder = builder;
+
+    var capability: string = protractor.Capability.BROWSER_NAME;
+
+    var capabilities: protractor.Capabilities = protractor.Capabilities.chrome();
+    var baseCapabilities: webdriver.Capabilities = capabilities;
+
+    var commandName: string = protractor.CommandName.CLICK_ELEMENT;
+
+    var command: protractor.Command = new protractor.Command(protractor.CommandName.CLICK);
+    var baseCommand: webdriver.Command = command;
+
+    var eventEmitter: protractor.EventEmitter = new protractor.EventEmitter();
+    var baseEventEmitter: webdriver.EventEmitter = eventEmitter;
+
+    var webElement: protractor.WebElement = new protractor.WebElement(driver, new protractor.promise.Promise());
+    var baseWebElement: webdriver.WebElement = webElement;
+
+    var locator: webdriver.Locator = by.id('abc');
+
+    var session: protractor.Session = new protractor.Session('ABC', webdriver.Capabilities.android());
+    var baseSession: webdriver.Session = session;
+
+    locator = protractor.By.name('name');
+
+    var driver: protractor.WebDriver = new protractor.WebDriver(session, <webdriver.CommandExecutor><any>{});
+    driver = new protractor.WebDriver(session, <webdriver.CommandExecutor><any>{}, new webdriver.promise.ControlFlow());
+    var baseDriver: webdriver.WebDriver = driver;
+
+    var webElement: protractor.WebElement = new protractor.WebElement(driver, { ELEMENT: 'abc' });
+    var baseWebElement: webdriver.WebElement = webElement;
+
+    var webElementPromise: protractor.WebElementPromise = new protractor.WebElementPromise(driver, { ELEMENT: 'abc' });
+    var baseWebElementPromise: webdriver.WebElementPromise = webElementPromise;
+}
+
+function TestWebDriverErrorModule() {
+    var errorCode: number = protractor.error.ErrorCode.ELEMENT_NOT_VISIBLE;
+    var error: protractor.error.Error = new protractor.error.Error(protractor.error.ErrorCode.ELEMENT_NOT_VISIBLE);
+    var baseError: webdriver.error.Error = error;
+}
+
+function TestWebDriverLoggingModule() {
+    var levelName: string = protractor.logging.Level.ALL.name;
+    var loggingType: string = protractor.logging.Type.CLIENT;
+
+    var level: webdriver.logging.ILevel = protractor.logging.Level.ALL;
+
+    var entry: protractor.logging.Entry = new protractor.logging.Entry(protractor.logging.Level.ALL, 'Message');
+    var baseEntry: webdriver.logging.Entry = entry;
+
+    level = protractor.logging.getLevel('DEBUG');
+
+    var prefs: protractor.logging.Preferences = new protractor.logging.Preferences();
+}
+
+function TestWebDriverPromiseModule() {
+    var cancelError: protractor.promise.CancellationError = new protractor.promise.CancellationError();
+    cancelError = new protractor.promise.CancellationError('message');
+    var baseCancelError: webdriver.promise.CancellationError = cancelError;
+
+    var thenable: protractor.promise.Thenable<any> = new protractor.promise.Thenable();
+    var baseThenable: webdriver.promise.Thenable<any> = thenable;
+
+    var promise: protractor.promise.Promise<any> = new protractor.promise.Promise();
+    var basePromise: webdriver.promise.Promise<any> = promise;
+
+    var deferred: protractor.promise.Deferred<any> = new protractor.promise.Deferred();
+    var baseDeferred: webdriver.promise.Deferred<any> = deferred;
+
+    var flow: protractor.promise.ControlFlow = new protractor.promise.ControlFlow();
+    var baseFlow: webdriver.promise.ControlFlow = flow;
+
+    var arrayPromise: protractor.promise.Promise<any[]> = protractor.promise.all([new protractor.promise.Promise<number>(), new protractor.promise.Promise<string>()]);
+
+    protractor.promise.asap(promise, function (value: any) { return true; });
+    protractor.promise.asap(promise, function (value: any) { }, function (err: any) { return 'ABC'; });
+
+    promise = protractor.promise.checkedNodeCall(function (err: any, value: any) { return 123; });
+
+    promise = protractor.promise.consume(function () {
+        return 5;
+    });
+    promise = protractor.promise.consume(function () {
+        return 5;
+    }, this);
+    promise = protractor.promise.consume(function () {
+        return 5;
+    }, this, 1, 2, 3);
+
+    flow = protractor.promise.controlFlow();
+
+    promise = protractor.promise.createFlow(function (newFlow: webdriver.promise.ControlFlow) { });
+
+    deferred = protractor.promise.defer();
+
+    promise = protractor.promise.delayed(123);
+
+    var numbersPromise: protractor.promise.Promise<number[]> = protractor.promise.filter([1, 2, 3], function (el: number, index: number, arr: number[]) {
+        return true;
+    });
+    numbersPromise = protractor.promise.filter([1, 2, 3], function (el: number, index: number, arr: number[]) {
+        return true;
+    }, this);
+    numbersPromise = protractor.promise.filter(numbersPromise, function (el: number, index: number, arr: number[]) {
+        return true;
+    });
+    numbersPromise = protractor.promise.filter(numbersPromise, function (el: number, index: number, arr: number[]) {
+        return true;
+    }, this);
+
+    numbersPromise = protractor.promise.map([1, 2, 3], function (el: number, index: number, arr: number[]) {
+        return true;
+    });
+    numbersPromise = protractor.promise.map([1, 2, 3], function (el: number, index: number, arr: number[]) {
+        return true;
+    }, this);
+    numbersPromise = protractor.promise.map(numbersPromise, function (el: number, index: number, arr: number[]) {
+        return true;
+    });
+    numbersPromise = protractor.promise.map(numbersPromise, function (el: number, index: number, arr: number[]) {
+        return true;
+    }, this);
+
+    promise = protractor.promise.fulfilled();
+    promise = protractor.promise.fulfilled({ a: 123 });
+
+    promise = protractor.promise.fullyResolved({ a: 123 });
+
+    var bool: boolean = protractor.promise.isGenerator(function () { });
+    var bool: boolean = protractor.promise.isPromise('ABC');
+
+    promise = protractor.promise.rejected({ a: 123 });
+
+    protractor.promise.setDefaultFlow(new webdriver.promise.ControlFlow());
+
+    promise = protractor.promise.when(promise, function (value: any) { return 123; }, function (err: Error) { return 123; });
+}
+
+function TestWebDriverStacktraceModule() {
+    var bool: boolean = protractor.stacktrace.BROWSER_SUPPORTED;
+
+    var frame: protractor.stacktrace.Frame = new protractor.stacktrace.Frame();
+    var baseFrame: webdriver.stacktrace.Frame = frame;
+
+    var snapshot: protractor.stacktrace.Snapshot = new protractor.stacktrace.Snapshot();
+    var baseSnapshot: webdriver.stacktrace.Snapshot = snapshot;
+
+    var err: Error = protractor.stacktrace.format(new Error("Error"));
+    var frames: protractor.stacktrace.Frame[] = protractor.stacktrace.get();
+}
+
+function TestWebDriverUntilModule() {
+    var conditionB: protractor.until.Condition<boolean> = new protractor.until.Condition<boolean>('message', function (driver: webdriver.WebDriver) { return true; });
+    var conditionBBase: webdriver.until.Condition<boolean> = conditionB;
+    var conditionWebElement: protractor.until.Condition<webdriver.IWebElement>;
+    var conditionWebElements: protractor.until.Condition<webdriver.IWebElement[]>;
+
+    conditionB = protractor.until.ableToSwitchToFrame(5);
+    var conditionAlert: protractor.until.Condition<webdriver.Alert> = protractor.until.alertIsPresent();
+    var el: protractor.ElementFinder = element(by.id('id'));
+    conditionB = protractor.until.elementIsDisabled(el);
+    conditionB = protractor.until.elementIsEnabled(el);
+    conditionB = protractor.until.elementIsNotSelected(el);
+    conditionB = protractor.until.elementIsNotVisible(el);
+    conditionB = protractor.until.elementIsSelected(el);
+    conditionB = protractor.until.elementIsVisible(el);
+    conditionB = protractor.until.elementTextContains(el, 'text');
+    conditionB = protractor.until.elementTextIs(el, 'text');
+    conditionB = protractor.until.elementTextMatches(el, /text/);
+    conditionB = protractor.until.stalenessOf(el);
+    conditionB = protractor.until.titleContains('text');
+    conditionB = protractor.until.titleIs('text');
+    conditionB = protractor.until.titleMatches(/text/);
+
+    conditionWebElement = protractor.until.elementLocated(by.id('id'));
+    conditionWebElements = protractor.until.elementsLocated(by.className('class'));
+}
+
+function TestWebDriverExpectedConditionsModule() {
+    var conditionB: protractor.until.Condition<boolean>;
+    var el: protractor.ElementFinder = element(by.id('id'));
+
+    conditionB = protractor.ExpectedConditions.alertIsPresent();
+    conditionB = protractor.ExpectedConditions.elementToBeClickable(el);
+    conditionB = protractor.ExpectedConditions.textToBePresentInElement(el, 'text');
+    conditionB = protractor.ExpectedConditions.textToBePresentInElementValue(el, 'text');
+    conditionB = protractor.ExpectedConditions.titleContains('text');
+    conditionB = protractor.ExpectedConditions.titleIs('text');
+    conditionB = protractor.ExpectedConditions.presenceOf(el);
+    conditionB = protractor.ExpectedConditions.stalenessOf(el);
+    conditionB = protractor.ExpectedConditions.visibilityOf(el);
+    conditionB = protractor.ExpectedConditions.invisibilityOf(el);
+    conditionB = protractor.ExpectedConditions.elementToBeSelected(el);
+
+    conditionB = protractor.ExpectedConditions.not(protractor.ExpectedConditions.alertIsPresent());
+    conditionB = protractor.ExpectedConditions.and(protractor.ExpectedConditions.alertIsPresent(), protractor.ExpectedConditions.elementToBeClickable(el));
+    conditionB = protractor.ExpectedConditions.or(protractor.ExpectedConditions.alertIsPresent(), protractor.ExpectedConditions.elementToBeClickable(el));
+}
+
+function TestProtractor() {
+    var ptor: protractor.Protractor;
+    var driver: webdriver.WebDriver = new webdriver.Builder().
+        withCapabilities(webdriver.Capabilities.chrome()).
+        build();
+
+    ptor = protractor.wrapDriver(driver);
+    ptor = protractor.wrapDriver(driver, 'baseUrl');
+    ptor = protractor.wrapDriver(driver, 'baseUrl', 'rootElement');
+
+    ptor = browser;
+
+    var actions: protractor.ActionSequence = ptor.actions();
+
+    var promise: protractor.promise.Promise<any> = ptor.call(function () { });
+    var promise: protractor.promise.Promise<any> = ptor.call(function () { }, this);
+    var promise: protractor.promise.Promise<any> = ptor.call(function (a: number, b: number, c:number) { }, this, 1, 2,3);
+
+    promise = ptor.executeAsyncScript('SomeScript');
+    promise = ptor.executeAsyncScript('SomeScript', 1, 2, 3);
+    promise = ptor.executeAsyncScript(function () { });
+    promise = ptor.executeAsyncScript(function (a: number, b: number, c: number) { }, 1, 2, 3);
+
+    promise = ptor.executeScript('SomeScript');
+    promise = ptor.executeScript('SomeScript', 1, 2, 3);
+    promise = ptor.executeScript(function () { });
+    promise = ptor.executeScript(function (a: number, b: number, c: number) { }, 1, 2, 3);
+
+    ptor = browser.forkNewDriverInstance();
+    ptor = browser.forkNewDriverInstance(true);
+    ptor = browser.forkNewDriverInstance(true, false);
+
+    driver = ptor.driver;
+    var baseUrl: string = ptor.baseUrl;
+    var rootEl: string = ptor.rootEl;
+    var ignoreSynchronization: boolean = ptor.ignoreSynchronization;
+    var params: any = ptor.params;
+    ptor.resetUrl = "url";
+
+    ptor.debugger();
+    ptor.close();
+    var controlFlow: protractor.promise.ControlFlow = ptor.controlFlow();
+
+    var webElement: protractor.WebElement = ptor.findElement(by.css('.class'));
+    ptor.findElements(by.css('.class')).then(function (elements: webdriver.WebElement[]) { });
+    ptor.isElementPresent(by.css('.class')).then(function (present: boolean) { });
+    ptor.isElementPresent(webElement).then(function (present: boolean) { });
+
+    ptor.clearMockModules();
+    ptor.addMockModule('name', 'script');
+    ptor.addMockModule('name', function() {});
+    ptor.removeMockModule('name');
+    ptor.waitForAngular();
+
+    var elementFinder: protractor.ElementFinder;
+    var elementArrayFinder: protractor.ElementArrayFinder;
+
+    elementFinder = ptor.element(by.id('ABC'));
+    elementFinder = ptor.$('.class');
+
+    elementArrayFinder = ptor.$$('.class');
+
+    var locationAbsUrl: webdriver.promise.Promise<string> = ptor.getLocationAbsUrl();
+    ptor.setLocation('webaddress.com');
+
+    var voidPromise: webdriver.promise.Promise<void> = ptor.get('webaddress.com');
+    voidPromise = ptor.get('webdaddress.com', 45);
+    voidPromise = ptor.quit();
+    voidPromise = ptor.sleep(5000);
+
+    ptor.refresh();
+    ptor.refresh(45);
+    var navigation: webdriver.WebDriverNavigation = ptor.navigate();
+    ptor.pause();
+    ptor.pause(8080);
+
+    ptor.getAllWindowHandles().then(function (handles: string[]) { });
+
+    var capabilities: protractor.promise.Promise<protractor.Capabilities> = ptor.getCapabilities();
+
+    var stringPromise: webdriver.promise.Promise<string>;
+    stringPromise = ptor.getCurrentUrl();
+    stringPromise = ptor.getPageSource();
+    stringPromise = ptor.getTitle();
+    stringPromise = ptor.getWindowHandle();
+    stringPromise = ptor.takeScreenshot();
+
+    ptor.getPageTimeout = 5000;
+
+    var session: protractor.promise.Promise<protractor.Session> = ptor.getSession();
+
+    var options: webdriver.WebDriverOptions = ptor.manage();
+
+    promise = ptor.schedule(new protractor.Command(protractor.CommandName.ACCEPT_ALERT), 'asdf');
+
+    var targetLocator: webdriver.WebDriverTargetLocator = ptor.switchTo();
+
+    ptor.wait(protractor.until.elementLocated(by.id('id')), 5000).then(function (el: webdriver.IWebElement) { });;
+    ptor.wait(protractor.until.elementLocated(by.id('id')), 5000, 'message').then(function (el: webdriver.IWebElement) { });;
+}
+
+function TestElement() {
+    var elementFinder: protractor.ElementFinder = element(by.id('id'));
+    var elementArrayFinder: protractor.ElementArrayFinder = element.all(by.className('class'));
+}
+
+function TestElementFinder() {
+    var elementFinder: protractor.ElementFinder = element(by.id('id'));
+    var voidPromise: webdriver.promise.Promise<void>;
+    var stringPromise: webdriver.promise.Promise<string>;
+    var booleanPromise: webdriver.promise.Promise<boolean>;
+
+    elementFinder.getId().then(function (id: webdriver.IWebElementId) { });
+    voidPromise = elementFinder.click();
+    elementFinder = elementFinder.allowAnimations('string');
+    voidPromise = elementFinder.sendKeys(protractor.Key.UP, protractor.Key.DOWN);
+    stringPromise = elementFinder.getTagName();
+    stringPromise = elementFinder.getCssValue('display');
+    stringPromise = elementFinder.getAttribute('atribute');
+    stringPromise = elementFinder.getText();
+    elementFinder.getSize().then(function (size: webdriver.ISize) { });
+    elementFinder.getLocation().then(function (location: webdriver.ILocation) { });
+    booleanPromise = elementFinder.isEnabled();
+    booleanPromise = elementFinder.isSelected();
+    voidPromise = elementFinder.submit();
+    voidPromise = elementFinder.clear();
+    booleanPromise = elementFinder.isDisplayed();
+    stringPromise = elementFinder.getOuterHtml();
+    stringPromise = elementFinder.getInnerHtml();
+    booleanPromise = elementFinder.isElementPresent(by.id('id'));
+    elementFinder = elementFinder.$('.class');
+    var finders: protractor.ElementArrayFinder = elementFinder.$$('.class');
+    elementFinder = elementFinder.evaluate('expression');
+    booleanPromise = elementFinder.isPresent();
+
+    var webElement: webdriver.WebElement = elementFinder.getWebElement();
+    finders = elementFinder.all(by.className('class'));
+    elementFinder = elementFinder.allowAnimations('abc');
+    elementFinder = elementFinder.clone();
+    elementFinder = elementFinder.element(by.id('id'));
+
+    var b: boolean = elementFinder.isPending();
+    var locator: webdriver.Locator = elementFinder.locator();
+}
+
+function TestElementArrayFinder() {
+    var elementArrayFinder: protractor.ElementArrayFinder = element.all(by.id('id'));
+
+    var voidPromise: webdriver.promise.Promise<void>;
+    var stringPromise: webdriver.promise.Promise<string[]>;
+    var booleanPromise: webdriver.promise.Promise<boolean[]>;
+
+    elementArrayFinder.getId().then(function (id: webdriver.IWebElementId[]) { });
+    voidPromise = elementArrayFinder.click();
+    elementArrayFinder = elementArrayFinder.allowAnimations(true);
+    voidPromise = elementArrayFinder.sendKeys(protractor.Key.UP, protractor.Key.DOWN);
+    stringPromise = elementArrayFinder.getTagName();
+    stringPromise = elementArrayFinder.getCssValue('display');
+    stringPromise = elementArrayFinder.getAttribute('atribute');
+    stringPromise = elementArrayFinder.getText();
+    elementArrayFinder.getSize().then(function (size: webdriver.ISize[]) { });
+    elementArrayFinder.getLocation().then(function (location: webdriver.ILocation[]) { });
+    booleanPromise = elementArrayFinder.isEnabled();
+    booleanPromise = elementArrayFinder.isSelected();
+    voidPromise = elementArrayFinder.submit();
+    voidPromise = elementArrayFinder.clear();
+    booleanPromise = elementArrayFinder.isDisplayed();
+    stringPromise = elementArrayFinder.getOuterHtml();
+    stringPromise = elementArrayFinder.getInnerHtml();
+    var finders: protractor.ElementArrayFinder = elementArrayFinder.$$('.class');
+    elementArrayFinder = elementArrayFinder.evaluate('expression');
+
+    finders = elementArrayFinder.all(by.className('class'));
+    elementArrayFinder = elementArrayFinder.clone();
+
+    var b: boolean = elementArrayFinder.isPending();
+    var locator: webdriver.Locator = elementArrayFinder.locator();
+
+    var findersArrayPromise: protractor.promise.Promise<protractor.ElementFinder[]> = elementArrayFinder.asElementFinders_();
+
+    var driverElementArray: webdriver.WebElement[] = elementArrayFinder.getWebElements();
+    var elementFinder: protractor.ElementFinder = elementArrayFinder.get(42);
+    elementFinder = elementArrayFinder.first();
+    elementFinder = elementArrayFinder.last();
+    elementFinder = elementArrayFinder.toElementFinder_()
+    var numberPromise: protractor.promise.Promise<number> = elementArrayFinder.count();
+    elementArrayFinder.each(function(element: protractor.ElementFinder){
+        // nothing
+    });
+
+    stringPromise = elementArrayFinder.map(function(element: protractor.ElementFinder, index: number){
+        return 'abc';
+    });
+
+    stringPromise = elementArrayFinder.map<string>(function(element: protractor.ElementFinder, index: number): string {
+        return 'abc';
+    });
+
+    stringPromise = elementArrayFinder.map<string, webdriver.promise.Promise<string>>(function(element: protractor.ElementFinder, index: number): webdriver.promise.Promise<string> {
+        return element.getText();
+    });
+
+    elementArrayFinder = elementArrayFinder.filter(function(element: protractor.ElementFinder, index: number){
+        return element.getText().then((text: string) => {
+            return text === "foo";
+        });
+    });
+    elementArrayFinder.reduce(function (accumulator: string, element: protractor.ElementFinder) {
+        return element.getText().then((text: string) => {
+            return accumulator + ',' + text;
+        });
+    }, '').then(function (result: string) { });
+    elementArrayFinder.reduce(function(accumulator: string, element: protractor.ElementFinder, index: number, array: protractor.ElementFinder[]){
+        return element.getText().then((text: string) => {
+            return accumulator + ',' + text;
+        });
+    }, '').then(function (result: string) { });
+    elementArrayFinder.then(function(underlyingElementFinders: protractor.ElementFinder[]){
+        //nothing
+    });
+}
+
+// This function tests the locator strategies.
+function TestLocatorStrategies() {
+    var ptor: protractor.Protractor = browser;
+    var webElement: webdriver.WebElement;
+
+    protractor.By.addLocator('customLocator', 'script');
+    protractor.By.addLocator('customLocator2', function(){
+        // nothing
+    });
+
+    // Angular specific locators.
+    webElement = ptor.findElement(protractor.By.binding('binding'));
+    webElement = ptor.findElement(protractor.By.exactBinding('exactBinding'));
+    webElement = ptor.findElement(protractor.By.model('model'));
+    webElement = ptor.findElement(protractor.By.repeater('repeater'));
+    webElement = ptor.findElement(protractor.By.repeater('repeater').column(0));
+    webElement = ptor.findElement(protractor.By.repeater('repeater').row(0));
+    webElement = ptor.findElement(protractor.By.repeater('repeater').row(0).column(0));
+    webElement = ptor.findElement(protractor.By.buttonText('buttonText'));
+    webElement = ptor.findElement(protractor.By.partialButtonText('partialButtonText'));
+    webElement = ptor.findElement(protractor.By.cssContainingText('cssSelector', 'search text'));
+    webElement = ptor.findElement(protractor.By.options('options'));
+    // One standard locator for good measure.
+    webElement = ptor.findElement(protractor.By.id('id'));
+
+    var el: protractor.ElementFinder;
+
+    // Angular specific locators.
+    el = element(by.binding('binding'));
+    el = element(by.exactBinding('exactBinding'));
+    el = element(by.model('model'));
+    el = element(by.repeater('repeater'));
+    el = element(by.repeater('repeater').column(0));
+    el = element(by.repeater('repeater').row(0));
+    el = element(by.repeater('repeater').row(0).column(0));
+    el = element(by.buttonText('buttonText'));
+    el = element(by.partialButtonText('partialButtonText'));
+    el = element(by.cssContainingText('cssSelector', 'search text'));
+    el = element(by.options('options'));
+    // One standard locator for good measure.
+    el = element(by.id('id'));
+}

protractor/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "protractor",
+  "version": "1.0.0",
+  "description": "protractor",
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@types/selenium-webdriver": "~2.44.28"
+  }
+}

protractor/tsconfig.json

@@ -0,0 +1,16 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "strictNullChecks": false,
+        "baseUrl": "../",
+        "types": ["selenium-webdriver"],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "angular-protractor-tests.ts"
+    ]
+}