@angular/material 10.0.0-rc.3 → 10.1.0

package/esm2015/select/testing/select-harness.js

@@ -10,139 +10,141 @@ import { HarnessPredicate } from '@angular/cdk/testing';
 import { MatFormFieldControlHarness } from '@angular/material/form-field/testing/control';
 import { MatOptionHarness, MatOptgroupHarness, } from '@angular/material/core/testing';
 /** Harness for interacting with a standard mat-select in tests. */
-let MatSelectHarness = /** @class */ (() => {
-    class MatSelectHarness extends MatFormFieldControlHarness {
-        constructor() {
-            super(...arguments);
-            this._documentRootLocator = this.documentRootLocatorFactory();
-            this._backdrop = this._documentRootLocator.locatorFor('.cdk-overlay-backdrop');
-            this._trigger = this.locatorFor('.mat-select-trigger');
-            this._value = this.locatorFor('.mat-select-value');
-        }
-        /**
-         * Gets a `HarnessPredicate` that can be used to search for a `MatSelectHarness` that meets
-         * certain criteria.
-         * @param options Options for filtering which select instances are considered a match.
-         * @return a `HarnessPredicate` configured with the given options.
-         */
-        static with(options = {}) {
-            return new HarnessPredicate(MatSelectHarness, options);
-        }
-        /** Gets a boolean promise indicating if the select is disabled. */
-        isDisabled() {
-            return __awaiter(this, void 0, void 0, function* () {
-                return (yield this.host()).hasClass('mat-select-disabled');
-            });
-        }
-        /** Gets a boolean promise indicating if the select is valid. */
-        isValid() {
-            return __awaiter(this, void 0, void 0, function* () {
-                return !(yield (yield this.host()).hasClass('ng-invalid'));
-            });
-        }
-        /** Gets a boolean promise indicating if the select is required. */
-        isRequired() {
-            return __awaiter(this, void 0, void 0, function* () {
-                return (yield this.host()).hasClass('mat-select-required');
-            });
-        }
-        /** Gets a boolean promise indicating if the select is empty (no value is selected). */
-        isEmpty() {
-            return __awaiter(this, void 0, void 0, function* () {
-                return (yield this.host()).hasClass('mat-select-empty');
-            });
-        }
-        /** Gets a boolean promise indicating if the select is in multi-selection mode. */
-        isMultiple() {
-            return __awaiter(this, void 0, void 0, function* () {
-                const ariaMultiselectable = (yield this.host()).getAttribute('aria-multiselectable');
-                return (yield ariaMultiselectable) === 'true';
-            });
-        }
-        /** Gets a promise for the select's value text. */
-        getValueText() {
-            return __awaiter(this, void 0, void 0, function* () {
-                return (yield this._value()).text();
-            });
-        }
-        /** Focuses the select and returns a void promise that indicates when the action is complete. */
-        focus() {
-            return __awaiter(this, void 0, void 0, function* () {
-                return (yield this.host()).focus();
-            });
-        }
-        /** Blurs the select and returns a void promise that indicates when the action is complete. */
-        blur() {
-            return __awaiter(this, void 0, void 0, function* () {
-                return (yield this.host()).blur();
-            });
-        }
-        /** Gets the options inside the select panel. */
-        getOptions(filter = {}) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return this._documentRootLocator.locatorForAll(MatOptionHarness.with(Object.assign(Object.assign({}, filter), { ancestor: yield this._getPanelSelector() })))();
-            });
-        }
-        /** Gets the groups of options inside the panel. */
-        getOptionGroups(filter = {}) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return this._documentRootLocator.locatorForAll(MatOptgroupHarness.with(Object.assign(Object.assign({}, filter), { ancestor: yield this._getPanelSelector() })))();
-            });
-        }
-        /** Gets whether the select is open. */
-        isOpen() {
-            return __awaiter(this, void 0, void 0, function* () {
-                return !!(yield this._documentRootLocator.locatorForOptional(yield this._getPanelSelector())());
-            });
-        }
-        /** Opens the select's panel. */
-        open() {
-            return __awaiter(this, void 0, void 0, function* () {
-                if (!(yield this.isOpen())) {
-                    return (yield this._trigger()).click();
-                }
-            });
-        }
-        /**
-         * Clicks the options that match the passed-in filter. If the select is in multi-selection
-         * mode all options will be clicked, otherwise the harness will pick the first matching option.
-         */
-        clickOptions(filter = {}) {
-            return __awaiter(this, void 0, void 0, function* () {
-                yield this.open();
-                const [isMultiple, options] = yield Promise.all([this.isMultiple(), this.getOptions(filter)]);
-                if (options.length === 0) {
-                    throw Error('Select does not have options matching the specified filter');
-                }
-                if (isMultiple) {
-                    yield Promise.all(options.map(option => option.click()));
-                }
-                else {
-                    yield options[0].click();
-                }
-            });
-        }
-        /** Closes the select's panel. */
-        close() {
-            return __awaiter(this, void 0, void 0, function* () {
-                if (yield this.isOpen()) {
-                    // This is the most consistent way that works both in both single and multi-select modes,
-                    // but it assumes that only one overlay is open at a time. We should be able to make it
-                    // a bit more precise after #16645 where we can dispatch an ESCAPE press to the host instead.
-                    return (yield this._backdrop()).click();
-                }
-            });
-        }
-        /** Gets the selector that should be used to find this select's panel. */
-        _getPanelSelector() {
-            return __awaiter(this, void 0, void 0, function* () {
-                const id = yield (yield this.host()).getAttribute('id');
-                return `#${id}-panel`;
-            });
-        }
-    }
-    MatSelectHarness.hostSelector = '.mat-select';
-    return MatSelectHarness;
-})();
-export { MatSelectHarness };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"select-harness.js","sourceRoot":"","sources":["../../../../../../../src/material/select/testing/select-harness.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 {HarnessPredicate} from '@angular/cdk/testing';\nimport {MatFormFieldControlHarness} from '@angular/material/form-field/testing/control';\nimport {\n  MatOptionHarness,\n  MatOptgroupHarness,\n  OptionHarnessFilters,\n  OptgroupHarnessFilters,\n} from '@angular/material/core/testing';\nimport {SelectHarnessFilters} from './select-harness-filters';\n\n\n/** Harness for interacting with a standard mat-select in tests. */\nexport class MatSelectHarness extends MatFormFieldControlHarness {\n  private _documentRootLocator = this.documentRootLocatorFactory();\n  private _backdrop = this._documentRootLocator.locatorFor('.cdk-overlay-backdrop');\n  private _trigger = this.locatorFor('.mat-select-trigger');\n  private _value = this.locatorFor('.mat-select-value');\n\n  static hostSelector = '.mat-select';\n\n  /**\n   * Gets a `HarnessPredicate` that can be used to search for a `MatSelectHarness` that meets\n   * certain criteria.\n   * @param options Options for filtering which select instances are considered a match.\n   * @return a `HarnessPredicate` configured with the given options.\n   */\n  static with(options: SelectHarnessFilters = {}): HarnessPredicate<MatSelectHarness> {\n    return new HarnessPredicate(MatSelectHarness, options);\n  }\n\n  /** Gets a boolean promise indicating if the select is disabled. */\n  async isDisabled(): Promise<boolean> {\n    return (await this.host()).hasClass('mat-select-disabled');\n  }\n\n  /** Gets a boolean promise indicating if the select is valid. */\n  async isValid(): Promise<boolean> {\n    return !(await (await this.host()).hasClass('ng-invalid'));\n  }\n\n  /** Gets a boolean promise indicating if the select is required. */\n  async isRequired(): Promise<boolean> {\n    return (await this.host()).hasClass('mat-select-required');\n  }\n\n  /** Gets a boolean promise indicating if the select is empty (no value is selected). */\n  async isEmpty(): Promise<boolean> {\n    return (await this.host()).hasClass('mat-select-empty');\n  }\n\n  /** Gets a boolean promise indicating if the select is in multi-selection mode. */\n  async isMultiple(): Promise<boolean> {\n    const ariaMultiselectable = (await this.host()).getAttribute('aria-multiselectable');\n    return (await ariaMultiselectable) === 'true';\n  }\n\n  /** Gets a promise for the select's value text. */\n  async getValueText(): Promise<string> {\n    return (await this._value()).text();\n  }\n\n  /** Focuses the select and returns a void promise that indicates when the action is complete. */\n  async focus(): Promise<void> {\n    return (await this.host()).focus();\n  }\n\n  /** Blurs the select and returns a void promise that indicates when the action is complete. */\n  async blur(): Promise<void> {\n    return (await this.host()).blur();\n  }\n\n  /** Gets the options inside the select panel. */\n  async getOptions(filter: Omit<OptionHarnessFilters, 'ancestor'> = {}):\n    Promise<MatOptionHarness[]> {\n    return this._documentRootLocator.locatorForAll(MatOptionHarness.with({\n      ...filter,\n      ancestor: await this._getPanelSelector()\n    }))();\n  }\n\n  /** Gets the groups of options inside the panel. */\n  async getOptionGroups(filter: Omit<OptgroupHarnessFilters, 'ancestor'> = {}):\n    Promise<MatOptgroupHarness[]> {\n    return this._documentRootLocator.locatorForAll(MatOptgroupHarness.with({\n      ...filter,\n      ancestor: await this._getPanelSelector()\n    }))();\n  }\n\n  /** Gets whether the select is open. */\n  async isOpen(): Promise<boolean> {\n    return !!await this._documentRootLocator.locatorForOptional(await this._getPanelSelector())();\n  }\n\n  /** Opens the select's panel. */\n  async open(): Promise<void> {\n    if (!await this.isOpen()) {\n      return (await this._trigger()).click();\n    }\n  }\n\n  /**\n   * Clicks the options that match the passed-in filter. If the select is in multi-selection\n   * mode all options will be clicked, otherwise the harness will pick the first matching option.\n   */\n  async clickOptions(filter: OptionHarnessFilters = {}): Promise<void> {\n    await this.open();\n\n    const [isMultiple, options] = await Promise.all([this.isMultiple(), this.getOptions(filter)]);\n\n    if (options.length === 0) {\n      throw Error('Select does not have options matching the specified filter');\n    }\n\n    if (isMultiple) {\n      await Promise.all(options.map(option => option.click()));\n    } else {\n      await options[0].click();\n    }\n  }\n\n  /** Closes the select's panel. */\n  async close(): Promise<void> {\n    if (await this.isOpen()) {\n      // This is the most consistent way that works both in both single and multi-select modes,\n      // but it assumes that only one overlay is open at a time. We should be able to make it\n      // a bit more precise after #16645 where we can dispatch an ESCAPE press to the host instead.\n      return (await this._backdrop()).click();\n    }\n  }\n\n  /** Gets the selector that should be used to find this select's panel. */\n  private async _getPanelSelector(): Promise<string> {\n    const id = await (await this.host()).getAttribute('id');\n    return `#${id}-panel`;\n  }\n}\n"]}
+export class MatSelectHarness extends MatFormFieldControlHarness {
+    constructor() {
+        super(...arguments);
+        this._documentRootLocator = this.documentRootLocatorFactory();
+        this._backdrop = this._documentRootLocator.locatorFor('.cdk-overlay-backdrop');
+        this._trigger = this.locatorFor('.mat-select-trigger');
+        this._value = this.locatorFor('.mat-select-value');
+    }
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `MatSelectHarness` that meets
+     * certain criteria.
+     * @param options Options for filtering which select instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options = {}) {
+        return new HarnessPredicate(MatSelectHarness, options);
+    }
+    /** Gets a boolean promise indicating if the select is disabled. */
+    isDisabled() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.host()).hasClass('mat-select-disabled');
+        });
+    }
+    /** Gets a boolean promise indicating if the select is valid. */
+    isValid() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return !(yield (yield this.host()).hasClass('ng-invalid'));
+        });
+    }
+    /** Gets a boolean promise indicating if the select is required. */
+    isRequired() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.host()).hasClass('mat-select-required');
+        });
+    }
+    /** Gets a boolean promise indicating if the select is empty (no value is selected). */
+    isEmpty() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.host()).hasClass('mat-select-empty');
+        });
+    }
+    /** Gets a boolean promise indicating if the select is in multi-selection mode. */
+    isMultiple() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ariaMultiselectable = (yield this.host()).getAttribute('aria-multiselectable');
+            return (yield ariaMultiselectable) === 'true';
+        });
+    }
+    /** Gets a promise for the select's value text. */
+    getValueText() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this._value()).text();
+        });
+    }
+    /** Focuses the select and returns a void promise that indicates when the action is complete. */
+    focus() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.host()).focus();
+        });
+    }
+    /** Blurs the select and returns a void promise that indicates when the action is complete. */
+    blur() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.host()).blur();
+        });
+    }
+    /** Whether the select is focused. */
+    isFocused() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.host()).isFocused();
+        });
+    }
+    /** Gets the options inside the select panel. */
+    getOptions(filter = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._documentRootLocator.locatorForAll(MatOptionHarness.with(Object.assign(Object.assign({}, filter), { ancestor: yield this._getPanelSelector() })))();
+        });
+    }
+    /** Gets the groups of options inside the panel. */
+    getOptionGroups(filter = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._documentRootLocator.locatorForAll(MatOptgroupHarness.with(Object.assign(Object.assign({}, filter), { ancestor: yield this._getPanelSelector() })))();
+        });
+    }
+    /** Gets whether the select is open. */
+    isOpen() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return !!(yield this._documentRootLocator.locatorForOptional(yield this._getPanelSelector())());
+        });
+    }
+    /** Opens the select's panel. */
+    open() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(yield this.isOpen())) {
+                return (yield this._trigger()).click();
+            }
+        });
+    }
+    /**
+     * Clicks the options that match the passed-in filter. If the select is in multi-selection
+     * mode all options will be clicked, otherwise the harness will pick the first matching option.
+     */
+    clickOptions(filter = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.open();
+            const [isMultiple, options] = yield Promise.all([this.isMultiple(), this.getOptions(filter)]);
+            if (options.length === 0) {
+                throw Error('Select does not have options matching the specified filter');
+            }
+            if (isMultiple) {
+                yield Promise.all(options.map(option => option.click()));
+            }
+            else {
+                yield options[0].click();
+            }
+        });
+    }
+    /** Closes the select's panel. */
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (yield this.isOpen()) {
+                // This is the most consistent way that works both in both single and multi-select modes,
+                // but it assumes that only one overlay is open at a time. We should be able to make it
+                // a bit more precise after #16645 where we can dispatch an ESCAPE press to the host instead.
+                return (yield this._backdrop()).click();
+            }
+        });
+    }
+    /** Gets the selector that should be used to find this select's panel. */
+    _getPanelSelector() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const id = yield (yield this.host()).getAttribute('id');
+            return `#${id}-panel`;
+        });
+    }
+}
+MatSelectHarness.hostSelector = '.mat-select';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"select-harness.js","sourceRoot":"","sources":["../../../../../../../src/material/select/testing/select-harness.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;;AAEH,OAAO,EAAC,gBAAgB,EAAC,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAC,0BAA0B,EAAC,MAAM,8CAA8C,CAAC;AACxF,OAAO,EACL,gBAAgB,EAChB,kBAAkB,GAGnB,MAAM,gCAAgC,CAAC;AAIxC,mEAAmE;AACnE,MAAM,OAAO,gBAAiB,SAAQ,0BAA0B;IAAhE;;QACU,yBAAoB,GAAG,IAAI,CAAC,0BAA0B,EAAE,CAAC;QACzD,cAAS,GAAG,IAAI,CAAC,oBAAoB,CAAC,UAAU,CAAC,uBAAuB,CAAC,CAAC;QAC1E,aAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,qBAAqB,CAAC,CAAC;QAClD,WAAM,GAAG,IAAI,CAAC,UAAU,CAAC,mBAAmB,CAAC,CAAC;IA6HxD,CAAC;IAzHC;;;;;OAKG;IACH,MAAM,CAAC,IAAI,CAAC,UAAgC,EAAE;QAC5C,OAAO,IAAI,gBAAgB,CAAC,gBAAgB,EAAE,OAAO,CAAC,CAAC;IACzD,CAAC;IAED,mEAAmE;IAC7D,UAAU;;YACd,OAAO,CAAC,MAAM,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,QAAQ,CAAC,qBAAqB,CAAC,CAAC;QAC7D,CAAC;KAAA;IAED,gEAAgE;IAC1D,OAAO;;YACX,OAAO,CAAC,CAAC,MAAM,CAAC,MAAM,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC,CAAC;QAC7D,CAAC;KAAA;IAED,mEAAmE;IAC7D,UAAU;;YACd,OAAO,CAAC,MAAM,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,QAAQ,CAAC,qBAAqB,CAAC,CAAC;QAC7D,CAAC;KAAA;IAED,uFAAuF;IACjF,OAAO;;YACX,OAAO,CAAC,MAAM,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,QAAQ,CAAC,kBAAkB,CAAC,CAAC;QAC1D,CAAC;KAAA;IAED,kFAAkF;IAC5E,UAAU;;YACd,MAAM,mBAAmB,GAAG,CAAC,MAAM,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,YAAY,CAAC,sBAAsB,CAAC,CAAC;YACrF,OAAO,CAAC,MAAM,mBAAmB,CAAC,KAAK,MAAM,CAAC;QAChD,CAAC;KAAA;IAED,kDAAkD;IAC5C,YAAY;;YAChB,OAAO,CAAC,MAAM,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;QACtC,CAAC;KAAA;IAED,gGAAgG;IAC1F,KAAK;;YACT,OAAO,CAAC,MAAM,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC;QACrC,CAAC;KAAA;IAED,8FAA8F;IACxF,IAAI;;YACR,OAAO,CAAC,MAAM,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;QACpC,CAAC;KAAA;IAED,qCAAqC;IAC/B,SAAS;;YACb,OAAO,CAAC,MAAM,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,SAAS,EAAE,CAAC;QACzC,CAAC;KAAA;IAED,gDAAgD;IAC1C,UAAU,CAAC,SAAiD,EAAE;;YAElE,OAAO,IAAI,CAAC,oBAAoB,CAAC,aAAa,CAAC,gBAAgB,CAAC,IAAI,iCAC/D,MAAM,KACT,QAAQ,EAAE,MAAM,IAAI,CAAC,iBAAiB,EAAE,IACxC,CAAC,EAAE,CAAC;QACR,CAAC;KAAA;IAED,mDAAmD;IAC7C,eAAe,CAAC,SAAmD,EAAE;;YAEzE,OAAO,IAAI,CAAC,oBAAoB,CAAC,aAAa,CAAC,kBAAkB,CAAC,IAAI,iCACjE,MAAM,KACT,QAAQ,EAAE,MAAM,IAAI,CAAC,iBAAiB,EAAE,IACxC,CAAC,EAAE,CAAC;QACR,CAAC;KAAA;IAED,uCAAuC;IACjC,MAAM;;YACV,OAAO,CAAC,CAAC,CAAA,MAAM,IAAI,CAAC,oBAAoB,CAAC,kBAAkB,CAAC,MAAM,IAAI,CAAC,iBAAiB,EAAE,CAAC,EAAE,CAAA,CAAC;QAChG,CAAC;KAAA;IAED,gCAAgC;IAC1B,IAAI;;YACR,IAAI,CAAC,CAAA,MAAM,IAAI,CAAC,MAAM,EAAE,CAAA,EAAE;gBACxB,OAAO,CAAC,MAAM,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC;aACxC;QACH,CAAC;KAAA;IAED;;;OAGG;IACG,YAAY,CAAC,SAA+B,EAAE;;YAClD,MAAM,IAAI,CAAC,IAAI,EAAE,CAAC;YAElB,MAAM,CAAC,UAAU,EAAE,OAAO,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,UAAU,EAAE,EAAE,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;YAE9F,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE;gBACxB,MAAM,KAAK,CAAC,4DAA4D,CAAC,CAAC;aAC3E;YAED,IAAI,UAAU,EAAE;gBACd,MAAM,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;aAC1D;iBAAM;gBACL,MAAM,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC;aAC1B;QACH,CAAC;KAAA;IAED,iCAAiC;IAC3B,KAAK;;YACT,IAAI,MAAM,IAAI,CAAC,MAAM,EAAE,EAAE;gBACvB,yFAAyF;gBACzF,uFAAuF;gBACvF,6FAA6F;gBAC7F,OAAO,CAAC,MAAM,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC;aACzC;QACH,CAAC;KAAA;IAED,yEAAyE;IAC3D,iBAAiB;;YAC7B,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;YACxD,OAAO,IAAI,EAAE,QAAQ,CAAC;QACxB,CAAC;KAAA;;AA1HM,6BAAY,GAAG,aAAa,CAAC","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 {HarnessPredicate} from '@angular/cdk/testing';\nimport {MatFormFieldControlHarness} from '@angular/material/form-field/testing/control';\nimport {\n  MatOptionHarness,\n  MatOptgroupHarness,\n  OptionHarnessFilters,\n  OptgroupHarnessFilters,\n} from '@angular/material/core/testing';\nimport {SelectHarnessFilters} from './select-harness-filters';\n\n\n/** Harness for interacting with a standard mat-select in tests. */\nexport class MatSelectHarness extends MatFormFieldControlHarness {\n  private _documentRootLocator = this.documentRootLocatorFactory();\n  private _backdrop = this._documentRootLocator.locatorFor('.cdk-overlay-backdrop');\n  private _trigger = this.locatorFor('.mat-select-trigger');\n  private _value = this.locatorFor('.mat-select-value');\n\n  static hostSelector = '.mat-select';\n\n  /**\n   * Gets a `HarnessPredicate` that can be used to search for a `MatSelectHarness` that meets\n   * certain criteria.\n   * @param options Options for filtering which select instances are considered a match.\n   * @return a `HarnessPredicate` configured with the given options.\n   */\n  static with(options: SelectHarnessFilters = {}): HarnessPredicate<MatSelectHarness> {\n    return new HarnessPredicate(MatSelectHarness, options);\n  }\n\n  /** Gets a boolean promise indicating if the select is disabled. */\n  async isDisabled(): Promise<boolean> {\n    return (await this.host()).hasClass('mat-select-disabled');\n  }\n\n  /** Gets a boolean promise indicating if the select is valid. */\n  async isValid(): Promise<boolean> {\n    return !(await (await this.host()).hasClass('ng-invalid'));\n  }\n\n  /** Gets a boolean promise indicating if the select is required. */\n  async isRequired(): Promise<boolean> {\n    return (await this.host()).hasClass('mat-select-required');\n  }\n\n  /** Gets a boolean promise indicating if the select is empty (no value is selected). */\n  async isEmpty(): Promise<boolean> {\n    return (await this.host()).hasClass('mat-select-empty');\n  }\n\n  /** Gets a boolean promise indicating if the select is in multi-selection mode. */\n  async isMultiple(): Promise<boolean> {\n    const ariaMultiselectable = (await this.host()).getAttribute('aria-multiselectable');\n    return (await ariaMultiselectable) === 'true';\n  }\n\n  /** Gets a promise for the select's value text. */\n  async getValueText(): Promise<string> {\n    return (await this._value()).text();\n  }\n\n  /** Focuses the select and returns a void promise that indicates when the action is complete. */\n  async focus(): Promise<void> {\n    return (await this.host()).focus();\n  }\n\n  /** Blurs the select and returns a void promise that indicates when the action is complete. */\n  async blur(): Promise<void> {\n    return (await this.host()).blur();\n  }\n\n  /** Whether the select is focused. */\n  async isFocused(): Promise<boolean> {\n    return (await this.host()).isFocused();\n  }\n\n  /** Gets the options inside the select panel. */\n  async getOptions(filter: Omit<OptionHarnessFilters, 'ancestor'> = {}):\n    Promise<MatOptionHarness[]> {\n    return this._documentRootLocator.locatorForAll(MatOptionHarness.with({\n      ...filter,\n      ancestor: await this._getPanelSelector()\n    }))();\n  }\n\n  /** Gets the groups of options inside the panel. */\n  async getOptionGroups(filter: Omit<OptgroupHarnessFilters, 'ancestor'> = {}):\n    Promise<MatOptgroupHarness[]> {\n    return this._documentRootLocator.locatorForAll(MatOptgroupHarness.with({\n      ...filter,\n      ancestor: await this._getPanelSelector()\n    }))();\n  }\n\n  /** Gets whether the select is open. */\n  async isOpen(): Promise<boolean> {\n    return !!await this._documentRootLocator.locatorForOptional(await this._getPanelSelector())();\n  }\n\n  /** Opens the select's panel. */\n  async open(): Promise<void> {\n    if (!await this.isOpen()) {\n      return (await this._trigger()).click();\n    }\n  }\n\n  /**\n   * Clicks the options that match the passed-in filter. If the select is in multi-selection\n   * mode all options will be clicked, otherwise the harness will pick the first matching option.\n   */\n  async clickOptions(filter: OptionHarnessFilters = {}): Promise<void> {\n    await this.open();\n\n    const [isMultiple, options] = await Promise.all([this.isMultiple(), this.getOptions(filter)]);\n\n    if (options.length === 0) {\n      throw Error('Select does not have options matching the specified filter');\n    }\n\n    if (isMultiple) {\n      await Promise.all(options.map(option => option.click()));\n    } else {\n      await options[0].click();\n    }\n  }\n\n  /** Closes the select's panel. */\n  async close(): Promise<void> {\n    if (await this.isOpen()) {\n      // This is the most consistent way that works both in both single and multi-select modes,\n      // but it assumes that only one overlay is open at a time. We should be able to make it\n      // a bit more precise after #16645 where we can dispatch an ESCAPE press to the host instead.\n      return (await this._backdrop()).click();\n    }\n  }\n\n  /** Gets the selector that should be used to find this select's panel. */\n  private async _getPanelSelector(): Promise<string> {\n    const id = await (await this.host()).getAttribute('id');\n    return `#${id}-panel`;\n  }\n}\n"]}