@angular/cdk
Version:
Angular Material Component Development Kit
219 lines • 35.9 kB
JavaScript
/**
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import { __awaiter } from "tslib";
import { parallel } from './change-detection';
import { ComponentHarness, HarnessPredicate, } from './component-harness';
/**
* Base harness environment class that can be extended to allow `ComponentHarness`es to be used in
* different test environments (e.g. testbed, protractor, etc.). This class implements the
* functionality of both a `HarnessLoader` and `LocatorFactory`. This class is generic on the raw
* element type, `E`, used by the particular test environment.
*/
export class HarnessEnvironment {
constructor(rawRootElement) {
this.rawRootElement = rawRootElement;
this.rootElement = this.createTestElement(rawRootElement);
}
// Implemented as part of the `LocatorFactory` interface.
documentRootLocatorFactory() {
return this.createEnvironment(this.getDocumentRoot());
}
// Implemented as part of the `LocatorFactory` interface.
locatorFor(...queries) {
return () => _assertResultFound(this._getAllHarnessesAndTestElements(queries), _getDescriptionForLocatorForQueries(queries));
}
// Implemented as part of the `LocatorFactory` interface.
locatorForOptional(...queries) {
return () => __awaiter(this, void 0, void 0, function* () { return (yield this._getAllHarnessesAndTestElements(queries))[0] || null; });
}
// Implemented as part of the `LocatorFactory` interface.
locatorForAll(...queries) {
return () => this._getAllHarnessesAndTestElements(queries);
}
// Implemented as part of the `LocatorFactory` interface.
rootHarnessLoader() {
return __awaiter(this, void 0, void 0, function* () {
return this;
});
}
// Implemented as part of the `LocatorFactory` interface.
harnessLoaderFor(selector) {
return __awaiter(this, void 0, void 0, function* () {
return this.createEnvironment(yield _assertResultFound(this.getAllRawElements(selector), [_getDescriptionForHarnessLoaderQuery(selector)]));
});
}
// Implemented as part of the `LocatorFactory` interface.
harnessLoaderForOptional(selector) {
return __awaiter(this, void 0, void 0, function* () {
const elements = yield this.getAllRawElements(selector);
return elements[0] ? this.createEnvironment(elements[0]) : null;
});
}
// Implemented as part of the `LocatorFactory` interface.
harnessLoaderForAll(selector) {
return __awaiter(this, void 0, void 0, function* () {
const elements = yield this.getAllRawElements(selector);
return elements.map(element => this.createEnvironment(element));
});
}
// Implemented as part of the `HarnessLoader` interface.
getHarness(query) {
return this.locatorFor(query)();
}
// Implemented as part of the `HarnessLoader` interface.
getAllHarnesses(query) {
return this.locatorForAll(query)();
}
// Implemented as part of the `HarnessLoader` interface.
getChildLoader(selector) {
return __awaiter(this, void 0, void 0, function* () {
return this.createEnvironment(yield _assertResultFound(this.getAllRawElements(selector), [_getDescriptionForHarnessLoaderQuery(selector)]));
});
}
// Implemented as part of the `HarnessLoader` interface.
getAllChildLoaders(selector) {
return __awaiter(this, void 0, void 0, function* () {
return (yield this.getAllRawElements(selector)).map(e => this.createEnvironment(e));
});
}
/** Creates a `ComponentHarness` for the given harness type with the given raw host element. */
createComponentHarness(harnessType, element) {
return new harnessType(this.createEnvironment(element));
}
/**
* Matches the given raw elements with the given list of element and harness queries to produce a
* list of matched harnesses and test elements.
*/
_getAllHarnessesAndTestElements(queries) {
return __awaiter(this, void 0, void 0, function* () {
const { allQueries, harnessQueries, elementQueries, harnessTypes } = _parseQueries(queries);
// Combine all of the queries into one large comma-delimited selector and use it to get all raw
// elements matching any of the individual queries.
const rawElements = yield this.getAllRawElements([...elementQueries, ...harnessQueries.map(predicate => predicate.getSelector())].join(','));
// If every query is searching for the same harness subclass, we know every result corresponds
// to an instance of that subclass. Likewise, if every query is for a `TestElement`, we know
// every result corresponds to a `TestElement`. Otherwise we need to verify which result was
// found by which selector so it can be matched to the appropriate instance.
const skipSelectorCheck = (elementQueries.length === 0 && harnessTypes.size === 1) ||
harnessQueries.length === 0;
const perElementMatches = yield parallel(() => rawElements.map((rawElement) => __awaiter(this, void 0, void 0, function* () {
const testElement = this.createTestElement(rawElement);
const allResultsForElement = yield Promise.all(
// For each query, get `null` if it doesn't match, or a `TestElement` or
// `ComponentHarness` as appropriate if it does match. This gives us everything that
// matches the current raw element, but it may contain duplicate entries (e.g.
// multiple `TestElement` or multiple `ComponentHarness` of the same type).
allQueries.map(query => this._getQueryResultForElement(query, rawElement, testElement, skipSelectorCheck)));
return _removeDuplicateQueryResults(allResultsForElement);
})));
return [].concat(...perElementMatches);
});
}
/**
* Check whether the given query matches the given element, if it does return the matched
* `TestElement` or `ComponentHarness`, if it does not, return null. In cases where the caller
* knows for sure that the query matches the element's selector, `skipSelectorCheck` can be used
* to skip verification and optimize performance.
*/
_getQueryResultForElement(query, rawElement, testElement, skipSelectorCheck = false) {
return __awaiter(this, void 0, void 0, function* () {
if (typeof query === 'string') {
return ((skipSelectorCheck || (yield testElement.matchesSelector(query))) ? testElement : null);
}
if (skipSelectorCheck || (yield testElement.matchesSelector(query.getSelector()))) {
const harness = this.createComponentHarness(query.harnessType, rawElement);
return (yield query.evaluate(harness)) ? harness : null;
}
return null;
});
}
}
/**
* Parses a list of queries in the format accepted by the `locatorFor*` methods into an easier to
* work with format.
*/
function _parseQueries(queries) {
const allQueries = [];
const harnessQueries = [];
const elementQueries = [];
const harnessTypes = new Set();
for (const query of queries) {
if (typeof query === 'string') {
allQueries.push(query);
elementQueries.push(query);
}
else {
const predicate = query instanceof HarnessPredicate ? query : new HarnessPredicate(query, {});
allQueries.push(predicate);
harnessQueries.push(predicate);
harnessTypes.add(predicate.harnessType);
}
}
return { allQueries, harnessQueries, elementQueries, harnessTypes };
}
/**
* Removes duplicate query results for a particular element. (e.g. multiple `TestElement`
* instances or multiple instances of the same `ComponentHarness` class.
*/
function _removeDuplicateQueryResults(results) {
return __awaiter(this, void 0, void 0, function* () {
let testElementMatched = false;
let matchedHarnessTypes = new Set();
const dedupedMatches = [];
for (const result of results) {
if (!result) {
continue;
}
if (result instanceof ComponentHarness) {
if (!matchedHarnessTypes.has(result.constructor)) {
matchedHarnessTypes.add(result.constructor);
dedupedMatches.push(result);
}
}
else if (!testElementMatched) {
testElementMatched = true;
dedupedMatches.push(result);
}
}
return dedupedMatches;
});
}
/** Verifies that there is at least one result in an array. */
function _assertResultFound(results, queryDescriptions) {
return __awaiter(this, void 0, void 0, function* () {
const result = (yield results)[0];
if (result == undefined) {
throw Error(`Failed to find element matching one of the following queries:\n` +
queryDescriptions.map(desc => `(${desc})`).join(',\n'));
}
return result;
});
}
/** Gets a list of description strings from a list of queries. */
function _getDescriptionForLocatorForQueries(queries) {
return queries.map(query => typeof query === 'string' ?
_getDescriptionForTestElementQuery(query) : _getDescriptionForComponentHarnessQuery(query));
}
/** Gets a description string for a `ComponentHarness` query. */
function _getDescriptionForComponentHarnessQuery(query) {
const harnessPredicate = query instanceof HarnessPredicate ? query : new HarnessPredicate(query, {});
const { name, hostSelector } = harnessPredicate.harnessType;
const description = `${name} with host element matching selector: "${hostSelector}"`;
const constraints = harnessPredicate.getDescription();
return description + (constraints ?
` satisfying the constraints: ${harnessPredicate.getDescription()}` : '');
}
/** Gets a description string for a `TestElement` query. */
function _getDescriptionForTestElementQuery(selector) {
return `TestElement for element matching selector: "${selector}"`;
}
/** Gets a description string for a `HarnessLoader` query. */
function _getDescriptionForHarnessLoaderQuery(selector) {
return `HarnessLoader for element matching selector: "${selector}"`;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"harness-environment.js","sourceRoot":"","sources":["../../../../../../src/cdk/testing/harness-environment.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {parallel} from './change-detection';\nimport {\n  AsyncFactoryFn,\n  ComponentHarness,\n  ComponentHarnessConstructor,\n  HarnessLoader,\n  HarnessPredicate,\n  HarnessQuery,\n  LocatorFactory,\n  LocatorFnResult,\n} from './component-harness';\nimport {TestElement} from './test-element';\n\n/** Parsed form of the queries passed to the `locatorFor*` methods. */\ntype ParsedQueries<T extends ComponentHarness> = {\n  /** The full list of queries, in their original order. */\n  allQueries: (string | HarnessPredicate<T>)[],\n  /**\n   * A filtered view of `allQueries` containing only the queries that are looking for a\n   * `ComponentHarness`\n   */\n  harnessQueries: HarnessPredicate<T>[],\n  /**\n   * A filtered view of `allQueries` containing only the queries that are looking for a\n   * `TestElement`\n   */\n  elementQueries: string[],\n  /** The set of all `ComponentHarness` subclasses represented in the original query list. */\n  harnessTypes: Set<ComponentHarnessConstructor<T>>,\n};\n\n/**\n * Base harness environment class that can be extended to allow `ComponentHarness`es to be used in\n * different test environments (e.g. testbed, protractor, etc.). This class implements the\n * functionality of both a `HarnessLoader` and `LocatorFactory`. This class is generic on the raw\n * element type, `E`, used by the particular test environment.\n */\nexport abstract class HarnessEnvironment<E> implements HarnessLoader, LocatorFactory {\n  // Implemented as part of the `LocatorFactory` interface.\n  rootElement: TestElement;\n\n  protected constructor(protected rawRootElement: E) {\n    this.rootElement = this.createTestElement(rawRootElement);\n  }\n\n  // Implemented as part of the `LocatorFactory` interface.\n  documentRootLocatorFactory(): LocatorFactory {\n    return this.createEnvironment(this.getDocumentRoot());\n  }\n\n  // Implemented as part of the `LocatorFactory` interface.\n  locatorFor<T extends (HarnessQuery<any> | string)[]>(...queries: T):\n      AsyncFactoryFn<LocatorFnResult<T>> {\n    return () => _assertResultFound(\n        this._getAllHarnessesAndTestElements(queries),\n        _getDescriptionForLocatorForQueries(queries));\n  }\n\n  // Implemented as part of the `LocatorFactory` interface.\n  locatorForOptional<T extends (HarnessQuery<any> | string)[]>(...queries: T):\n      AsyncFactoryFn<LocatorFnResult<T> | null> {\n    return async () => (await this._getAllHarnessesAndTestElements(queries))[0] || null;\n  }\n\n  // Implemented as part of the `LocatorFactory` interface.\n  locatorForAll<T extends (HarnessQuery<any> | string)[]>(...queries: T):\n      AsyncFactoryFn<LocatorFnResult<T>[]> {\n    return () => this._getAllHarnessesAndTestElements(queries);\n  }\n\n  // Implemented as part of the `LocatorFactory` interface.\n  async rootHarnessLoader(): Promise<HarnessLoader> {\n    return this;\n  }\n\n  // Implemented as part of the `LocatorFactory` interface.\n  async harnessLoaderFor(selector: string): Promise<HarnessLoader> {\n    return this.createEnvironment(await _assertResultFound(this.getAllRawElements(selector),\n        [_getDescriptionForHarnessLoaderQuery(selector)]));\n  }\n\n  // Implemented as part of the `LocatorFactory` interface.\n  async harnessLoaderForOptional(selector: string): Promise<HarnessLoader | null> {\n    const elements = await this.getAllRawElements(selector);\n    return elements[0] ? this.createEnvironment(elements[0]) : null;\n  }\n\n  // Implemented as part of the `LocatorFactory` interface.\n  async harnessLoaderForAll(selector: string): Promise<HarnessLoader[]> {\n    const elements = await this.getAllRawElements(selector);\n    return elements.map(element => this.createEnvironment(element));\n  }\n\n  // Implemented as part of the `HarnessLoader` interface.\n  getHarness<T extends ComponentHarness>(query: HarnessQuery<T>): Promise<T> {\n    return this.locatorFor(query)();\n  }\n\n  // Implemented as part of the `HarnessLoader` interface.\n  getAllHarnesses<T extends ComponentHarness>(query: HarnessQuery<T>): Promise<T[]> {\n    return this.locatorForAll(query)();\n  }\n\n  // Implemented as part of the `HarnessLoader` interface.\n  async getChildLoader(selector: string): Promise<HarnessLoader> {\n    return this.createEnvironment(await _assertResultFound(this.getAllRawElements(selector),\n        [_getDescriptionForHarnessLoaderQuery(selector)]));\n  }\n\n  // Implemented as part of the `HarnessLoader` interface.\n  async getAllChildLoaders(selector: string): Promise<HarnessLoader[]> {\n    return (await this.getAllRawElements(selector)).map(e => this.createEnvironment(e));\n  }\n\n  /** Creates a `ComponentHarness` for the given harness type with the given raw host element. */\n  protected createComponentHarness<T extends ComponentHarness>(\n      harnessType: ComponentHarnessConstructor<T>, element: E): T {\n    return new harnessType(this.createEnvironment(element));\n  }\n\n  // Part of LocatorFactory interface, subclasses will implement.\n  abstract forceStabilize(): Promise<void>;\n\n  // Part of LocatorFactory interface, subclasses will implement.\n  abstract waitForTasksOutsideAngular(): Promise<void>;\n\n  /** Gets the root element for the document. */\n  protected abstract getDocumentRoot(): E;\n\n  /** Creates a `TestElement` from a raw element. */\n  protected abstract createTestElement(element: E): TestElement;\n\n  /** Creates a `HarnessLoader` rooted at the given raw element. */\n  protected abstract createEnvironment(element: E): HarnessEnvironment<E>;\n\n  /**\n   * Gets a list of all elements matching the given selector under this environment's root element.\n   */\n  protected abstract getAllRawElements(selector: string): Promise<E[]>;\n\n  /**\n   * Matches the given raw elements with the given list of element and harness queries to produce a\n   * list of matched harnesses and test elements.\n   */\n  private async _getAllHarnessesAndTestElements<T extends (HarnessQuery<any> | string)[]>(\n      queries: T): Promise<LocatorFnResult<T>[]> {\n    const {allQueries, harnessQueries, elementQueries, harnessTypes} = _parseQueries(queries);\n\n    // Combine all of the queries into one large comma-delimited selector and use it to get all raw\n    // elements matching any of the individual queries.\n    const rawElements = await this.getAllRawElements(\n        [...elementQueries, ...harnessQueries.map(predicate => predicate.getSelector())].join(','));\n\n    // If every query is searching for the same harness subclass, we know every result corresponds\n    // to an instance of that subclass. Likewise, if every query is for a `TestElement`, we know\n    // every result corresponds to a `TestElement`. Otherwise we need to verify which result was\n    // found by which selector so it can be matched to the appropriate instance.\n    const skipSelectorCheck = (elementQueries.length === 0 && harnessTypes.size === 1) ||\n        harnessQueries.length === 0;\n\n    const perElementMatches = await parallel(() => rawElements.map(async rawElement => {\n      const testElement = this.createTestElement(rawElement);\n      const allResultsForElement = await Promise.all(\n          // For each query, get `null` if it doesn't match, or a `TestElement` or\n          // `ComponentHarness` as appropriate if it does match. This gives us everything that\n          // matches the current raw element, but it may contain duplicate entries (e.g.\n          // multiple `TestElement` or multiple `ComponentHarness` of the same type).\n          allQueries.map(query => this._getQueryResultForElement(\n              query, rawElement, testElement, skipSelectorCheck)));\n      return _removeDuplicateQueryResults(allResultsForElement);\n    }));\n    return ([] as any).concat(...perElementMatches);\n  }\n\n  /**\n   * Check whether the given query matches the given element, if it does return the matched\n   * `TestElement` or `ComponentHarness`, if it does not, return null. In cases where the caller\n   * knows for sure that the query matches the element's selector, `skipSelectorCheck` can be used\n   * to skip verification and optimize performance.\n   */\n  private async _getQueryResultForElement<T extends ComponentHarness>(\n      query: string | HarnessPredicate<T>, rawElement: E, testElement: TestElement,\n      skipSelectorCheck: boolean = false): Promise<T | TestElement | null> {\n    if (typeof query === 'string') {\n      return ((skipSelectorCheck || await testElement.matchesSelector(query)) ? testElement : null);\n    }\n    if (skipSelectorCheck || await testElement.matchesSelector(query.getSelector())) {\n      const harness = this.createComponentHarness(query.harnessType, rawElement);\n      return (await query.evaluate(harness)) ? harness : null;\n    }\n    return null;\n  }\n}\n\n/**\n * Parses a list of queries in the format accepted by the `locatorFor*` methods into an easier to\n * work with format.\n */\nfunction _parseQueries<T extends (HarnessQuery<any> | string)[]>(queries: T):\n    ParsedQueries<LocatorFnResult<T> & ComponentHarness> {\n  const allQueries = [];\n  const harnessQueries = [];\n  const elementQueries = [];\n  const harnessTypes =\n      new Set<ComponentHarnessConstructor<LocatorFnResult<T> & ComponentHarness>>();\n\n  for (const query of queries) {\n    if (typeof query === 'string') {\n      allQueries.push(query);\n      elementQueries.push(query);\n    } else {\n      const predicate = query instanceof HarnessPredicate ? query : new HarnessPredicate(query, {});\n      allQueries.push(predicate);\n      harnessQueries.push(predicate);\n      harnessTypes.add(predicate.harnessType);\n    }\n  }\n\n  return {allQueries, harnessQueries, elementQueries, harnessTypes};\n}\n\n/**\n * Removes duplicate query results for a particular element. (e.g. multiple `TestElement`\n * instances or multiple instances of the same `ComponentHarness` class.\n */\nasync function _removeDuplicateQueryResults<T extends (ComponentHarness | TestElement | null)[]>(\n    results: T): Promise<T> {\n  let testElementMatched = false;\n  let matchedHarnessTypes = new Set();\n  const dedupedMatches = [];\n  for (const result of results) {\n    if (!result) {\n      continue;\n    }\n    if (result instanceof ComponentHarness) {\n      if (!matchedHarnessTypes.has(result.constructor)) {\n        matchedHarnessTypes.add(result.constructor);\n        dedupedMatches.push(result);\n      }\n    } else if (!testElementMatched) {\n      testElementMatched = true;\n      dedupedMatches.push(result);\n    }\n  }\n  return dedupedMatches as T;\n}\n\n/** Verifies that there is at least one result in an array. */\nasync function _assertResultFound<T>(results: Promise<T[]>, queryDescriptions: string[]):\n    Promise<T> {\n  const result = (await results)[0];\n  if (result == undefined) {\n    throw Error(`Failed to find element matching one of the following queries:\\n` +\n        queryDescriptions.map(desc => `(${desc})`).join(',\\n'));\n  }\n  return result;\n}\n\n/** Gets a list of description strings from a list of queries. */\nfunction _getDescriptionForLocatorForQueries(queries: (string | HarnessQuery<any>)[]) {\n  return queries.map(query => typeof query === 'string' ?\n      _getDescriptionForTestElementQuery(query) : _getDescriptionForComponentHarnessQuery(query));\n}\n\n/** Gets a description string for a `ComponentHarness` query. */\nfunction _getDescriptionForComponentHarnessQuery(query: HarnessQuery<any>) {\n  const harnessPredicate =\n      query instanceof HarnessPredicate ? query : new HarnessPredicate(query, {});\n  const {name, hostSelector} = harnessPredicate.harnessType;\n  const description = `${name} with host element matching selector: \"${hostSelector}\"`;\n  const constraints = harnessPredicate.getDescription();\n  return description + (constraints ?\n      ` satisfying the constraints: ${harnessPredicate.getDescription()}` : '');\n}\n\n/** Gets a description string for a `TestElement` query. */\nfunction _getDescriptionForTestElementQuery(selector: string) {\n  return `TestElement for element matching selector: \"${selector}\"`;\n}\n\n/** Gets a description string for a `HarnessLoader` query. */\nfunction _getDescriptionForHarnessLoaderQuery(selector: string) {\n  return `HarnessLoader for element matching selector: \"${selector}\"`;\n}\n"]}