From b52cf0230ece5d49570735767a98907334fbb367 Mon Sep 17 00:00:00 2001 From: Misko Hevery Date: Fri, 30 Sep 2016 16:03:32 -0700 Subject: [PATCH] fix: stop using class extends as it breaks rollup --- .travis.yml | 2 +- lib/jasmine/jasmine.ts | 57 ++++++++++++++++++++++++------------------ 2 files changed, 33 insertions(+), 26 deletions(-) diff --git a/.travis.yml b/.travis.yml index 7af2e931d..0be6a7bd1 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,7 +1,7 @@ language: node_js sudo: false node_js: - - '4.2.1' + - '6.3.1' env: global: - BROWSER_PROVIDER_READY_FILE=/tmp/sauce-connect-ready diff --git a/lib/jasmine/jasmine.ts b/lib/jasmine/jasmine.ts index f5b5ad381..deadda470 100644 --- a/lib/jasmine/jasmine.ts +++ b/lib/jasmine/jasmine.ts @@ -1,9 +1,14 @@ 'use strict'; (() => { + var __extends = function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; // 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"); - if (typeof jasmine == 'undefined') throw new Error("Missing: jasmine.js"); + if (typeof jasmine == 'undefined') throw new Error("Missing: jasmine.js"); if (jasmine['__zone_patch__']) throw new Error("'jasmine' has already been patched with 'Zone'."); jasmine['__zone_patch__'] = true; @@ -13,19 +18,19 @@ if (!ProxyZoneSpec) throw new Error("Missing: ProxyZoneSpec"); const ambientZone = Zone.current; - // Create a synchronous-only zone in which to run `describe` blocks in order to raise an - // error if any asynchronous operations are attempted inside of a `describe` but outside of + // Create a synchronous-only zone in which to run `describe` blocks in order to raise an + // error if any asynchronous operations are attempted inside of a `describe` but outside of // a `beforeEach` or `it`. const syncZone = ambientZone.fork(new SyncTestZoneSpec('jasmine.describe')); // This is the zone which will be used for running individual tests. // It will be a proxy zone, so that the tests function can retroactively install - // different zones. + // different zones. // Example: // - In beforeEach() do childZone = Zone.current.fork(...); - // - In it() try to do fakeAsync(). The issue is that because the beforeEach forked the + // - In it() try to do fakeAsync(). The issue is that because the beforeEach forked the // zone outside of fakeAsync it will be able to escope the fakeAsync rules. - // - Because ProxyZone is parent fo `childZone` fakeAsync can retroactively add + // - Because ProxyZone is parent fo `childZone` fakeAsync can retroactively add // fakeAsync behavior to the childZone. let testProxyZone: Zone = null; @@ -35,26 +40,26 @@ let originalJasmineFn: Function = jasmineEnv[methodName]; jasmineEnv[methodName] = function(description: string, specDefinitions: Function) { return originalJasmineFn.call(this, description, wrapDescribeInZone(specDefinitions)); - } + } }); ['it', 'xit', 'fit'].forEach((methodName) => { let originalJasmineFn: Function = jasmineEnv[methodName]; jasmineEnv[methodName] = function(description: string, specDefinitions: Function, timeout: number) { arguments[1] = wrapTestInZone(specDefinitions); return originalJasmineFn.apply(this, arguments); - } + } }); ['beforeEach', 'afterEach'].forEach((methodName) => { let originalJasmineFn: Function = jasmineEnv[methodName]; jasmineEnv[methodName] = function(specDefinitions: Function, timeout: number) { arguments[0] = wrapTestInZone(specDefinitions); return originalJasmineFn.apply(this, arguments); - } + } }); - /** - * Gets a function wrapping the body of a Jasmine `describe` block to execute in a - * synchronous-only zone. + /** + * Gets a function wrapping the body of a Jasmine `describe` block to execute in a + * synchronous-only zone. */ function wrapDescribeInZone(describeBody: Function): Function { return function() { @@ -62,16 +67,16 @@ } } - /** - * Gets a function wrapping the body of a Jasmine `it/beforeEach/afterEach` block to - * execute in a ProxyZone zone. + /** + * Gets a function wrapping the body of a Jasmine `it/beforeEach/afterEach` block to + * execute in a ProxyZone zone. * This will run in `testProxyZone`. The `testProxyZone` will be reset by the `ZoneQueueRunner` */ function wrapTestInZone(testBody: Function): Function { // The `done` callback is only passed through if the function expects at least one argument. // Note we have to make a function with correct number of arguments, otherwise jasmine will // think that all functions are sync or async. - return (testBody.length == 0) + return (testBody.length == 0) ? function() { return testProxyZone.run(testBody, this); } : function(done) { return testProxyZone.run(testBody, this, [done]); }; } @@ -90,17 +95,17 @@ } const QueueRunner = (jasmine as any).QueueRunner as { new(attrs: QueueRunnerAttrs): QueueRunner }; - (jasmine as any).QueueRunner = class ZoneQueueRunner extends QueueRunner { - constructor(attrs: QueueRunnerAttrs) { + (jasmine as any).QueueRunner = (function (_super) { + __extends(ZoneQueueRunner, _super); + function ZoneQueueRunner(attrs) { attrs.onComplete = ((fn) => () => { // All functions are done, clear the test zone. testProxyZone = null; ambientZone.scheduleMicroTask('jasmine.onComplete', fn); })(attrs.onComplete); - super(attrs); + _super.call(this, attrs); } - - execute() { + ZoneQueueRunner.prototype.execute = function () { if(Zone.current !== ambientZone) throw new Error("Unexpected Zone: " + Zone.current.name); testProxyZone = ambientZone.fork(new ProxyZoneSpec()); if (!Zone.currentTask) { @@ -109,10 +114,12 @@ // addEventListener callback would think that it is the top most task and would // drain the microtask queue on element.click() which would be incorrect. // For this reason we always force a task when running jasmine tests. - Zone.current.scheduleMicroTask('jasmine.execute().forceTask', () => super.execute()); + Zone.current.scheduleMicroTask('jasmine.execute().forceTask', + () => QueueRunner.prototype.execute.call(this)); } else { - super.execute(); + _super.prototype.execute.call(this); } - } - }; + }; + return ZoneQueueRunner; + }(QueueRunner)); })();