@angular/cdk/esm2022/testing/selenium-webdriver/selenium-web-driver-harness-environment.mjs

Angular Material Component Development Kit

/**
 * @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 { HarnessEnvironment } from '@angular/cdk/testing';
import * as webdriver from 'selenium-webdriver';
import { SeleniumWebDriverElement } from './selenium-web-driver-element';
/** The default environment options. */
const defaultEnvironmentOptions = {
    queryFn: async (selector, root) => root().findElements(webdriver.By.css(selector)),
};
/**
 * This function is meant to be executed in the browser. It taps into the hooks exposed by Angular
 * and invokes the specified `callback` when the application is stable (no more pending tasks).
 */
function whenStable(callback) {
    Promise.all(window.frameworkStabilizers.map(stabilizer => new Promise(stabilizer))).then(callback);
}
/**
 * This function is meant to be executed in the browser. It checks whether the Angular framework has
 * bootstrapped yet.
 */
function isBootstrapped() {
    return !!window.frameworkStabilizers;
}
/** Waits for angular to be ready after the page load. */
export async function waitForAngularReady(wd) {
    await wd.wait(() => wd.executeScript(isBootstrapped));
    await wd.executeAsyncScript(whenStable);
}
/** A `HarnessEnvironment` implementation for WebDriver. */
export class SeleniumWebDriverHarnessEnvironment extends HarnessEnvironment {
    constructor(rawRootElement, options) {
        super(rawRootElement);
        this._options = { ...defaultEnvironmentOptions, ...options };
        this._stabilizeCallback = () => this.forceStabilize();
    }
    /** Gets the ElementFinder corresponding to the given TestElement. */
    static getNativeElement(el) {
        if (el instanceof SeleniumWebDriverElement) {
            return el.element();
        }
        throw Error('This TestElement was not created by the WebDriverHarnessEnvironment');
    }
    /** Creates a `HarnessLoader` rooted at the document root. */
    static loader(driver, options) {
        return new SeleniumWebDriverHarnessEnvironment(() => driver.findElement(webdriver.By.css('body')), options);
    }
    /**
     * Flushes change detection and async tasks captured in the Angular zone.
     * In most cases it should not be necessary to call this manually. However, there may be some edge
     * cases where it is needed to fully flush animation events.
     */
    async forceStabilize() {
        await this.rawRootElement().getDriver().executeAsyncScript(whenStable);
    }
    /** @docs-private */
    async waitForTasksOutsideAngular() {
        // TODO: figure out how we can do this for the webdriver environment.
        //  https://github.com/angular/components/issues/17412
    }
    /** Gets the root element for the document. */
    getDocumentRoot() {
        return () => this.rawRootElement().getDriver().findElement(webdriver.By.css('body'));
    }
    /** Creates a `TestElement` from a raw element. */
    createTestElement(element) {
        return new SeleniumWebDriverElement(element, this._stabilizeCallback);
    }
    /** Creates a `HarnessLoader` rooted at the given raw element. */
    createEnvironment(element) {
        return new SeleniumWebDriverHarnessEnvironment(element, this._options);
    }
    // Note: This seems to be working, though we may need to re-evaluate if we encounter issues with
    // stale element references. `() => Promise<webdriver.WebElement[]>` seems like a more correct
    // return type, though supporting it would require changes to the public harness API.
    /**
     * Gets a list of all elements matching the given selector under this environment's root element.
     */
    async getAllRawElements(selector) {
        const els = await this._options.queryFn(selector, this.rawRootElement);
        return els.map((x) => () => x);
    }
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"selenium-web-driver-harness-environment.js","sourceRoot":"","sources":["../../../../../../../src/cdk/testing/selenium-webdriver/selenium-web-driver-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 {HarnessEnvironment, HarnessLoader, TestElement} from '@angular/cdk/testing';\nimport * as webdriver from 'selenium-webdriver';\nimport {SeleniumWebDriverElement} from './selenium-web-driver-element';\n\n/**\n * An Angular framework stabilizer function that takes a callback and calls it when the application\n * is stable, passing a boolean indicating if any work was done.\n */\ndeclare interface FrameworkStabilizer {\n  (callback: (didWork: boolean) => void): void;\n}\n\ndeclare global {\n  interface Window {\n    /**\n     * These hooks are exposed by Angular to register a callback for when the application is stable\n     * (no more pending tasks).\n     *\n     * For the implementation, see: https://github.com/\n     *  angular/angular/blob/main/packages/platform-browser/src/browser/testability.ts#L30-L49\n     */\n    frameworkStabilizers: FrameworkStabilizer[];\n  }\n}\n\n/** Options to configure the environment. */\nexport interface WebDriverHarnessEnvironmentOptions {\n  /** The query function used to find DOM elements. */\n  queryFn: (selector: string, root: () => webdriver.WebElement) => Promise<webdriver.WebElement[]>;\n}\n\n/** The default environment options. */\nconst defaultEnvironmentOptions: WebDriverHarnessEnvironmentOptions = {\n  queryFn: async (selector: string, root: () => webdriver.WebElement) =>\n    root().findElements(webdriver.By.css(selector)),\n};\n\n/**\n * This function is meant to be executed in the browser. It taps into the hooks exposed by Angular\n * and invokes the specified `callback` when the application is stable (no more pending tasks).\n */\nfunction whenStable(callback: (didWork: boolean[]) => void): void {\n  Promise.all(window.frameworkStabilizers.map(stabilizer => new Promise(stabilizer))).then(\n    callback,\n  );\n}\n\n/**\n * This function is meant to be executed in the browser. It checks whether the Angular framework has\n * bootstrapped yet.\n */\nfunction isBootstrapped() {\n  return !!window.frameworkStabilizers;\n}\n\n/** Waits for angular to be ready after the page load. */\nexport async function waitForAngularReady(wd: webdriver.WebDriver) {\n  await wd.wait(() => wd.executeScript(isBootstrapped));\n  await wd.executeAsyncScript(whenStable);\n}\n\n/** A `HarnessEnvironment` implementation for WebDriver. */\nexport class SeleniumWebDriverHarnessEnvironment extends HarnessEnvironment<\n  () => webdriver.WebElement\n> {\n  /** The options for this environment. */\n  private _options: WebDriverHarnessEnvironmentOptions;\n\n  /** Environment stabilization callback passed to the created test elements. */\n  private _stabilizeCallback: () => Promise<void>;\n\n  protected constructor(\n    rawRootElement: () => webdriver.WebElement,\n    options?: WebDriverHarnessEnvironmentOptions,\n  ) {\n    super(rawRootElement);\n    this._options = {...defaultEnvironmentOptions, ...options};\n    this._stabilizeCallback = () => this.forceStabilize();\n  }\n\n  /** Gets the ElementFinder corresponding to the given TestElement. */\n  static getNativeElement(el: TestElement): webdriver.WebElement {\n    if (el instanceof SeleniumWebDriverElement) {\n      return el.element();\n    }\n    throw Error('This TestElement was not created by the WebDriverHarnessEnvironment');\n  }\n\n  /** Creates a `HarnessLoader` rooted at the document root. */\n  static loader(\n    driver: webdriver.WebDriver,\n    options?: WebDriverHarnessEnvironmentOptions,\n  ): HarnessLoader {\n    return new SeleniumWebDriverHarnessEnvironment(\n      () => driver.findElement(webdriver.By.css('body')),\n      options,\n    );\n  }\n\n  /**\n   * Flushes change detection and async tasks captured in the Angular zone.\n   * In most cases it should not be necessary to call this manually. However, there may be some edge\n   * cases where it is needed to fully flush animation events.\n   */\n  async forceStabilize(): Promise<void> {\n    await this.rawRootElement().getDriver().executeAsyncScript(whenStable);\n  }\n\n  /** @docs-private */\n  async waitForTasksOutsideAngular(): Promise<void> {\n    // TODO: figure out how we can do this for the webdriver environment.\n    //  https://github.com/angular/components/issues/17412\n  }\n\n  /** Gets the root element for the document. */\n  protected getDocumentRoot(): () => webdriver.WebElement {\n    return () => this.rawRootElement().getDriver().findElement(webdriver.By.css('body'));\n  }\n\n  /** Creates a `TestElement` from a raw element. */\n  protected createTestElement(element: () => webdriver.WebElement): TestElement {\n    return new SeleniumWebDriverElement(element, this._stabilizeCallback);\n  }\n\n  /** Creates a `HarnessLoader` rooted at the given raw element. */\n  protected createEnvironment(\n    element: () => webdriver.WebElement,\n  ): HarnessEnvironment<() => webdriver.WebElement> {\n    return new SeleniumWebDriverHarnessEnvironment(element, this._options);\n  }\n\n  // Note: This seems to be working, though we may need to re-evaluate if we encounter issues with\n  // stale element references. `() => Promise<webdriver.WebElement[]>` seems like a more correct\n  // return type, though supporting it would require changes to the public harness API.\n  /**\n   * Gets a list of all elements matching the given selector under this environment's root element.\n   */\n  protected async getAllRawElements(selector: string): Promise<(() => webdriver.WebElement)[]> {\n    const els = await this._options.queryFn(selector, this.rawRootElement);\n    return els.map((x: webdriver.WebElement) => () => x);\n  }\n}\n"]}