ava 0.16.0 → 0.17.0

package/lib/caching-precompiler.js

@@ -3,23 +3,25 @@ var path = require('path');
 var fs = require('fs');
 var convertSourceMap = require('convert-source-map');
 var cachingTransform = require('caching-transform');
+var packageHash = require('package-hash');
 var stripBom = require('strip-bom');
+var autoBind = require('auto-bind');
 var md5Hex = require('md5-hex');
-var packageHash = require('package-hash');
 var babelConfigHelper = require('./babel-config');
 
-function CachingPrecompiler(cacheDirPath, babelConfig) {
+function CachingPrecompiler(options) {
 	if (!(this instanceof CachingPrecompiler)) {
 		throw new TypeError('Class constructor CachingPrecompiler cannot be invoked without \'new\'');
 	}
 
-	this.babelConfig = babelConfigHelper.validate(babelConfig);
-	this.cacheDirPath = cacheDirPath;
-	this.fileHashes = {};
+	autoBind(this);
 
-	Object.keys(CachingPrecompiler.prototype).forEach(function (name) {
-		this[name] = this[name].bind(this);
-	}, this);
+	options = options || {};
+
+	this.babelConfig = babelConfigHelper.validate(options.babel);
+	this.cacheDirPath = options.path;
+	this.powerAssert = Boolean(options.powerAssert);
+	this.fileHashes = {};
 
 	this.transform = this._createTransform();
 }
@@ -37,35 +39,24 @@ CachingPrecompiler.prototype.precompileFile = function (filePath) {
 };
 
 // conditionally called by caching-transform when precompiling is required
-CachingPrecompiler.prototype._factory = function () {
-	this._init();
-
-	return this._transform;
-};
-
 CachingPrecompiler.prototype._init = function () {
 	this.babel = require('babel-core');
+
+	return this._transform;
 };
 
 CachingPrecompiler.prototype._transform = function (code, filePath, hash) {
 	code = code.toString();
 
-	var options = babelConfigHelper.build(this.babelConfig, filePath, code);
+	var options = babelConfigHelper.build(this.babelConfig, this.powerAssert, filePath, code);
 	var result = this.babel.transform(code, options);
 
 	// save source map
 	var mapPath = path.join(this.cacheDirPath, hash + '.js.map');
 	fs.writeFileSync(mapPath, JSON.stringify(result.map));
 
-	// When loading the test file, test workers intercept the require call and
-	// load the cached code instead. Libraries like nyc may also be intercepting
-	// require calls, however they won't know that different code was loaded.
-	// They may then attempt to resolve a source map from the original file
-	// location.
-	//
-	// Add a source map file comment to the cached code. The file path is
-	// relative from the directory of the original file to where the source map
-	// is cached. This will allow the source map to be resolved.
+	// append source map comment to transformed code
+	// so that other libraries (like nyc) can find the source map
 	var dirPath = path.dirname(filePath);
 	var relativeMapPath = path.relative(dirPath, mapPath);
 	var comment = convertSourceMap.generateMapFileComment(relativeMapPath);
@@ -74,13 +65,18 @@ CachingPrecompiler.prototype._transform = function (code, filePath, hash) {
 };
 
 CachingPrecompiler.prototype._createTransform = function () {
-	var salt = packageHash.sync(
-		[require.resolve('../package.json')].concat(babelConfigHelper.pluginPackages),
-		JSON.stringify(this.babelConfig)
-	);
+	var pluginPackages = babelConfigHelper.pluginPackages;
+	var avaPackage = require.resolve('../package.json');
+	var packages = [avaPackage].concat(pluginPackages);
+
+	var majorNodeVersion = process.version.split('.')[0];
+	var babelConfig = JSON.stringify(this.babelConfig);
+	var packageSalt = babelConfig + majorNodeVersion;
+
+	var salt = packageHash.sync(packages, packageSalt);
 
 	return cachingTransform({
-		factory: this._factory,
+		factory: this._init,
 		cacheDir: this.cacheDirPath,
 		hash: this._generateHash,
 		salt: salt,

package/lib/cli.js

@@ -0,0 +1,172 @@
+'use strict';
+var path = require('path');
+var updateNotifier = require('update-notifier');
+var figures = require('figures');
+var arrify = require('arrify');
+var meow = require('meow');
+var Promise = require('bluebird');
+var pkgConf = require('pkg-conf');
+var isCi = require('is-ci');
+var hasFlag = require('has-flag');
+var Api = require('../api');
+var colors = require('./colors');
+var verboseReporter = require('./reporters/verbose');
+var miniReporter = require('./reporters/mini');
+var tapReporter = require('./reporters/tap');
+var Logger = require('./logger');
+var Watcher = require('./watcher');
+var babelConfig = require('./babel-config');
+
+// Bluebird specific
+Promise.longStackTraces();
+
+exports.run = function () {
+	var conf = pkgConf.sync('ava');
+
+	var filepath = pkgConf.filepath(conf);
+	var pkgDir = filepath === null ? process.cwd() : path.dirname(filepath);
+
+	var cli = meow([
+		'Usage',
+		'  ava [<file|directory|glob> ...]',
+		'',
+		'Options',
+		'  --init             Add AVA to your project',
+		'  --fail-fast        Stop after first test failure',
+		'  --serial, -s       Run tests serially',
+		'  --tap, -t          Generate TAP output',
+		'  --verbose, -v      Enable verbose output',
+		'  --no-cache         Disable the transpiler cache',
+		'  --no-power-assert  Disable Power Assert',
+		'  --match, -m        Only run tests with matching title (Can be repeated)',
+		'  --watch, -w        Re-run tests when tests and source files change',
+		'  --source, -S       Pattern to match source files so tests can be re-run (Can be repeated)',
+		'  --timeout, -T      Set global timeout',
+		'  --concurrency, -c  Maximum number of test files running at the same time (EXPERIMENTAL)',
+		'',
+		'Examples',
+		'  ava',
+		'  ava test.js test2.js',
+		'  ava test-*.js',
+		'  ava test',
+		'  ava --init',
+		'  ava --init foo.js',
+		'',
+		'Default patterns when no arguments:',
+		'test.js test-*.js test/**/*.js **/__tests__/**/*.js **/*.test.js'
+	], {
+		string: [
+			'_',
+			'timeout',
+			'source',
+			'match',
+			'concurrency'
+		],
+		boolean: [
+			'fail-fast',
+			'verbose',
+			'serial',
+			'tap',
+			'watch'
+		],
+		default: conf,
+		alias: {
+			t: 'tap',
+			v: 'verbose',
+			s: 'serial',
+			m: 'match',
+			w: 'watch',
+			S: 'source',
+			T: 'timeout',
+			c: 'concurrency'
+		}
+	});
+
+	updateNotifier({pkg: cli.pkg}).notify();
+
+	if (cli.flags.init) {
+		require('ava-init')();
+		return;
+	}
+
+	if (
+		((hasFlag('--watch') || hasFlag('-w')) && (hasFlag('--tap') || hasFlag('-t'))) ||
+		(conf.watch && conf.tap)
+	) {
+		throw new Error(colors.error(figures.cross) + ' The TAP reporter is not available when using watch mode.');
+	}
+
+	if (hasFlag('--require') || hasFlag('-r')) {
+		throw new Error(colors.error(figures.cross) + ' The --require and -r flags are deprecated. Requirements should be configured in package.json - see documentation.');
+	}
+
+	var api = new Api({
+		failFast: cli.flags.failFast,
+		serial: cli.flags.serial,
+		require: arrify(conf.require),
+		cacheEnabled: cli.flags.cache !== false,
+		powerAssert: cli.flags.powerAssert !== false,
+		explicitTitles: cli.flags.watch,
+		match: arrify(cli.flags.match),
+		babelConfig: babelConfig.validate(conf.babel),
+		resolveTestsFrom: cli.input.length === 0 ? pkgDir : process.cwd(),
+		pkgDir: pkgDir,
+		timeout: cli.flags.timeout,
+		concurrency: cli.flags.concurrency ? parseInt(cli.flags.concurrency, 10) : 0
+	});
+
+	var reporter;
+
+	if (cli.flags.tap && !cli.flags.watch) {
+		reporter = tapReporter();
+	} else if (cli.flags.verbose || isCi) {
+		reporter = verboseReporter();
+	} else {
+		reporter = miniReporter({watching: cli.flags.watch});
+	}
+
+	reporter.api = api;
+	var logger = new Logger(reporter);
+
+	logger.start();
+
+	api.on('test-run', function (runStatus) {
+		reporter.api = runStatus;
+		runStatus.on('test', logger.test);
+		runStatus.on('error', logger.unhandledError);
+
+		runStatus.on('stdout', logger.stdout);
+		runStatus.on('stderr', logger.stderr);
+	});
+
+	var files = cli.input.length ? cli.input : arrify(conf.files);
+
+	if (cli.flags.watch) {
+		try {
+			var watcher = new Watcher(logger, api, files, arrify(cli.flags.source));
+			watcher.observeStdin(process.stdin);
+		} catch (err) {
+			if (err.name === 'AvaError') {
+				// An AvaError may be thrown if chokidar is not installed. Log it nicely.
+				console.error('  ' + colors.error(figures.cross) + ' ' + err.message);
+				logger.exit(1);
+			} else {
+				// Rethrow so it becomes an uncaught exception.
+				throw err;
+			}
+		}
+	} else {
+		api.run(files)
+			.then(function (runStatus) {
+				logger.finish(runStatus);
+				logger.exit(runStatus.failCount > 0 || runStatus.rejectionCount > 0 || runStatus.exceptionCount > 0 ? 1 : 0);
+			})
+			.catch(function (err) {
+				// Don't swallow exceptions. Note that any expected error should already
+				// have been logged.
+				setImmediate(function () {
+					throw err;
+				});
+			});
+	}
+};

package/lib/colors.js

@@ -2,10 +2,12 @@
 var chalk = require('chalk');
 
 module.exports = {
+	title: chalk.white,
 	error: chalk.red,
 	skip: chalk.yellow,
 	todo: chalk.blue,
 	pass: chalk.green,
 	duration: chalk.gray.dim,
+	errorStack: chalk.gray,
 	stack: chalk.red
 };

package/lib/concurrent.js

@@ -1,6 +1,7 @@
 'use strict';
 var Promise = require('bluebird');
 var isPromise = require('is-promise');
+var autoBind = require('auto-bind');
 var AvaError = require('./ava-error');
 
 function noop() {}
@@ -22,9 +23,7 @@ function Concurrent(tests, bail) {
 	this.tests = tests;
 	this.bail = bail || false;
 
-	Object.keys(Concurrent.prototype).forEach(function (key) {
-		this[key] = this[key].bind(this);
-	}, this);
+	autoBind(this);
 }
 
 Concurrent.prototype.run = function () {

package/lib/fork.js

@@ -6,7 +6,6 @@ var objectAssign = require('object-assign');
 var Promise = require('bluebird');
 var debug = require('debug')('ava');
 var AvaError = require('./ava-error');
-var doSend = require('./send');
 
 if (fs.realpathSync(__filename) !== __filename) {
 	console.warn(
@@ -31,7 +30,11 @@ if (env.NODE_PATH) {
 		.join(path.delimiter);
 }
 
-module.exports = function (file, opts) {
+// In case the test file imports a different AVA install, the presence of this variable allows it to require this one
+// instead.
+env.AVA_PATH = path.resolve(__dirname, '..');
+
+module.exports = function (file, opts, execArgv) {
 	opts = objectAssign({
 		file: file,
 		baseDir: process.cwd(),
@@ -42,20 +45,25 @@ module.exports = function (file, opts) {
 	}, opts);
 
 	var ps = childProcess.fork(path.join(__dirname, 'test-worker.js'), [JSON.stringify(opts)], {
-		cwd: path.dirname(file),
+		cwd: opts.pkgDir,
 		silent: true,
-		env: env
+		env: env,
+		execArgv: execArgv || process.execArgv
 	});
 
 	var relFile = path.relative('.', file);
 
 	var exiting = false;
-	var send = function (ps, name, data) {
+	var send = function (name, data) {
 		if (!exiting) {
 			// This seems to trigger a Node bug which kills the AVA master process, at
 			// least while running AVA's tests. See
 			// <https://github.com/novemberborn/_ava-tap-crash> for more details.
-			doSend(ps, name, data);
+			ps.send({
+				name: 'ava-' + name,
+				data: data,
+				ava: true
+			});
 		}
 	};
 
@@ -71,7 +79,7 @@ module.exports = function (file, opts) {
 				return;
 			}
 
-			event.name = event.name.replace(/^ava\-/, '');
+			event.name = event.name.replace(/^ava-/, '');
 			event.data.file = relFile;
 
 			debug('ipc %s:\n%o', event.name, event.data);
@@ -86,7 +94,7 @@ module.exports = function (file, opts) {
 		ps.on('results', function (data) {
 			results = data;
 			data.tests = testResults;
-			send(ps, 'teardown');
+			send('teardown');
 		});
 
 		ps.on('exit', function (code, signal) {
@@ -106,7 +114,7 @@ module.exports = function (file, opts) {
 		});
 
 		ps.on('no-tests', function (data) {
-			send(ps, 'teardown');
+			send('teardown');
 
 			var message = 'No tests found in ' + relFile;
 
@@ -120,13 +128,13 @@ module.exports = function (file, opts) {
 
 	// teardown finished, now exit
 	ps.on('teardown', function () {
-		send(ps, 'exit');
+		send('exit');
 		exiting = true;
 	});
 
 	// uncaught exception in fork, need to exit
 	ps.on('uncaughtException', function () {
-		send(ps, 'teardown');
+		send('teardown');
 	});
 
 	ps.stdout.on('data', function (data) {
@@ -144,13 +152,13 @@ module.exports = function (file, opts) {
 	};
 
 	promise.send = function (name, data) {
-		send(ps, name, data);
+		send(name, data);
 
 		return promise;
 	};
 
 	promise.exit = function () {
-		send(ps, 'init-exit');
+		send('init-exit');
 
 		return promise;
 	};
@@ -164,12 +172,12 @@ module.exports = function (file, opts) {
 
 	promise.run = function (options) {
 		if (isReady) {
-			send(ps, 'run', options);
+			send('run', options);
 			return promise;
 		}
 
 		ps.on('stats', function () {
-			send(ps, 'run', options);
+			send('run', options);
 		});
 
 		return promise;

package/lib/logger.js

@@ -1,15 +1,14 @@
 'use strict';
+var autoBind = require('auto-bind');
 
 function Logger(reporter) {
 	if (!(this instanceof Logger)) {
 		throw new TypeError('Class constructor Logger cannot be invoked without \'new\'');
 	}
 
-	Object.keys(Logger.prototype).forEach(function (key) {
-		this[key] = this[key].bind(this);
-	}, this);
-
 	this.reporter = reporter;
+
+	autoBind(this);
 }
 
 module.exports = Logger;
@@ -99,6 +98,6 @@ Logger.prototype.exit = function (code) {
 
 	// timeout required to correctly flush IO on Node.js 0.10 on Windows
 	setTimeout(function () {
-		process.exit(code); // eslint-disable-line xo/no-process-exit
+		process.exit(code); // eslint-disable-line unicorn/no-process-exit
 	}, process.env.AVA_APPVEYOR ? 500 : 0);
 };

package/lib/main.js

@@ -0,0 +1,89 @@
+'use strict';
+
+var process = require('./process-adapter');
+var serializeError = require('./serialize-error');
+var globals = require('./globals');
+var Runner = require('./runner');
+var send = process.send;
+
+var opts = globals.options;
+var runner = new Runner({
+	serial: opts.serial,
+	bail: opts.failFast,
+	match: opts.match
+});
+
+// note that test files have require('ava')
+require('./test-worker').avaRequired = true;
+
+// if fail-fast is enabled, use this variable to detect
+// that no more tests should be logged
+var isFailed = false;
+
+Error.stackTraceLimit = Infinity;
+
+function test(props) {
+	if (isFailed) {
+		return;
+	}
+
+	var hasError = typeof props.error !== 'undefined';
+
+	// don't display anything if it's a passed hook
+	if (!hasError && props.type !== 'test') {
+		return;
+	}
+
+	if (hasError) {
+		props.error = serializeError(props.error);
+	} else {
+		props.error = null;
+	}
+
+	send('test', props);
+
+	if (hasError && opts.failFast) {
+		isFailed = true;
+		exit();
+	}
+}
+
+function exit() {
+	var stats = runner._buildStats();
+
+	send('results', {
+		stats: stats
+	});
+}
+
+globals.setImmediate(function () {
+	var hasExclusive = runner.tests.hasExclusive;
+	var numberOfTests = runner.tests.tests.concurrent.length + runner.tests.tests.serial.length;
+
+	if (numberOfTests === 0) {
+		send('no-tests', {avaRequired: true});
+		return;
+	}
+
+	send('stats', {
+		testCount: numberOfTests,
+		hasExclusive: hasExclusive
+	});
+
+	runner.on('test', test);
+
+	process.on('ava-run', function (options) {
+		runner.run(options).then(exit);
+	});
+
+	process.on('ava-init-exit', function () {
+		exit();
+	});
+});
+
+module.exports = runner.test;
+
+// TypeScript imports the `default` property for
+// an ES2015 default import (`import test from 'ava'`)
+// See: https://github.com/Microsoft/TypeScript/issues/2242#issuecomment-83694181
+module.exports.default = runner.test;

package/lib/prefix-title.js

@@ -0,0 +1,25 @@
+'use strict';
+var path = require('path');
+
+module.exports = function (file, base, separator) {
+	var prefix = file
+		.replace(base, function (match, offset) {
+			// only replace this.base if it is found at the start of the path
+			return offset === 0 ? '' : match;
+		})
+		.replace(/\.spec/, '')
+		.replace(/\.test/, '')
+		.replace(/test-/g, '')
+		.replace(/\.js$/, '')
+		.split(path.sep)
+		.filter(function (p) {
+			return p !== '__tests__';
+		})
+		.join(separator);
+
+	if (prefix.length > 0) {
+		prefix += separator;
+	}
+
+	return prefix;
+};

package/lib/process-adapter.js

@@ -0,0 +1,107 @@
+'use strict';
+var fs = require('fs');
+var path = require('path');
+var chalk = require('chalk');
+var sourceMapSupport = require('source-map-support');
+var installPrecompiler = require('require-precompiled');
+
+var debug = require('debug')('ava');
+
+// check if the test is being run without AVA cli
+var isForked = typeof process.send === 'function';
+
+if (!isForked) {
+	var fp = path.relative('.', process.argv[1]);
+
+	console.log();
+	console.error('Test files must be run with the AVA CLI:\n\n    ' + chalk.grey.dim('$') + ' ' + chalk.cyan('ava ' + fp) + '\n');
+
+	process.exit(1); // eslint-disable-line unicorn/no-process-exit
+}
+
+exports.send = function (name, data) {
+	process.send({
+		name: 'ava-' + name,
+		data: data,
+		ava: true
+	});
+};
+
+exports.on = process.on.bind(process);
+exports.emit = process.emit.bind(process);
+exports.exit = process.exit.bind(process);
+exports.env = process.env;
+
+var opts = exports.opts = JSON.parse(process.argv[2]);
+
+// Fake TTY support
+if (opts.tty) {
+	process.stdout.isTTY = true;
+	process.stdout.columns = opts.tty.columns || 80;
+	process.stdout.rows = opts.tty.rows;
+
+	var tty = require('tty');
+	var isatty = tty.isatty;
+
+	tty.isatty = function (fd) {
+		if (fd === 1 || fd === process.stdout) {
+			return true;
+		}
+
+		return isatty(fd);
+	};
+}
+
+if (debug.enabled) {
+	// Forward the `time-require` `--sorted` flag.
+	// Intended for internal optimization tests only.
+	if (opts._sorted) {
+		process.argv.push('--sorted');
+	}
+
+	require('time-require'); // eslint-disable-line import/no-unassigned-import
+}
+
+var sourceMapCache = Object.create(null);
+var cacheDir = opts.cacheDir;
+
+exports.installSourceMapSupport = function () {
+	sourceMapSupport.install({
+		environment: 'node',
+		handleUncaughtExceptions: false,
+		retrieveSourceMap: function (source) {
+			if (sourceMapCache[source]) {
+				return {
+					url: source,
+					map: fs.readFileSync(sourceMapCache[source], 'utf8')
+				};
+			}
+		}
+	});
+};
+
+exports.installPrecompilerHook = function () {
+	installPrecompiler(function (filename) {
+		var precompiled = opts.precompiled[filename];
+
+		if (precompiled) {
+			sourceMapCache[filename] = path.join(cacheDir, precompiled + '.js.map');
+			return fs.readFileSync(path.join(cacheDir, precompiled + '.js'), 'utf8');
+		}
+
+		return null;
+	});
+};
+
+exports.installDependencyTracking = function (dependencies, testPath) {
+	Object.keys(require.extensions).forEach(function (ext) {
+		var wrappedHandler = require.extensions[ext];
+		require.extensions[ext] = function (module, filename) {
+			if (filename !== testPath) {
+				dependencies.push(filename);
+			}
+
+			wrappedHandler(module, filename);
+		};
+	});
+};