honeymoose
/
angular-cn
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
angular-cn/packages/zone.js/test/extra/bluebird.spec.ts

757 lines
28 KiB
TypeScript
Raw Normal View History

build: move zone.js to angular repo (#30962) PR Close #30962
2019-05-31 11:56:07 -04:00
/**
* @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
*/
// test bluebird promise patch
// this spec will not be integrated with Travis CI, because I don't
// want to add bluebird into devDependencies, you can run this spec
// on your local environment
process.on('unhandledRejection', (reason, p) => {
console.log('Unhandled Rejection at:', p, 'reason:', reason);
// application specific logging, throwing an error, or other logic here
});
describe('bluebird promise', () => {
let BluebirdPromise: any;
beforeAll(() => {
BluebirdPromise = require('bluebird');
// import bluebird patch
require('../../lib/extra/bluebird');
const patchBluebird = (Zone as any)[(Zone as any).__symbol__('bluebird')];
patchBluebird(BluebirdPromise);
});
let log: string[];
const zone = Zone.root.fork({
name: 'bluebird',
onScheduleTask: (delegate, curr, targetZone, task) => {
log.push('schedule bluebird task ' + task.source);
return delegate.scheduleTask(targetZone, task);
},
onInvokeTask: (delegate, curr, target, task, applyThis, applyArgs) => {
log.push('invoke bluebird task ' + task.source);
return delegate.invokeTask(target, task, applyThis, applyArgs);
}
});
beforeEach(() => { log = []; });
it('bluebird promise then method should be in zone and treated as microTask', (done) => {
zone.run(() => {
const p = new BluebirdPromise(
(resolve: any, reject: any) => { setTimeout(() => { resolve('test'); }, 0); });
p.then(() => {
expect(Zone.current.name).toEqual('bluebird');
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length).toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
done();
});
});
});
it('bluebird promise catch method should be in zone and treated as microTask', (done) => {
zone.run(() => {
const p = new BluebirdPromise(
(resolve: any, reject: any) => { setTimeout(() => { reject('test'); }, 0); });
p.catch(() => {
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length).toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
done();
});
});
});
it('bluebird promise spread method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise.all([BluebirdPromise.resolve('test1'), BluebirdPromise.resolve('test2')])
.spread((r1: string, r2: string) => {
expect(r1).toEqual('test1');
expect(r2).toEqual('test2');
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length)
.toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
done();
});
});
});
it('bluebird promise finally method should be in zone', (done) => {
zone.run(() => {
const p = new BluebirdPromise(
(resolve: any, reject: any) => { setTimeout(() => { resolve('test'); }, 0); });
p.finally(() => {
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length).toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
done();
});
});
});
it('bluebird promise join method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise
.join(
BluebirdPromise.resolve('test1'), BluebirdPromise.resolve('test2'),
(r1: string, r2: string) => {
expect(r1).toEqual('test1');
expect(r2).toEqual('test2');
expect(Zone.current.name).toEqual('bluebird');
})
.then(() => {
expect(Zone.current.name).toEqual('bluebird');
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length)
.toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
done();
});
});
});
it('bluebird promise try method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise.try(() => { throw new Error('promise error'); }).catch((err: Error) => {
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length).toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
expect(err.message).toEqual('promise error');
done();
});
});
});
it('bluebird promise method method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise.method(() => { return 'test'; })().then((result: string) => {
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length).toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
expect(result).toEqual('test');
done();
});
});
});
it('bluebird promise resolve method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise.resolve('test').then((result: string) => {
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length).toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
expect(result).toEqual('test');
done();
});
});
});
it('bluebird promise reject method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise.reject('error').catch((error: any) => {
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length).toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
expect(error).toEqual('error');
done();
});
});
});
it('bluebird promise all method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise.all([BluebirdPromise.resolve('test1'), BluebirdPromise.resolve('test2')])
.then((r: string[]) => {
expect(r[0]).toEqual('test1');
expect(r[1]).toEqual('test2');
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length)
.toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
done();
});
});
});
it('bluebird promise props method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise
.props({test1: BluebirdPromise.resolve('test1'), test2: BluebirdPromise.resolve('test2')})
.then((r: any) => {
expect(r.test1).toEqual('test1');
expect(r.test2).toEqual('test2');
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length)
.toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
done();
});
});
});
it('bluebird promise any method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise.any([BluebirdPromise.resolve('test1'), BluebirdPromise.resolve('test2')])
.then((r: any) => {
expect(r).toEqual('test1');
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length)
.toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
done();
});
});
});
it('bluebird promise some method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise.some([BluebirdPromise.resolve('test1'), BluebirdPromise.resolve('test2')], 1)
.then((r: any) => {
expect(r.length).toBe(1);
expect(r[0]).toEqual('test1');
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length)
.toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
done();
});
});
});
it('bluebird promise map method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise
.map(['test1', 'test2'], (value: any) => { return BluebirdPromise.resolve(value); })
.then((r: string[]) => {
expect(r.length).toBe(2);
expect(r[0]).toEqual('test1');
expect(r[1]).toEqual('test2');
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length)
.toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
done();
});
});
});
it('bluebird promise reduce method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise
.reduce(
[1, 2],
(total: string, value: string) => { return BluebirdPromise.resolve(total + value); })
.then((r: number) => {
expect(r).toBe(3);
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length)
.toBeTruthy();
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length)
.toBeTruthy();
expect(Zone.current.name).toEqual('bluebird');
done();
});
});
});
it('bluebird promise filter method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise
.filter(
[1, 2, 3],
(value: number) => {
return value % 2 === 0 ? BluebirdPromise.resolve(true) :
BluebirdPromise.resolve(false);
})
.then((r: number[]) => {
expect(r[0]).toBe(2);
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length)
.toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
done();
});
});
});
it('bluebird promise each method should be in zone', (done) => {
zone.run(() => {
const arr = [1, 2, 3];
BluebirdPromise
.each(
BluebirdPromise.map(arr, (item: number) => BluebirdPromise.resolve(item)),
(r: number[], idx: number) => {
expect(r[idx] === arr[idx]);
expect(Zone.current.name).toEqual('bluebird');
})
.then((r: any) => {
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length)
.toBeTruthy();
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length)
.toBeTruthy();
expect(Zone.current.name).toEqual('bluebird');
done();
});
});
});
it('bluebird promise mapSeries method should be in zone', (done) => {
zone.run(() => {
const arr = [1, 2, 3];
BluebirdPromise
.mapSeries(
BluebirdPromise.map(arr, (item: number) => BluebirdPromise.resolve(item)),
(r: number[], idx: number) => {
expect(r[idx] === arr[idx]);
expect(Zone.current.name).toEqual('bluebird');
})
.then((r: any) => {
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length)
.toBeTruthy();
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length)
.toBeTruthy();
expect(Zone.current.name).toEqual('bluebird');
done();
});
;
});
});
it('bluebird promise race method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise.race([BluebirdPromise.resolve('test1'), BluebirdPromise.resolve('test2')])
.then((r: string) => {
expect(r).toEqual('test1');
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length)
.toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
done();
});
});
});
it('bluebird promise using/disposer method should be in zone', (done) => {
zone.run(() => {
const p = new BluebirdPromise(
(resolve: Function, reject: any) => { setTimeout(() => { resolve('test'); }, 0); });
p.leakObj = [];
const disposer = p.disposer(() => { p.leakObj = null; });
BluebirdPromise.using(disposer, (v: string) => { p.leakObj.push(v); }).then(() => {
expect(Zone.current.name).toEqual('bluebird');
expect(p.leakObj).toBe(null);
// using will generate several promise inside bluebird
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length)
.toBeTruthy();
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length)
.toBeTruthy();
done();
});
});
});
it('bluebird promise promisify method should be in zone and treated as microTask', (done) => {
const func = (cb: Function) => { setTimeout(() => { cb(null, 'test'); }, 10); };
const promiseFunc = BluebirdPromise.promisify(func);
zone.run(() => {
promiseFunc().then((r: string) => {
expect(Zone.current.name).toEqual('bluebird');
expect(r).toBe('test');
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length).toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
done();
});
});
});
it('bluebird promise promisifyAll method should be in zone', (done) => {
const obj = {
func1: (cb: Function) => { setTimeout(() => { cb(null, 'test1'); }, 10); },
func2: (cb: Function) => { setTimeout(() => { cb(null, 'test2'); }, 10); },
};
const promiseObj = BluebirdPromise.promisifyAll(obj);
zone.run(() => {
BluebirdPromise.all([promiseObj.func1Async(), promiseObj.func2Async()])
.then((r: string[]) => {
expect(Zone.current.name).toEqual('bluebird');
expect(r[0]).toBe('test1');
expect(r[1]).toBe('test2');
// using will generate several promise inside
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length)
.toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
done();
});
});
});
it('bluebird promise fromCallback method should be in zone', (done) => {
const resolver = (cb: Function) => { setTimeout(() => { cb(null, 'test'); }, 10); };
zone.run(() => {
BluebirdPromise.fromCallback(resolver).then((r: string) => {
expect(Zone.current.name).toEqual('bluebird');
expect(r).toBe('test');
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length).toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
done();
});
});
});
it('bluebird promise asCallback method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise.resolve('test').asCallback((err: Error, r: string) => {
expect(Zone.current.name).toEqual('bluebird');
expect(r).toBe('test');
done();
});
});
});
it('bluebird promise delay method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise.resolve('test').delay(10).then((r: string) => {
expect(Zone.current.name).toEqual('bluebird');
expect(r).toBe('test');
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length).toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
done();
});
});
});
it('bluebird promise timeout method should be in zone', (done) => {
zone.run(() => {
new BluebirdPromise(
(resolve: any, reject: any) => { setTimeout(() => { resolve('test'); }, 10); })
.timeout(100)
.then((r: string) => {
expect(Zone.current.name).toEqual('bluebird');
expect(r).toBe('test');
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length)
.toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
done();
});
});
});
it('bluebird promise tap method should be in zone', (done) => {
zone.run(() => {
const p = new BluebirdPromise(
(resolve: any, reject: any) => { setTimeout(() => { resolve('test'); }, 0); });
p.tap(() => { expect(Zone.current.name).toEqual('bluebird'); }).then(() => {
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length).toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
done();
});
});
});
it('bluebird promise call method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise
.map(['test1', 'test2'], (value: any) => { return BluebirdPromise.resolve(value); })
.call('shift', (value: any) => { return value; })
.then((r: string) => {
expect(r).toEqual('test1');
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length)
.toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
done();
});
});
});
it('bluebird promise get method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise.resolve(['test1', 'test2']).get(-1).then((r: string) => {
expect(r).toEqual('test2');
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length).toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
done();
});
});
});
it('bluebird promise return method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise.resolve().return ('test1').then((r: string) => {
expect(r).toEqual('test1');
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length).toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
done();
});
});
});
it('bluebird promise throw method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise.resolve().throw('test1').catch((r: string) => {
expect(r).toEqual('test1');
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length).toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
done();
});
});
});
it('bluebird promise catchReturn method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise.reject().catchReturn('test1').then((r: string) => {
expect(r).toEqual('test1');
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length).toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
done();
});
});
});
it('bluebird promise catchThrow method should be in zone', (done) => {
zone.run(() => {
BluebirdPromise.reject().catchThrow('test1').catch((r: string) => {
expect(r).toEqual('test1');
expect(log.filter(item => item === 'schedule bluebird task Promise.then').length).toBe(1);
expect(log.filter(item => item === 'invoke bluebird task Promise.then').length).toBe(1);
expect(Zone.current.name).toEqual('bluebird');
done();
});
});
});
it('bluebird promise reflect method should be in zone', (done) => {
zone.run(() => {
const promises = [BluebirdPromise.resolve('test1'), BluebirdPromise.reject('test2')];
BluebirdPromise.all(promises.map(promise => { return promise.reflect(); })).each((r: any) => {
if (r.isFulfilled()) {
expect(r.value()).toEqual('test1');
} else {
expect(r.reason()).toEqual('test2');
done();
}
expect(Zone.current.name).toEqual('bluebird');
});
});
});
it('bluebird should be able to run into different zone', (done: Function) => {
Zone.current.fork({name: 'zone_A'}).run(() => {
new BluebirdPromise((resolve: any, reject: any) => {
expect(Zone.current.name).toEqual('zone_A');
resolve(1);
}).then((r: any) => { expect(Zone.current.name).toEqual('zone_A'); });
});
Zone.current.fork({name: 'zone_B'}).run(() => {
new BluebirdPromise((resolve: any, reject: any) => {
expect(Zone.current.name).toEqual('zone_B');
resolve(2);
}).then((r: any) => {
expect(Zone.current.name).toEqual('zone_B');
done();
});
});
});
it('should be able to chain promise', (done: DoneFn) => {
Zone.current.fork({name: 'zone_A'}).run(() => {
new BluebirdPromise((resolve: any, reject: any) => {
expect(Zone.current.name).toEqual('zone_A');
resolve(1);
})
.then((r: any) => {
expect(r).toBe(1);
expect(Zone.current.name).toEqual('zone_A');
return Promise.resolve(2);
})
.then((r: any) => {
expect(r).toBe(2);
expect(Zone.current.name).toEqual('zone_A');
});
});
Zone.current.fork({name: 'zone_B'}).run(() => {
new BluebirdPromise((resolve: any, reject: any) => {
expect(Zone.current.name).toEqual('zone_B');
reject(1);
})
.then(
() => { fail('should not be here.'); },
(r: any) => {
expect(r).toBe(1);
expect(Zone.current.name).toEqual('zone_B');
return Promise.resolve(2);
})
.then((r: any) => {
expect(r).toBe(2);
expect(Zone.current.name).toEqual('zone_B');
done();
});
});
});
it('should catch rejected chained bluebird promise', (done: DoneFn) => {
const logs: string[] = [];
const zone = Zone.current.fork({
name: 'testErrorHandling',
onHandleError: function() {
// should not get here
logs.push('onHandleError');
return true;
}
});
zone.runGuarded(() => {
return BluebirdPromise.resolve().then(() => { throw new Error('test error'); }).catch(() => {
expect(logs).toEqual([]);
done();
});
});
});
it('should catch rejected chained global promise', (done: DoneFn) => {
const logs: string[] = [];
const zone = Zone.current.fork({
name: 'testErrorHandling',
onHandleError: function() {
// should not get here
logs.push('onHandleError');
return true;
}
});
zone.runGuarded(() => {
return Promise.resolve().then(() => { throw new Error('test error'); }).catch(() => {
expect(logs).toEqual([]);
done();
});
});
});
it('should catch rejected bluebird promise', (done: DoneFn) => {
const logs: string[] = [];
const zone = Zone.current.fork({
name: 'testErrorHandling',
onHandleError: function() {
// should not get here
logs.push('onHandleError');
return true;
}
});
zone.runGuarded(() => {
return BluebirdPromise.reject().catch(() => {
expect(logs).toEqual([]);
done();
});
});
});
it('should catch rejected global promise', (done: DoneFn) => {
const logs: string[] = [];
const zone = Zone.current.fork({
name: 'testErrorHandling',
onHandleError: function() {
// should not get here
logs.push('onHandleError');
return true;
}
});
zone.runGuarded(() => {
return Promise.reject(new Error('reject')).catch(() => {
expect(logs).toEqual([]);
done();
});
});
});
it('should trigger onHandleError when unhandledRejection', (done: DoneFn) => {
const zone = Zone.current.fork({
name: 'testErrorHandling',
onHandleError: function() {
setTimeout(done, 100);
return true;
}
});
zone.runGuarded(() => { return Promise.reject(new Error('reject')); });
});
it('should trigger onHandleError when unhandledRejection in chained Promise', (done: DoneFn) => {
const zone = Zone.current.fork({
name: 'testErrorHandling',
onHandleError: function() {
setTimeout(done, 100);
return true;
}
});
zone.runGuarded(() => { return Promise.resolve().then(() => { throw new Error('test'); }); });
});
fix(zone.js): don't fire unhandledrejection if Zone handled error (#31718) Close #31701 PR Close #31718
2019-07-21 06:49:41 -04:00
it('should not trigger unhandledrejection if zone.onHandleError return false', (done: DoneFn) => {
const listener = function() { fail('should not be here'); };
if (typeof window !== 'undefined') {
window.addEventListener('unhandledrejection', listener);
} else if (typeof process !== 'undefined') {
process.on('unhandledRejection', listener);
}
const zone = Zone.current.fork({
name: 'testErrorHandling',
onHandleError: function() {
setTimeout(() => {
if (typeof window !== 'undefined') {
window.removeEventListener('unhandledrejection', listener);
} else if (typeof process !== 'undefined') {
process.removeListener('unhandledRejection', listener);
}
done();
}, 500);
return false;
}
});
zone.runGuarded(() => { return Promise.resolve().then(() => { throw new Error('test'); }); });
});
it('should trigger unhandledrejection if zone.onHandleError return true', (done: DoneFn) => {
const listener = function(event: any) {
if (typeof window !== 'undefined') {
expect(event.detail.reason.message).toEqual('test');
} else if (typeof process !== 'undefined') {
expect(event.message).toEqual('test');
}
if (typeof window !== 'undefined') {
window.removeEventListener('unhandledrejection', listener);
} else if (typeof process !== 'undefined') {
process.removeListener('unhandledRejection', listener);
}
done();
};
if (typeof window !== 'undefined') {
window.addEventListener('unhandledrejection', listener);
} else if (typeof process !== 'undefined') {
process.on('unhandledRejection', listener);
}
const zone =
Zone.current.fork({name: 'testErrorHandling', onHandleError: function() { return true; }});
zone.runGuarded(() => { return Promise.resolve().then(() => { throw new Error('test'); }); });
});
build: move zone.js to angular repo (#30962) PR Close #30962
2019-05-31 11:56:07 -04:00
});