source: trip-planner-front/node_modules/@angular/cdk/esm2015/testing/harness-environment.js@ 6a3a178

Last change on this file since 6a3a178 was 6a3a178, checked in by Ema <ema_spirova@…>, 3 years ago

initial commit

  • Property mode set to 100644
File size: 35.1 KB
Line 
1/**
2 * @license
3 * Copyright Google LLC All Rights Reserved.
4 *
5 * Use of this source code is governed by an MIT-style license that can be
6 * found in the LICENSE file at https://angular.io/license
7 */
8import { __awaiter } from "tslib";
9import { parallel } from './change-detection';
10import { ComponentHarness, HarnessPredicate, } from './component-harness';
11/**
12 * Base harness environment class that can be extended to allow `ComponentHarness`es to be used in
13 * different test environments (e.g. testbed, protractor, etc.). This class implements the
14 * functionality of both a `HarnessLoader` and `LocatorFactory`. This class is generic on the raw
15 * element type, `E`, used by the particular test environment.
16 */
17export class HarnessEnvironment {
18 constructor(rawRootElement) {
19 this.rawRootElement = rawRootElement;
20 this.rootElement = this.createTestElement(rawRootElement);
21 }
22 // Implemented as part of the `LocatorFactory` interface.
23 documentRootLocatorFactory() {
24 return this.createEnvironment(this.getDocumentRoot());
25 }
26 // Implemented as part of the `LocatorFactory` interface.
27 locatorFor(...queries) {
28 return () => _assertResultFound(this._getAllHarnessesAndTestElements(queries), _getDescriptionForLocatorForQueries(queries));
29 }
30 // Implemented as part of the `LocatorFactory` interface.
31 locatorForOptional(...queries) {
32 return () => __awaiter(this, void 0, void 0, function* () { return (yield this._getAllHarnessesAndTestElements(queries))[0] || null; });
33 }
34 // Implemented as part of the `LocatorFactory` interface.
35 locatorForAll(...queries) {
36 return () => this._getAllHarnessesAndTestElements(queries);
37 }
38 // Implemented as part of the `LocatorFactory` interface.
39 rootHarnessLoader() {
40 return __awaiter(this, void 0, void 0, function* () {
41 return this;
42 });
43 }
44 // Implemented as part of the `LocatorFactory` interface.
45 harnessLoaderFor(selector) {
46 return __awaiter(this, void 0, void 0, function* () {
47 return this.createEnvironment(yield _assertResultFound(this.getAllRawElements(selector), [_getDescriptionForHarnessLoaderQuery(selector)]));
48 });
49 }
50 // Implemented as part of the `LocatorFactory` interface.
51 harnessLoaderForOptional(selector) {
52 return __awaiter(this, void 0, void 0, function* () {
53 const elements = yield this.getAllRawElements(selector);
54 return elements[0] ? this.createEnvironment(elements[0]) : null;
55 });
56 }
57 // Implemented as part of the `LocatorFactory` interface.
58 harnessLoaderForAll(selector) {
59 return __awaiter(this, void 0, void 0, function* () {
60 const elements = yield this.getAllRawElements(selector);
61 return elements.map(element => this.createEnvironment(element));
62 });
63 }
64 // Implemented as part of the `HarnessLoader` interface.
65 getHarness(query) {
66 return this.locatorFor(query)();
67 }
68 // Implemented as part of the `HarnessLoader` interface.
69 getAllHarnesses(query) {
70 return this.locatorForAll(query)();
71 }
72 // Implemented as part of the `HarnessLoader` interface.
73 getChildLoader(selector) {
74 return __awaiter(this, void 0, void 0, function* () {
75 return this.createEnvironment(yield _assertResultFound(this.getAllRawElements(selector), [_getDescriptionForHarnessLoaderQuery(selector)]));
76 });
77 }
78 // Implemented as part of the `HarnessLoader` interface.
79 getAllChildLoaders(selector) {
80 return __awaiter(this, void 0, void 0, function* () {
81 return (yield this.getAllRawElements(selector)).map(e => this.createEnvironment(e));
82 });
83 }
84 /** Creates a `ComponentHarness` for the given harness type with the given raw host element. */
85 createComponentHarness(harnessType, element) {
86 return new harnessType(this.createEnvironment(element));
87 }
88 /**
89 * Matches the given raw elements with the given list of element and harness queries to produce a
90 * list of matched harnesses and test elements.
91 */
92 _getAllHarnessesAndTestElements(queries) {
93 return __awaiter(this, void 0, void 0, function* () {
94 const { allQueries, harnessQueries, elementQueries, harnessTypes } = _parseQueries(queries);
95 // Combine all of the queries into one large comma-delimited selector and use it to get all raw
96 // elements matching any of the individual queries.
97 const rawElements = yield this.getAllRawElements([...elementQueries, ...harnessQueries.map(predicate => predicate.getSelector())].join(','));
98 // If every query is searching for the same harness subclass, we know every result corresponds
99 // to an instance of that subclass. Likewise, if every query is for a `TestElement`, we know
100 // every result corresponds to a `TestElement`. Otherwise we need to verify which result was
101 // found by which selector so it can be matched to the appropriate instance.
102 const skipSelectorCheck = (elementQueries.length === 0 && harnessTypes.size === 1) ||
103 harnessQueries.length === 0;
104 const perElementMatches = yield parallel(() => rawElements.map((rawElement) => __awaiter(this, void 0, void 0, function* () {
105 const testElement = this.createTestElement(rawElement);
106 const allResultsForElement = yield parallel(
107 // For each query, get `null` if it doesn't match, or a `TestElement` or
108 // `ComponentHarness` as appropriate if it does match. This gives us everything that
109 // matches the current raw element, but it may contain duplicate entries (e.g.
110 // multiple `TestElement` or multiple `ComponentHarness` of the same type).
111 () => allQueries.map(query => this._getQueryResultForElement(query, rawElement, testElement, skipSelectorCheck)));
112 return _removeDuplicateQueryResults(allResultsForElement);
113 })));
114 return [].concat(...perElementMatches);
115 });
116 }
117 /**
118 * Check whether the given query matches the given element, if it does return the matched
119 * `TestElement` or `ComponentHarness`, if it does not, return null. In cases where the caller
120 * knows for sure that the query matches the element's selector, `skipSelectorCheck` can be used
121 * to skip verification and optimize performance.
122 */
123 _getQueryResultForElement(query, rawElement, testElement, skipSelectorCheck = false) {
124 return __awaiter(this, void 0, void 0, function* () {
125 if (typeof query === 'string') {
126 return ((skipSelectorCheck || (yield testElement.matchesSelector(query))) ? testElement : null);
127 }
128 if (skipSelectorCheck || (yield testElement.matchesSelector(query.getSelector()))) {
129 const harness = this.createComponentHarness(query.harnessType, rawElement);
130 return (yield query.evaluate(harness)) ? harness : null;
131 }
132 return null;
133 });
134 }
135}
136/**
137 * Parses a list of queries in the format accepted by the `locatorFor*` methods into an easier to
138 * work with format.
139 */
140function _parseQueries(queries) {
141 const allQueries = [];
142 const harnessQueries = [];
143 const elementQueries = [];
144 const harnessTypes = new Set();
145 for (const query of queries) {
146 if (typeof query === 'string') {
147 allQueries.push(query);
148 elementQueries.push(query);
149 }
150 else {
151 const predicate = query instanceof HarnessPredicate ? query : new HarnessPredicate(query, {});
152 allQueries.push(predicate);
153 harnessQueries.push(predicate);
154 harnessTypes.add(predicate.harnessType);
155 }
156 }
157 return { allQueries, harnessQueries, elementQueries, harnessTypes };
158}
159/**
160 * Removes duplicate query results for a particular element. (e.g. multiple `TestElement`
161 * instances or multiple instances of the same `ComponentHarness` class.
162 */
163function _removeDuplicateQueryResults(results) {
164 return __awaiter(this, void 0, void 0, function* () {
165 let testElementMatched = false;
166 let matchedHarnessTypes = new Set();
167 const dedupedMatches = [];
168 for (const result of results) {
169 if (!result) {
170 continue;
171 }
172 if (result instanceof ComponentHarness) {
173 if (!matchedHarnessTypes.has(result.constructor)) {
174 matchedHarnessTypes.add(result.constructor);
175 dedupedMatches.push(result);
176 }
177 }
178 else if (!testElementMatched) {
179 testElementMatched = true;
180 dedupedMatches.push(result);
181 }
182 }
183 return dedupedMatches;
184 });
185}
186/** Verifies that there is at least one result in an array. */
187function _assertResultFound(results, queryDescriptions) {
188 return __awaiter(this, void 0, void 0, function* () {
189 const result = (yield results)[0];
190 if (result == undefined) {
191 throw Error(`Failed to find element matching one of the following queries:\n` +
192 queryDescriptions.map(desc => `(${desc})`).join(',\n'));
193 }
194 return result;
195 });
196}
197/** Gets a list of description strings from a list of queries. */
198function _getDescriptionForLocatorForQueries(queries) {
199 return queries.map(query => typeof query === 'string' ?
200 _getDescriptionForTestElementQuery(query) : _getDescriptionForComponentHarnessQuery(query));
201}
202/** Gets a description string for a `ComponentHarness` query. */
203function _getDescriptionForComponentHarnessQuery(query) {
204 const harnessPredicate = query instanceof HarnessPredicate ? query : new HarnessPredicate(query, {});
205 const { name, hostSelector } = harnessPredicate.harnessType;
206 const description = `${name} with host element matching selector: "${hostSelector}"`;
207 const constraints = harnessPredicate.getDescription();
208 return description + (constraints ?
209 ` satisfying the constraints: ${harnessPredicate.getDescription()}` : '');
210}
211/** Gets a description string for a `TestElement` query. */
212function _getDescriptionForTestElementQuery(selector) {
213 return `TestElement for element matching selector: "${selector}"`;
214}
215/** Gets a description string for a `HarnessLoader` query. */
216function _getDescriptionForHarnessLoaderQuery(selector) {
217 return `HarnessLoader for element matching selector: "${selector}"`;
218}
219//# 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 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          () => 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"]}
Note: See TracBrowser for help on using the repository browser.