Core: Run before and after hooks with module context

The before and after hooks run once per module as long as there is at least one
test in the module. Using environment inheritance allows us to use the module
context in those hooks, which allows reading the expected changes to the
context from a before hook inside nested modules.

Fixes qunitjs#1328.
Ref qunitjs#869.

src/module.js

@@ -21,9 +21,9 @@ function createModule (name, testEnvironment, modifiers) {
   const skip = (parentModule !== null && parentModule.skip) || modifiers.skip;
   const todo = (parentModule !== null && parentModule.todo) || modifiers.todo;
 
-  const env = {};
+  let env = {};
   if (parentModule) {
-    extend(env, parentModule.testEnvironment);
+    env = Object.create(parentModule.testEnvironment || {});
   }
   extend(env, testEnvironment);
 

src/test.js

@@ -158,7 +158,7 @@ Test.prototype = {
     return moduleStartChain.then(() => {
       config.current = this;
 
-      this.testEnvironment = extend({}, module.testEnvironment);
+      this.testEnvironment = Object.create(module.testEnvironment || {});
 
       this.started = performance.now();
       emit('testStart', this.testReport.start(true));
@@ -251,17 +251,18 @@ Test.prototype = {
 
   queueHook (hook, hookName, hookOwner) {
     const callHook = () => {
-      const promise = hook.call(this.testEnvironment, this.assert);
+      let promise;
+      if (hookName === 'before' || hookName === 'after') {
+        promise = hook.call(this.module.testEnvironment, this.assert);
+      } else {
+        promise = hook.call(this.testEnvironment, this.assert);
+      }
       this.resolvePromise(promise, hookName);
     };
 
     const runHook = () => {
-      if (hookName === 'before') {
-        if (hookOwner.testsRun !== 0) {
-          return;
-        }
-
-        this.preserveEnvironment = true;
+      if (hookName === 'before' && hookOwner.testsRun !== 0) {
+        return;
       }
 
       // The 'after' hook should only execute when there are not tests left and
@@ -483,13 +484,6 @@ Test.prototype = {
     }
   },
 
-  preserveTestEnvironment: function () {
-    if (this.preserveEnvironment) {
-      this.module.testEnvironment = this.testEnvironment;
-      this.testEnvironment = extend({}, this.module.testEnvironment);
-    }
-  },
-
   queue () {
     const test = this;
 
@@ -505,11 +499,6 @@ Test.prototype = {
         },
 
         ...test.hooks('before'),
-
-        function () {
-          test.preserveTestEnvironment();
-        },
-
         ...test.hooks('beforeEach'),
 
         function () {

test/main/async.js

@@ -242,18 +242,22 @@ QUnit.module('assert.async', function () {
     QUnit.test('test', function () {});
   });
 
+  var inBeforeHookModuleState;
   QUnit.module('in before hook', {
     before: function (assert) {
       var done = assert.async();
-      var testContext = this;
       setTimeout(function () {
-        testContext.state = 'before';
+        inBeforeHookModuleState = 'before';
         done();
       });
     }
   }, function () {
     QUnit.test('call order', function (assert) {
-      assert.equal(this.state, 'before', 'called before test callback');
+      assert.equal(
+        inBeforeHookModuleState,
+        'before',
+        'called before test callback'
+      );
     });
   });
 
@@ -289,18 +293,18 @@ QUnit.module('assert.async', function () {
     });
   });
 
+  var inAfterHookModuleState;
   QUnit.module('in after hook', {
     after: function (assert) {
-      assert.equal(this.state, 'done', 'called after test callback');
+      assert.equal(inAfterHookModuleState, 'done', 'called after test callback');
       assert.true(true, 'called before expected assert count is validated');
     }
   }, function () {
     QUnit.test('call order', function (assert) {
       assert.expect(2);
       var done = assert.async();
-      var testContext = this;
       setTimeout(function () {
-        testContext.state = 'done';
+        inAfterHookModuleState = 'done';
         done();
       });
     });