/**
 * @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 { 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 {
    // Implemented as part of the `LocatorFactory` interface.
    get rootElement() {
        this._rootElement = this._rootElement || this.createTestElement(this.rawRootElement);
        return this._rootElement;
    }
    set rootElement(element) {
        this._rootElement = element;
    }
    constructor(rawRootElement) {
        this.rawRootElement = 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 async () => (await 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.
    async rootHarnessLoader() {
        return this;
    }
    // Implemented as part of the `LocatorFactory` interface.
    async harnessLoaderFor(selector) {
        return this.createEnvironment(await _assertResultFound(this.getAllRawElements(selector), [
            _getDescriptionForHarnessLoaderQuery(selector),
        ]));
    }
    // Implemented as part of the `LocatorFactory` interface.
    async harnessLoaderForOptional(selector) {
        const elements = await this.getAllRawElements(selector);
        return elements[0] ? this.createEnvironment(elements[0]) : null;
    }
    // Implemented as part of the `LocatorFactory` interface.
    async harnessLoaderForAll(selector) {
        const elements = await 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.
    getHarnessOrNull(query) {
        return this.locatorForOptional(query)();
    }
    // Implemented as part of the `HarnessLoader` interface.
    getAllHarnesses(query) {
        return this.locatorForAll(query)();
    }
    // Implemented as part of the `HarnessLoader` interface.
    async hasHarness(query) {
        return (await this.locatorForOptional(query)()) !== null;
    }
    // Implemented as part of the `HarnessLoader` interface.
    async getChildLoader(selector) {
        return this.createEnvironment(await _assertResultFound(this.getAllRawElements(selector), [
            _getDescriptionForHarnessLoaderQuery(selector),
        ]));
    }
    // Implemented as part of the `HarnessLoader` interface.
    async getAllChildLoaders(selector) {
        return (await 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.
     */
    async _getAllHarnessesAndTestElements(queries) {
        if (!queries.length) {
            throw Error('CDK Component harness query must contain at least one element.');
        }
        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 = await 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 = await parallel(() => rawElements.map(async (rawElement) => {
            const testElement = this.createTestElement(rawElement);
            const allResultsForElement = await parallel(
            // 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.
     */
    async _getQueryResultForElement(query, rawElement, testElement, skipSelectorCheck = false) {
        if (typeof query === 'string') {
            return skipSelectorCheck || (await testElement.matchesSelector(query)) ? testElement : null;
        }
        if (skipSelectorCheck || (await testElement.matchesSelector(query.getSelector()))) {
            const harness = this.createComponentHarness(query.harnessType, rawElement);
            return (await 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.
 */
async function _removeDuplicateQueryResults(results) {
    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. */
async function _assertResultFound(results, queryDescriptions) {
    const result = (await 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  get rootElement(): TestElement {\n    this._rootElement = this._rootElement || this.createTestElement(this.rawRootElement);\n    return this._rootElement;\n  }\n  set rootElement(element: TestElement) {\n    this._rootElement = element;\n  }\n  private _rootElement: TestElement | undefined;\n\n  protected constructor(protected rawRootElement: E) {}\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)[]>(\n    ...queries: T\n  ): AsyncFactoryFn<LocatorFnResult<T>> {\n    return () =>\n      _assertResultFound(\n        this._getAllHarnessesAndTestElements(queries),\n        _getDescriptionForLocatorForQueries(queries),\n      );\n  }\n\n  // Implemented as part of the `LocatorFactory` interface.\n  locatorForOptional<T extends (HarnessQuery<any> | string)[]>(\n    ...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)[]>(\n    ...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(\n      await _assertResultFound(this.getAllRawElements(selector), [\n        _getDescriptionForHarnessLoaderQuery(selector),\n      ]),\n    );\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  getHarnessOrNull<T extends ComponentHarness>(query: HarnessQuery<T>): Promise<T | null> {\n    return this.locatorForOptional(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 hasHarness<T extends ComponentHarness>(query: HarnessQuery<T>): Promise<boolean> {\n    return (await this.locatorForOptional(query)()) !== null;\n  }\n\n  // Implemented as part of the `HarnessLoader` interface.\n  async getChildLoader(selector: string): Promise<HarnessLoader> {\n    return this.createEnvironment(\n      await _assertResultFound(this.getAllRawElements(selector), [\n        _getDescriptionForHarnessLoaderQuery(selector),\n      ]),\n    );\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>,\n    element: E,\n  ): 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,\n  ): Promise<LocatorFnResult<T>[]> {\n    if (!queries.length) {\n      throw Error('CDK Component harness query must contain at least one element.');\n    }\n\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\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 =\n      (elementQueries.length === 0 && harnessTypes.size === 1) || harnessQueries.length === 0;\n\n    const perElementMatches = await parallel(() =>\n      rawElements.map(async rawElement => {\n        const testElement = this.createTestElement(rawElement);\n        const allResultsForElement = await parallel(\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          () =>\n            allQueries.map(query =>\n              this._getQueryResultForElement(query, rawElement, testElement, skipSelectorCheck),\n            ),\n        );\n        return _removeDuplicateQueryResults(allResultsForElement);\n      }),\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>,\n    rawElement: E,\n    testElement: TestElement,\n    skipSelectorCheck: boolean = false,\n  ): 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)[]>(\n  queries: T,\n): ParsedQueries<LocatorFnResult<T> & ComponentHarness> {\n  const allQueries = [];\n  const harnessQueries = [];\n  const elementQueries = [];\n  const harnessTypes = new Set<\n    ComponentHarnessConstructor<LocatorFnResult<T> & ComponentHarness>\n  >();\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,\n): 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>(\n  results: Promise<T[]>,\n  queryDescriptions: string[],\n): Promise<T> {\n  const result = (await results)[0];\n  if (result == undefined) {\n    throw Error(\n      `Failed to find element matching one of the following queries:\\n` +\n        queryDescriptions.map(desc => `(${desc})`).join(',\\n'),\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 =>\n    typeof query === 'string'\n      ? _getDescriptionForTestElementQuery(query)\n      : _getDescriptionForComponentHarnessQuery(query),\n  );\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 (\n    description +\n    (constraints ? ` satisfying the constraints: ${harnessPredicate.getDescription()}` : '')\n  );\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"]}