fix(task): findEventTask should return Task array (#633)

lib/browser/browser.ts

@@ -146,16 +146,16 @@ if (_global['navigator'] && _global['navigator'].geolocation) {
 // handle unhandled promise rejection
 function findPromiseRejectionHandler(evtName: string) {
   return function(e: any) {
-    const eventTask = findEventTask(_global, evtName);
-    if (eventTask) {
+    const eventTasks = findEventTask(_global, evtName);
+    eventTasks.forEach(eventTask => {
       // windows has added unhandledrejection event listener
       // trigger the event listener
       const PromiseRejectionEvent = _global['PromiseRejectionEvent'];
       if (PromiseRejectionEvent) {
         const evt = new PromiseRejectionEvent(evtName, {promise: e.promise, reason: e.rejection});
         eventTask.invoke(evt);
       }
-    }
+    });
   };
 }
 

lib/common/utils.ts

@@ -554,17 +554,18 @@ export function patchMicroTask(
   });
 }
 
-export function findEventTask(target: any, evtName: string) {
+export function findEventTask(target: any, evtName: string): Task[] {
   const eventTasks: Task[] = target[zoneSymbol('eventTasks')];
+  const result: Task[] = [];
   if (eventTasks) {
     for (let i = 0; i < eventTasks.length; i++) {
       const eventTask = eventTasks[i];
       const data = eventTask.data;
       const eventName = data && (<any>data).eventName;
       if (eventName === evtName) {
-        return eventTask;
+        result.push(eventTask);
       }
     }
   }
-  return undefined;
+  return result;
 }

lib/node/node.ts

@@ -73,16 +73,16 @@ function patchProcess() {
 // handle unhandled promise rejection
 function findProcessPromiseRejectionHandler(evtName: string) {
   return function(e: any) {
-    const eventTask = findEventTask(process, evtName);
-    if (eventTask) {
+    const eventTasks = findEventTask(process, evtName);
+    eventTasks.forEach(eventTask => {
       // process has added unhandledrejection event listener
       // trigger the event listener
       if (evtName === 'unhandledRejection') {
         eventTask.invoke(e.rejection, e.promise);
       } else if (evtName === 'rejectionHandled') {
         eventTask.invoke(e.promise);
       }
-    }
+    });
   };
 }
 

test/browser/browser.spec.ts

@@ -193,6 +193,34 @@ describe('Zone', function() {
           });
         });
       });
+
+      it('should support multiple window.addEventListener(unhandledrejection)', function(done) {
+        if (!promiseUnhandleRejectionSupport()) {
+          done();
+          return;
+        }
+        Zone[zoneSymbol('ignoreConsoleErrorUncaughtError')] = true;
+        rootZone.fork({name: 'promise'}).run(function() {
+          const listener1 = (evt: any) => {
+            expect(evt.type).toEqual('unhandledrejection');
+            expect(evt.promise.constructor.name).toEqual('Promise');
+            expect(evt.reason.message).toBe('promise error');
+            window.removeEventListener('unhandledrejection', listener1);
+          };
+          const listener2 = (evt: any) => {
+            expect(evt.type).toEqual('unhandledrejection');
+            expect(evt.promise.constructor.name).toEqual('Promise');
+            expect(evt.reason.message).toBe('promise error');
+            window.removeEventListener('unhandledrejection', listener2);
+            done();
+          };
+          window.addEventListener('unhandledrejection', listener1);
+          window.addEventListener('unhandledrejection', listener2);
+          new Promise((resolve, reject) => {
+            throw new Error('promise error');
+          });
+        });
+      });
     });
   });
 });

test/node/process.spec.ts

@@ -22,7 +22,7 @@ describe('process related test', () => {
       });
     });
   });
-  it('process.nextTick should be excuted before macroTask and promise', (done) => {
+  it('process.nextTick should be executed before macroTask and promise', (done) => {
     zoneA.run(function() {
       setTimeout(() => {
         result.push('timeout');
@@ -64,13 +64,16 @@ describe('process related test', () => {
       done();
     });
   });
-  it('should support window.addEventListener(unhandledrejection)', function(done) {
+
+  it('should support process.on(unhandledRejection)', function(done) {
     const hookSpy = jasmine.createSpy('hook');
     Zone[zoneSymbol('ignoreConsoleErrorUncaughtError')] = true;
     Zone.current.fork({name: 'promise'}).run(function() {
-      process.on('unhandledRejection', function(reason, promise) {
+      const listener = function(reason, promise) {
         hookSpy(promise, reason.message);
-      });
+        process.removeListener('unhandledRejection', listener);
+      };
+      process.on('unhandledRejection', listener);
       const p = new Promise((resolve, reject) => {
         throw new Error('promise error');
       });
@@ -82,13 +85,15 @@ describe('process related test', () => {
     });
   });
 
-  it('should support window.addEventListener(rejectionHandled)', function(done) {
+  it('should support process.on(rejectionHandled)', function(done) {
     Zone[zoneSymbol('ignoreConsoleErrorUncaughtError')] = true;
     Zone.current.fork({name: 'promise'}).run(function() {
-      process.on('rejectionHandled', function(promise) {
+      const listener = function(promise) {
         expect(promise).toEqual(p);
+        process.removeListener('rejectionHandled', listener);
         done();
-      });
+      };
+      process.on('rejectionHandled', listener);
       const p = new Promise((resolve, reject) => {
         throw new Error('promise error');
       });
@@ -98,4 +103,30 @@ describe('process related test', () => {
       }, 10);
     });
   });
+
+  it('should support multiple process.on(unhandledRejection)', function(done) {
+    const hookSpy = jasmine.createSpy('hook');
+    Zone[zoneSymbol('ignoreConsoleErrorUncaughtError')] = true;
+    Zone.current.fork({name: 'promise'}).run(function() {
+      const listener1 = function(reason, promise) {
+        hookSpy(promise, reason.message);
+        process.removeListener('unhandledRejection', listener1);
+      };
+      const listener2 = function(reason, promise) {
+        hookSpy(promise, reason.message);
+        process.removeListener('unhandledRejection', listener2);
+      };
+      process.on('unhandledRejection', listener1);
+      process.on('unhandledRejection', listener2);
+      const p = new Promise((resolve, reject) => {
+        throw new Error('promise error');
+      });
+
+      setTimeout(function() {
+        expect(hookSpy.calls.count()).toBe(2);
+        expect(hookSpy.calls.allArgs()).toEqual([[p, 'promise error'], [p, 'promise error']]);
+        done();
+      }, 10);
+    });
+  });
 });