nits

Author: mmalerba

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

@@ -24,8 +24,10 @@ import {TestElement} from './test-element';
 export abstract class HarnessEnvironment<E> implements HarnessLoader, LocatorFactory {
   protected constructor(protected rawRootElement: E) {}
 
-  // Part of the `HarnessLoader` interface, delegated to concrete implementation.
-  abstract documentRootLocatorFactory(): LocatorFactory;
+  // Implemented as part of the `LocatorFactory` interface.
+  documentRootLocatorFactory(): LocatorFactory {
+    return this.createEnvironment(this.getDocumentRoot());
+  }
 
   // Implemented as part of the `LocatorFactory` interface.
   rootElement(): TestElement {
@@ -34,7 +36,7 @@ export abstract class HarnessEnvironment<E> implements HarnessLoader, LocatorFac
 
   // Implemented as part of the `LocatorFactory` interface.
   locatorForRequired(selector: string): AsyncFn<TestElement>;
-  locatorForRequired<T extends ComponentHarness>(harness: ComponentHarnessConstructor<T>):
+  locatorForRequired<T extends ComponentHarness>(harnessType: ComponentHarnessConstructor<T>):
       AsyncFn<T>;
   locatorForRequired<T extends ComponentHarness>(
       arg: string | ComponentHarnessConstructor<T>): AsyncFn<TestElement | T> {
@@ -57,7 +59,7 @@ export abstract class HarnessEnvironment<E> implements HarnessLoader, LocatorFac
 
   // Implemented as part of the `LocatorFactory` interface.
   locatorForOptional(selector: string): AsyncFn<TestElement | null>;
-  locatorForOptional<T extends ComponentHarness>(harness: ComponentHarnessConstructor<T>):
+  locatorForOptional<T extends ComponentHarness>(harnessType: ComponentHarnessConstructor<T>):
       AsyncFn<T | null>;
   locatorForOptional<T extends ComponentHarness>(
       arg: string | ComponentHarnessConstructor<T>): AsyncFn<TestElement | T | null> {
@@ -74,7 +76,8 @@ export abstract class HarnessEnvironment<E> implements HarnessLoader, LocatorFac
 
   // Implemented as part of the `LocatorFactory` interface.
   locatorForAll(selector: string): AsyncFn<TestElement[]>;
-  locatorForAll<T extends ComponentHarness>(harness: ComponentHarnessConstructor<T>): AsyncFn<T[]>;
+  locatorForAll<T extends ComponentHarness>(harnessType: ComponentHarnessConstructor<T>):
+      AsyncFn<T[]>;
   locatorForAll<T extends ComponentHarness>(
       arg: string | ComponentHarnessConstructor<T>): AsyncFn<TestElement[] | T[]> {
     return async () => {
@@ -88,50 +91,57 @@ 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.locatorForRequired(harness)();
+  requiredHarness<T extends ComponentHarness>(harnessType: ComponentHarnessConstructor<T>):
+      Promise<T> {
+    return this.locatorForRequired(harnessType)();
   }
 
   // Implemented as part of the `HarnessLoader` interface.
-  optionalHarness<T extends ComponentHarness>(harness: ComponentHarnessConstructor<T>):
-    Promise<T | null> {
-    return this.locatorForOptional(harness)();
+  optionalHarness<T extends ComponentHarness>(harnessType: ComponentHarnessConstructor<T>):
+      Promise<T | null> {
+    return this.locatorForOptional(harnessType)();
   }
 
   // Implemented as part of the `HarnessLoader` interface.
-  allHarnesses<T extends ComponentHarness>(harness: ComponentHarnessConstructor<T>): Promise<T[]> {
-    return this.locatorForAll(harness)();
+  allHarnesses<T extends ComponentHarness>(harnessType: ComponentHarnessConstructor<T>):
+      Promise<T[]> {
+    return this.locatorForAll(harnessType)();
   }
 
   // Implemented as part of the `HarnessLoader` interface.
   async findRequired(selector: string): Promise<HarnessLoader> {
     const element = await this.getRawElement(selector);
     if (element) {
-      return this.createHarnessLoader(element);
+      return this.createEnvironment(element);
     }
     throw Error(`Expected to find element matching selector: "${selector}", but none was found`);
   }
 
   // Implemented as part of the `HarnessLoader` interface.
   async findOptional(selector: string): Promise<HarnessLoader | null> {
     const element = await this.getRawElement(selector);
-    return element ? this.createHarnessLoader(element) : null;
+    return element ? this.createEnvironment(element) : null;
   }
 
   // Implemented as part of the `HarnessLoader` interface.
   async findAll(selector: string): Promise<HarnessLoader[]> {
-    return (await this.getAllRawElements(selector)).map(e => this.createHarnessLoader(e));
+    return (await this.getAllRawElements(selector)).map(e => this.createEnvironment(e));
+  }
+
+  /** Creates a `ComponentHarness` for the given harness type with the given raw host element. */
+  protected createComponentHarness<T extends ComponentHarness>(
+      harnessType: ComponentHarnessConstructor<T>, element: E): T {
+    return new harnessType(this.createEnvironment(element));
   }
 
+  /** Gets the root element for the document. */
+  protected abstract getDocumentRoot(): E;
+
   /** Creates a `TestElement` from a raw element. */
   protected abstract createTestElement(element: E): TestElement;
 
-  /** Creates a `ComponentHarness` for the given harness type with the given raw host element. */
-  protected abstract createComponentHarness<T extends ComponentHarness>(
-    harnessType: ComponentHarnessConstructor<T>, element: E): T;
-
   /** Creates a `HarnessLoader` rooted at the given raw element. */
-  protected abstract createHarnessLoader(element: E): HarnessLoader;
+  protected abstract createEnvironment(element: E): HarnessEnvironment<E>;
 
   /**
    * Gets the first element matching the given selector under this environment's root element, or

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

@@ -7,12 +7,7 @@
  */
 
 import {by, element as protractorElement, ElementFinder} from 'protractor';
-import {
-  ComponentHarness,
-  ComponentHarnessConstructor,
-  HarnessLoader,
-  LocatorFactory,
-} from '../component-harness';
+import {HarnessLoader} from '../component-harness';
 import {HarnessEnvironment} from '../harness-environment';
 import {TestElement} from '../test-element';
 import {ProtractorElement} from './protractor-element';
@@ -28,20 +23,15 @@ export class ProtractorHarnessEnvironment extends HarnessEnvironment<ElementFind
     return new ProtractorHarnessEnvironment(protractorElement(by.css('body')));
   }
 
-  documentRootLocatorFactory(): LocatorFactory {
-    return new ProtractorHarnessEnvironment(protractorElement(by.css('body')));
+  protected getDocumentRoot(): ElementFinder {
+    return protractorElement(by.css('body'));
   }
 
   protected createTestElement(element: ElementFinder): TestElement {
     return new ProtractorElement(element);
   }
 
-  protected createComponentHarness<T extends ComponentHarness>(
-      harnessType: ComponentHarnessConstructor<T>, element: ElementFinder): T {
-    return new harnessType(new ProtractorHarnessEnvironment(element));
-  }
-
-  protected createHarnessLoader(element: ElementFinder): HarnessLoader {
+  protected createEnvironment(element: ElementFinder): HarnessEnvironment<ElementFinder> {
     return new ProtractorHarnessEnvironment(element);
   }
 

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

@@ -7,29 +7,20 @@
  */
 
 import {ComponentFixture} from '@angular/core/testing';
-import {
-  ComponentHarness,
-  ComponentHarnessConstructor,
-  HarnessLoader,
-  LocatorFactory
-} from '../component-harness';
+import {ComponentHarness, ComponentHarnessConstructor, HarnessLoader} from '../component-harness';
 import {HarnessEnvironment} from '../harness-environment';
 import {TestElement} from '../test-element';
 import {UnitTestElement} from './unit-test-element';
 
 /** A `HarnessEnvironment` implementation for Angular's Testbed. */
 export class TestbedHarnessEnvironment extends HarnessEnvironment<Element> {
-  protected constructor(rawRootElement: Element, private _stabilize: () => Promise<void>) {
+  protected constructor(rawRootElement: Element, private _fixture: ComponentFixture<unknown>) {
     super(rawRootElement);
   }
 
   /** Creates a `HarnessLoader` rooted at the given fixture's root element. */
   static create(fixture: ComponentFixture<unknown>): HarnessLoader {
-    const stabilize = async () => {
-      fixture.detectChanges();
-      await fixture.whenStable();
-    };
-    return new TestbedHarnessEnvironment(fixture.nativeElement, stabilize);
+    return new TestbedHarnessEnvironment(fixture.nativeElement, fixture);
   }
 
   /**
@@ -40,34 +31,21 @@ export class TestbedHarnessEnvironment extends HarnessEnvironment<Element> {
    */
   static async harnessForFixtureRoot<T extends ComponentHarness>(
       fixture: ComponentFixture<unknown>, harnessType: ComponentHarnessConstructor<T>): Promise<T> {
-    const stabilize = async () => {
-      fixture.detectChanges();
-      await fixture.whenStable();
-    };
-    const environment = new TestbedHarnessEnvironment(fixture.nativeElement, stabilize);
+    const environment = new TestbedHarnessEnvironment(fixture.nativeElement, fixture);
     await environment._stabilize();
     return environment.createComponentHarness(harnessType, fixture.nativeElement);
   }
 
-  documentRootLocatorFactory(): LocatorFactory {
-    let element = this.rawRootElement;
-    while (element.parentElement) {
-      element = element.parentElement;
-    }
-    return new TestbedHarnessEnvironment(element, this._stabilize);
+  protected getDocumentRoot(): Element {
+    return this._fixture.nativeElement;
   }
 
   protected createTestElement(element: Element): TestElement {
     return new UnitTestElement(element, this._stabilize);
   }
 
-  protected createComponentHarness<T extends ComponentHarness>(
-      harnessType: ComponentHarnessConstructor<T>, element: Element): T {
-    return new harnessType(new TestbedHarnessEnvironment(element, this._stabilize));
-  }
-
-  protected createHarnessLoader(element: Element): HarnessLoader {
-    return new TestbedHarnessEnvironment(element, this._stabilize);
+  protected createEnvironment(element: Element): HarnessEnvironment<Element> {
+    return new TestbedHarnessEnvironment(element, this._fixture);
   }
 
   protected async getRawElement(selector: string): Promise<Element | null> {
@@ -79,4 +57,9 @@ export class TestbedHarnessEnvironment extends HarnessEnvironment<Element> {
     await this._stabilize();
     return Array.from(this.rawRootElement.querySelectorAll(selector));
   }
+
+  private _stabilize = async (): Promise<void> => {
+    this._fixture.detectChanges();
+    await this._fixture.whenStable();
+  }
 }

src/cdk-experimental/testing/testbed/unit-test-element.ts

@@ -17,7 +17,7 @@ import {TestElement} from '../test-element';
 
 function isTextInput(element: Element): element is HTMLInputElement | HTMLTextAreaElement {
   return element.nodeName.toLowerCase() === 'input' ||
-    element.nodeName.toLowerCase() === 'textarea' ;
+      element.nodeName.toLowerCase() === 'textarea' ;
 }
 
 /** A `TestElement` implementation for unit tests. */