tape/test/teardown.js

'use strict';

var tape = require('../');
var tap = require('tap');
var concat = require('concat-stream');
var forEach = require('for-each');
var v = require('es-value-fixtures');
var inspect = require('object-inspect');
var flatMap = require('array.prototype.flatmap');

var stripFullStack = require('./common').stripFullStack;

tap.test('teardowns', function (tt) {
	tt.plan(1);

	var test = tape.createHarness();
	test.createStream().pipe(concat(function (body) {
		tt.same(stripFullStack(body.toString('utf8')), [].concat(
			'TAP version 13',
			'# success',
			'ok 1 should be truthy',
			'# success teardown',
			'# success teardown 2',
			'# success (async)',
			'ok 2 should be truthy',
			'# success (async) teardown',
			'# success (async) teardown 2',
			'# nested teardowns',
			'# nested success',
			'ok 3 should be truthy',
			'# nested teardown (nested success level)',
			'# nested teardown (nested success level) 2',
			'# nested failure',
			'not ok 4 nested failure!',
			'  ---',
			'    operator: fail',
			'    at: Test.<anonymous> ($TEST/teardown.js:$LINE:$COL)',
			'    stack: |-',
			'      Error: nested failure!',
			'          [... stack stripped ...]',
			'          at Test.<anonymous> ($TEST/teardown.js:$LINE:$COL)',
			'          [... stack stripped ...]',
			'  ...',
			'# nested teardown (nested fail level)',
			'# nested teardown (nested fail level) 2',
			'# nested teardown (top level)',
			'# nested teardown (top level) 2',
			'# fail',
			'not ok 5 failure!',
			'  ---',
			'    operator: fail',
			'    at: Test.<anonymous> ($TEST/teardown.js:$LINE:$COL)',
			'    stack: |-',
			'      Error: failure!',
			'          [... stack stripped ...]',
			'          at Test.<anonymous> ($TEST/teardown.js:$LINE:$COL)',
			'          [... stack stripped ...]',
			'  ...',
			'# failure teardown',
			'# failure teardown 2',
			'# teardown errors do not stop the next teardown fn from running',
			'ok 6 should be truthy',
			'not ok 7 SyntaxError: teardown error!',
			'  ---',
			'    operator: fail',
			'    stack: |-',
			'      Error: SyntaxError: teardown error!',
			'          [... stack stripped ...]',
			'  ...',
			'not ok 8 plan != count',
			'  ---',
			'    operator: fail',
			'    expected: 1',
			'    actual:   2',
			'    stack: |-',
			'      Error: plan != count',
			'          [... stack stripped ...]',
			'  ...',
			'# teardown runs after teardown error',
			'# teardown given non-function fails the test',
			'ok 9 should be truthy',
			flatMap(v.nonFunctions, function (nonFunction, i) {
				var offset = 10;
				return [].concat(
					'not ok ' + (offset + (i > 0 ? i + 1 : i)) + ' teardown: ' + inspect(nonFunction) + ' is not a function',
					'  ---',
					'    operator: fail',
					'    at: <anonymous> ($TEST/teardown.js:$LINE:$COL)',
					'    stack: |-',
					'      Error: teardown: ' + inspect(nonFunction) + ' is not a function',
					'          [... stack stripped ...]',
					'          at $TEST/teardown.js:$LINE:$COL',
					'          [... stack stripped ...]',
					'          at Test.<anonymous> ($TEST/teardown.js:$LINE:$COL)',
					'          [... stack stripped ...]',
					'  ...',
					i > 0 ? [] : [
						'not ok ' + (offset + 1) + ' plan != count',
						'  ---',
						'    operator: fail',
						'    expected: 1',
						'    actual:   2',
						'    at: <anonymous> ($TEST/teardown.js:$LINE:$COL)',
						'    stack: |-',
						'      Error: plan != count',
						'          [... stack stripped ...]',
						'          at $TEST/teardown.js:$LINE:$COL',
						'          [... stack stripped ...]',
						'          at Test.<anonymous> ($TEST/teardown.js:$LINE:$COL)',
						'          [... stack stripped ...]',
						'  ...'
					]
				);
			}),
			typeof Promise === 'function' ? [
				'# teardown is only ever called once, even when async',
				'ok ' + (11 + v.nonFunctions.length) + ' passes',
				'# teardown: once?',
				'# success (promise)',
				'ok ' + (12 + v.nonFunctions.length) + ' should be truthy',
				'# success (promise) teardown: 1',
				'# success (promise) teardown: 2',
				'# success (promise) teardown: 3'
			] : [
				'# SKIP teardown is only ever called once, even when async',
				'# SKIP success (promise)'
			],
			[
				'',
				'1..' + ((typeof Promise === 'function' ? 2 : 0) + 10 + v.nonFunctions.length),
				'# tests ' + ((typeof Promise === 'function' ? 2 : 0) + 10 + v.nonFunctions.length),
				'# pass  ' + ((typeof Promise === 'function' ? 2 : 0) + 5),
				'# fail  ' + (5 + v.nonFunctions.length),
				''
			]
		));
	}));

	test('success', function (t) {
		t.plan(1);
		t.teardown(function () {
			t.comment('success teardown');
		});
		t.teardown(function () {
			t.comment('success teardown 2');
		});
		t.ok('success!');
	});

	test('success (async)', function (t) {
		t.plan(1);
		t.teardown(function () {
			t.comment('success (async) teardown');
		});
		t.teardown(function () {
			t.comment('success (async) teardown 2');
		});
		setTimeout(function () {
			t.ok('success!');
		}, 10);
	});

	test('nested teardowns', function (t) {
		t.plan(2);

		t.teardown(function () {
			t.comment('nested teardown (top level)');
		});
		t.teardown(function () {
			t.comment('nested teardown (top level) 2');
		});

		t.test('nested success', function (st) {
			st.teardown(function () {
				st.comment('nested teardown (nested success level)');
			});
			st.teardown(function () {
				st.comment('nested teardown (nested success level) 2');
			});

			st.ok('nested success!');
			st.end();
		});

		t.test('nested failure', function (st) {
			st.plan(1);

			st.teardown(function () {
				st.comment('nested teardown (nested fail level)');
			});
			st.teardown(function () {
				st.comment('nested teardown (nested fail level) 2');
			});

			st.fail('nested failure!');
		});
	});

	test('fail', function (t) {
		t.plan(1);

		t.teardown(function () {
			t.comment('failure teardown');
		});
		t.teardown(function () {
			t.comment('failure teardown 2');
		});

		t.fail('failure!');
	});

	test('teardown errors do not stop the next teardown fn from running', function (t) {
		t.plan(1);

		t.ok('teardown error test');

		t.teardown(function () {
			throw new SyntaxError('teardown error!');
		});
		t.teardown(function () {
			t.comment('teardown runs after teardown error');
		});
	});

	test('teardown given non-function fails the test', function (t) {
		t.plan(1);

		t.ok('non-function test');

		forEach(v.nonFunctions, function (nonFunction) {
			t.teardown(nonFunction);
		});
	});

	test('teardown is only ever called once, even when async', { skip: typeof Promise !== 'function' }, function (t) {
		t.plan(1);

		t.teardown(function () {
			t.comment('teardown: once?');
		});

		t.pass('passes');

		return Promise.resolve();
	});

	test('success (promise)', { skip: typeof Promise !== 'function' }, function (t) {
		t.plan(1);

		t.teardown(function () {
			return new Promise(function (resolve) {
				t.comment('success (promise) teardown: 1');
				setTimeout(resolve, 10);
			}).then(function () {
				t.comment('success (promise) teardown: 2');
			});
		});
		t.teardown(function () {
			t.comment('success (promise) teardown: 3');
		});

		setTimeout(function () {
			t.ok('success!');
		}, 10);
	});
});

tap.test('teardown with promise', { skip: typeof Promise !== 'function', timeout: 1e3 }, function (tt) {
	tt.plan(2);
	tape('dummy test', function (t) {
		var resolved = false;
		t.teardown(function () {
			tt.pass('tape teardown');
			var p = Promise.resolve();
			p.then(function () {
				resolved = true;
			});
			return p;
		});
		t.on('end', function () {
			tt.is(resolved, true);
		});
		t.end();
	});
});

tap.test('teardown only runs once', { skip: typeof Promise !== 'function', timeout: 1e3 }, function (tt) {
	tt.plan(1);

	var test = tape.createHarness();
	test.createStream().pipe(concat(function (body) {
		tt.same(stripFullStack(body.toString('utf8')), [].concat(
			'TAP version 13',
			'# teardown is only called once, even with a plan',
			'ok 1 passes',
			'# Tearing down!',
			'',
			'1..1',
			'# tests 1',
			'# pass  1',
			'',
			'# ok',
			''
		));
	}));

	test('teardown is only called once, even with a plan', function (t) {
		t.plan(1);

		t.teardown(function () {
			t.comment('Tearing down!');
		});

		t.pass('passes');

		return Promise.resolve();
	});
});