Split up cli.js tests

Tests from this file are now consistently timing out in TravisCI. Split
across multiple files in the hope that this reduces the failure rate.

Author: novemberborn

test/cli.js

@@ -0,0 +1,55 @@
+'use strict';
+const path = require('path');
+const childProcess = require('child_process');
+const getStream = require('get-stream');
+
+const cliPath = path.join(__dirname, '../../cli.js');
+
+function execCli(args, opts, cb) {
+	let dirname;
+	let env;
+
+	if (typeof opts === 'function') {
+		cb = opts;
+		dirname = path.resolve(__dirname, '..');
+		env = {};
+	} else {
+		dirname = path.resolve(__dirname, '..', opts.dirname ? opts.dirname : '');
+		env = opts.env || {};
+	}
+
+	let child;
+	let stdout;
+	let stderr;
+
+	const processPromise = new Promise(resolve => {
+		child = childProcess.spawn(process.execPath, [cliPath].concat(args), {
+			cwd: dirname,
+			env: Object.assign({CI: '1'}, env), // Force CI to ensure the correct reporter is selected
+			// env,
+			stdio: [null, 'pipe', 'pipe']
+		});
+
+		child.on('close', (code, signal) => {
+			if (code) {
+				const err = new Error(`test-worker exited with a non-zero exit code: ${code}`);
+				err.code = code;
+				err.signal = signal;
+				resolve(err);
+				return;
+			}
+
+			resolve(code);
+		});
+
+		stdout = getStream(child.stdout);
+		stderr = getStream(child.stderr);
+	});
+
+	Promise.all([processPromise, stdout, stderr]).then(args => {
+		cb.apply(null, args);
+	});
+
+	return child;
+}
+exports.execCli = execCli;

test/helper/cli.js

@@ -0,0 +1,156 @@
+'use strict';
+const fs = require('fs');
+const childProcess = require('child_process');
+const path = require('path');
+const makeDir = require('make-dir');
+const stripAnsi = require('strip-ansi');
+const test = require('tap').test;
+const {execCli} = require('../helper/cli');
+
+test('timeout', t => {
+	execCli(['fixture/long-running.js', '-T', '1s'], (err, stdout) => {
+		t.ok(err);
+		t.match(stdout, /Exited because no new tests completed within the last 1000ms of inactivity/);
+		t.end();
+	});
+});
+
+test('include anonymous functions in error reports', t => {
+	execCli('fixture/error-in-anonymous-function.js', (err, stdout) => {
+		t.ok(err);
+		t.match(stdout, /test\/fixture\/error-in-anonymous-function\.js:4:8/);
+		t.end();
+	});
+});
+
+test('--match works', t => {
+	execCli(['-m=foo', '-m=bar', '-m=!baz', '-m=t* a* f*', '-m=!t* a* n* f*', 'fixture/matcher-skip.js'], err => {
+		t.ifError(err);
+		t.end();
+	});
+});
+
+['--tap', '-t'].forEach(tapFlag => {
+	test(`${tapFlag} should produce TAP output`, t => {
+		execCli([tapFlag, 'test.js'], {dirname: 'fixture/watcher'}, err => {
+			t.ok(!err);
+			t.end();
+		});
+	});
+});
+
+test('handles NODE_PATH', t => {
+	const nodePaths = `fixture/node-paths/modules${path.delimiter}fixture/node-paths/deep/nested`;
+
+	execCli('fixture/node-paths.js', {env: {NODE_PATH: nodePaths}}, err => {
+		t.ifError(err);
+		t.end();
+	});
+});
+
+test('works when no files are found', t => {
+	execCli('!*', (err, stdout) => {
+		t.is(err.code, 1);
+		t.match(stdout, 'Couldn\'t find any files to test');
+		t.end();
+	});
+});
+
+test('should warn ava is required without the cli', t => {
+	childProcess.execFile(process.execPath, [path.resolve(__dirname, '../../index.js')], error => {
+		t.ok(error);
+		t.match(error.message, /Test files must be run with the AVA CLI/);
+		t.end();
+	});
+});
+
+test('prefers local version of ava', t => {
+	execCli('', {
+		dirname: 'fixture/local-bin',
+		env: {
+			DEBUG: 'ava'
+		}
+	}, (err, stdout, stderr) => {
+		t.ifError(err);
+		t.match(stderr, 'Using local install of AVA');
+		t.end();
+	});
+});
+
+test('workers ensure test files load the same version of ava', t => {
+	const target = path.join(__dirname, '..', 'fixture', 'ava-paths', 'target');
+
+	// Copy the index.js so the testFile imports it. It should then load the correct AVA install.
+	const targetInstall = path.join(target, 'node_modules/ava');
+	makeDir.sync(targetInstall);
+	fs.writeFileSync(
+		path.join(targetInstall, 'index.js'),
+		fs.readFileSync(path.join(__dirname, '../../index.js'))
+	);
+
+	const testFile = path.join(target, 'test.js');
+	execCli([testFile], {dirname: path.join('fixture', 'ava-paths', 'cwd')}, err => {
+		t.ifError(err);
+		t.end();
+	});
+});
+
+test('tests without assertions do not fail if failWithoutAssertions option is set to false', t => {
+	execCli([], {dirname: 'fixture/pkg-conf/fail-without-assertions'}, err => {
+		t.ifError(err);
+		t.end();
+	});
+});
+
+test('--no-color disables formatting colors', t => {
+	execCli(['--no-color', '--verbose', 'formatting-color.js'], {dirname: 'fixture'}, (err, stdout) => {
+		t.ok(err);
+		t.is(stripAnsi(stdout), stdout);
+		t.end();
+	});
+});
+
+test('--color enables formatting colors', t => {
+	execCli(['--color', '--verbose', 'formatting-color.js'], {dirname: 'fixture'}, (err, stdout) => {
+		t.ok(err);
+		t.isNot(stripAnsi(stdout), stdout);
+		t.end();
+	});
+});
+
+test('sets NODE_ENV to test when it is not set', t => {
+	execCli([path.join('fixture', 'node-env-test.js')], {env: {}}, (err, stdout) => {
+		t.ifError(err);
+		t.match(stdout, /1 test passed/);
+		t.end();
+	});
+});
+
+test('doesn\'t set NODE_ENV when it is set', t => {
+	execCli([path.join('fixture', 'node-env-foo.js')], {env: {NODE_ENV: 'foo'}}, (err, stdout) => {
+		t.ifError(err);
+		t.match(stdout, /1 test passed/);
+		t.end();
+	});
+});
+
+test('additional arguments are forwarded to the worker', t => {
+	execCli(['worker-argv.js', '--serial', '--', '--hello', 'world'], {dirname: 'fixture'}, err => {
+		t.ifError(err);
+		t.end();
+	});
+});
+
+test('--reset-cache resets cache', t => {
+	const cacheDir = path.join(__dirname, '..', 'fixture', 'reset-cache', 'node_modules', '.cache', 'ava');
+	execCli([], {dirname: 'fixture/reset-cache'}, err => {
+		t.ifError(err);
+		t.true(fs.readdirSync(cacheDir).length > 0);
+
+		execCli(['--reset-cache'], {dirname: 'fixture/reset-cache'}, err => {
+			t.ifError(err);
+			t.true(fs.readdirSync(cacheDir).length === 0);
+			t.end();
+		});
+	});
+});

test/integration/assorted.js

@@ -0,0 +1,32 @@
+'use strict';
+const test = require('tap').test;
+const figures = require('figures');
+const pkg = require('../../package.json');
+const {execCli} = require('../helper/cli');
+
+for (const which of [
+	'bad-key',
+	'bad-shortcut',
+	'array-test-options',
+	'false-test-options',
+	'null-test-options',
+	'null-extensions',
+	'obj-extensions',
+	'string-extensions',
+	'non-string-value-extensions',
+	'empty-string-value-extensions'
+]) {
+	test(`validates babel config: ${which}`, t => {
+		execCli(['es2015.js'], {dirname: `fixture/invalid-babel-config/${which}`}, (err, stdout, stderr) => {
+			t.ok(err);
+
+			let expectedOutput = '\n';
+			expectedOutput += figures.cross + ' Unexpected Babel configuration for AVA.';
+			expectedOutput += ` See https://github.com/avajs/ava/blob/v${pkg.version}/docs/recipes/babel.md for allowed values.`;
+			expectedOutput += '\n';
+
+			t.is(stderr, expectedOutput);
+			t.end();
+		});
+	});
+}

test/integration/babel.js

@@ -0,0 +1,70 @@
+'use strict';
+const stripAnsi = require('strip-ansi');
+const test = require('tap').test;
+const {execCli} = require('../helper/cli');
+
+test('precompiler require hook does not apply to source files', t => {
+	t.plan(3);
+
+	execCli('fixture/babel-hook.js', (err, stdout) => {
+		t.ok(err);
+		t.is(err.code, 1);
+		t.match(stdout, /Unexpected (token|reserved word)/);
+		t.end();
+	});
+});
+
+test('skips test file compilation when babel=false and compileEnhancements=false', t => {
+	execCli(['import.js'], {dirname: 'fixture/no-babel-compilation'}, (err, stdout) => {
+		t.ok(err);
+		t.match(stdout, /SyntaxError: Unexpected (reserved word|token import|identifier)/);
+		t.end();
+	});
+});
+
+test('skips helper file compilation when babel=false and compileEnhancements=false', t => {
+	execCli(['require-helper.js'], {dirname: 'fixture/no-babel-compilation'}, (err, stdout) => {
+		t.ifError(err);
+		t.match(stdout, /1 test passed/);
+		t.end();
+	});
+});
+
+test('no power-assert when babel=false and compileEnhancements=false', t => {
+	execCli(['no-power-assert.js'], {dirname: 'fixture/no-babel-compilation'}, (err, stdout) => {
+		t.ok(err);
+		t.notMatch(stripAnsi(stdout), /bool\n.*=> false/);
+		t.end();
+	});
+});
+
+test('skips stage-4 transform when babel=false and compileEnhancements=true', t => {
+	execCli(['import.js'], {dirname: 'fixture/just-enhancement-compilation'}, (err, stdout) => {
+		t.ok(err);
+		t.match(stdout, /SyntaxError: Unexpected (reserved word|token import|identifier)/);
+		t.end();
+	});
+});
+
+test('power-assert when babel=false and compileEnhancements=true', t => {
+	execCli(['power-assert.js'], {dirname: 'fixture/just-enhancement-compilation'}, (err, stdout) => {
+		t.ok(err);
+		t.match(stripAnsi(stdout), /bool\n.*=> false/);
+		t.end();
+	});
+});
+
+test('power-assert with custom extension and no regular babel pipeline', t => {
+	execCli(['.'], {dirname: 'fixture/just-enhancement-compilation/custom-extension'}, (err, stdout) => {
+		t.ok(err);
+		t.match(stripAnsi(stdout), /bool\n.*=> false/);
+		t.end();
+	});
+});
+
+test('workers load compiled helpers if in the require configuration', t => {
+	execCli(['test/verify.js'], {dirname: 'fixture/require-compiled-helper'}, err => {
+		t.ifError(err);
+		t.end();
+	});
+});

test/integration/compilation.js

@@ -0,0 +1,52 @@
+'use strict';
+const test = require('tap').test;
+const {execCli} = require('../helper/cli');
+
+['--concurrency', '-c'].forEach(concurrencyFlag => {
+	test(`bails when ${concurrencyFlag} is provided without value`, t => {
+		execCli(['test.js', concurrencyFlag], {dirname: 'fixture/concurrency'}, (err, stdout, stderr) => {
+			t.is(err.code, 1);
+			t.match(stderr, 'The --concurrency or -c flag must be provided with a nonnegative integer.');
+			t.end();
+		});
+	});
+});
+
+['--concurrency', '-c'].forEach(concurrencyFlag => {
+	test(`bails when ${concurrencyFlag} is provided with an input that is a string`, t => {
+		execCli([`${concurrencyFlag}=foo`, 'test.js', concurrencyFlag], {dirname: 'fixture/concurrency'}, (err, stdout, stderr) => {
+			t.is(err.code, 1);
+			t.match(stderr, 'The --concurrency or -c flag must be provided with a nonnegative integer.');
+			t.end();
+		});
+	});
+});
+
+['--concurrency', '-c'].forEach(concurrencyFlag => {
+	test(`bails when ${concurrencyFlag} is provided with an input that is a float`, t => {
+		execCli([`${concurrencyFlag}=4.7`, 'test.js', concurrencyFlag], {dirname: 'fixture/concurrency'}, (err, stdout, stderr) => {
+			t.is(err.code, 1);
+			t.match(stderr, 'The --concurrency or -c flag must be provided with a nonnegative integer.');
+			t.end();
+		});
+	});
+});
+
+['--concurrency', '-c'].forEach(concurrencyFlag => {
+	test(`bails when ${concurrencyFlag} is provided with an input that is negative`, t => {
+		execCli([`${concurrencyFlag}=-1`, 'test.js', concurrencyFlag], {dirname: 'fixture/concurrency'}, (err, stdout, stderr) => {
+			t.is(err.code, 1);
+			t.match(stderr, 'The --concurrency or -c flag must be provided with a nonnegative integer.');
+			t.end();
+		});
+	});
+});
+
+['--concurrency', '-c'].forEach(concurrencyFlag => {
+	test(`works when ${concurrencyFlag} is provided with a value`, t => {
+		execCli([`${concurrencyFlag}=1`, 'test.js'], {dirname: 'fixture/concurrency'}, err => {
+			t.ifError(err);
+			t.end();
+		});
+	});
+});