@angular/core
Version:
Angular - the core framework
242 lines • 33 kB
JavaScript
/**
* @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 { ApplicationRef, getDebugNode, inject, NgZone, RendererFactory2, ɵdetectChangesInViewIfRequired, ɵEffectScheduler as EffectScheduler, ɵgetDeferBlocks as getDeferBlocks, ɵNoopNgZone as NoopNgZone, ɵPendingTasks as PendingTasks, } from '@angular/core';
import { Subscription } from 'rxjs';
import { first } from 'rxjs/operators';
import { DeferBlockFixture } from './defer';
import { ComponentFixtureAutoDetect, ComponentFixtureNoNgZone } from './test_bed_common';
/**
* Fixture for debugging and testing a component.
*
* @publicApi
*/
export class ComponentFixture {
/** @nodoc */
constructor(componentRef) {
this.componentRef = componentRef;
this._isDestroyed = false;
/** @internal */
this._noZoneOptionIsSet = inject(ComponentFixtureNoNgZone, { optional: true });
/** @internal */
this._ngZone = this._noZoneOptionIsSet ? new NoopNgZone() : inject(NgZone);
/** @internal */
this._effectRunner = inject(EffectScheduler);
// Inject ApplicationRef to ensure NgZone stableness causes after render hooks to run
// This will likely happen as a result of fixture.detectChanges because it calls ngZone.run
// This is a crazy way of doing things but hey, it's the world we live in.
// The zoneless scheduler should instead do this more imperatively by attaching
// the `ComponentRef` to `ApplicationRef` and calling `appRef.tick` as the `detectChanges`
// behavior.
/** @internal */
this._appRef = inject(ApplicationRef);
/** @internal */
this._testAppRef = this._appRef;
this.pendingTasks = inject(PendingTasks);
// TODO(atscott): Remove this from public API
this.ngZone = this._noZoneOptionIsSet ? null : this._ngZone;
this.changeDetectorRef = componentRef.changeDetectorRef;
this.elementRef = componentRef.location;
this.debugElement = getDebugNode(this.elementRef.nativeElement);
this.componentInstance = componentRef.instance;
this.nativeElement = this.elementRef.nativeElement;
this.componentRef = componentRef;
}
/**
* Do a change detection run to make sure there were no changes.
*/
checkNoChanges() {
this.changeDetectorRef.checkNoChanges();
}
/**
* Return whether the fixture is currently stable or has async tasks that have not been completed
* yet.
*/
isStable() {
return !this.pendingTasks.hasPendingTasks.value;
}
/**
* Get a promise that resolves when the fixture is stable.
*
* This can be used to resume testing after events have triggered asynchronous activity or
* asynchronous change detection.
*/
whenStable() {
if (this.isStable()) {
return Promise.resolve(false);
}
return this._appRef.isStable.pipe(first((stable) => stable)).toPromise();
}
/**
* Retrieves all defer block fixtures in the component fixture.
*/
getDeferBlocks() {
const deferBlocks = [];
const lView = this.componentRef.hostView['_lView'];
getDeferBlocks(lView, deferBlocks);
const deferBlockFixtures = [];
for (const block of deferBlocks) {
deferBlockFixtures.push(new DeferBlockFixture(block, this));
}
return Promise.resolve(deferBlockFixtures);
}
_getRenderer() {
if (this._renderer === undefined) {
this._renderer = this.componentRef.injector.get(RendererFactory2, null);
}
return this._renderer;
}
/**
* Get a promise that resolves when the ui state is stable following animations.
*/
whenRenderingDone() {
const renderer = this._getRenderer();
if (renderer && renderer.whenRenderingDone) {
return renderer.whenRenderingDone();
}
return this.whenStable();
}
/**
* Trigger component destruction.
*/
destroy() {
if (!this._isDestroyed) {
this.componentRef.destroy();
this._isDestroyed = true;
}
}
}
/**
* ComponentFixture behavior that actually attaches the component to the application to ensure
* behaviors between fixture and application do not diverge. `detectChanges` is disabled by default
* (instead, tests should wait for the scheduler to detect changes), `whenStable` is directly the
* `ApplicationRef.isStable`, and `autoDetectChanges` cannot be disabled.
*/
export class ScheduledComponentFixture extends ComponentFixture {
constructor() {
super(...arguments);
this._autoDetect = inject(ComponentFixtureAutoDetect, { optional: true }) ?? true;
}
initialize() {
if (this._autoDetect) {
this._appRef.attachView(this.componentRef.hostView);
}
}
detectChanges(checkNoChanges = true) {
if (!checkNoChanges) {
throw new Error('Cannot disable `checkNoChanges` in this configuration. ' +
'Use `fixture.componentRef.hostView.changeDetectorRef.detectChanges()` instead.');
}
this._effectRunner.flush();
this._appRef.tick();
this._effectRunner.flush();
}
autoDetectChanges(autoDetect = true) {
if (!autoDetect) {
throw new Error('Cannot disable autoDetect after it has been enabled when using the zoneless scheduler. ' +
'To disable autoDetect, add `{provide: ComponentFixtureAutoDetect, useValue: false}` to the TestBed providers.');
}
else if (!this._autoDetect) {
this._autoDetect = autoDetect;
this._appRef.attachView(this.componentRef.hostView);
}
this.detectChanges();
}
}
/**
* ComponentFixture behavior that attempts to act as a "mini application".
*/
export class PseudoApplicationComponentFixture extends ComponentFixture {
constructor() {
super(...arguments);
this._subscriptions = new Subscription();
this._autoDetect = inject(ComponentFixtureAutoDetect, { optional: true }) ?? false;
this.afterTickSubscription = undefined;
this.beforeRenderSubscription = undefined;
}
initialize() {
if (this._autoDetect) {
this.subscribeToAppRefEvents();
}
this.componentRef.hostView.onDestroy(() => {
this.unsubscribeFromAppRefEvents();
});
// Create subscriptions outside the NgZone so that the callbacks run outside
// of NgZone.
this._ngZone.runOutsideAngular(() => {
this._subscriptions.add(this._ngZone.onError.subscribe({
next: (error) => {
throw error;
},
}));
});
}
detectChanges(checkNoChanges = true) {
this._effectRunner.flush();
// Run the change detection inside the NgZone so that any async tasks as part of the change
// detection are captured by the zone and can be waited for in isStable.
this._ngZone.run(() => {
this.changeDetectorRef.detectChanges();
if (checkNoChanges) {
this.checkNoChanges();
}
});
// Run any effects that were created/dirtied during change detection. Such effects might become
// dirty in response to input signals changing.
this._effectRunner.flush();
}
autoDetectChanges(autoDetect = true) {
if (this._noZoneOptionIsSet) {
throw new Error('Cannot call autoDetectChanges when ComponentFixtureNoNgZone is set.');
}
if (autoDetect !== this._autoDetect) {
if (autoDetect) {
this.subscribeToAppRefEvents();
}
else {
this.unsubscribeFromAppRefEvents();
}
}
this._autoDetect = autoDetect;
this.detectChanges();
}
subscribeToAppRefEvents() {
this._ngZone.runOutsideAngular(() => {
this.afterTickSubscription = this._testAppRef.afterTick.subscribe(() => {
this.checkNoChanges();
});
this.beforeRenderSubscription = this._testAppRef.beforeRender.subscribe((isFirstPass) => {
try {
ɵdetectChangesInViewIfRequired(this.componentRef.hostView._lView, this.componentRef.hostView.notifyErrorHandler, isFirstPass, false /** zoneless enabled */);
}
catch (e) {
// If an error occurred during change detection, remove the test view from the application
// ref tracking. Note that this isn't exactly desirable but done this way because of how
// things used to work with `autoDetect` and uncaught errors. Ideally we would surface
// this error to the error handler instead and continue refreshing the view like
// what would happen in the application.
this.unsubscribeFromAppRefEvents();
throw e;
}
});
this._testAppRef.externalTestViews.add(this.componentRef.hostView);
});
}
unsubscribeFromAppRefEvents() {
this.afterTickSubscription?.unsubscribe();
this.beforeRenderSubscription?.unsubscribe();
this.afterTickSubscription = undefined;
this.beforeRenderSubscription = undefined;
this._testAppRef.externalTestViews.delete(this.componentRef.hostView);
}
destroy() {
this.unsubscribeFromAppRefEvents();
this._subscriptions.unsubscribe();
super.destroy();
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component_fixture.js","sourceRoot":"","sources":["../../../../../../../packages/core/testing/src/component_fixture.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  ApplicationRef,\n  ChangeDetectorRef,\n  ComponentRef,\n  DebugElement,\n  ElementRef,\n  getDebugNode,\n  inject,\n  NgZone,\n  RendererFactory2,\n  ViewRef,\n  ɵDeferBlockDetails as DeferBlockDetails,\n  ɵdetectChangesInViewIfRequired,\n  ɵEffectScheduler as EffectScheduler,\n  ɵgetDeferBlocks as getDeferBlocks,\n  ɵNoopNgZone as NoopNgZone,\n  ɵPendingTasks as PendingTasks,\n} from '@angular/core';\nimport {Subject, Subscription} from 'rxjs';\nimport {first} from 'rxjs/operators';\n\nimport {DeferBlockFixture} from './defer';\nimport {ComponentFixtureAutoDetect, ComponentFixtureNoNgZone} from './test_bed_common';\n\n/**\n * Fixture for debugging and testing a component.\n *\n * @publicApi\n */\nexport abstract class ComponentFixture<T> {\n  /**\n   * The DebugElement associated with the root element of this component.\n   */\n  debugElement: DebugElement;\n\n  /**\n   * The instance of the root component class.\n   */\n  componentInstance: T;\n\n  /**\n   * The native element at the root of the component.\n   */\n  nativeElement: any;\n\n  /**\n   * The ElementRef for the element at the root of the component.\n   */\n  elementRef: ElementRef;\n\n  /**\n   * The ChangeDetectorRef for the component\n   */\n  changeDetectorRef: ChangeDetectorRef;\n\n  private _renderer: RendererFactory2 | null | undefined;\n  private _isDestroyed: boolean = false;\n  /** @internal */\n  protected readonly _noZoneOptionIsSet = inject(ComponentFixtureNoNgZone, {optional: true});\n  /** @internal */\n  protected _ngZone: NgZone = this._noZoneOptionIsSet ? new NoopNgZone() : inject(NgZone);\n  /** @internal */\n  protected _effectRunner = inject(EffectScheduler);\n  // Inject ApplicationRef to ensure NgZone stableness causes after render hooks to run\n  // This will likely happen as a result of fixture.detectChanges because it calls ngZone.run\n  // This is a crazy way of doing things but hey, it's the world we live in.\n  // The zoneless scheduler should instead do this more imperatively by attaching\n  // the `ComponentRef` to `ApplicationRef` and calling `appRef.tick` as the `detectChanges`\n  // behavior.\n  /** @internal */\n  protected readonly _appRef = inject(ApplicationRef);\n  /** @internal */\n  protected readonly _testAppRef = this._appRef as unknown as TestAppRef;\n  private readonly pendingTasks = inject(PendingTasks);\n\n  // TODO(atscott): Remove this from public API\n  ngZone = this._noZoneOptionIsSet ? null : this._ngZone;\n\n  /** @nodoc */\n  constructor(public componentRef: ComponentRef<T>) {\n    this.changeDetectorRef = componentRef.changeDetectorRef;\n    this.elementRef = componentRef.location;\n    this.debugElement = <DebugElement>getDebugNode(this.elementRef.nativeElement);\n    this.componentInstance = componentRef.instance;\n    this.nativeElement = this.elementRef.nativeElement;\n    this.componentRef = componentRef;\n  }\n\n  /**\n   * Trigger a change detection cycle for the component.\n   */\n  abstract detectChanges(checkNoChanges?: boolean): void;\n\n  /**\n   * Do a change detection run to make sure there were no changes.\n   */\n  checkNoChanges(): void {\n    this.changeDetectorRef.checkNoChanges();\n  }\n\n  /**\n   * Set whether the fixture should autodetect changes.\n   *\n   * Also runs detectChanges once so that any existing change is detected.\n   */\n  abstract autoDetectChanges(autoDetect?: boolean): void;\n\n  /**\n   * Return whether the fixture is currently stable or has async tasks that have not been completed\n   * yet.\n   */\n  isStable(): boolean {\n    return !this.pendingTasks.hasPendingTasks.value;\n  }\n\n  /**\n   * Get a promise that resolves when the fixture is stable.\n   *\n   * This can be used to resume testing after events have triggered asynchronous activity or\n   * asynchronous change detection.\n   */\n  whenStable(): Promise<any> {\n    if (this.isStable()) {\n      return Promise.resolve(false);\n    }\n    return this._appRef.isStable.pipe(first((stable) => stable)).toPromise();\n  }\n\n  /**\n   * Retrieves all defer block fixtures in the component fixture.\n   */\n  getDeferBlocks(): Promise<DeferBlockFixture[]> {\n    const deferBlocks: DeferBlockDetails[] = [];\n    const lView = (this.componentRef.hostView as any)['_lView'];\n    getDeferBlocks(lView, deferBlocks);\n\n    const deferBlockFixtures = [];\n    for (const block of deferBlocks) {\n      deferBlockFixtures.push(new DeferBlockFixture(block, this));\n    }\n\n    return Promise.resolve(deferBlockFixtures);\n  }\n\n  private _getRenderer() {\n    if (this._renderer === undefined) {\n      this._renderer = this.componentRef.injector.get(RendererFactory2, null);\n    }\n    return this._renderer as RendererFactory2 | null;\n  }\n\n  /**\n   * Get a promise that resolves when the ui state is stable following animations.\n   */\n  whenRenderingDone(): Promise<any> {\n    const renderer = this._getRenderer();\n    if (renderer && renderer.whenRenderingDone) {\n      return renderer.whenRenderingDone();\n    }\n    return this.whenStable();\n  }\n\n  /**\n   * Trigger component destruction.\n   */\n  destroy(): void {\n    if (!this._isDestroyed) {\n      this.componentRef.destroy();\n      this._isDestroyed = true;\n    }\n  }\n}\n\n/**\n * ComponentFixture behavior that actually attaches the component to the application to ensure\n * behaviors between fixture and application do not diverge. `detectChanges` is disabled by default\n * (instead, tests should wait for the scheduler to detect changes), `whenStable` is directly the\n * `ApplicationRef.isStable`, and `autoDetectChanges` cannot be disabled.\n */\nexport class ScheduledComponentFixture<T> extends ComponentFixture<T> {\n  private _autoDetect = inject(ComponentFixtureAutoDetect, {optional: true}) ?? true;\n\n  initialize(): void {\n    if (this._autoDetect) {\n      this._appRef.attachView(this.componentRef.hostView);\n    }\n  }\n\n  override detectChanges(checkNoChanges = true): void {\n    if (!checkNoChanges) {\n      throw new Error(\n        'Cannot disable `checkNoChanges` in this configuration. ' +\n          'Use `fixture.componentRef.hostView.changeDetectorRef.detectChanges()` instead.',\n      );\n    }\n    this._effectRunner.flush();\n    this._appRef.tick();\n    this._effectRunner.flush();\n  }\n\n  override autoDetectChanges(autoDetect = true): void {\n    if (!autoDetect) {\n      throw new Error(\n        'Cannot disable autoDetect after it has been enabled when using the zoneless scheduler. ' +\n          'To disable autoDetect, add `{provide: ComponentFixtureAutoDetect, useValue: false}` to the TestBed providers.',\n      );\n    } else if (!this._autoDetect) {\n      this._autoDetect = autoDetect;\n      this._appRef.attachView(this.componentRef.hostView);\n    }\n    this.detectChanges();\n  }\n}\n\ninterface TestAppRef {\n  externalTestViews: Set<ViewRef>;\n  beforeRender: Subject<boolean>;\n  afterTick: Subject<void>;\n}\n\n/**\n * ComponentFixture behavior that attempts to act as a \"mini application\".\n */\nexport class PseudoApplicationComponentFixture<T> extends ComponentFixture<T> {\n  private _subscriptions = new Subscription();\n  private _autoDetect = inject(ComponentFixtureAutoDetect, {optional: true}) ?? false;\n  private afterTickSubscription: Subscription | undefined = undefined;\n  private beforeRenderSubscription: Subscription | undefined = undefined;\n\n  initialize(): void {\n    if (this._autoDetect) {\n      this.subscribeToAppRefEvents();\n    }\n    this.componentRef.hostView.onDestroy(() => {\n      this.unsubscribeFromAppRefEvents();\n    });\n    // Create subscriptions outside the NgZone so that the callbacks run outside\n    // of NgZone.\n    this._ngZone.runOutsideAngular(() => {\n      this._subscriptions.add(\n        this._ngZone.onError.subscribe({\n          next: (error: any) => {\n            throw error;\n          },\n        }),\n      );\n    });\n  }\n\n  override detectChanges(checkNoChanges = true): void {\n    this._effectRunner.flush();\n    // Run the change detection inside the NgZone so that any async tasks as part of the change\n    // detection are captured by the zone and can be waited for in isStable.\n    this._ngZone.run(() => {\n      this.changeDetectorRef.detectChanges();\n      if (checkNoChanges) {\n        this.checkNoChanges();\n      }\n    });\n    // Run any effects that were created/dirtied during change detection. Such effects might become\n    // dirty in response to input signals changing.\n    this._effectRunner.flush();\n  }\n\n  override autoDetectChanges(autoDetect = true): void {\n    if (this._noZoneOptionIsSet) {\n      throw new Error('Cannot call autoDetectChanges when ComponentFixtureNoNgZone is set.');\n    }\n\n    if (autoDetect !== this._autoDetect) {\n      if (autoDetect) {\n        this.subscribeToAppRefEvents();\n      } else {\n        this.unsubscribeFromAppRefEvents();\n      }\n    }\n\n    this._autoDetect = autoDetect;\n    this.detectChanges();\n  }\n\n  private subscribeToAppRefEvents() {\n    this._ngZone.runOutsideAngular(() => {\n      this.afterTickSubscription = this._testAppRef.afterTick.subscribe(() => {\n        this.checkNoChanges();\n      });\n      this.beforeRenderSubscription = this._testAppRef.beforeRender.subscribe((isFirstPass) => {\n        try {\n          ɵdetectChangesInViewIfRequired(\n            (this.componentRef.hostView as any)._lView,\n            (this.componentRef.hostView as any).notifyErrorHandler,\n            isFirstPass,\n            false /** zoneless enabled */,\n          );\n        } catch (e: unknown) {\n          // If an error occurred during change detection, remove the test view from the application\n          // ref tracking. Note that this isn't exactly desirable but done this way because of how\n          // things used to work with `autoDetect` and uncaught errors. Ideally we would surface\n          // this error to the error handler instead and continue refreshing the view like\n          // what would happen in the application.\n          this.unsubscribeFromAppRefEvents();\n\n          throw e;\n        }\n      });\n      this._testAppRef.externalTestViews.add(this.componentRef.hostView);\n    });\n  }\n\n  private unsubscribeFromAppRefEvents() {\n    this.afterTickSubscription?.unsubscribe();\n    this.beforeRenderSubscription?.unsubscribe();\n    this.afterTickSubscription = undefined;\n    this.beforeRenderSubscription = undefined;\n    this._testAppRef.externalTestViews.delete(this.componentRef.hostView);\n  }\n\n  override destroy(): void {\n    this.unsubscribeFromAppRefEvents();\n    this._subscriptions.unsubscribe();\n    super.destroy();\n  }\n}\n"]}