/**
 * @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 { handleAutoChangeDetectionStatus, HarnessEnvironment, stopHandlingAutoChangeDetectionStatus, } from '@angular/cdk/testing';
import { flush } from '@angular/core/testing';
import { takeWhile } from 'rxjs/operators';
import { TaskStateZoneInterceptor } from './task-state-zone-interceptor';
import { UnitTestElement } from './unit-test-element';
/** The default environment options. */
const defaultEnvironmentOptions = {
    queryFn: (selector, root) => root.querySelectorAll(selector),
};
/** Whether auto change detection is currently disabled. */
let disableAutoChangeDetection = false;
/**
 * The set of non-destroyed fixtures currently being used by `TestbedHarnessEnvironment` instances.
 */
const activeFixtures = new Set();
/**
 * Installs a handler for change detection batching status changes for a specific fixture.
 * @param fixture The fixture to handle change detection batching for.
 */
function installAutoChangeDetectionStatusHandler(fixture) {
    if (!activeFixtures.size) {
        handleAutoChangeDetectionStatus(({ isDisabled, onDetectChangesNow }) => {
            disableAutoChangeDetection = isDisabled;
            if (onDetectChangesNow) {
                Promise.all(Array.from(activeFixtures).map(detectChanges)).then(onDetectChangesNow);
            }
        });
    }
    activeFixtures.add(fixture);
}
/**
 * Uninstalls a handler for change detection batching status changes for a specific fixture.
 * @param fixture The fixture to stop handling change detection batching for.
 */
function uninstallAutoChangeDetectionStatusHandler(fixture) {
    activeFixtures.delete(fixture);
    if (!activeFixtures.size) {
        stopHandlingAutoChangeDetectionStatus();
    }
}
/** Whether we are currently in the fake async zone. */
function isInFakeAsyncZone() {
    return Zone.current.get('FakeAsyncTestZoneSpec') != null;
}
/**
 * Triggers change detection for a specific fixture.
 * @param fixture The fixture to trigger change detection for.
 */
async function detectChanges(fixture) {
    fixture.detectChanges();
    if (isInFakeAsyncZone()) {
        flush();
    }
    else {
        await fixture.whenStable();
    }
}
/** A `HarnessEnvironment` implementation for Angular's Testbed. */
export class TestbedHarnessEnvironment extends HarnessEnvironment {
    constructor(rawRootElement, _fixture, options) {
        super(rawRootElement);
        this._fixture = _fixture;
        /** Whether the environment has been destroyed. */
        this._destroyed = false;
        this._options = { ...defaultEnvironmentOptions, ...options };
        this._taskState = TaskStateZoneInterceptor.setup();
        this._stabilizeCallback = () => this.forceStabilize();
        installAutoChangeDetectionStatusHandler(_fixture);
        _fixture.componentRef.onDestroy(() => {
            uninstallAutoChangeDetectionStatusHandler(_fixture);
            this._destroyed = true;
        });
    }
    /** Creates a `HarnessLoader` rooted at the given fixture's root element. */
    static loader(fixture, options) {
        return new TestbedHarnessEnvironment(fixture.nativeElement, fixture, options);
    }
    /**
     * Creates a `HarnessLoader` at the document root. This can be used if harnesses are
     * located outside of a fixture (e.g. overlays appended to the document body).
     */
    static documentRootLoader(fixture, options) {
        return new TestbedHarnessEnvironment(document.body, fixture, options);
    }
    /** Gets the native DOM element corresponding to the given TestElement. */
    static getNativeElement(el) {
        if (el instanceof UnitTestElement) {
            return el.element;
        }
        throw Error('This TestElement was not created by the TestbedHarnessEnvironment');
    }
    /**
     * Creates an instance of the given harness type, using the fixture's root element as the
     * harness's host element. This method should be used when creating a harness for the root element
     * of a fixture, as components do not have the correct selector when they are created as the root
     * of the fixture.
     */
    static async harnessForFixture(fixture, harnessType, options) {
        const environment = new TestbedHarnessEnvironment(fixture.nativeElement, fixture, options);
        await environment.forceStabilize();
        return environment.createComponentHarness(harnessType, fixture.nativeElement);
    }
    /**
     * 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() {
        if (!disableAutoChangeDetection) {
            if (this._destroyed) {
                throw Error('Harness is attempting to use a fixture that has already been destroyed.');
            }
            await detectChanges(this._fixture);
        }
    }
    /**
     * Waits for all scheduled or running async tasks to complete. This allows harness
     * authors to wait for async tasks outside of the Angular zone.
     */
    async waitForTasksOutsideAngular() {
        // If we run in the fake async zone, we run "flush" to run any scheduled tasks. This
        // ensures that the harnesses behave inside of the FakeAsyncTestZone similar to the
        // "AsyncTestZone" and the root zone (i.e. neither fakeAsync or async). Note that we
        // cannot just rely on the task state observable to become stable because the state will
        // never change. This is because the task queue will be only drained if the fake async
        // zone is being flushed.
        if (isInFakeAsyncZone()) {
            flush();
        }
        // Wait until the task queue has been drained and the zone is stable. Note that
        // we cannot rely on "fixture.whenStable" since it does not catch tasks scheduled
        // outside of the Angular zone. For test harnesses, we want to ensure that the
        // app is fully stabilized and therefore need to use our own zone interceptor.
        await this._taskState.pipe(takeWhile(state => !state.stable)).toPromise();
    }
    /** Gets the root element for the document. */
    getDocumentRoot() {
        return document.body;
    }
    /** Creates a `TestElement` from a raw element. */
    createTestElement(element) {
        return new UnitTestElement(element, this._stabilizeCallback);
    }
    /** Creates a `HarnessLoader` rooted at the given raw element. */
    createEnvironment(element) {
        return new TestbedHarnessEnvironment(element, this._fixture, this._options);
    }
    /**
     * Gets a list of all elements matching the given selector under this environment's root element.
     */
    async getAllRawElements(selector) {
        await this.forceStabilize();
        return Array.from(this._options.queryFn(selector, this.rawRootElement));
    }
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"testbed-harness-environment.js","sourceRoot":"","sources":["../../../../../../../src/cdk/testing/testbed/testbed-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 {\n  ComponentHarness,\n  ComponentHarnessConstructor,\n  handleAutoChangeDetectionStatus,\n  HarnessEnvironment,\n  HarnessLoader,\n  stopHandlingAutoChangeDetectionStatus,\n  TestElement,\n} from '@angular/cdk/testing';\nimport {ComponentFixture, flush} from '@angular/core/testing';\nimport {Observable} from 'rxjs';\nimport {takeWhile} from 'rxjs/operators';\nimport {TaskState, TaskStateZoneInterceptor} from './task-state-zone-interceptor';\nimport {UnitTestElement} from './unit-test-element';\n\n/** Options to configure the environment. */\nexport interface TestbedHarnessEnvironmentOptions {\n  /** The query function used to find DOM elements. */\n  queryFn: (selector: string, root: Element) => Iterable<Element> | ArrayLike<Element>;\n}\n\n/** The default environment options. */\nconst defaultEnvironmentOptions: TestbedHarnessEnvironmentOptions = {\n  queryFn: (selector: string, root: Element) => root.querySelectorAll(selector),\n};\n\n/** Whether auto change detection is currently disabled. */\nlet disableAutoChangeDetection = false;\n\n/**\n * The set of non-destroyed fixtures currently being used by `TestbedHarnessEnvironment` instances.\n */\nconst activeFixtures = new Set<ComponentFixture<unknown>>();\n\n/**\n * Installs a handler for change detection batching status changes for a specific fixture.\n * @param fixture The fixture to handle change detection batching for.\n */\nfunction installAutoChangeDetectionStatusHandler(fixture: ComponentFixture<unknown>) {\n  if (!activeFixtures.size) {\n    handleAutoChangeDetectionStatus(({isDisabled, onDetectChangesNow}) => {\n      disableAutoChangeDetection = isDisabled;\n      if (onDetectChangesNow) {\n        Promise.all(Array.from(activeFixtures).map(detectChanges)).then(onDetectChangesNow);\n      }\n    });\n  }\n  activeFixtures.add(fixture);\n}\n\n/**\n * Uninstalls a handler for change detection batching status changes for a specific fixture.\n * @param fixture The fixture to stop handling change detection batching for.\n */\nfunction uninstallAutoChangeDetectionStatusHandler(fixture: ComponentFixture<unknown>) {\n  activeFixtures.delete(fixture);\n  if (!activeFixtures.size) {\n    stopHandlingAutoChangeDetectionStatus();\n  }\n}\n\n/** Whether we are currently in the fake async zone. */\nfunction isInFakeAsyncZone() {\n  return Zone!.current.get('FakeAsyncTestZoneSpec') != null;\n}\n\n/**\n * Triggers change detection for a specific fixture.\n * @param fixture The fixture to trigger change detection for.\n */\nasync function detectChanges(fixture: ComponentFixture<unknown>) {\n  fixture.detectChanges();\n  if (isInFakeAsyncZone()) {\n    flush();\n  } else {\n    await fixture.whenStable();\n  }\n}\n\n/** A `HarnessEnvironment` implementation for Angular's Testbed. */\nexport class TestbedHarnessEnvironment extends HarnessEnvironment<Element> {\n  /** Whether the environment has been destroyed. */\n  private _destroyed = false;\n\n  /** Observable that emits whenever the test task state changes. */\n  private _taskState: Observable<TaskState>;\n\n  /** The options for this environment. */\n  private _options: TestbedHarnessEnvironmentOptions;\n\n  /** Environment stabilization callback passed to the created test elements. */\n  private _stabilizeCallback: () => Promise<void>;\n\n  protected constructor(\n    rawRootElement: Element,\n    private _fixture: ComponentFixture<unknown>,\n    options?: TestbedHarnessEnvironmentOptions,\n  ) {\n    super(rawRootElement);\n    this._options = {...defaultEnvironmentOptions, ...options};\n    this._taskState = TaskStateZoneInterceptor.setup();\n    this._stabilizeCallback = () => this.forceStabilize();\n    installAutoChangeDetectionStatusHandler(_fixture);\n    _fixture.componentRef.onDestroy(() => {\n      uninstallAutoChangeDetectionStatusHandler(_fixture);\n      this._destroyed = true;\n    });\n  }\n\n  /** Creates a `HarnessLoader` rooted at the given fixture's root element. */\n  static loader(\n    fixture: ComponentFixture<unknown>,\n    options?: TestbedHarnessEnvironmentOptions,\n  ): HarnessLoader {\n    return new TestbedHarnessEnvironment(fixture.nativeElement, fixture, options);\n  }\n\n  /**\n   * Creates a `HarnessLoader` at the document root. This can be used if harnesses are\n   * located outside of a fixture (e.g. overlays appended to the document body).\n   */\n  static documentRootLoader(\n    fixture: ComponentFixture<unknown>,\n    options?: TestbedHarnessEnvironmentOptions,\n  ): HarnessLoader {\n    return new TestbedHarnessEnvironment(document.body, fixture, options);\n  }\n\n  /** Gets the native DOM element corresponding to the given TestElement. */\n  static getNativeElement(el: TestElement): Element {\n    if (el instanceof UnitTestElement) {\n      return el.element;\n    }\n    throw Error('This TestElement was not created by the TestbedHarnessEnvironment');\n  }\n\n  /**\n   * Creates an instance of the given harness type, using the fixture's root element as the\n   * harness's host element. This method should be used when creating a harness for the root element\n   * of a fixture, as components do not have the correct selector when they are created as the root\n   * of the fixture.\n   */\n  static async harnessForFixture<T extends ComponentHarness>(\n    fixture: ComponentFixture<unknown>,\n    harnessType: ComponentHarnessConstructor<T>,\n    options?: TestbedHarnessEnvironmentOptions,\n  ): Promise<T> {\n    const environment = new TestbedHarnessEnvironment(fixture.nativeElement, fixture, options);\n    await environment.forceStabilize();\n    return environment.createComponentHarness(harnessType, fixture.nativeElement);\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    if (!disableAutoChangeDetection) {\n      if (this._destroyed) {\n        throw Error('Harness is attempting to use a fixture that has already been destroyed.');\n      }\n\n      await detectChanges(this._fixture);\n    }\n  }\n\n  /**\n   * Waits for all scheduled or running async tasks to complete. This allows harness\n   * authors to wait for async tasks outside of the Angular zone.\n   */\n  async waitForTasksOutsideAngular(): Promise<void> {\n    // If we run in the fake async zone, we run \"flush\" to run any scheduled tasks. This\n    // ensures that the harnesses behave inside of the FakeAsyncTestZone similar to the\n    // \"AsyncTestZone\" and the root zone (i.e. neither fakeAsync or async). Note that we\n    // cannot just rely on the task state observable to become stable because the state will\n    // never change. This is because the task queue will be only drained if the fake async\n    // zone is being flushed.\n    if (isInFakeAsyncZone()) {\n      flush();\n    }\n\n    // Wait until the task queue has been drained and the zone is stable. Note that\n    // we cannot rely on \"fixture.whenStable\" since it does not catch tasks scheduled\n    // outside of the Angular zone. For test harnesses, we want to ensure that the\n    // app is fully stabilized and therefore need to use our own zone interceptor.\n    await this._taskState.pipe(takeWhile(state => !state.stable)).toPromise();\n  }\n\n  /** Gets the root element for the document. */\n  protected getDocumentRoot(): Element {\n    return document.body;\n  }\n\n  /** Creates a `TestElement` from a raw element. */\n  protected createTestElement(element: Element): TestElement {\n    return new UnitTestElement(element, this._stabilizeCallback);\n  }\n\n  /** Creates a `HarnessLoader` rooted at the given raw element. */\n  protected createEnvironment(element: Element): HarnessEnvironment<Element> {\n    return new TestbedHarnessEnvironment(element, this._fixture, this._options);\n  }\n\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<Element[]> {\n    await this.forceStabilize();\n    return Array.from(this._options.queryFn(selector, this.rawRootElement));\n  }\n}\n"]}