Use bind behaviour to clone contextRef.context

Author: kugtong33

lib/test-collection.js

@@ -1,9 +1,41 @@
 'use strict';
 const EventEmitter = require('events');
+const cloneDeep = require('lodash.clonedeep');
 const Concurrent = require('./concurrent');
 const Sequence = require('./sequence');
 const Test = require('./test');
 
+class ContextBind {
+	constructor(ref) {
+		this.ref = ref;
+		this.bound = false;
+		this.boundContext = {};
+	}
+
+	get context() {
+		if (!this.bound) {
+			this.context = cloneDeep(this.ref.context);
+		}
+
+		return this.boundContext;
+	}
+
+	set context(context) {
+		this.bound = true;
+		this.boundContext = context;
+	}
+}
+
+class Context {
+	constructor() {
+		this.context = {};
+	}
+
+	clone() {
+		return new ContextBind(this);
+	}
+}
+
 class TestCollection extends EventEmitter {
 	constructor(options) {
 		super();
@@ -110,9 +142,9 @@ class TestCollection extends EventEmitter {
 		this.emit('test', result);
 	}
 
-	_buildHooks(hooks, testTitle, context) {
+	_buildHooks(hooks, testTitle, contextRef) {
 		return hooks.map(hook => {
-			const test = this._buildHook(hook, testTitle, context);
+			const test = this._buildHook(hook, testTitle, contextRef);
 
 			if (hook.metadata.skipped || hook.metadata.todo) {
 				return this._skippedTest(test);
@@ -129,10 +161,6 @@ class TestCollection extends EventEmitter {
 			title += ` for ${testTitle}`;
 		}
 
-		if (!contextRef) {
-			contextRef = null;
-		}
-
 		const test = new Test({
 			contextRef,
 			failWithoutAssertions: false,
@@ -147,10 +175,6 @@ class TestCollection extends EventEmitter {
 	}
 
 	_buildTest(test, contextRef) {
-		if (!contextRef) {
-			contextRef = null;
-		}
-
 		test = new Test({
 			contextRef,
 			failWithoutAssertions: this.failWithoutAssertions,
@@ -164,26 +188,26 @@ class TestCollection extends EventEmitter {
 		return test;
 	}
 
-	_buildTestWithHooks(test, context) {
+	_buildTestWithHooks(test, contextRef) {
 		if (test.metadata.skipped || test.metadata.todo) {
 			return new Sequence([this._skippedTest(this._buildTest(test))], true);
 		}
 
-		const contextRef = context ? Object.create(context) : {context: {}};
+		const context = contextRef.clone();
 
-		const beforeHooks = this._buildHooks(this.hooks.beforeEach, test.title, contextRef);
-		const afterHooks = this._buildHooks(this.hooks.afterEach, test.title, contextRef);
+		const beforeHooks = this._buildHooks(this.hooks.beforeEach, test.title, context);
+		const afterHooks = this._buildHooks(this.hooks.afterEach, test.title, context);
 
-		let sequence = new Sequence([].concat(beforeHooks, this._buildTest(test, contextRef), afterHooks), true);
+		let sequence = new Sequence([].concat(beforeHooks, this._buildTest(test, context), afterHooks), true);
 		if (this.hooks.afterEachAlways.length > 0) {
-			const afterAlwaysHooks = new Sequence(this._buildHooks(this.hooks.afterEachAlways, test.title, contextRef));
+			const afterAlwaysHooks = new Sequence(this._buildHooks(this.hooks.afterEachAlways, test.title, context));
 			sequence = new Sequence([sequence, afterAlwaysHooks], false);
 		}
 		return sequence;
 	}
 
-	_buildTests(tests, context) {
-		return tests.map(test => this._buildTestWithHooks(test, context));
+	_buildTests(tests, contextRef) {
+		return tests.map(test => this._buildTestWithHooks(test, contextRef));
 	}
 
 	_hasUnskippedTests() {
@@ -194,26 +218,24 @@ class TestCollection extends EventEmitter {
 	}
 
 	build() {
-		const sequenceTests = context => {
-			const serialTests = new Sequence(this._buildTests(this.tests.serial, context), this.bail);
-			const concurrentTests = new Concurrent(this._buildTests(this.tests.concurrent, context), this.bail);
-			return new Sequence([serialTests, concurrentTests]);
-		};
+		const context = new Context();
+
+		const serialTests = new Sequence(this._buildTests(this.tests.serial, context), this.bail);
+		const concurrentTests = new Concurrent(this._buildTests(this.tests.concurrent, context), this.bail);
+		const allTests = new Sequence([serialTests, concurrentTests]);
 
 		let finalTests;
 		// Only run before and after hooks when there are unskipped tests
 		if (this._hasUnskippedTests()) {
-			const context = {context: {}};
-
 			const beforeHooks = new Sequence(this._buildHooks(this.hooks.before, null, context));
-			const afterHooks = new Sequence(this._buildHooks(this.hooks.after));
-			finalTests = new Sequence([beforeHooks, sequenceTests(context), afterHooks], true);
+			const afterHooks = new Sequence(this._buildHooks(this.hooks.after, null, context));
+			finalTests = new Sequence([beforeHooks, allTests, afterHooks], true);
 		} else {
-			finalTests = new Sequence([sequenceTests()], true);
+			finalTests = new Sequence([allTests], true);
 		}
 
 		if (this.hooks.afterAlways.length > 0) {
-			const afterAlwaysHooks = new Sequence(this._buildHooks(this.hooks.afterAlways));
+			const afterAlwaysHooks = new Sequence(this._buildHooks(this.hooks.afterAlways, null, context));
 			finalTests = new Sequence([finalTests, afterAlwaysHooks], false);
 		}
 

package-lock.json

@@ -112,6 +112,7 @@
 		"is-observable": "^1.1.0",
 		"is-promise": "^2.1.0",
 		"last-line-stream": "^1.0.0",
+		"lodash.clone": "^4.5.0",
 		"lodash.clonedeepwith": "^4.5.0",
 		"lodash.debounce": "^4.0.3",
 		"lodash.difference": "^4.3.0",

package.json

@@ -459,7 +459,7 @@ test('shared context', t => {
 	});
 
 	runner.chain.after(a => {
-		a.is(a.context, null);
+		a.deepEqual(a.context.arr, ['a']);
 	});
 
 	runner.chain.beforeEach(a => {