task.spec.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
 */

const noop = function() {};
let log = [];
const detectTask = Zone.current.scheduleMacroTask('detectTask', noop, null, noop, noop);
const originalTransitionTo = detectTask.constructor.prototype._transitionTo;
// patch _transitionTo of ZoneTask to add log for test
detectTask.constructor.prototype._transitionTo = function(
    toState: TaskState, fromState1: TaskState, fromState2?: TaskState) {
  log.push({
    zone: Zone.current.name,
    taskZone: this.zone && this.zone.name,
    toState: toState,
    fromState: this._state
  });
  originalTransitionTo.apply(this, arguments);
};

describe('task lifecycle', () => {
  afterAll(() => {
    detectTask.constructor.prototype._transitionTo = originalTransitionTo;
  });

  describe('event task lifecycle', () => {
    beforeEach(() => {
      log = [];
    });

    it('task should transit from notScheduled to scheduling then to scheduled state when scheduleTask',
       () => {
         Zone.current.fork({name: 'testEventTaskZone'}).run(() => {
           Zone.current.scheduleEventTask('testEventTask', noop, null, noop, noop);
         });
         expect(log.map(item => {
           return {toState: item.toState, fromState: item.fromState};
         }))
             .toEqual([
               {toState: 'scheduling', fromState: 'notScheduled'},
               {toState: 'scheduled', fromState: 'scheduling'}
             ]);
       });

    it('task should not transit from scheduling to scheduled when zoneSpec onScheduleTask callback throw error',
       () => {
         Zone.current
             .fork({
               name: 'testEventTaskZone',
               onScheduleTask: (delegate, currZone, targetZone, task) => {
                 throw Error('error in onScheduleTask');
               }
             })
             .run(() => {
               try {
                 Zone.current.scheduleEventTask('testEventTask', noop, null, noop, noop);
               } catch (err) {
               }
             });
         expect(log.map(item => {
           return {toState: item.toState, fromState: item.fromState};
         })).toEqual([{toState: 'scheduling', fromState: 'notScheduled'}]);
       });

    it('task should transit from scheduled to running when task is invoked then from running to scheduled after invoke',
       () => {
         Zone.current.fork({name: 'testEventTaskZone'}).run(() => {
           const task = Zone.current.scheduleEventTask('testEventTask', noop, null, noop, noop);
           task.invoke();
         });
         expect(log.map(item => {
           return {toState: item.toState, fromState: item.fromState};
         }))
             .toEqual([
               {toState: 'scheduling', fromState: 'notScheduled'},
               {toState: 'scheduled', fromState: 'scheduling'},
               {toState: 'running', fromState: 'scheduled'},
               {toState: 'scheduled', fromState: 'running'}
             ]);
       });

    it('task should transit from scheduled to canceling then from canceling to notScheduled when task is canceled before running',
       () => {
         Zone.current.fork({name: 'testEventTaskZone'}).run(() => {
           const task = Zone.current.scheduleEventTask('testEventTask', noop, null, noop, noop);
           Zone.current.cancelTask(task);
         });
         expect(log.map(item => {
           return {toState: item.toState, fromState: item.fromState};
         }))
             .toEqual([
               {toState: 'scheduling', fromState: 'notScheduled'},
               {toState: 'scheduled', fromState: 'scheduling'},
               {toState: 'canceling', fromState: 'scheduled'},
               {toState: 'notScheduled', fromState: 'canceling'}
             ]);
       });

    it('task should transit from running to canceling then from canceling to notScheduled when task is canceled in running state',
       () => {
         Zone.current.fork({name: 'testEventTaskZone'}).run(() => {
           const task = Zone.current.scheduleEventTask('testEventTask', () => {
             Zone.current.cancelTask(task);
           }, null, noop, noop);
           task.invoke();
         });
         // TODO: @JiaLiPassion, this case will fail because of #642
         // remove splice after #642 is merged
         expect(log.map(item => {
                     return {toState: item.toState, fromState: item.fromState};
                   })
                    .splice(0, 5))
             .toEqual([
               {toState: 'scheduling', fromState: 'notScheduled'},
               {toState: 'scheduled', fromState: 'scheduling'},
               {toState: 'running', fromState: 'scheduled'},
               {toState: 'canceling', fromState: 'running'},
               {toState: 'notScheduled', fromState: 'canceling'}
             ]);
       });

    it('task should transit from running to scheduled when task.callback throw error', () => {
      Zone.current.fork({name: 'testEventTaskZone'}).run(() => {
        const task = Zone.current.scheduleEventTask('testEventTask', () => {
          throw Error('invoke error');
        }, null, noop, noop);
        try {
          task.invoke();
        } catch (err) {
        }
      });
      expect(log.map(item => {
        return {toState: item.toState, fromState: item.fromState};
      }))
          .toEqual([
            {toState: 'scheduling', fromState: 'notScheduled'},
            {toState: 'scheduled', fromState: 'scheduling'},
            {toState: 'running', fromState: 'scheduled'},
            {toState: 'scheduled', fromState: 'running'}
          ]);
    });

    // TODO: @JiaLiPassion, what is the correct behavior?
    it('task should transit from canceling to ? when zoneSpec.onCancelTask throw error before task running',
       () => {
         Zone.current.fork({name: 'testEventTaskZone'}).run(() => {
           const task = Zone.current.scheduleEventTask('testEventTask', noop, null, noop, () => {
             throw Error('cancel task');
           });
           try {
             Zone.current.cancelTask(task);
           } catch (err) {
           }
         });
         expect(log.map(item => {
           return {toState: item.toState, fromState: item.fromState};
         }))
             .toEqual([
               {toState: 'scheduling', fromState: 'notScheduled'},
               {toState: 'scheduled', fromState: 'scheduling'},
               {toState: 'canceling', fromState: 'scheduled'}
             ]);
       });

    // TODO: @JiaLiPassion, what is the correct behavior?
    it('task should transit from canceling to ? when zoneSpec.onCancelTask throw error in running state',
       () => {
         Zone.current.fork({name: 'testEventTaskZone'}).run(() => {
           const task = Zone.current.scheduleEventTask('testEventTask', noop, null, noop, () => {
             throw Error('cancel task');
           });
           try {
             Zone.current.cancelTask(task);
           } catch (err) {
           }
         });
         expect(log.map(item => {
           return {toState: item.toState, fromState: item.fromState};
         }))
             .toEqual([
               {toState: 'scheduling', fromState: 'notScheduled'},
               {toState: 'scheduled', fromState: 'scheduling'},
               {toState: 'canceling', fromState: 'scheduled'}
             ]);
       });

    // TODO: @JiaLiPassion, what is the correct behavior?
    it('task should transit from notScheduled to scheduled if zoneSpec.onHasTask throw error when scheduleTask',
       () => {
         Zone.current
             .fork({
               name: 'testEventTaskZone',
               onHasTask: (delegate, currZone, targetZone, hasTaskState) => {
                 throw Error('hasTask Error');
               }
             })
             .run(() => {
               try {
                 Zone.current.scheduleEventTask('testEventTask', noop, null, noop, noop);
               } catch (err) {
               }
             });
         expect(log.map(item => {
           return {toState: item.toState, fromState: item.fromState};
         })).toEqual([{toState: 'scheduling', fromState: 'notScheduled'}]);
       });

    // TODO: @JiaLiPassion, what is the correct behavior?
    it('task should still in canceling state if zoneSpec.onHasTask throw error when task is canceled',
       () => {
         let task;
         Zone.current
             .fork({
               name: 'testEventTaskZone',
               onHasTask: (delegate, currZone, targetZone, hasTaskState) => {
                 if (task && task._state === 'canceling') {
                   throw Error('hasTask Error');
                 }
               }
             })
             .run(() => {
               try {
                 task = Zone.current.scheduleEventTask('testEventTask', noop, null, noop, noop);
                 Zone.current.cancelTask(task);
               } catch (err) {
               }
             });
         expect(log.map(item => {
           return {toState: item.toState, fromState: item.fromState};
         }))
             .toEqual([
               {toState: 'scheduling', fromState: 'notScheduled'},
               {toState: 'scheduled', fromState: 'scheduling'},
               {toState: 'canceling', fromState: 'scheduled'}
             ]);
       });
  });

  describe('non periodical macroTask lifecycle', () => {
    beforeEach(() => {
      log = [];
    });

    it('task should transit from notScheduled to scheduling then to scheduled state when scheduleTask',
       () => {
         Zone.current.fork({name: 'testMacroTaskZone'}).run(() => {
           Zone.current.scheduleMacroTask('testMacroTask', noop, null, noop, noop);
         });
         expect(log.map(item => {
           return {toState: item.toState, fromState: item.fromState};
         }))
             .toEqual([
               {toState: 'scheduling', fromState: 'notScheduled'},
               {toState: 'scheduled', fromState: 'scheduling'}
             ]);
       });

    it('task should not transit from scheduling to scheduled when zoneSpec onScheduleTask callback throw error',
       () => {
         Zone.current
             .fork({
               name: 'testMacroTaskZone',
               onScheduleTask: (delegate, currZone, targetZone, task) => {
                 throw Error('error in onScheduleTask');
               }
             })
             .run(() => {
               try {
                 Zone.current.scheduleMacroTask('testMacroTask', noop, null, noop, noop);
               } catch (err) {
               }
             });
         expect(log.map(item => {
           return {toState: item.toState, fromState: item.fromState};
         })).toEqual([{toState: 'scheduling', fromState: 'notScheduled'}]);
       });

    it('task should transit from scheduled to running when task is invoked then from running to noScheduled after invoke',
       () => {
         Zone.current.fork({name: 'testMacroTaskZone'}).run(() => {
           const task = Zone.current.scheduleMacroTask('testMacroTask', noop, null, noop, noop);
           task.invoke();
         });
         expect(log.map(item => {
           return {toState: item.toState, fromState: item.fromState};
         }))
             .toEqual([
               {toState: 'scheduling', fromState: 'notScheduled'},
               {toState: 'scheduled', fromState: 'scheduling'},
               {toState: 'running', fromState: 'scheduled'},
               {toState: 'notScheduled', fromState: 'running'}
             ]);
       });

    // TODO: @JiaLiPassion, this case will fail because #642, after #642 is merged, this will be ok
    it('task should transit from scheduled to canceling then from canceling to notScheduled when task is canceled before running',
       () => {
         Zone.current.fork({name: 'testMacroTaskZone'}).run(() => {
           const task = Zone.current.scheduleMacroTask('testMacrotask', noop, null, noop, noop);
           Zone.current.cancelTask(task);
         });
         expect(log.map(item => {
           return {toState: item.toState, fromState: item.fromState};
         }))
             .toEqual([
               {toState: 'scheduling', fromState: 'notScheduled'},
               {toState: 'scheduled', fromState: 'scheduling'},
               {toState: 'canceling', fromState: 'scheduled'},
               {toState: 'notScheduled', fromState: 'canceling'}
             ]);
       });

    // TODO @JiaLiPassion, for non periodical macroTask, should we allow the task be canceled after
    // running?
    it('task should transit from running to canceling then from canceling to notScheduled when task is canceled in running state',
       () => {
         Zone.current.fork({name: 'testMacroTaskZone'}).run(() => {
           const task = Zone.current.scheduleMacroTask('testMacroTask', () => {
             Zone.current.cancelTask(task);
           }, null, noop, noop);
           // TODO: @JiaLiPassion, this case will fail because of #642
           // remove comment after #642 is merged
           // task.invoke();
         });
         // TODO: @JiaLiPassion, this case will fail because of #642
         // remove comment after #642 is merged
         /*expect(log.map(item => {
           return {
             toState: item.toState,
             fromState: item.fromState
           };
         }).splice(0, 5)).toEqual([
           {toState: 'scheduling', fromState: 'notScheduled'},
           {toState: 'scheduled', fromState: 'scheduling'},
           {toState: 'running', fromState: 'scheduled'},
           {toState: 'canceling', fromState: 'running'},
           {toState: 'notScheduled', fromState: 'canceling'}
         ]);*/
       });

    it('task should transit from running to noScheduled when task.callback throw error', () => {
      Zone.current.fork({name: 'testMacroTaskZone'}).run(() => {
        const task = Zone.current.scheduleMacroTask('testMacroTask', () => {
          throw Error('invoke error');
        }, null, noop, noop);
        try {
          task.invoke();
        } catch (err) {
        }
      });
      expect(log.map(item => {
        return {toState: item.toState, fromState: item.fromState};
      }))
          .toEqual([
            {toState: 'scheduling', fromState: 'notScheduled'},
            {toState: 'scheduled', fromState: 'scheduling'},
            {toState: 'running', fromState: 'scheduled'},
            {toState: 'notScheduled', fromState: 'running'}
          ]);
    });

    // TODO: @JiaLiPassion, what is the correct behavior?
    it('task should transit from canceling to ? when zoneSpec.onCancelTask throw error before task running',
       () => {
         Zone.current.fork({name: 'testMacroTaskZone'}).run(() => {
           const task = Zone.current.scheduleMacroTask('testMacroTask', noop, null, noop, () => {
             throw Error('cancel task');
           });
           try {
             Zone.current.cancelTask(task);
           } catch (err) {
           }
         });
         expect(log.map(item => {
           return {toState: item.toState, fromState: item.fromState};
         }))
             .toEqual([
               {toState: 'scheduling', fromState: 'notScheduled'},
               {toState: 'scheduled', fromState: 'scheduling'},
               {toState: 'canceling', fromState: 'scheduled'}
             ]);
       });

    // TODO: @JiaLiPassion, what is the correct behavior?
    it('task should transit from canceling to ? when zoneSpec.onCancelTask throw error in running state',
       () => {
         Zone.current.fork({name: 'testMacroTaskZone'}).run(() => {
           const task = Zone.current.scheduleMacroTask('testMacroTask', noop, null, noop, () => {
             throw Error('cancel task');
           });
           try {
             Zone.current.cancelTask(task);
           } catch (err) {
           }
         });
         expect(log.map(item => {
           return {toState: item.toState, fromState: item.fromState};
         }))
             .toEqual([
               {toState: 'scheduling', fromState: 'notScheduled'},
               {toState: 'scheduled', fromState: 'scheduling'},
               {toState: 'canceling', fromState: 'scheduled'}
             ]);
       });

    // TODO: @JiaLiPassion, what is the correct behavior?
    it('task should only transit from notScheduled to scheduling if zoneSpec.onHasTask throw error when scheduleTask',
       () => {
         Zone.current
             .fork({
               name: 'testMacroTaskZone',
               onHasTask: (delegate, currZone, targetZone, hasTaskState) => {
                 throw Error('hasTask Error');
               }
             })
             .run(() => {
               try {
                 Zone.current.scheduleMacroTask('testMacroTask', noop, null, noop, noop);
               } catch (err) {
               }
             });
         expect(log.map(item => {
           return {toState: item.toState, fromState: item.fromState};
         })).toEqual([{toState: 'scheduling', fromState: 'notScheduled'}]);
       });

    // TODO: @JiaLiPassion, what is the correct behavior?
    it('task should still in running state if zoneSpec.onHasTask throw error after task.callback being invoked',
       () => {
         let task;
         Zone.current
             .fork({
               name: 'testMacroTaskZone',
               onHasTask: (delegate, currZone, targetZone, hasTaskState) => {
                 if (task && task._state === 'running') {
                   throw Error('hasTask Error');
                 }
               }
             })
             .run(() => {
               try {
                 task = Zone.current.scheduleMacroTask('testMacroTask', noop, null, noop, noop);
                 task.invoke();
               } catch (err) {
               }
             });
         expect(log.map(item => {
           return {toState: item.toState, fromState: item.fromState};
         }))
             .toEqual([
               {toState: 'scheduling', fromState: 'notScheduled'},
               {toState: 'scheduled', fromState: 'scheduling'},
               {toState: 'running', fromState: 'scheduled'}
             ]);
       });

    // TODO: @JiaLiPassion, what is the correct behavior?
    it('task should still in canceling state if zoneSpec.onHasTask throw error when task is canceled before running',
       () => {
         let task;
         Zone.current
             .fork({
               name: 'testMacroTaskZone',
               onHasTask: (delegate, currZone, targetZone, hasTaskState) => {
                 if (task && task._state === 'canceling') {
                   throw Error('hasTask Error');
                 }
               }
             })
             .run(() => {
               try {
                 task = Zone.current.scheduleMacroTask('testMacroTask', noop, null, noop, noop);
                 Zone.current.cancelTask(task);
               } catch (err) {
               }
             });
         expect(log.map(item => {
           return {toState: item.toState, fromState: item.fromState};
         }))
             .toEqual([
               {toState: 'scheduling', fromState: 'notScheduled'},
               {toState: 'scheduled', fromState: 'scheduling'},
               {toState: 'canceling', fromState: 'scheduled'}
             ]);
       });
  });

  describe('periodical macroTask lifecycle', () => {
    let task;
    beforeEach(() => {
      log = [];
      task = null;
    });
    afterEach(() => {
      task && task._state !== 'notScheduled' && task._state !== 'canceling' &&
          task.zone.cancelTask(task);
    });

    it('task should transit from notScheduled to scheduling then to scheduled state when scheduleTask',
       () => {
         Zone.current.fork({name: 'testPeriodicalTaskZone'}).run(() => {
           task = Zone.current.scheduleMacroTask(
               'testPeriodicalTask', noop, {isPeriodic: true}, noop, noop);
         });
         expect(log.map(item => {
           return {toState: item.toState, fromState: item.fromState};
         }))
             .toEqual([
               {toState: 'scheduling', fromState: 'notScheduled'},
               {toState: 'scheduled', fromState: 'scheduling'}
             ]);
       });

    it('task should not transit from scheduling to scheduled when zoneSpec onScheduleTask callback throw error',
       () => {
         Zone.current
             .fork({
               name: 'testPeriodicalTaskZone',
               onScheduleTask: (delegate, currZone, targetZone, task) => {
                 throw Error('error in onScheduleTask');
               }
             })
             .run(() => {
               try {
                 task = Zone.current.scheduleMacroTask(
                     'testPeriodicalTask', noop, {isPeriodic: true}, noop, noop);
               } catch (err) {
               }
             });
         expect(log.map(item => {
           return {toState: item.toState, fromState: item.fromState};
         })).toEqual([{toState: 'scheduling', fromState: 'notScheduled'}]);
       });

    it('task should transit from scheduled to running when task is invoked then from running to scheduled after invoke',
       () => {
         Zone.current.fork({name: 'testPeriodicalTaskZone'}).run(() => {
           task = Zone.current.scheduleMacroTask(
               'testPeriodicalTask', noop, {isPeriodic: true}, noop, noop);
           task.invoke();
         });
         expect(log.map(item => {
           return {toState: item.toState, fromState: item.fromState};
         }))
             .toEqual([
               {toState: 'scheduling', fromState: 'notScheduled'},
               {toState: 'scheduled', fromState: 'scheduling'},
               {toState: 'running', fromState: 'scheduled'},
               {toState: 'scheduled', fromState: 'running'}
             ]);
       });

    it('task should transit from scheduled to canceling then from canceling to notScheduled when task is canceled before running',
       () => {
         Zone.current.fork({name: 'testPeriodicalTaskZone'}).run(() => {
           task = Zone.current.scheduleMacroTask(
               'testPeriodicalTask', noop, {isPeriodic: true}, noop, noop);
           Zone.current.cancelTask(task);
         });
         expect(log.map(item => {
           return {toState: item.toState, fromState: item.fromState};
         }))
             .toEqual([
               {toState: 'scheduling', fromState: 'notScheduled'},
               {toState: 'scheduled', fromState: 'scheduling'},
               {toState: 'canceling', fromState: 'scheduled'},
               {toState: 'notScheduled', fromState: 'canceling'}
             ]);
       });

    it('task should transit from running to canceling then from canceling to notScheduled when task is canceled in running state',
       () => {
         Zone.current.fork({name: 'testPeriodicalTaskZone'}).run(() => {
           task = Zone.current.scheduleMacroTask('testPeriodicalTask', () => {
             Zone.current.cancelTask(task);
           }, {isPeriodic: true}, noop, noop);
           // TODO: @JiaLiPassion, this case will fail because of #642
           // remove comment after #642 is merged
           // task.invoke();
         });
         // TODO: @JiaLiPassion, this case will fail because of #642
         // remove comment after #642 is merged
         /*expect(log.map(item => {
           return {
             toState: item.toState,
             fromState: item.fromState
           };
         }).splice(0, 5)).toEqual([
           {toState: 'scheduling', fromState: 'notScheduled'},
           {toState: 'scheduled', fromState: 'scheduling'},
           {toState: 'running', fromState: 'scheduled'},
           {toState: 'canceling', fromState: 'running'},
           {toState: 'notScheduled', fromState: 'canceling'}
         ]);*/
       });

    it('task should transit from running to scheduled when task.callback throw error', () => {
      Zone.current.fork({name: 'testPeriodicalTaskZone'}).run(() => {
        task = Zone.current.scheduleMacroTask('testPeriodicalTask', () => {
          throw Error('invoke error');
        }, {isPeriodic: true}, noop, noop);
        try {
          task.invoke();
        } catch (err) {
        }
      });
      expect(log.map(item => {
        return {toState: item.toState, fromState: item.fromState};
      }))
          .toEqual([
            {toState: 'scheduling', fromState: 'notScheduled'},
            {toState: 'scheduled', fromState: 'scheduling'},
            {toState: 'running', fromState: 'scheduled'},
            {toState: 'scheduled', fromState: 'running'}
          ]);
    });

    // TODO: @JiaLiPassion, what is the correct behavior?
    it('task should transit from canceling to ? when zoneSpec.onCancelTask throw error before task running',
       () => {
         Zone.current.fork({name: 'testPeriodicalTaskZone'}).run(() => {
           task = Zone.current.scheduleMacroTask(
               'testPeriodicalTask', noop, {isPeriodic: true}, noop, () => {
                 throw Error('cancel task');
               });
           try {
             Zone.current.cancelTask(task);
           } catch (err) {
           }
         });
         expect(log.map(item => {
           return {toState: item.toState, fromState: item.fromState};
         }))
             .toEqual([
               {toState: 'scheduling', fromState: 'notScheduled'},
               {toState: 'scheduled', fromState: 'scheduling'},
               {toState: 'canceling', fromState: 'scheduled'}
             ]);
       });

    // TODO: @JiaLiPassion, what is the correct behavior?
    it('task should transit from canceling to ? when zoneSpec.onCancelTask throw error in running state',
       () => {
         Zone.current.fork({name: 'testPeriodicalTaskZone'}).run(() => {
           task = Zone.current.scheduleMacroTask(
               'testPeriodicalTask', noop, {isPeriodic: true}, noop, () => {
                 throw Error('cancel task');
               });
           try {
             Zone.current.cancelTask(task);
           } catch (err) {
           }
         });
         expect(log.map(item => {
           return {toState: item.toState, fromState: item.fromState};
         }))
             .toEqual([
               {toState: 'scheduling', fromState: 'notScheduled'},
               {toState: 'scheduled', fromState: 'scheduling'},
               {toState: 'canceling', fromState: 'scheduled'}
             ]);
       });

    // TODO: @JiaLiPassion, what is the correct behavior?
    it('task should transit from notScheduled to scheduled if zoneSpec.onHasTask throw error when scheduleTask',
       () => {
         Zone.current
             .fork({
               name: 'testPeriodicalTaskZone',
               onHasTask: (delegate, currZone, targetZone, hasTaskState) => {
                 throw Error('hasTask Error');
               }
             })
             .run(() => {
               try {
                 task = Zone.current.scheduleMacroTask(
                     'testPeriodicalTask', noop, {isPeriodic: true}, noop, noop);
               } catch (err) {
               }
             });
         expect(log.map(item => {
           return {toState: item.toState, fromState: item.fromState};
         })).toEqual([{toState: 'scheduling', fromState: 'notScheduled'}]);
       });

    // TODO: @JiaLiPassion, what is the correct behavior?
    it('task should still in canceling state if zoneSpec.onHasTask throw error when task is canceled',
       () => {
         Zone.current
             .fork({
               name: 'testPeriodicalTaskZone',
               onHasTask: (delegate, currZone, targetZone, hasTaskState) => {
                 if (task && task._state === 'canceling') {
                   throw Error('hasTask Error');
                 }
               }
             })
             .run(() => {
               try {
                 task = Zone.current.scheduleMacroTask(
                     'testPeriodicalTask', noop, {isPeriodic: true}, noop, noop);
                 Zone.current.cancelTask(task);
               } catch (err) {
               }
             });
         expect(log.map(item => {
           return {toState: item.toState, fromState: item.fromState};
         }))
             .toEqual([
               {toState: 'scheduling', fromState: 'notScheduled'},
               {toState: 'scheduled', fromState: 'scheduling'},
               {toState: 'canceling', fromState: 'scheduled'}
             ]);
       });
  });

  describe('microTask lifecycle', () => {
    beforeEach(() => {
      log = [];
    });

    it('task should transit from notScheduled to scheduling then to scheduled state when scheduleTask',
       () => {
         Zone.current.fork({name: 'testMicroTaskZone'}).run(() => {
           Zone.current.scheduleMicroTask('testMicroTask', noop, null, noop);
         });
         expect(log.map(item => {
           return {toState: item.toState, fromState: item.fromState};
         }))
             .toEqual([
               {toState: 'scheduling', fromState: 'notScheduled'},
               {toState: 'scheduled', fromState: 'scheduling'}
             ]);
       });

    it('task should not transit from scheduling to scheduled when zoneSpec onScheduleTask callback throw error',
       () => {
         Zone.current
             .fork({
               name: 'testMicroTaskZone',
               onScheduleTask: (delegate, currZone, targetZone, task) => {
                 throw Error('error in onScheduleTask');
               }
             })
             .run(() => {
               try {
                 Zone.current.scheduleMicroTask('testMicroTask', noop, null, noop);
               } catch (err) {
               }
             });
         expect(log.map(item => {
           return {toState: item.toState, fromState: item.fromState};
         })).toEqual([{toState: 'scheduling', fromState: 'notScheduled'}]);
       });

    it('task should transit from scheduled to running when task is invoked then from running to noScheduled after invoke',
       () => {
         Zone.current.fork({name: 'testMicroTaskZone'}).run(() => {
           const task = Zone.current.scheduleMicroTask('testMicroTask', noop, null, noop);
           task.invoke();
         });
         expect(log.map(item => {
           return {toState: item.toState, fromState: item.fromState};
         }))
             .toEqual([
               {toState: 'scheduling', fromState: 'notScheduled'},
               {toState: 'scheduled', fromState: 'scheduling'},
               {toState: 'running', fromState: 'scheduled'},
               {toState: 'notScheduled', fromState: 'running'}
             ]);
       });

    // TODO @JiaLiPassion, should we support cancel a microTask
    // should we check task.cancelFn is null or not in zone.ts#1022
    it('should throw error when try to cancel a microTask', () => {
      Zone.current.fork({name: 'testMicroTaskZone'}).run(() => {
        const task = Zone.current.scheduleMicroTask('testMacroTask', () => {}, null, noop);
        expect(() => {
          Zone.current.cancelTask(task);
          // TODO @JiaLiPassion, add expected error here
        }).toThrow();
      });
    });

    it('task should transit from running to notScheduled when task.callback throw error', () => {
      Zone.current.fork({name: 'testMicroTaskZone'}).run(() => {
        const task = Zone.current.scheduleMicroTask('testMicroTask', () => {
          throw Error('invoke error');
        }, null, noop);
        try {
          task.invoke();
        } catch (err) {
        }
      });
      expect(log.map(item => {
        return {toState: item.toState, fromState: item.fromState};
      }))
          .toEqual([
            {toState: 'scheduling', fromState: 'notScheduled'},
            {toState: 'scheduled', fromState: 'scheduling'},
            {toState: 'running', fromState: 'scheduled'},
            {toState: 'notScheduled', fromState: 'running'}
          ]);
    });

    // TODO: @JiaLiPassion, what is the correct behavior?
    it('task should only transit from notScheduled to scheduling if zoneSpec.onHasTask throw error when scheduleTask',
       () => {
         Zone.current
             .fork({
               name: 'testMicroTaskZone',
               onHasTask: (delegate, currZone, targetZone, hasTaskState) => {
                 throw Error('hasTask Error');
               }
             })
             .run(() => {
               try {
                 Zone.current.scheduleMicroTask('testMicroTask', noop, null, noop);
               } catch (err) {
               }
             });
         expect(log.map(item => {
           return {toState: item.toState, fromState: item.fromState};
         })).toEqual([{toState: 'scheduling', fromState: 'notScheduled'}]);
       });

    // TODO: @JiaLiPassion, what is the correct behavior?
    it('task should still in running state if zoneSpec.onHasTask throw error after task.callback being invoked',
       () => {
         let task;
         Zone.current
             .fork({
               name: 'testMicroTaskZone',
               onHasTask: (delegate, currZone, targetZone, hasTaskState) => {
                 if (task && task._state === 'running') {
                   throw Error('hasTask Error');
                 }
               }
             })
             .run(() => {
               try {
                 task = Zone.current.scheduleMicroTask('testMicroTask', noop, null, noop);
                 task.invoke();
               } catch (err) {
               }
             });
         expect(log.map(item => {
           return {toState: item.toState, fromState: item.fromState};
         }))
             .toEqual([
               {toState: 'scheduling', fromState: 'notScheduled'},
               {toState: 'scheduled', fromState: 'scheduling'},
               {toState: 'running', fromState: 'scheduled'}
             ]);
       });


  });

  describe('override zone', () => {
    let callbackLogs;
    const newZone = Zone.root.fork({
      name: 'new',
      onScheduleTask: (delegate, currZone, targetZone, task) => {
        callbackLogs.push(
            {pos: 'before', method: 'onScheduleTask', zone: currZone.name, task: task.zone.name});
        return delegate.scheduleTask(targetZone, task);
      },
      onInvokeTask: (delegate, currZone, targetZone, task, applyThis, applyArgs) => {
        callbackLogs.push(
            {pos: 'before', method: 'onInvokeTask', zone: currZone.name, task: task.zone.name});
        return delegate.invokeTask(targetZone, task, applyThis, applyArgs);
      },
      onCancelTask: (delegate, currZone, targetZone, task) => {
        callbackLogs.push(
            {pos: 'before', method: 'onCancelTask', zone: currZone.name, task: task.zone.name});
        return delegate.cancelTask(targetZone, task);
      },
      onHasTask: (delegate, currZone, targetZone, hasTaskState) => {
        hasTaskState['zone'] = targetZone.name;
        callbackLogs.push(hasTaskState);
        return delegate.hasTask(targetZone, hasTaskState);
      }
    });
    const zone = Zone.root.fork({
      name: 'original',
      onScheduleTask: (delegate, currZone, targetZone, task) => {
        callbackLogs.push(
            {pos: 'before', method: 'onScheduleTask', zone: currZone.name, task: task.zone.name});
        task.zone = newZone;
        const t = delegate.scheduleTask(targetZone, task);
        callbackLogs.push(
            {pos: 'after', method: 'onScheduleTask', zone: currZone.name, task: task.zone.name});
        return t;
      },
      onInvokeTask: (delegate, currZone, targetZone, task, applyThis, applyArgs) => {
        callbackLogs.push(
            {pos: 'before', method: 'onInvokeTask', zone: currZone.name, task: task.zone.name});
        return delegate.invokeTask(targetZone, task, applyThis, applyArgs);
      },
      onCancelTask: (delegate, currZone, targetZone, task) => {
        callbackLogs.push(
            {pos: 'before', method: 'onCancelTask', zone: currZone.name, task: task.zone.name});
        return delegate.cancelTask(targetZone, task);
      },
      onHasTask: (delegate, currZone, targetZone, hasTaskState) => {
        hasTaskState['zone'] = targetZone.name;
        callbackLogs.push(hasTaskState);
        return delegate.hasTask(targetZone, hasTaskState);
      }
    });

    beforeEach(() => {
      callbackLogs = [];
    });

    it('should be able to override zone when in scheduling state, after overriding, onInvokeTask should run on override zone, hasTask run on original zone',
       () => {
         zone.run(() => {
           const t = Zone.current.scheduleMacroTask('testOverrideZoneTask', noop, null, noop, noop);
           t.invoke();
         });

         expect(callbackLogs).toEqual([
           {pos: 'before', method: 'onScheduleTask', zone: 'original', task: 'original'},
           {pos: 'after', method: 'onScheduleTask', zone: 'original', task: 'new'}, {
             microTask: false,
             macroTask: true,
             eventTask: false,
             change: 'macroTask',
             zone: 'original'
           },
           {pos: 'before', method: 'onInvokeTask', zone: 'new', task: 'new'}, {
             microTask: false,
             macroTask: false,
             eventTask: false,
             change: 'macroTask',
             zone: 'original'
           }
         ]);
       });

    it('should be able to override zone when in scheduling state, after overriding, onCancelTask should run on override zone, hasTask run on original zone',
       () => {
         zone.run(() => {
           const t = Zone.current.scheduleMacroTask('testOverrideZoneTask', noop, null, noop, noop);
           t.zone.cancelTask(t);
         });

         expect(callbackLogs).toEqual([
           {pos: 'before', method: 'onScheduleTask', zone: 'original', task: 'original'},
           {pos: 'after', method: 'onScheduleTask', zone: 'original', task: 'new'}, {
             microTask: false,
             macroTask: true,
             eventTask: false,
             change: 'macroTask',
             zone: 'original'
           },
           {pos: 'before', method: 'onCancelTask', zone: 'new', task: 'new'}, {
             microTask: false,
             macroTask: false,
             eventTask: false,
             change: 'macroTask',
             zone: 'original'
           }
         ]);
       });

    it('can we override zone when state in running/canceling/notScheduled state',
       () => {
           // TODO: add cases after the requirement confirmed.
       });
  });

  describe('reschedule zone', () => {
    let callbackLogs;
    const newZone = Zone.root.fork({
      name: 'new',
      onScheduleTask: (delegate, currZone, targetZone, task) => {
        callbackLogs.push(
            {pos: 'before', method: 'onScheduleTask', zone: currZone.name, task: task.zone.name});
        return delegate.scheduleTask(targetZone, task);
      },
      onInvokeTask: (delegate, currZone, targetZone, task, applyThis, applyArgs) => {
        callbackLogs.push(
            {pos: 'before', method: 'onInvokeTask', zone: currZone.name, task: task.zone.name});
        return delegate.invokeTask(targetZone, task, applyThis, applyArgs);
      },
      onCancelTask: (delegate, currZone, targetZone, task) => {
        callbackLogs.push(
            {pos: 'before', method: 'onCancelTask', zone: currZone.name, task: task.zone.name});
        return delegate.cancelTask(targetZone, task);
      },
      onHasTask: (delegate, currZone, targetZone, hasTaskState) => {
        hasTaskState['zone'] = targetZone.name;
        callbackLogs.push(hasTaskState);
        return delegate.hasTask(targetZone, hasTaskState);
      }
    });
    const zone = Zone.root.fork({
      name: 'original',
      onScheduleTask: (delegate, currZone, targetZone, task) => {
        callbackLogs.push(
            {pos: 'before', method: 'onScheduleTask', zone: currZone.name, task: task.zone.name});
        task.cancelScheduleRequest();
        task = newZone.scheduleTask(task);
        callbackLogs.push(
            {pos: 'after', method: 'onScheduleTask', zone: currZone.name, task: task.zone.name});
        return task;
      },
      onInvokeTask: (delegate, currZone, targetZone, task, applyThis, applyArgs) => {
        callbackLogs.push(
            {pos: 'before', method: 'onInvokeTask', zone: currZone.name, task: task.zone.name});
        return delegate.invokeTask(targetZone, task, applyThis, applyArgs);
      },
      onCancelTask: (delegate, currZone, targetZone, task) => {
        callbackLogs.push(
            {pos: 'before', method: 'onCancelTask', zone: currZone.name, task: task.zone.name});
        return delegate.cancelTask(targetZone, task);
      },
      onHasTask: (delegate, currZone, targetZone, hasTaskState) => {
        hasTaskState['zone'] = targetZone.name;
        callbackLogs.push(hasTaskState);
        return delegate.hasTask(targetZone, hasTaskState);
      }
    });

    beforeEach(() => {
      callbackLogs = [];
    });

    it('should be able to reschedule zone when in scheduling state, after that, task will completely go to new zone, has nothing to do with original one',
       () => {
         zone.run(() => {
           const t =
               Zone.current.scheduleMacroTask('testRescheduleZoneTask', noop, null, noop, noop);
           t.invoke();
         });

         expect(callbackLogs).toEqual([
           {pos: 'before', method: 'onScheduleTask', zone: 'original', task: 'original'},
           {pos: 'before', method: 'onScheduleTask', zone: 'new', task: 'new'},
           {microTask: false, macroTask: true, eventTask: false, change: 'macroTask', zone: 'new'},
           {pos: 'after', method: 'onScheduleTask', zone: 'original', task: 'new'},
           {pos: 'before', method: 'onInvokeTask', zone: 'new', task: 'new'}, {
             microTask: false,
             macroTask: false,
             eventTask: false,
             change: 'macroTask',
             zone: 'new'
           }
         ]);
       });

    it('should not be able to reschedule task in notScheduled/running/canceling state', () => {
      Zone.current.fork({name: 'rescheduleNotScheduled'}).run(() => {
        const t = Zone.current.scheduleMacroTask('testRescheduleZoneTask', noop, null, noop, noop);
        Zone.current.cancelTask(t);
        expect(() => {
          t.cancelScheduleRequest();
        })
            .toThrow(Error(
                `macroTask 'testRescheduleZoneTask': can not transition to 'notScheduled', expecting state 'scheduling', was 'notScheduled'.`));
      });

      Zone.current
          .fork({
            name: 'rescheduleRunning',
            onInvokeTask: (delegate, currZone, targetZone, task, applyThis, applyArgs) => {
              expect(() => {
                task.cancelScheduleRequest();
              })
                  .toThrow(Error(
                      `macroTask 'testRescheduleZoneTask': can not transition to 'notScheduled', expecting state 'scheduling', was 'running'.`));
            }
          })
          .run(() => {
            const t =
                Zone.current.scheduleMacroTask('testRescheduleZoneTask', noop, null, noop, noop);
            t.invoke();
          });

      Zone.current
          .fork({
            name: 'rescheduleCanceling',
            onCancelTask: (delegate, currZone, targetZone, task) => {
              expect(() => {
                task.cancelScheduleRequest();
              })
                  .toThrow(Error(
                      `macroTask 'testRescheduleZoneTask': can not transition to 'notScheduled', expecting state 'scheduling', was 'canceling'.`));
            }
          })
          .run(() => {
            const t =
                Zone.current.scheduleMacroTask('testRescheduleZoneTask', noop, null, noop, noop);
            Zone.current.cancelTask(t);
          });
    });
  });
});