Class Testability

packages/core/src/testability/testability.ts:94–284

 */
@Injectable()
export class Testability implements PublicTestability {
  private _isZoneStable: boolean = true;
  private _callbacks: WaitCallback[] = [];

  private _taskTrackingZone: {macroTasks: Task[]} | null = null;

  private _destroyRef?: DestroyRef;

  private readonly pendingTasksInternal = inject(PendingTasksInternal);
  private readonly _usePendingTasks = inject(USE_PENDING_TASKS);
  constructor(
    private _ngZone: NgZone,
    private registry: TestabilityRegistry,
    @Inject(TESTABILITY_GETTER) testabilityGetter: GetTestability,
  ) {
    // Attempt to retrieve a `DestroyRef` optionally.
    // For backwards compatibility reasons, this cannot be required.
    if (isInInjectionContext()) {
      this._destroyRef = inject(DestroyRef, {optional: true}) ?? undefined;
    }

    // If there was no Testability logic registered in the global scope
    // before, register the current testability getter as a global one.
    if (!_testabilityGetter) {
      setTestabilityGetter(testabilityGetter);
      testabilityGetter.addToWindow(registry);
    }
    this._watchAngularEvents();
    _ngZone.run(() => {
      this._taskTrackingZone =
        typeof Zone == 'undefined' ? null : Zone.current.get('TaskTrackingZone');
    });
  }

  private _watchAngularEvents(): void {
    const onUnstableSubscription = this._ngZone.onUnstable.subscribe({
      next: () => {
        this._isZoneStable = false;
      },
    });

    let pendingTasksSubscription: any;
    let onStableSubscription: any;

    this._ngZone.runOutsideAngular(() => {
      if (this._usePendingTasks) {
        pendingTasksSubscription = this.pendingTasksInternal.hasPendingTasksObservable.subscribe(
          () => {
            if (this.isStable()) {
              this._ngZone.runOutsideAngular(() => {
                this._runCallbacksIfReady();
              });
            }
          },
        );
      }

      onStableSubscription = this._ngZone.onStable.subscribe({