address feedback

Author: mmalerba

src/cdk-experimental/testing/component-harness.ts

@@ -99,7 +99,7 @@ export interface LocatorFactory {
    * @return An asynchronous locator function that searches for elements with the given selector,
    *     and either finds one or throws an error
    */
-  requiredLocator(selector: string): AsyncFn<TestElement>;
+  locatorForRequired(selector: string): AsyncFn<TestElement>;
 
   /**
    * Creates an asynchronous locator function that can be used to find a `ComponentHarness` for a
@@ -110,7 +110,7 @@ export interface LocatorFactory {
    * @return An asynchronous locator function that searches components matching the given harness
    *     type, and either returns a `ComponentHarness` for the component, or throws an error.
    */
-  requiredLocator<T extends ComponentHarness>(harnessType: ComponentHarnessConstructor<T>):
+  locatorForRequired<T extends ComponentHarness>(harnessType: ComponentHarnessConstructor<T>):
       AsyncFn<T>;
 
   /**
@@ -122,7 +122,7 @@ export interface LocatorFactory {
    * @return An asynchronous locator function that searches for elements with the given selector,
    *     and either finds one or returns null.
    */
-  optionalLocator(selector: string): AsyncFn<TestElement | null>;
+  locatorForOptional(selector: string): AsyncFn<TestElement | null>;
 
   /**
    * Creates an asynchronous locator function that can be used to find a `ComponentHarness` for a
@@ -133,7 +133,7 @@ export interface LocatorFactory {
    * @return An asynchronous locator function that searches components matching the given harness
    *     type, and either returns a `ComponentHarness` for the component, or null if none is found.
    */
-  optionalLocator<T extends ComponentHarness>(harnessType: ComponentHarnessConstructor<T>):
+  locatorForOptional<T extends ComponentHarness>(harnessType: ComponentHarnessConstructor<T>):
       AsyncFn<T | null>;
 
   /**
@@ -144,7 +144,7 @@ export interface LocatorFactory {
    * @return An asynchronous locator function that searches for elements with the given selector,
    *     and either finds one or throws an error
    */
-  allLocator(selector: string): AsyncFn<TestElement[]>;
+  locatorForAll(selector: string): AsyncFn<TestElement[]>;
 
   /**
    * Creates an asynchronous locator function that can be used to find a list of
@@ -155,7 +155,8 @@ export interface LocatorFactory {
    * @return An asynchronous locator function that searches components matching the given harness
    *     type, and returns a list of `ComponentHarness`es.
    */
-  allLocator<T extends ComponentHarness>(harnessType: ComponentHarnessConstructor<T>): AsyncFn<T[]>;
+  locatorForAll<T extends ComponentHarness>(harnessType: ComponentHarnessConstructor<T>):
+      AsyncFn<T[]>;
 }
 
 /**
@@ -189,7 +190,7 @@ export abstract class ComponentHarness {
    * @return An asynchronous locator function that searches for elements with the given selector,
    *     and either finds one or throws an error
    */
-  protected requiredLocator(selector: string): AsyncFn<TestElement>;
+  protected locatorForRequired(selector: string): AsyncFn<TestElement>;
 
   /**
    * Creates an asynchronous locator function that can be used to find a `ComponentHarness` for a
@@ -200,11 +201,11 @@ export abstract class ComponentHarness {
    * @return An asynchronous locator function that searches components matching the given harness
    *     type, and either returns a `ComponentHarness` for the component, or throws an error.
    */
-  protected requiredLocator<T extends ComponentHarness>(
+  protected locatorForRequired<T extends ComponentHarness>(
       harnessType: ComponentHarnessConstructor<T>): AsyncFn<T>;
 
-  protected requiredLocator(arg: any): any {
-    return this.locatorFacotry.requiredLocator(arg);
+  protected locatorForRequired(arg: any): any {
+    return this.locatorFacotry.locatorForRequired(arg);
   }
 
   /**
@@ -216,7 +217,7 @@ export abstract class ComponentHarness {
    * @return An asynchronous locator function that searches for elements with the given selector,
    *     and either finds one or returns null.
    */
-  protected optionalLocator(selector: string): AsyncFn<TestElement | null>;
+  protected locatorForOptional(selector: string): AsyncFn<TestElement | null>;
 
   /**
    * Creates an asynchronous locator function that can be used to find a `ComponentHarness` for a
@@ -227,11 +228,11 @@ export abstract class ComponentHarness {
    * @return An asynchronous locator function that searches components matching the given harness
    *     type, and either returns a `ComponentHarness` for the component, or null if none is found.
    */
-  protected optionalLocator<T extends ComponentHarness>(
+  protected locatorForOptional<T extends ComponentHarness>(
       harnessType: ComponentHarnessConstructor<T>): AsyncFn<T | null>;
 
-  protected optionalLocator(arg: any): any {
-    return this.locatorFacotry.optionalLocator(arg);
+  protected locatorForOptional(arg: any): any {
+    return this.locatorFacotry.locatorForOptional(arg);
   }
 
   /**
@@ -242,7 +243,7 @@ export abstract class ComponentHarness {
    * @return An asynchronous locator function that searches for elements with the given selector,
    *     and either finds one or throws an error
    */
-  protected allLocator(selector: string): AsyncFn<TestElement[]>;
+  protected locatorForAll(selector: string): AsyncFn<TestElement[]>;
 
   /**
    * Creates an asynchronous locator function that can be used to find a list of
@@ -253,11 +254,11 @@ export abstract class ComponentHarness {
    * @return An asynchronous locator function that searches components matching the given harness
    *     type, and returns a list of `ComponentHarness`es.
    */
-  protected allLocator<T extends ComponentHarness>(harnessType: ComponentHarnessConstructor<T>):
+  protected locatorForAll<T extends ComponentHarness>(harnessType: ComponentHarnessConstructor<T>):
       AsyncFn<T[]>;
 
-  protected allLocator(arg: any): any {
-    return this.locatorFacotry.allLocator(arg);
+  protected locatorForAll(arg: any): any {
+    return this.locatorFacotry.locatorForAll(arg);
   }
 }
 

src/cdk-experimental/testing/harness-environment.ts

@@ -33,9 +33,10 @@ export abstract class HarnessEnvironment<E> implements HarnessLoader, LocatorFac
   }
 
   // Implemented as part of the `LocatorFactory` interface.
-  requiredLocator(selector: string): AsyncFn<TestElement>;
-  requiredLocator<T extends ComponentHarness>(harness: ComponentHarnessConstructor<T>): AsyncFn<T>;
-  requiredLocator<T extends ComponentHarness>(
+  locatorForRequired(selector: string): AsyncFn<TestElement>;
+  locatorForRequired<T extends ComponentHarness>(harness: ComponentHarnessConstructor<T>):
+      AsyncFn<T>;
+  locatorForRequired<T extends ComponentHarness>(
       arg: string | ComponentHarnessConstructor<T>): AsyncFn<TestElement | T> {
     return async () => {
       if (typeof arg === 'string') {
@@ -55,10 +56,10 @@ export abstract class HarnessEnvironment<E> implements HarnessLoader, LocatorFac
   }
 
   // Implemented as part of the `LocatorFactory` interface.
-  optionalLocator(selector: string): AsyncFn<TestElement | null>;
-  optionalLocator<T extends ComponentHarness>(harness: ComponentHarnessConstructor<T>):
+  locatorForOptional(selector: string): AsyncFn<TestElement | null>;
+  locatorForOptional<T extends ComponentHarness>(harness: ComponentHarnessConstructor<T>):
       AsyncFn<T | null>;
-  optionalLocator<T extends ComponentHarness>(
+  locatorForOptional<T extends ComponentHarness>(
       arg: string | ComponentHarnessConstructor<T>): AsyncFn<TestElement | T | null> {
     return async () => {
       if (typeof arg === 'string') {
@@ -72,9 +73,9 @@ export abstract class HarnessEnvironment<E> implements HarnessLoader, LocatorFac
   }
 
   // Implemented as part of the `LocatorFactory` interface.
-  allLocator(selector: string): AsyncFn<TestElement[]>;
-  allLocator<T extends ComponentHarness>(harness: ComponentHarnessConstructor<T>): AsyncFn<T[]>;
-  allLocator<T extends ComponentHarness>(
+  locatorForAll(selector: string): AsyncFn<TestElement[]>;
+  locatorForAll<T extends ComponentHarness>(harness: ComponentHarnessConstructor<T>): AsyncFn<T[]>;
+  locatorForAll<T extends ComponentHarness>(
       arg: string | ComponentHarnessConstructor<T>): AsyncFn<TestElement[] | T[]> {
     return async () => {
       if (typeof arg === 'string') {
@@ -88,18 +89,18 @@ export abstract class HarnessEnvironment<E> implements HarnessLoader, LocatorFac
 
   // Implemented as part of the `HarnessLoader` interface.
   requiredHarness<T extends ComponentHarness>(harness: ComponentHarnessConstructor<T>): Promise<T> {
-    return this.requiredLocator(harness)();
+    return this.locatorForRequired(harness)();
   }
 
   // Implemented as part of the `HarnessLoader` interface.
   optionalHarness<T extends ComponentHarness>(harness: ComponentHarnessConstructor<T>):
     Promise<T | null> {
-    return this.optionalLocator(harness)();
+    return this.locatorForOptional(harness)();
   }
 
   // Implemented as part of the `HarnessLoader` interface.
   allHarnesses<T extends ComponentHarness>(harness: ComponentHarnessConstructor<T>): Promise<T[]> {
-    return this.allLocator(harness)();
+    return this.locatorForAll(harness)();
   }
 
   // Implemented as part of the `HarnessLoader` interface.

src/cdk-experimental/testing/protractor/protractor-element.ts

@@ -14,7 +14,7 @@ export class ProtractorElement implements TestElement {
   constructor(readonly element: ElementFinder) {}
 
   async blur(): Promise<void> {
-    return this.element['blur']();
+    return browser.executeScript('arguments[0].blur()', this.element);
   }
 
   async clear(): Promise<void> {
@@ -26,7 +26,7 @@ export class ProtractorElement implements TestElement {
   }
 
   async focus(): Promise<void> {
-    return this.element['focus']();
+    return browser.executeScript('arguments[0].focus()', this.element);
   }
 
   async getCssValue(property: string): Promise<string> {

src/cdk-experimental/testing/testbed/testbed-harness-environment.ts

@@ -77,6 +77,6 @@ export class TestbedHarnessEnvironment extends HarnessEnvironment<Element> {
 
   protected async getAllRawElements(selector: string): Promise<Element[]> {
     await this._stabilize();
-    return Array.prototype.slice.call(this.rawRootElement.querySelectorAll(selector));
+    return Array.from(this.rawRootElement.querySelectorAll(selector));
   }
 }

src/cdk-experimental/testing/tests/harnesses/main-component-harness.ts

@@ -17,33 +17,33 @@ export class WrongComponentHarness extends ComponentHarness {
 export class MainComponentHarness extends ComponentHarness {
   static readonly hostSelector = 'test-main';
 
-  readonly title = this.requiredLocator('h1');
-  readonly asyncCounter = this.requiredLocator('#asyncCounter');
-  readonly counter = this.requiredLocator('#counter');
-  readonly input = this.requiredLocator('#input');
-  readonly value = this.requiredLocator('#value');
-  readonly allLabels = this.allLocator('label');
-  readonly allLists = this.allLocator(SubComponentHarness);
-  readonly memo = this.requiredLocator('textarea');
+  readonly title = this.locatorForRequired('h1');
+  readonly button = this.locatorForRequired('button');
+  readonly asyncCounter = this.locatorForRequired('#asyncCounter');
+  readonly counter = this.locatorForRequired('#counter');
+  readonly input = this.locatorForRequired('#input');
+  readonly value = this.locatorForRequired('#value');
+  readonly allLabels = this.locatorForAll('label');
+  readonly allLists = this.locatorForAll(SubComponentHarness);
+  readonly memo = this.locatorForRequired('textarea');
   // Allow null for element
-  readonly nullItem = this.optionalLocator('wrong locator');
+  readonly nullItem = this.locatorForOptional('wrong locator');
   // Allow null for component harness
-  readonly nullComponentHarness = this.optionalLocator(WrongComponentHarness);
-  readonly errorItem = this.requiredLocator('wrong locator');
+  readonly nullComponentHarness = this.locatorForOptional(WrongComponentHarness);
+  readonly errorItem = this.locatorForRequired('wrong locator');
 
-  readonly globalEl = this.documentRootLocatorFactory().requiredLocator('.sibling');
-  readonly errorGlobalEl = this.documentRootLocatorFactory().requiredLocator('wrong locator');
-  readonly nullGlobalEl = this.documentRootLocatorFactory().optionalLocator('wrong locator');
+  readonly globalEl = this.documentRootLocatorFactory().locatorForRequired('.sibling');
+  readonly errorGlobalEl = this.documentRootLocatorFactory().locatorForRequired('wrong locator');
+  readonly nullGlobalEl = this.documentRootLocatorFactory().locatorForOptional('wrong locator');
 
-  readonly optionalDiv = this.optionalLocator('div');
-  readonly optionalSubComponent = this.optionalLocator(SubComponentHarness);
-  readonly errorSubComponent = this.requiredLocator(WrongComponentHarness);
+  readonly optionalDiv = this.locatorForOptional('div');
+  readonly optionalSubComponent = this.locatorForOptional(SubComponentHarness);
+  readonly errorSubComponent = this.locatorForRequired(WrongComponentHarness);
 
-  private _button = this.requiredLocator('button');
-  private _testTools = this.requiredLocator(SubComponentHarness);
+  private _testTools = this.locatorForRequired(SubComponentHarness);
 
   async increaseCounter(times: number) {
-    const button = await this._button();
+    const button = await this.button();
     for (let i = 0; i < times; i++) {
       await button.click();
     }

src/cdk-experimental/testing/tests/harnesses/sub-component-harness.ts

@@ -12,9 +12,9 @@ import {TestElement} from '../../test-element';
 export class SubComponentHarness extends ComponentHarness {
   static readonly hostSelector = 'test-sub';
 
-  readonly title = this.requiredLocator('h2');
-  readonly getItems = this.allLocator('li');
-  readonly globalElement = this.documentRootLocatorFactory().requiredLocator('#username');
+  readonly title = this.locatorForRequired('h2');
+  readonly getItems = this.locatorForAll('li');
+  readonly globalElement = this.documentRootLocatorFactory().locatorForRequired('#username');
 
   async getItem(index: number): Promise<TestElement> {
     const items = await this.getItems();

src/cdk-experimental/testing/tests/protractor.e2e.spec.ts

@@ -232,5 +232,16 @@ describe('ProtractorHarnessEnvironment', () => {
       const title = await harness.title();
       expect(await title.getCssValue('height')).toBe('50px');
     });
+
+    it('should focus and blur element', async () => {
+      let button = await harness.button();
+      expect(await (await browser.switchTo().activeElement()).getText())
+          .not.toBe(await button.text());
+      await button.focus();
+      expect(await (await browser.switchTo().activeElement()).getText()).toBe(await button.text());
+      await button.blur();
+      expect(await (await browser.switchTo().activeElement()).getText())
+          .not.toBe(await button.text());
+    });
   });
 });

src/cdk-experimental/testing/tests/testbed.spec.ts

@@ -6,6 +6,10 @@ import {SubComponentHarness} from './harnesses/sub-component-harness';
 import {TestComponentsModule} from './test-components-module';
 import {TestMainComponent} from './test-main-component';
 
+function activeElementText() {
+  return document.activeElement && (document.activeElement as HTMLElement).innerText || '';
+}
+
 describe('TestbedHarnessEnvironment', () => {
   let fixture: ComponentFixture<{}>;
 
@@ -247,5 +251,14 @@ describe('TestbedHarnessEnvironment', () => {
       const title = await harness.title();
       expect(await title.getCssValue('height')).toBe('50px');
     });
+
+    it('should focus and blur element', async () => {
+      let button = await harness.button();
+      expect(activeElementText()).not.toBe(await button.text());
+      await button.focus();
+      expect(activeElementText()).toBe(await button.text());
+      await button.blur();
+      expect(activeElementText()).not.toBe(await button.text());
+    });
   });
 });