source: trip-planner-front/node_modules/@angular/cdk/esm2015/testing/selenium-webdriver/selenium-web-driver-harness-environment.js

/**
 * @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 { 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: (selector, root) => __awaiter(void 0, void 0, void 0, function* () { return 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 function waitForAngularReady(wd) {
    return __awaiter(this, void 0, void 0, function* () {
        yield wd.wait(() => wd.executeScript(isBootstrapped));
        yield wd.executeAsyncScript(whenStable);
    });
}
/** A `HarnessEnvironment` implementation for WebDriver. */
export class SeleniumWebDriverHarnessEnvironment extends HarnessEnvironment {
    constructor(rawRootElement, options) {
        super(rawRootElement);
        this._options = Object.assign(Object.assign({}, defaultEnvironmentOptions), options);
    }
    /** 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.
     */
    forceStabilize() {
        return __awaiter(this, void 0, void 0, function* () {
            yield this.rawRootElement().getDriver().executeAsyncScript(whenStable);
        });
    }
    /** @docs-private */
    waitForTasksOutsideAngular() {
        return __awaiter(this, void 0, void 0, function* () {
            // 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.forceStabilize());
    }
    /** 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.
     */
    getAllRawElements(selector) {
        return __awaiter(this, void 0, void 0, function* () {
            const els = yield 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/master/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)))\n      .then(callback);\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\n    HarnessEnvironment<() => webdriver.WebElement> {\n  /** The options for this environment. */\n  private _options: WebDriverHarnessEnvironmentOptions;\n\n  protected constructor(\n      rawRootElement: () => webdriver.WebElement, options?: WebDriverHarnessEnvironmentOptions) {\n    super(rawRootElement);\n    this._options = {...defaultEnvironmentOptions, ...options};\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(driver: webdriver.WebDriver, options?: WebDriverHarnessEnvironmentOptions):\n      HarnessLoader {\n    return new SeleniumWebDriverHarnessEnvironment(\n        () => driver.findElement(webdriver.By.css('body')), options);\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.forceStabilize());\n  }\n\n  /** Creates a `HarnessLoader` rooted at the given raw element. */\n  protected createEnvironment(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"]}