Merge pull request #257 from unexpectedjs/wip/replaceTestFrameworkPat…

…chWithAfterHook Wip: Replace test framework patch with afterEach hook
unexpectedjs · Jan 28, 2016 · 6464167 · 6464167
2 parents 047e72f + 5d6237f
commit 6464167
Show file tree

Hide file tree

Showing 7 changed files with 134 additions and 132 deletions.
diff --git a/lib/Unexpected.js b/lib/Unexpected.js
@@ -8,7 +8,7 @@ var makeAndMethod = require('./makeAndMethod');
 var isPendingPromise = require('./isPendingPromise');
 var oathbreaker = require('./oathbreaker');
 var UnexpectedError = require('./UnexpectedError');
-var testFrameworkPatch = require('./testFrameworkPatch');
+var notifyPendingPromise = require('./notifyPendingPromise');
 var defaultDepth = require('./defaultDepth');
 var createWrappedExpectProto = require('./createWrappedExpectProto');
 var AssertionString = require('./AssertionString');
@@ -1110,7 +1110,7 @@ Unexpected.prototype.expect = function expect(subject, testDescriptionString) {
     try {
         var result = executeExpect(subject, testDescriptionString, args);
         if (isPendingPromise(result)) {
-            testFrameworkPatch.promiseCreated();
+            notifyPendingPromise(result);
             result = result.then(undefined, function (e) {
                 if (e && e._isUnexpected) {
                     that.setErrorMessage(e);

diff --git a/lib/createWrappedExpectProto.js b/lib/createWrappedExpectProto.js
@@ -3,7 +3,7 @@ var makePromise = require('./makePromise');
 var isPendingPromise = require('./isPendingPromise');
 var oathbreaker = require('./oathbreaker');
 var UnexpectedError = require('./UnexpectedError');
-var testFrameworkPatch = require('./testFrameworkPatch');
+var notifyPendingPromise = require('./notifyPendingPromise');
 var makeAndMethod = require('./makeAndMethod');
 var utils = require('./utils');
 
@@ -57,7 +57,7 @@ module.exports = function createWrappedExpectProto(unexpected) {
             try {
                 var result = oathbreaker(callback());
                 if (isPendingPromise(result)) {
-                    testFrameworkPatch.promiseCreated();
+                    notifyPendingPromise(result);
                     result = result.then(undefined, function (e) {
                         if (e && e._isUnexpected) {
                             throw new UnexpectedError(that, e);

diff --git a/lib/index.js b/lib/index.js
@@ -1,23 +1,3 @@
-var testFrameworkPatch = require('./testFrameworkPatch');
-
-function applyTestFrameworkPatchWhenLoaded(mod) {
-    Object.defineProperty(require.cache, mod.id, {
-        get: function () {
-            testFrameworkPatch.applyPatch();
-            return mod;
-        }
-    });
-}
-
-if (testFrameworkPatch.applyPatch() && typeof require === 'function' && require.cache) {
-    // Make sure that the 'it' global gets patched in every context where Unexpected is required,
-    // but prevent rereading index.js and the chain of parent modules from disc each time:
-
-    for (var mod = module ; mod ; mod = mod.parent) {
-        applyTestFrameworkPatchWhenLoaded(mod);
-    }
-}
-
 module.exports = require('./Unexpected').create()
     .use(require('./styles'))
     .use(require('./types'))

diff --git a/lib/notifyPendingPromise.js b/lib/notifyPendingPromise.js
@@ -0,0 +1,54 @@
+/*global afterEach, jasmine*/
+var pendingPromisesForTheCurrentTest = [];
+var afterEachRegistered = false;
+
+var currentSpec = null;
+
+if (typeof jasmine === 'object') {
+    // Add a custom reporter that allows us to capture the name of the currently executing spec:
+    jasmine.getEnv().addReporter({
+        specStarted: function (spec) {
+            currentSpec = spec;
+        },
+        specDone: function (spec) {
+            currentSpec = null;
+        }
+    });
+}
+
+function registerAfterEachHook() {
+    if (typeof afterEach === 'function' && !afterEachRegistered) {
+        afterEachRegistered = true;
+        try {
+            afterEach(function () {
+                var error;
+                if (pendingPromisesForTheCurrentTest.some(function (promise) {return promise.isPending();})) {
+                    var displayName;
+                    if (this.currentTest) {
+                        // mocha
+                        displayName = this.currentTest.title;
+                    } else if (currentSpec) {
+                        displayName = currentSpec.fullName;
+                    }
+                    error = new Error(displayName + ': You have created a promise that was not returned from the it block');
+                }
+                pendingPromisesForTheCurrentTest = [];
+                if (error) {
+                    throw error;
+                }
+            });
+        } catch (e) {
+            // The benchmark suite fails when attempting to add an afterEach
+        }
+    }
+}
+
+// When running in jasmine/node.js, afterEach is available immediately,
+// but doesn't work within the it block. Register the hook immediately:
+registerAfterEachHook();
+
+module.exports = function notifyPendingPromise(promise) {
+    pendingPromisesForTheCurrentTest.push(promise);
+    // Register the afterEach hook lazily (mocha/node.js):
+    registerAfterEachHook();
+};
diff --git a/lib/testFrameworkPatch.js b/lib/testFrameworkPatch.js
diff --git a/package.json b/package.json
@@ -46,6 +46,6 @@
     "rsvp": "3.0.18",
     "serve": "*",
     "unexpected-documentation-site-generator": "^4.0.0",
-    "unexpected-markdown": "1.3.0"
+    "unexpected-markdown": "1.3.1"
   }
 }
diff --git a/test/support/jasmineSetup.js b/test/support/jasmineSetup.js
@@ -1,4 +1,78 @@
-/*global xdescribe, xit, beforeAll, afterAll, before:true, after:true*/
+/*global jasmine, it:true, xdescribe, xit, beforeAll, afterAll, before:true, after:true*/
+function jasmineFail(err) {
+    if (typeof jasmine === 'object') {
+        jasmine.getEnv().fail(err);
+    }
+}
+
+function jasmineSuccess(err) {
+    if (typeof jasmine === 'object') {
+        jasmine.getEnv().expect(true).toBe(true);
+    }
+}
+
+var shouldApplyPatch =
+    typeof jasmine !== 'undefined' &&
+    typeof jasmine.version === 'string' &&
+    jasmine.version.match(/^2\./);
+
+if (typeof it === 'function' && shouldApplyPatch) {
+    var originalIt = it;
+    it = function (title, fn) {
+        if (!fn) {
+            return originalIt(title);
+        }
+        var async = fn.length > 0;
+        var wrapper = function (done) {
+            var result;
+            try {
+                if (async) {
+                    fn.call(this, function (err) {
+                        if (err) {
+                            jasmineFail(err);
+                            done(err);
+                        } else {
+                            jasmineSuccess();
+                            done();
+                        }
+                    });
+                    return;
+                } else {
+                    result = fn.call(this);
+                }
+
+                var isPromise =
+                    result &&
+                    typeof result === 'object' &&
+                    typeof result.then === 'function';
+
+                if (isPromise) {
+                    result.then(function () {
+                        jasmineSuccess();
+                        done();
+                    }, function (err) {
+                        jasmineFail(err);
+                        done(err);
+                    });
+                } else {
+                    jasmineSuccess();
+                    done();
+                }
+            } catch (err) {
+                jasmineFail(err);
+                return done(err);
+            }
+        };
+        wrapper.toString = function () {
+            return fn.toString();
+        };
+        return originalIt(title, wrapper);
+    };
+    Object.keys(originalIt).forEach(function (methodName) {
+        it[methodName] = originalIt[methodName];
+    });
+    it.patchApplied = true;
+}
 
 if (!it.skip && xit) {
     it.skip = function () {