fix(proxy): proxyZone should call onHasTask when change delegate (#1030)

Author: JiaLiPassion

lib/jasmine/jasmine.ts

@@ -18,6 +18,7 @@
         ? Object.create(b)
         : ((__.prototype = b.prototype), new (__ as any)());
   };
+  const _global: any = typeof window !== 'undefined' && window || typeof self !== 'undefined' && self || global;
   // Patch jasmine's describe/it/beforeEach/afterEach functions so test code always runs
   // in a testZone (ProxyZone). (See: angular/zone.js#91 & angular/angular#10503)
   if (!Zone) throw new Error('Missing: zone.js');
@@ -202,13 +203,24 @@
     function ZoneQueueRunner(attrs: {
       onComplete: Function;
       userContext?: any;
+      timeout?: { setTimeout: Function; clearTimeout: Function };
     }) {
       attrs.onComplete = (fn => () => {
         // All functions are done, clear the test zone.
         this.testProxyZone = null;
         this.testProxyZoneSpec = null;
         ambientZone.scheduleMicroTask('jasmine.onComplete', fn);
       })(attrs.onComplete);
+
+      const nativeSetTimeout = _global['__zone_symbol__setTimeout'];
+      const nativeClearTimeout = _global['__zone_symbol__clearTimeout'];
+      if (nativeSetTimeout) {
+        // should run setTimeout inside jasmine outside of zone
+        attrs.timeout = {
+          setTimeout: nativeSetTimeout ? nativeSetTimeout : _global.setTimeout,
+          clearTimeout: nativeClearTimeout ? nativeClearTimeout : _global.clearTimeout
+        };
+      }
       // create a userContext to hold the queueRunner itself
       // so we can access the testProxy in it/xit/beforeEach ...
       if ((jasmine as any).UserContext) {

lib/zone-spec/async-test.ts

@@ -14,6 +14,7 @@ class AsyncTestZoneSpec implements ZoneSpec {
   _pendingMicroTasks: boolean = false;
   _pendingMacroTasks: boolean = false;
   _alreadyErrored: boolean = false;
+  _isSync: boolean = false;
   runZone = Zone.current;
   unresolvedChainedPromiseCount = 0;
 
@@ -60,6 +61,9 @@ class AsyncTestZoneSpec implements ZoneSpec {
   properties: {[key: string]: any};
 
   onScheduleTask(delegate: ZoneDelegate, current: Zone, target: Zone, task: Task): Task {
+    if (task.type !== 'eventTask') {
+      this._isSync = false;
+    }
     if (task.type === 'microTask' && task.data && task.data instanceof Promise) {
       // check whether the promise is a chained promise 
       if ((task.data as any)[AsyncTestZoneSpec.symbolParentUnresolved] === true) {
@@ -70,18 +74,39 @@ class AsyncTestZoneSpec implements ZoneSpec {
     return delegate.scheduleTask(target, task);
   }
 
+  onInvokeTask(delegate: ZoneDelegate, current: Zone, target: Zone, task: Task, applyThis: any, applyArgs: any) {
+    if (task.type !== 'eventTask') {
+      this._isSync = false;
+    }
+    return delegate.invokeTask(target, task, applyThis, applyArgs);
+  }
+
+  onCancelTask(delegate: ZoneDelegate, current: Zone, target: Zone, task: Task) {
+    if (task.type !== 'eventTask') {
+      this._isSync = false;
+    }
+    return delegate.cancelTask(target, task);
+  }
+
   // Note - we need to use onInvoke at the moment to call finish when a test is
   // fully synchronous. TODO(juliemr): remove this when the logic for
   // onHasTask changes and it calls whenever the task queues are dirty.
+  // updated by(JiaLiPassion), only call finish callback when no task
+  // was scheduled/invoked/canceled.
   onInvoke(
       parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, delegate: Function,
       applyThis: any, applyArgs: any[], source: string): any {
+    let previousTaskCounts: any = null;
     try {
       this.patchPromiseForTest();
+      this._isSync = true;
       return parentZoneDelegate.invoke(targetZone, delegate, applyThis, applyArgs, source);
     } finally {
       this.unPatchPromiseForTest();
-      this._finishCallbackIfDone();
+      const afterTaskCounts: any = (parentZoneDelegate as any)._taskCounts;
+      if (this._isSync) {
+        this._finishCallbackIfDone();
+      }
     }
   }
 

lib/zone-spec/proxy.ts

@@ -14,6 +14,9 @@ class ProxyZoneSpec implements ZoneSpec {
   properties: {[k: string]: any} = {'ProxyZoneSpec': this};
   propertyKeys: string[] = null;
 
+  lastTaskState: HasTaskState = null;
+  isNeedToTriggerHasTask = false;
+
   static get(): ProxyZoneSpec {
     return Zone.current.get('ProxyZoneSpec');
   }
@@ -35,13 +38,20 @@ class ProxyZoneSpec implements ZoneSpec {
 
 
   setDelegate(delegateSpec: ZoneSpec) {
+    const isNewDelegate = this._delegateSpec !== delegateSpec;
     this._delegateSpec = delegateSpec;
     this.propertyKeys && this.propertyKeys.forEach((key) => delete this.properties[key]);
     this.propertyKeys = null;
     if (delegateSpec && delegateSpec.properties) {
       this.propertyKeys = Object.keys(delegateSpec.properties);
       this.propertyKeys.forEach((k) => this.properties[k] = delegateSpec.properties[k]);
     }
+    // if set a new delegateSpec, shoulde check whether need to
+    // trigger hasTask or not
+    if (isNewDelegate && this.lastTaskState &&
+        (this.lastTaskState.macroTask || this.lastTaskState.microTask)) {
+      this.isNeedToTriggerHasTask = true;
+    }
   }
 
   getDelegate() {
@@ -53,6 +63,15 @@ class ProxyZoneSpec implements ZoneSpec {
     this.setDelegate(this.defaultSpecDelegate);
   }
 
+  tryTriggerHasTask(parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone) {
+    if (this.isNeedToTriggerHasTask && this.lastTaskState) {
+      // last delegateSpec has microTask or macroTask
+      // should call onHasTask in current delegateSpec
+      this.isNeedToTriggerHasTask = false;
+      this.onHasTask(parentZoneDelegate, currentZone, targetZone, this.lastTaskState); 
+    }
+  }
+
 
   onFork(parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, zoneSpec: ZoneSpec):
       Zone {
@@ -79,6 +98,7 @@ class ProxyZoneSpec implements ZoneSpec {
   onInvoke(
       parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, delegate: Function,
       applyThis: any, applyArgs: any[], source: string): any {
+    this.tryTriggerHasTask(parentZoneDelegate, currentZone, targetZone);
     if (this._delegateSpec && this._delegateSpec.onInvoke) {
       return this._delegateSpec.onInvoke(
           parentZoneDelegate, currentZone, targetZone, delegate, applyThis, applyArgs, source);
@@ -108,7 +128,8 @@ class ProxyZoneSpec implements ZoneSpec {
   onInvokeTask(
       parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task,
       applyThis: any, applyArgs: any): any {
-    if (this._delegateSpec && this._delegateSpec.onFork) {
+    this.tryTriggerHasTask(parentZoneDelegate, currentZone, targetZone);
+    if (this._delegateSpec && this._delegateSpec.onInvokeTask) {
       return this._delegateSpec.onInvokeTask(
           parentZoneDelegate, currentZone, targetZone, task, applyThis, applyArgs);
     } else {
@@ -118,6 +139,7 @@ class ProxyZoneSpec implements ZoneSpec {
 
   onCancelTask(parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task):
       any {
+    this.tryTriggerHasTask(parentZoneDelegate, currentZone, targetZone);
     if (this._delegateSpec && this._delegateSpec.onCancelTask) {
       return this._delegateSpec.onCancelTask(parentZoneDelegate, currentZone, targetZone, task);
     } else {
@@ -126,6 +148,7 @@ class ProxyZoneSpec implements ZoneSpec {
   }
 
   onHasTask(delegate: ZoneDelegate, current: Zone, target: Zone, hasTaskState: HasTaskState): void {
+    this.lastTaskState = hasTaskState;
     if (this._delegateSpec && this._delegateSpec.onHasTask) {
       this._delegateSpec.onHasTask(delegate, current, target, hasTaskState);
     } else {