angular-cn/packages/zone.js/lib/zone-spec/fake-async-test.ts

/**
 * @license
 * Copyright Google Inc. 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
 */

(function(global: any) {
  interface ScheduledFunction {
    endTime: number;
    id: number;
    func: Function;
    args: any[];
    delay: number;
    isPeriodic: boolean;
    isRequestAnimationFrame: boolean;
  }

  interface MicroTaskScheduledFunction {
    func: Function;
    args?: any[];
    target: any;
  }

  interface MacroTaskOptions {
    source: string;
    isPeriodic?: boolean;
    callbackArgs?: any;
  }

  const OriginalDate = global.Date;
  class FakeDate {
    constructor() {
      if (arguments.length === 0) {
        const d = new OriginalDate();
        d.setTime(FakeDate.now());
        return d;
      } else {
        const args = Array.prototype.slice.call(arguments);
        return new OriginalDate(...args);
      }
    }

    static now() {
      const fakeAsyncTestZoneSpec = Zone.current.get('FakeAsyncTestZoneSpec');
      if (fakeAsyncTestZoneSpec) {
        return fakeAsyncTestZoneSpec.getCurrentRealTime() + fakeAsyncTestZoneSpec.getCurrentTime();
      }
      return OriginalDate.now.apply(this, arguments);
    }
  }

  (FakeDate as any).UTC = OriginalDate.UTC;
  (FakeDate as any).parse = OriginalDate.parse;

  // keep a reference for zone patched timer function
  const timers = {
    setTimeout: global.setTimeout,
    setInterval: global.setInterval,
    clearTimeout: global.clearTimeout,
    clearInterval: global.clearInterval
  };

  class Scheduler {
    // Next scheduler id.
    public static nextId: number = 1;

    // Scheduler queue with the tuple of end time and callback function - sorted by end time.
    private _schedulerQueue: ScheduledFunction[] = [];
    // Current simulated time in millis.
    private _currentTime: number = 0;
    // Current real time in millis.
    private _currentRealTime: number = OriginalDate.now();
    // track requeuePeriodicTimer
    private _currentTickRequeuePeriodicEntries: any[] = [];

    constructor() {}

    getCurrentTime() { return this._currentTime; }

    getCurrentRealTime() { return this._currentRealTime; }

    setCurrentRealTime(realTime: number) { this._currentRealTime = realTime; }

    scheduleFunction(cb: Function, delay: number, options?: {
      args?: any[],
      isPeriodic?: boolean,
      isRequestAnimationFrame?: boolean,
      id?: number,
      isRequeuePeriodic?: boolean
    }): number {
      options = {
        ...{
          args: [],
          isPeriodic: false,
          isRequestAnimationFrame: false,
          id: -1,
          isRequeuePeriodic: false
        },
        ...options
      };
      let currentId = options.id ! < 0 ? Scheduler.nextId++ : options.id !;
      let endTime = this._currentTime + delay;

      // Insert so that scheduler queue remains sorted by end time.
      let newEntry: ScheduledFunction = {
        endTime: endTime,
        id: currentId,
        func: cb,
        args: options.args !,
        delay: delay,
        isPeriodic: options.isPeriodic !,
        isRequestAnimationFrame: options.isRequestAnimationFrame !
      };
      if (options.isRequeuePeriodic !) {
        this._currentTickRequeuePeriodicEntries.push(newEntry);
      }
      let i = 0;
      for (; i < this._schedulerQueue.length; i++) {
        let currentEntry = this._schedulerQueue[i];
        if (newEntry.endTime < currentEntry.endTime) {
          break;
        }
      }
      this._schedulerQueue.splice(i, 0, newEntry);
      return currentId;
    }

    removeScheduledFunctionWithId(id: number): void {
      for (let i = 0; i < this._schedulerQueue.length; i++) {
        if (this._schedulerQueue[i].id == id) {
          this._schedulerQueue.splice(i, 1);
          break;
        }
      }
    }

    tick(millis: number = 0, doTick?: (elapsed: number) => void, tickOptions?: {
      processNewMacroTasksSynchronously: boolean
    }): void {
      let finalTime = this._currentTime + millis;
      let lastCurrentTime = 0;
      tickOptions = Object.assign({processNewMacroTasksSynchronously: true}, tickOptions);
      // we need to copy the schedulerQueue so nested timeout
      // will not be wrongly called in the current tick
      // https://github.com/angular/angular/issues/33799
      const schedulerQueue = tickOptions.processNewMacroTasksSynchronously ?
          this._schedulerQueue :
          this._schedulerQueue.slice();
      if (schedulerQueue.length === 0 && doTick) {
        doTick(millis);
        return;
      }
      while (schedulerQueue.length > 0) {
        // clear requeueEntries before each loop
        this._currentTickRequeuePeriodicEntries = [];
        let current = schedulerQueue[0];
        if (finalTime < current.endTime) {
          // Done processing the queue since it's sorted by endTime.
          break;
        } else {
          // Time to run scheduled function. Remove it from the head of queue.
          let current = schedulerQueue.shift() !;
          if (!tickOptions.processNewMacroTasksSynchronously) {
            const idx = this._schedulerQueue.indexOf(current);
            if (idx >= 0) {
              this._schedulerQueue.splice(idx, 1);
            }
          }
          lastCurrentTime = this._currentTime;
          this._currentTime = current.endTime;
          if (doTick) {
            doTick(this._currentTime - lastCurrentTime);
          }
          let retval = current.func.apply(
              global, current.isRequestAnimationFrame ? [this._currentTime] : current.args);
          if (!retval) {
            // Uncaught exception in the current scheduled function. Stop processing the queue.
            break;
          }

          // check is there any requeue periodic entry is added in
          // current loop, if there is, we need to add to current loop
          if (!tickOptions.processNewMacroTasksSynchronously) {
            this._currentTickRequeuePeriodicEntries.forEach(newEntry => {
              let i = 0;
              for (; i < schedulerQueue.length; i++) {
                const currentEntry = schedulerQueue[i];
                if (newEntry.endTime < currentEntry.endTime) {
                  break;
                }
              }
              schedulerQueue.splice(i, 0, newEntry);
            });
          }
        }
      }
      lastCurrentTime = this._currentTime;
      this._currentTime = finalTime;
      if (doTick) {
        doTick(this._currentTime - lastCurrentTime);
      }
    }

    flush(limit = 20, flushPeriodic = false, doTick?: (elapsed: number) => void): number {
      if (flushPeriodic) {
        return this.flushPeriodic(doTick);
      } else {
        return this.flushNonPeriodic(limit, doTick);
      }
    }

    private flushPeriodic(doTick?: (elapsed: number) => void): number {
      if (this._schedulerQueue.length === 0) {
        return 0;
      }
      // Find the last task currently queued in the scheduler queue and tick
      // till that time.
      const startTime = this._currentTime;
      const lastTask = this._schedulerQueue[this._schedulerQueue.length - 1];
      this.tick(lastTask.endTime - startTime, doTick);
      return this._currentTime - startTime;
    }

    private flushNonPeriodic(limit: number, doTick?: (elapsed: number) => void): number {
      const startTime = this._currentTime;
      let lastCurrentTime = 0;
      let count = 0;
      while (this._schedulerQueue.length > 0) {
        count++;
        if (count > limit) {
          throw new Error(
              'flush failed after reaching the limit of ' + limit +
              ' tasks. Does your code use a polling timeout?');
        }

        // flush only non-periodic timers.
        // If the only remaining tasks are periodic(or requestAnimationFrame), finish flushing.
        if (this._schedulerQueue.filter(task => !task.isPeriodic && !task.isRequestAnimationFrame)
                .length === 0) {
          break;
        }

        const current = this._schedulerQueue.shift() !;
        lastCurrentTime = this._currentTime;
        this._currentTime = current.endTime;
        if (doTick) {
          // Update any secondary schedulers like Jasmine mock Date.
          doTick(this._currentTime - lastCurrentTime);
        }
        const retval = current.func.apply(global, current.args);
        if (!retval) {
          // Uncaught exception in the current scheduled function. Stop processing the queue.
          break;
        }
      }
      return this._currentTime - startTime;
    }
  }

  class FakeAsyncTestZoneSpec implements ZoneSpec {
    static assertInZone(): void {
      if (Zone.current.get('FakeAsyncTestZoneSpec') == null) {
        throw new Error('The code should be running in the fakeAsync zone to call this function');
      }
    }

    private _scheduler: Scheduler = new Scheduler();
    private _microtasks: MicroTaskScheduledFunction[] = [];
    private _lastError: Error|null = null;
    private _uncaughtPromiseErrors: {rejection: any}[] =
        (Promise as any)[(Zone as any).__symbol__('uncaughtPromiseErrors')];

    pendingPeriodicTimers: number[] = [];
    pendingTimers: number[] = [];

    private patchDateLocked = false;

    constructor(
        namePrefix: string, private trackPendingRequestAnimationFrame = false,
        private macroTaskOptions?: MacroTaskOptions[]) {
      this.name = 'fakeAsyncTestZone for ' + namePrefix;
      // in case user can't access the construction of FakeAsyncTestSpec
      // user can also define macroTaskOptions by define a global variable.
      if (!this.macroTaskOptions) {
        this.macroTaskOptions = global[Zone.__symbol__('FakeAsyncTestMacroTask')];
      }
    }

    private _fnAndFlush(fn: Function, completers: {onSuccess?: Function, onError?: Function}):
        Function {
      return (...args: any[]): boolean => {
        fn.apply(global, args);

        if (this._lastError === null) {  // Success
          if (completers.onSuccess != null) {
            completers.onSuccess.apply(global);
          }
          // Flush microtasks only on success.
          this.flushMicrotasks();
        } else {  // Failure
          if (completers.onError != null) {
            completers.onError.apply(global);
          }
        }
        // Return true if there were no errors, false otherwise.
        return this._lastError === null;
      };
    }

    private static _removeTimer(timers: number[], id: number): void {
      let index = timers.indexOf(id);
      if (index > -1) {
        timers.splice(index, 1);
      }
    }

    private _dequeueTimer(id: number): Function {
      return () => { FakeAsyncTestZoneSpec._removeTimer(this.pendingTimers, id); };
    }

    private _requeuePeriodicTimer(fn: Function, interval: number, args: any[], id: number):
        Function {
      return () => {
        // Requeue the timer callback if it's not been canceled.
        if (this.pendingPeriodicTimers.indexOf(id) !== -1) {
          this._scheduler.scheduleFunction(
              fn, interval, {args, isPeriodic: true, id, isRequeuePeriodic: true});
        }
      };
    }

    private _dequeuePeriodicTimer(id: number): Function {
      return () => { FakeAsyncTestZoneSpec._removeTimer(this.pendingPeriodicTimers, id); };
    }

    private _setTimeout(fn: Function, delay: number, args: any[], isTimer = true): number {
      let removeTimerFn = this._dequeueTimer(Scheduler.nextId);
      // Queue the callback and dequeue the timer on success and error.
      let cb = this._fnAndFlush(fn, {onSuccess: removeTimerFn, onError: removeTimerFn});
      let id =
          this._scheduler.scheduleFunction(cb, delay, {args, isRequestAnimationFrame: !isTimer});
      if (isTimer) {
        this.pendingTimers.push(id);
      }
      return id;
    }

    private _clearTimeout(id: number): void {
      FakeAsyncTestZoneSpec._removeTimer(this.pendingTimers, id);
      this._scheduler.removeScheduledFunctionWithId(id);
    }

    private _setInterval(fn: Function, interval: number, args: any[]): number {
      let id = Scheduler.nextId;
      let completers = {onSuccess: null as any, onError: this._dequeuePeriodicTimer(id)};
      let cb = this._fnAndFlush(fn, completers);

      // Use the callback created above to requeue on success.
      completers.onSuccess = this._requeuePeriodicTimer(cb, interval, args, id);

      // Queue the callback and dequeue the periodic timer only on error.
      this._scheduler.scheduleFunction(cb, interval, {args, isPeriodic: true});
      this.pendingPeriodicTimers.push(id);
      return id;
    }

    private _clearInterval(id: number): void {
      FakeAsyncTestZoneSpec._removeTimer(this.pendingPeriodicTimers, id);
      this._scheduler.removeScheduledFunctionWithId(id);
    }

    private _resetLastErrorAndThrow(): void {
      let error = this._lastError || this._uncaughtPromiseErrors[0];
      this._uncaughtPromiseErrors.length = 0;
      this._lastError = null;
      throw error;
    }

    getCurrentTime() { return this._scheduler.getCurrentTime(); }

    getCurrentRealTime() { return this._scheduler.getCurrentRealTime(); }

    setCurrentRealTime(realTime: number) { this._scheduler.setCurrentRealTime(realTime); }

    static patchDate() {
      if (!!global[Zone.__symbol__('disableDatePatching')]) {
        // we don't want to patch global Date
        // because in some case, global Date
        // is already being patched, we need to provide
        // an option to let user still use their
        // own version of Date.
        return;
      }

      if (global['Date'] === FakeDate) {
        // already patched
        return;
      }
      global['Date'] = FakeDate;
      FakeDate.prototype = OriginalDate.prototype;

      // try check and reset timers
      // because jasmine.clock().install() may
      // have replaced the global timer
      FakeAsyncTestZoneSpec.checkTimerPatch();
    }

    static resetDate() {
      if (global['Date'] === FakeDate) {
        global['Date'] = OriginalDate;
      }
    }

    static checkTimerPatch() {
      if (global.setTimeout !== timers.setTimeout) {
        global.setTimeout = timers.setTimeout;
        global.clearTimeout = timers.clearTimeout;
      }
      if (global.setInterval !== timers.setInterval) {
        global.setInterval = timers.setInterval;
        global.clearInterval = timers.clearInterval;
      }
    }

    lockDatePatch() {
      this.patchDateLocked = true;
      FakeAsyncTestZoneSpec.patchDate();
    }
    unlockDatePatch() {
      this.patchDateLocked = false;
      FakeAsyncTestZoneSpec.resetDate();
    }

    tick(millis: number = 0, doTick?: (elapsed: number) => void, tickOptions: {
      processNewMacroTasksSynchronously: boolean
    } = {processNewMacroTasksSynchronously: true}): void {
      FakeAsyncTestZoneSpec.assertInZone();
      this.flushMicrotasks();
      this._scheduler.tick(millis, doTick, tickOptions);
      if (this._lastError !== null) {
        this._resetLastErrorAndThrow();
      }
    }

    flushMicrotasks(): void {
      FakeAsyncTestZoneSpec.assertInZone();
      const flushErrors = () => {
        if (this._lastError !== null || this._uncaughtPromiseErrors.length) {
          // If there is an error stop processing the microtask queue and rethrow the error.
          this._resetLastErrorAndThrow();
        }
      };
      while (this._microtasks.length > 0) {
        let microtask = this._microtasks.shift() !;
        microtask.func.apply(microtask.target, microtask.args);
      }
      flushErrors();
    }

    flush(limit?: number, flushPeriodic?: boolean, doTick?: (elapsed: number) => void): number {
      FakeAsyncTestZoneSpec.assertInZone();
      this.flushMicrotasks();
      const elapsed = this._scheduler.flush(limit, flushPeriodic, doTick);
      if (this._lastError !== null) {
        this._resetLastErrorAndThrow();
      }
      return elapsed;
    }

    // ZoneSpec implementation below.

    name: string;

    properties: {[key: string]: any} = {'FakeAsyncTestZoneSpec': this};

    onScheduleTask(delegate: ZoneDelegate, current: Zone, target: Zone, task: Task): Task {
      switch (task.type) {
        case 'microTask':
          let args = task.data && (task.data as any).args;
          // should pass additional arguments to callback if have any
          // currently we know process.nextTick will have such additional
          // arguments
          let additionalArgs: any[]|undefined;
          if (args) {
            let callbackIndex = (task.data as any).cbIdx;
            if (typeof args.length === 'number' && args.length > callbackIndex + 1) {
              additionalArgs = Array.prototype.slice.call(args, callbackIndex + 1);
            }
          }
          this._microtasks.push({
            func: task.invoke,
            args: additionalArgs,
            target: task.data && (task.data as any).target
          });
          break;
        case 'macroTask':
          switch (task.source) {
            case 'setTimeout':
              task.data !['handleId'] = this._setTimeout(
                  task.invoke, task.data !['delay'] !,
                  Array.prototype.slice.call((task.data as any)['args'], 2));
              break;
            case 'setImmediate':
              task.data !['handleId'] = this._setTimeout(
                  task.invoke, 0, Array.prototype.slice.call((task.data as any)['args'], 1));
              break;
            case 'setInterval':
              task.data !['handleId'] = this._setInterval(
                  task.invoke, task.data !['delay'] !,
                  Array.prototype.slice.call((task.data as any)['args'], 2));
              break;
            case 'XMLHttpRequest.send':
              throw new Error(
                  'Cannot make XHRs from within a fake async test. Request URL: ' +
                  (task.data as any)['url']);
            case 'requestAnimationFrame':
            case 'webkitRequestAnimationFrame':
            case 'mozRequestAnimationFrame':
              // Simulate a requestAnimationFrame by using a setTimeout with 16 ms.
              // (60 frames per second)
              task.data !['handleId'] = this._setTimeout(
                  task.invoke, 16, (task.data as any)['args'],
                  this.trackPendingRequestAnimationFrame);
              break;
            default:
              // user can define which macroTask they want to support by passing
              // macroTaskOptions
              const macroTaskOption = this.findMacroTaskOption(task);
              if (macroTaskOption) {
                const args = task.data && (task.data as any)['args'];
                const delay = args && args.length > 1 ? args[1] : 0;
                let callbackArgs =
                    macroTaskOption.callbackArgs ? macroTaskOption.callbackArgs : args;
                if (!!macroTaskOption.isPeriodic) {
                  // periodic macroTask, use setInterval to simulate
                  task.data !['handleId'] = this._setInterval(task.invoke, delay, callbackArgs);
                  task.data !.isPeriodic = true;
                } else {
                  // not periodic, use setTimeout to simulate
                  task.data !['handleId'] = this._setTimeout(task.invoke, delay, callbackArgs);
                }
                break;
              }
              throw new Error('Unknown macroTask scheduled in fake async test: ' + task.source);
          }
          break;
        case 'eventTask':
          task = delegate.scheduleTask(target, task);
          break;
      }
      return task;
    }

    onCancelTask(delegate: ZoneDelegate, current: Zone, target: Zone, task: Task): any {
      switch (task.source) {
        case 'setTimeout':
        case 'requestAnimationFrame':
        case 'webkitRequestAnimationFrame':
        case 'mozRequestAnimationFrame':
          return this._clearTimeout(<number>task.data !['handleId']);
        case 'setInterval':
          return this._clearInterval(<number>task.data !['handleId']);
        default:
          // user can define which macroTask they want to support by passing
          // macroTaskOptions
          const macroTaskOption = this.findMacroTaskOption(task);
          if (macroTaskOption) {
            const handleId: number = <number>task.data !['handleId'];
            return macroTaskOption.isPeriodic ? this._clearInterval(handleId) :
                                                this._clearTimeout(handleId);
          }
          return delegate.cancelTask(target, task);
      }
    }

    onInvoke(
        delegate: ZoneDelegate, current: Zone, target: Zone, callback: Function, applyThis: any,
        applyArgs?: any[], source?: string): any {
      try {
        FakeAsyncTestZoneSpec.patchDate();
        return delegate.invoke(target, callback, applyThis, applyArgs, source);
      } finally {
        if (!this.patchDateLocked) {
          FakeAsyncTestZoneSpec.resetDate();
        }
      }
    }

    findMacroTaskOption(task: Task) {
      if (!this.macroTaskOptions) {
        return null;
      }
      for (let i = 0; i < this.macroTaskOptions.length; i++) {
        const macroTaskOption = this.macroTaskOptions[i];
        if (macroTaskOption.source === task.source) {
          return macroTaskOption;
        }
      }
      return null;
    }

    onHandleError(
        parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone,
        error: any): boolean {
      this._lastError = error;
      return false;  // Don't propagate error to parent zone.
    }
  }

  // Export the class so that new instances can be created with proper
  // constructor params.
  (Zone as any)['FakeAsyncTestZoneSpec'] = FakeAsyncTestZoneSpec;
})(typeof window === 'object' && window || typeof self === 'object' && self || global);