Dont run before and after hooks when all tests are skipped (avajs#1283)

Author: Nick Jaggars

lib/test-collection.js

@@ -178,19 +178,32 @@ class TestCollection extends EventEmitter {
 	_buildTests(tests) {
 		return tests.map(test => this._buildTestWithHooks(test));
 	}
+	_hasUnskippedTests() {
+		const getUnskippedCount = tests => tests.filter(test => {
+			return !(test.metadata && test.metadata.skipped === true);
+		}).length;
+		return (getUnskippedCount(this.tests.serial) + getUnskippedCount(this.tests.concurrent)) > 0;
+	}
 	build() {
-		const beforeHooks = new Sequence(this._buildHooks(this.hooks.before));
-		const afterHooks = new Sequence(this._buildHooks(this.hooks.after));
-
 		const serialTests = new Sequence(this._buildTests(this.tests.serial), this.bail);
 		const concurrentTests = new Concurrent(this._buildTests(this.tests.concurrent), this.bail);
 		const allTests = new Sequence([serialTests, concurrentTests]);
 
-		let finalTests = new Sequence([beforeHooks, allTests, afterHooks], true);
+		let finalTests;
+		// Only run before and after hooks when there are unskipped tests
+		if (this._hasUnskippedTests()) {
+			const beforeHooks = new Sequence(this._buildHooks(this.hooks.before));
+			const afterHooks = new Sequence(this._buildHooks(this.hooks.after));
+			finalTests = new Sequence([beforeHooks, allTests, afterHooks], true);
+		} else {
+			finalTests = new Sequence([allTests], true);
+		}
+
 		if (this.hooks.afterAlways.length > 0) {
 			const afterAlwaysHooks = new Sequence(this._buildHooks(this.hooks.afterAlways));
 			finalTests = new Sequence([finalTests, afterAlwaysHooks], false);
 		}
+
 		return finalTests;
 	}
 	attributeLeakedError(err) {

test/api.js

@@ -714,6 +714,18 @@ function generateTests(prefix, apiCreator) {
 			});
 	});
 
+	test(`${prefix} test file with only skipped tests does not run hooks`, t => {
+		const api = apiCreator();
+
+		return api.run([path.join(__dirname, 'fixture/hooks-skipped.js')])
+			.then(result => {
+				t.is(result.tests.length, 1);
+				t.is(result.skipCount, 1);
+				t.is(result.passCount, 0);
+				t.is(result.failCount, 0);
+			});
+	});
+
 	test(`${prefix} resets state before running`, t => {
 		const api = apiCreator();
 

test/fixture/hooks-skipped.js

@@ -0,0 +1,21 @@
+import test from '../..';
+
+test.before(() => {
+	throw new Error('should not run');
+});
+
+test.after(() => {
+	throw new Error('should not run');
+});
+
+test.beforeEach(() => {
+	throw new Error('should not run');
+});
+
+test.afterEach(() => {
+	throw new Error('should not run');
+});
+
+test.skip('some skipped test', t => {
+	t.fail();
+});

test/test-collection.js

@@ -239,6 +239,80 @@ test('adding a bunch of different types', t => {
 	t.end();
 });
 
+test('skips before and after hooks when all tests are skipped', t => {
+	t.plan(5);
+
+	const collection = new TestCollection({});
+	collection.add({
+		metadata: metadata({type: 'before'}),
+		fn: a => a.fail()
+	});
+	collection.add({
+		metadata: metadata({type: 'after'}),
+		fn: a => a.fail()
+	});
+	collection.add({
+		title: 'some serial test',
+		metadata: metadata({skipped: true, serial: true}),
+		fn: a => a.fail()
+	});
+	collection.add({
+		title: 'some concurrent test',
+		metadata: metadata({skipped: true}),
+		fn: a => a.fail()
+	});
+
+	const log = [];
+	collection.on('test', result => {
+		t.is(result.result.metadata.skipped, true);
+		t.is(result.result.metadata.type, 'test');
+		log.push(result.result.title);
+	});
+
+	collection.build().run();
+
+	t.strictDeepEqual(log, [
+		'some serial test',
+		'some concurrent test'
+	]);
+
+	t.end();
+});
+
+test('skips beforeEach and afterEach hooks when test is skipped', t => {
+	t.plan(3);
+
+	const collection = new TestCollection({});
+	collection.add({
+		metadata: metadata({type: 'beforeEach'}),
+		fn: a => a.fail()
+	});
+	collection.add({
+		metadata: metadata({type: 'afterEach'}),
+		fn: a => a.fail()
+	});
+	collection.add({
+		title: 'some test',
+		metadata: metadata({skipped: true}),
+		fn: a => a.fail()
+	});
+
+	const log = [];
+	collection.on('test', result => {
+		t.is(result.result.metadata.skipped, true);
+		t.is(result.result.metadata.type, 'test');
+		log.push(result.result.title);
+	});
+
+	collection.build().run();
+
+	t.strictDeepEqual(log, [
+		'some test'
+	]);
+
+	t.end();
+});
+
 test('foo', t => {
 	const collection = new TestCollection({});
 	const log = [];