ava 0.16.0 → 0.18.2

package/lib/logger.js

@@ -1,104 +1,81 @@
 'use strict';
+const autoBind = require('auto-bind');
 
-function Logger(reporter) {
-	if (!(this instanceof Logger)) {
-		throw new TypeError('Class constructor Logger cannot be invoked without \'new\'');
+class Logger {
+	constructor(reporter) {
+		this.reporter = reporter;
+		autoBind(this);
 	}
+	start(runStatus) {
+		if (!this.reporter.start) {
+			return;
+		}
 
-	Object.keys(Logger.prototype).forEach(function (key) {
-		this[key] = this[key].bind(this);
-	}, this);
-
-	this.reporter = reporter;
-}
-
-module.exports = Logger;
-
-Logger.prototype.start = function (runStatus) {
-	if (!this.reporter.start) {
-		return;
+		this.write(this.reporter.start(runStatus), runStatus);
 	}
+	reset(runStatus) {
+		if (!this.reporter.reset) {
+			return;
+		}
 
-	this.write(this.reporter.start(runStatus), runStatus);
-};
-
-Logger.prototype.reset = function (runStatus) {
-	if (!this.reporter.reset) {
-		return;
+		this.write(this.reporter.reset(runStatus), runStatus);
 	}
-
-	this.write(this.reporter.reset(runStatus), runStatus);
-};
-
-Logger.prototype.test = function (test, runStatus) {
-	this.write(this.reporter.test(test, runStatus), runStatus);
-};
-
-Logger.prototype.unhandledError = function (err, runStatus) {
-	if (!this.reporter.unhandledError) {
-		return;
+	test(test, runStatus) {
+		this.write(this.reporter.test(test, runStatus), runStatus);
 	}
+	unhandledError(err, runStatus) {
+		if (!this.reporter.unhandledError) {
+			return;
+		}
 
-	this.write(this.reporter.unhandledError(err, runStatus), runStatus);
-};
-
-Logger.prototype.finish = function (runStatus) {
-	if (!this.reporter.finish) {
-		return;
+		this.write(this.reporter.unhandledError(err, runStatus), runStatus);
 	}
+	finish(runStatus) {
+		if (!this.reporter.finish) {
+			return;
+		}
 
-	this.write(this.reporter.finish(runStatus), runStatus);
-};
-
-Logger.prototype.section = function () {
-	if (!this.reporter.section) {
-		return;
+		this.write(this.reporter.finish(runStatus), runStatus);
 	}
+	section() {
+		if (!this.reporter.section) {
+			return;
+		}
 
-	this.write(this.reporter.section());
-};
-
-Logger.prototype.clear = function () {
-	if (!this.reporter.clear) {
-		return false;
+		this.write(this.reporter.section());
 	}
+	clear() {
+		if (!this.reporter.clear) {
+			return false;
+		}
 
-	this.write(this.reporter.clear());
-	return true;
-};
-
-Logger.prototype.write = function (str, runStatus) {
-	if (typeof str === 'undefined') {
-		return;
+		this.write(this.reporter.clear());
+		return true;
 	}
+	write(str, runStatus) {
+		if (typeof str === 'undefined') {
+			return;
+		}
 
-	this.reporter.write(str, runStatus);
-};
-
-Logger.prototype.stdout = function (data, runStatus) {
-	if (!this.reporter.stdout) {
-		return;
+		this.reporter.write(str, runStatus);
 	}
+	stdout(data, runStatus) {
+		if (!this.reporter.stdout) {
+			return;
+		}
 
-	this.reporter.stdout(data, runStatus);
-};
-
-Logger.prototype.stderr = function (data, runStatus) {
-	if (!this.reporter.stderr) {
-		return;
+		this.reporter.stdout(data, runStatus);
 	}
+	stderr(data, runStatus) {
+		if (!this.reporter.stderr) {
+			return;
+		}
 
-	this.reporter.stderr(data, runStatus);
-};
-
-Logger.prototype.exit = function (code) {
-	// TODO: figure out why this needs to be here to
-	// correctly flush the output when multiple test files
-	process.stdout.write('');
-	process.stderr.write('');
+		this.reporter.stderr(data, runStatus);
+	}
+	exit(code) {
+		process.exit(code); // eslint-disable-line unicorn/no-process-exit
+	}
+}
 
-	// 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.env.AVA_APPVEYOR ? 500 : 0);
-};
+module.exports = Logger;

package/lib/main.js

@@ -0,0 +1,90 @@
+'use strict';
+const process = require('./process-adapter');
+const serializeError = require('./serialize-error');
+const globals = require('./globals');
+const Runner = require('./runner');
+const send = process.send;
+
+const opts = globals.options;
+const 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
+let isFailed = false;
+
+Error.stackTraceLimit = Infinity;
+
+function test(props) {
+	if (isFailed) {
+		return;
+	}
+
+	const 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() {
+	const stats = runner._buildStats();
+
+	send('results', {stats});
+}
+
+globals.setImmediate(() => {
+	const hasExclusive = runner.tests.hasExclusive;
+	const numberOfTests = runner.tests.testCount;
+
+	if (numberOfTests === 0) {
+		send('no-tests', {avaRequired: true});
+		return;
+	}
+
+	send('stats', {
+		testCount: numberOfTests,
+		hasExclusive
+	});
+
+	runner.on('test', test);
+
+	process.on('ava-run', options => {
+		runner.run(options)
+			.then(exit)
+			.catch(err => {
+				process.emit('uncaughtException', err);
+			});
+	});
+
+	process.on('ava-init-exit', () => {
+		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,21 @@
+'use strict';
+const path = require('path');
+
+module.exports = (file, base, separator) => {
+	let prefix = file
+		// Only replace this.base if it is found at the start of the path
+		.replace(base, (match, offset) => offset === 0 ? '' : match)
+		.replace(/\.spec/, '')
+		.replace(/\.test/, '')
+		.replace(/test-/g, '')
+		.replace(/\.js$/, '')
+		.split(path.sep)
+		.filter(p => p !== '__tests__')
+		.join(separator);
+
+	if (prefix.length > 0) {
+		prefix += separator;
+	}
+
+	return prefix;
+};

package/lib/process-adapter.js

@@ -0,0 +1,108 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const sourceMapSupport = require('source-map-support');
+const installPrecompiler = require('require-precompiled');
+
+const debug = require('debug')('ava');
+
+// Check if the test is being run without AVA cli
+const isForked = typeof process.send === 'function';
+
+if (!isForked) {
+	const 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 = (name, data) => {
+	process.send({
+		name: `ava-${name}`,
+		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;
+
+const 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;
+
+	const tty = require('tty');
+	const 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
+}
+
+const sourceMapCache = new Map();
+const cacheDir = opts.cacheDir;
+
+exports.installSourceMapSupport = () => {
+	sourceMapSupport.install({
+		environment: 'node',
+		handleUncaughtExceptions: false,
+		retrieveSourceMap(source) {
+			if (sourceMapCache.has(source)) {
+				return {
+					url: source,
+					map: fs.readFileSync(sourceMapCache.get(source), 'utf8')
+				};
+			}
+		}
+	});
+};
+
+exports.installPrecompilerHook = () => {
+	installPrecompiler(filename => {
+		const precompiled = opts.precompiled[filename];
+
+		if (precompiled) {
+			sourceMapCache.set(filename, path.join(cacheDir, `${precompiled}.js.map`));
+			return fs.readFileSync(path.join(cacheDir, `${precompiled}.js`), 'utf8');
+		}
+
+		return null;
+	});
+};
+
+exports.installDependencyTracking = (dependencies, testPath) => {
+	Object.keys(require.extensions).forEach(ext => {
+		const wrappedHandler = require.extensions[ext];
+
+		require.extensions[ext] = (module, filename) => {
+			if (filename !== testPath) {
+				dependencies.push(filename);
+			}
+
+			wrappedHandler(module, filename);
+		};
+	});
+};