ava 0.16.0 → 0.18.2

package/api.js

@@ -1,315 +1,347 @@
 'use strict';
-var EventEmitter = require('events').EventEmitter;
-var path = require('path');
-var util = require('util');
-var Promise = require('bluebird');
-var objectAssign = require('object-assign');
-var commonPathPrefix = require('common-path-prefix');
-var resolveCwd = require('resolve-cwd');
-var uniqueTempDir = require('unique-temp-dir');
-var findCacheDir = require('find-cache-dir');
-var debounce = require('lodash.debounce');
-var ms = require('ms');
-var AvaFiles = require('ava-files');
-var AvaError = require('./lib/ava-error');
-var fork = require('./lib/fork');
-var CachingPrecompiler = require('./lib/caching-precompiler');
-var RunStatus = require('./lib/run-status');
-
-function Api(options) {
-	if (!(this instanceof Api)) {
-		throw new TypeError('Class constructor Api cannot be invoked without \'new\'');
-	}
-
-	EventEmitter.call(this);
-
-	this.options = objectAssign({
-		cwd: process.cwd(),
-		resolveTestsFrom: process.cwd(),
-		match: []
-	}, options);
-
-	this.options.require = (this.options.require || []).map(function (moduleId) {
-		var ret = resolveCwd(moduleId);
-		if (ret === null) {
-			throw new Error('Could not resolve required module \'' + moduleId + '\'');
+const EventEmitter = require('events');
+const path = require('path');
+const fs = require('fs');
+const commonPathPrefix = require('common-path-prefix');
+const uniqueTempDir = require('unique-temp-dir');
+const findCacheDir = require('find-cache-dir');
+const resolveCwd = require('resolve-cwd');
+const debounce = require('lodash.debounce');
+const autoBind = require('auto-bind');
+const Promise = require('bluebird');
+const getPort = require('get-port');
+const arrify = require('arrify');
+const ms = require('ms');
+const CachingPrecompiler = require('./lib/caching-precompiler');
+const RunStatus = require('./lib/run-status');
+const AvaError = require('./lib/ava-error');
+const AvaFiles = require('./lib/ava-files');
+const fork = require('./lib/fork');
+
+function resolveModules(modules) {
+	return arrify(modules).map(name => {
+		const modulePath = resolveCwd(name);
+
+		if (modulePath === null) {
+			throw new Error(`Could not resolve required module '${name}'`);
 		}
 
-		return ret;
+		return modulePath;
 	});
-
-	Object.keys(Api.prototype).forEach(function (key) {
-		this[key] = this[key].bind(this);
-	}, this);
 }
 
-util.inherits(Api, EventEmitter);
-module.exports = Api;
-
-Api.prototype._runFile = function (file, runStatus) {
-	var hash = this.precompiler.precompileFile(file);
-	var precompiled = {};
-	precompiled[file] = hash;
-
-	var options = objectAssign({}, this.options, {
-		precompiled: precompiled
-	});
-
-	var emitter = fork(file, options);
-
-	runStatus.observeFork(emitter);
-
-	return emitter;
-};
-
-Api.prototype._onTimeout = function (runStatus) {
-	var timeout = ms(this.options.timeout);
-	var message = 'Exited because no new tests completed within the last ' + timeout + 'ms of inactivity';
+function getBlankResults() {
+	return {
+		stats: {
+			knownFailureCount: 0,
+			testCount: 0,
+			passCount: 0,
+			skipCount: 0,
+			todoCount: 0,
+			failCount: 0
+		},
+		tests: []
+	};
+}
 
-	runStatus.handleExceptions({
-		exception: new AvaError(message),
-		file: undefined
-	});
+class Api extends EventEmitter {
+	constructor(options) {
+		super();
+		autoBind(this);
 
-	runStatus.emit('timeout');
-};
+		this.options = Object.assign({match: []}, options);
+		this.options.require = resolveModules(this.options.require);
+	}
+	_runFile(file, runStatus, execArgv) {
+		const hash = this.precompiler.precompileFile(file);
+		const precompiled = Object.assign({}, this._precompiledHelpers);
+		const resolvedfpath = fs.realpathSync(file);
+		precompiled[resolvedfpath] = hash;
 
-Api.prototype.run = function (files, options) {
-	var self = this;
+		const options = Object.assign({}, this.options, {precompiled});
+		const emitter = fork(file, options, execArgv);
+		runStatus.observeFork(emitter);
 
-	return new AvaFiles({files: files, cwd: this.options.resolveTestsFrom})
-		.findTestFiles()
-		.then(function (files) {
-			return self._run(files, options);
-		});
-};
-
-Api.prototype._run = function (files, _options) {
-	var self = this;
-	var runStatus = new RunStatus({
-		prefixTitles: this.options.explicitTitles || files.length > 1,
-		runOnlyExclusive: _options && _options.runOnlyExclusive,
-		base: path.relative('.', commonPathPrefix(files)) + path.sep
-	});
+		return emitter;
+	}
+	run(files, options) {
+		return new AvaFiles({cwd: this.options.resolveTestsFrom, files})
+			.findTestFiles()
+			.then(files => this._run(files, options));
+	}
+	_onTimeout(runStatus) {
+		const timeout = ms(this.options.timeout);
+		const err = new AvaError(`Exited because no new tests completed within the last ${timeout}ms of inactivity`);
+		this._handleError(runStatus, err);
+		runStatus.emit('timeout');
+	}
+	_setupTimeout(runStatus) {
+		const timeout = ms(this.options.timeout);
 
-	if (self.options.timeout) {
-		var timeout = ms(self.options.timeout);
-		runStatus._restartTimer = debounce(function () {
-			self._onTimeout(runStatus);
+		runStatus._restartTimer = debounce(() => {
+			this._onTimeout(runStatus);
 		}, timeout);
+
 		runStatus._restartTimer();
 		runStatus.on('test', runStatus._restartTimer);
 	}
+	_cancelTimeout(runStatus) {
+		runStatus._restartTimer.cancel();
+	}
+	_setupPrecompiler(files) {
+		const isCacheEnabled = this.options.cacheEnabled !== false;
+		let cacheDir = uniqueTempDir();
+
+		if (isCacheEnabled) {
+			const foundDir = findCacheDir({
+				name: 'ava',
+				files
+			});
+			if (foundDir !== null) {
+				cacheDir = foundDir;
+			}
+		}
 
-	self.emit('test-run', runStatus, files);
+		this.options.cacheDir = cacheDir;
 
-	if (files.length === 0) {
-		runStatus.handleExceptions({
-			exception: new AvaError('Couldn\'t find any files to test'),
-			file: undefined
+		const isPowerAssertEnabled = this.options.powerAssert !== false;
+		this.precompiler = new CachingPrecompiler({
+			path: cacheDir,
+			babel: this.options.babelConfig,
+			powerAssert: isPowerAssertEnabled
 		});
-
-		return Promise.resolve(runStatus);
 	}
-
-	var cacheEnabled = self.options.cacheEnabled !== false;
-	var cacheDir = (cacheEnabled && findCacheDir({
-		name: 'ava',
-		files: files
-	})) || uniqueTempDir();
-
-	self.options.cacheDir = cacheDir;
-	self.precompiler = new CachingPrecompiler(cacheDir, self.options.babelConfig);
-	self.fileCount = files.length;
-
-	var overwatch;
-	if (this.options.concurrency > 0) {
-		overwatch = this._runLimitedPool(files, runStatus, self.options.serial ? 1 : this.options.concurrency);
-	} else {
-		// _runNoPool exists to preserve legacy behavior, specifically around `.only`
-		overwatch = this._runNoPool(files, runStatus);
+	_precompileHelpers() {
+		this._precompiledHelpers = {};
+
+		// Assumes the tests only load helpers from within the `resolveTestsFrom`
+		// directory. Without arguments this is the `projectDir`, else it's
+		// `process.cwd()` which may be nested too deeply. This will be solved
+		// as we implement RFC 001 and move helper compilation into the worker
+		// processes, avoiding the need for precompilation.
+		return new AvaFiles({cwd: this.options.resolveTestsFrom})
+			.findTestHelpers()
+			.map(file => { // eslint-disable-line array-callback-return
+				const hash = this.precompiler.precompileFile(file);
+				this._precompiledHelpers[file] = hash;
+			});
 	}
-
-	return overwatch;
-};
-
-Api.prototype._runNoPool = function (files, runStatus) {
-	var self = this;
-	var tests = new Array(self.fileCount);
-
-	// TODO: thid should be cleared at the end of the run
-	runStatus.on('timeout', function () {
-		tests.forEach(function (fork) {
-			fork.exit();
+	_run(files, options) {
+		options = options || {};
+
+		const runStatus = new RunStatus({
+			runOnlyExclusive: options.runOnlyExclusive,
+			prefixTitles: this.options.explicitTitles || files.length > 1,
+			base: path.relative(process.cwd(), commonPathPrefix(files)) + path.sep,
+			failFast: this.options.failFast
 		});
-	});
-
-	return new Promise(function (resolve) {
-		function run() {
-			if (self.options.match.length > 0 && !runStatus.hasExclusive) {
-				runStatus.handleExceptions({
-					exception: new AvaError('Couldn\'t find any matching tests'),
-					file: undefined
-				});
 
-				resolve([]);
-				return;
-			}
+		this.emit('test-run', runStatus, files);
 
-			var method = self.options.serial ? 'mapSeries' : 'map';
-			var options = {
-				runOnlyExclusive: runStatus.hasExclusive
-			};
-
-			resolve(Promise[method](files, function (file, index) {
-				return tests[index].run(options).catch(function (err) {
-					// The test failed catastrophically. Flag it up as an
-					// exception, then return an empty result. Other tests may
-					// continue to run.
-					runStatus.handleExceptions({
-						exception: err,
-						file: path.relative('.', file)
-					});
-
-					return getBlankResults();
-				});
-			}));
+		if (files.length === 0) {
+			const err = new AvaError('Couldn\'t find any files to test');
+			this._handleError(runStatus, err);
+			return Promise.resolve(runStatus);
 		}
 
-		// receive test count from all files and then run the tests
-		var unreportedFiles = self.fileCount;
-		var bailed = false;
-
-		files.every(function (file, index) {
-			var tried = false;
+		this._setupPrecompiler(files);
 
-			function tryRun() {
-				if (!tried && !bailed) {
-					tried = true;
-					unreportedFiles--;
+		return this._precompileHelpers()
+			.then(() => {
+				if (this.options.timeout) {
+					this._setupTimeout(runStatus);
+				}
 
-					if (unreportedFiles === 0) {
-						run();
-					}
+				let overwatch;
+				if (this.options.concurrency > 0) {
+					const concurrency = this.options.serial ? 1 : this.options.concurrency;
+					overwatch = this._runWithPool(files, runStatus, concurrency);
+				} else {
+					// _runWithoutPool exists to preserve legacy behavior, specifically around `.only`
+					overwatch = this._runWithoutPool(files, runStatus);
 				}
+
+				return overwatch;
+			});
+	}
+	_computeForkExecArgs(files) {
+		const execArgv = this.options.testOnlyExecArgv || process.execArgv;
+		let debugArgIndex = -1;
+
+		// --debug-brk is used in addition to --inspect to break on first line and wait
+		execArgv.some((arg, index) => {
+			const isDebugArg = arg === '--inspect' || arg.indexOf('--inspect=') === 0;
+			if (isDebugArg) {
+				debugArgIndex = index;
 			}
 
-			try {
-				var test = tests[index] = self._runFile(file, runStatus);
+			return isDebugArg;
+		});
+
+		const isInspect = debugArgIndex >= 0;
+		if (!isInspect) {
+			execArgv.some((arg, index) => {
+				const isDebugArg = arg === '--debug' || arg === '--debug-brk' || arg.indexOf('--debug-brk=') === 0 || arg.indexOf('--debug=') === 0;
+				if (isDebugArg) {
+					debugArgIndex = index;
+				}
 
-				test.on('stats', tryRun);
-				test.catch(tryRun);
+				return isDebugArg;
+			});
+		}
 
-				return true;
-			} catch (err) {
-				bailed = true;
+		if (debugArgIndex === -1) {
+			return Promise.resolve([]);
+		}
 
-				runStatus.handleExceptions({
-					exception: err,
-					file: path.relative('.', file)
-				});
+		return Promise
+			.map(files, getPort)
+			.map(port => {
+				const forkExecArgv = execArgv.slice();
+				let flagName = isInspect ? '--inspect' : '--debug';
+				const oldValue = forkExecArgv[debugArgIndex];
+				if (oldValue.indexOf('brk') > 0) {
+					flagName += '-brk';
+				}
 
-				resolve([]);
+				forkExecArgv[debugArgIndex] = `${flagName}=${port}`;
 
-				return false;
-			}
+				return forkExecArgv;
+			});
+	}
+	_handleError(runStatus, err) {
+		runStatus.handleExceptions({
+			exception: err,
+			file: err.file ? path.relative(process.cwd(), err.file) : undefined
 		});
-	}).then(function (results) {
-		if (results.length === 0) {
-			// No tests ran, make sure to tear down the child processes.
-			tests.forEach(function (test) {
-				test.send('teardown');
+	}
+	_runWithoutPool(files, runStatus) {
+		const tests = [];
+		let execArgvList;
+
+		// TODO: This should be cleared at the end of the run
+		runStatus.on('timeout', () => {
+			tests.forEach(fork => {
+				fork.exit();
 			});
-		}
-
-		return results;
-	}).then(function (results) {
-		// cancel debounced _onTimeout() from firing
-		if (self.options.timeout) {
-			runStatus._restartTimer.cancel();
-		}
+		});
 
-		runStatus.processResults(results);
-		return runStatus;
-	});
-};
+		return this._computeForkExecArgs(files)
+			.then(argvList => {
+				execArgvList = argvList;
+			})
+			.return(files)
+			.each((file, index) => {
+				return new Promise(resolve => {
+					const forkArgs = execArgvList[index];
+					const test = this._runFile(file, runStatus, forkArgs);
+					tests.push(test);
+					test.on('stats', resolve);
+					test.catch(resolve);
+				}).catch(err => {
+					err.results = [];
+					err.file = file;
+					return Promise.reject(err);
+				});
+			})
+			.then(() => {
+				if (this.options.match.length > 0 && !runStatus.hasExclusive) {
+					const err = new AvaError('Couldn\'t find any matching tests');
+					err.file = undefined;
+					err.results = [];
+					return Promise.reject(err);
+				}
 
-function getBlankResults() {
-	return {
-		stats: {
-			testCount: 0,
-			passCount: 0,
-			knownFailureCount: 0,
-			skipCount: 0,
-			todoCount: 0,
-			failCount: 0
-		},
-		tests: []
-	};
-}
+				const method = this.options.serial ? 'mapSeries' : 'map';
+				const options = {
+					runOnlyExclusive: runStatus.hasExclusive
+				};
 
-Api.prototype._runLimitedPool = function (files, runStatus, concurrency) {
-	var self = this;
-	var tests = {};
+				return Promise[method](files, (file, index) => {
+					return tests[index].run(options).catch(err => {
+						err.file = file;
+						this._handleError(runStatus, err);
+						return getBlankResults();
+					});
+				});
+			})
+			.catch(err => {
+				this._handleError(runStatus, err);
+				return err.results;
+			})
+			.tap(results => {
+				// If no tests ran, make sure to tear down the child processes
+				if (results.length === 0) {
+					tests.forEach(test => {
+						test.send('teardown');
+					});
+				}
+			})
+			.then(results => {
+				// Cancel debounced _onTimeout() from firing
+				if (this.options.timeout) {
+					this._cancelTimeout(runStatus);
+				}
 
-	runStatus.on('timeout', function () {
-		Object.keys(tests).forEach(function (file) {
-			var fork = tests[file];
-			fork.exit();
-		});
-	});
+				runStatus.processResults(results);
 
-	return Promise.map(files, function (file) {
-		var handleException = function (err) {
-			runStatus.handleExceptions({
-				exception: err,
-				file: path.relative('.', file)
+				return runStatus;
 			});
-		};
+	}
+	_runWithPool(files, runStatus, concurrency) {
+		const tests = [];
+		let execArgvList;
 
-		try {
-			var test = tests[file] = self._runFile(file, runStatus);
+		runStatus.on('timeout', () => {
+			tests.forEach(fork => {
+				fork.exit();
+			});
+		});
 
-			return new Promise(function (resolve, reject) {
-				var runner = function () {
-					var options = {
-						// If we're looking for matches, run every single test process in exclusive-only mode
-						runOnlyExclusive: self.options.match.length > 0
+		return this._computeForkExecArgs(files)
+			.then(argvList => {
+				execArgvList = argvList;
+			})
+			.return(files)
+			.map((file, index) => {
+				return new Promise(resolve => {
+					const forkArgs = execArgvList[index];
+					const test = this._runFile(file, runStatus, forkArgs);
+					tests.push(test);
+
+					// If we're looking for matches, run every single test process in exclusive-only mode
+					const options = {
+						runOnlyExclusive: this.options.match.length > 0
 					};
-					test.run(options)
-						.then(resolve)
-						.catch(reject);
-				};
 
-				test.on('stats', runner);
-				test.on('exit', function () {
-					delete tests[file];
+					resolve(test.run(options));
+				}).catch(err => {
+					err.file = file;
+					this._handleError(runStatus, err);
+					return getBlankResults();
 				});
-				test.catch(runner);
-			}).catch(handleException);
-		} catch (err) {
-			handleException(err);
-		}
-	}, {concurrency: concurrency})
-		.then(function (results) {
-			// Filter out undefined results (usually result of caught exceptions)
-			results = results.filter(Boolean);
-
-			// cancel debounced _onTimeout() from firing
-			if (self.options.timeout) {
-				runStatus._restartTimer.cancel();
-			}
+			}, {concurrency})
+			.then(results => {
+				// Filter out undefined results (usually result of caught exceptions)
+				results = results.filter(Boolean);
+
+				// Cancel debounced _onTimeout() from firing
+				if (this.options.timeout) {
+					this._cancelTimeout(runStatus);
+				}
 
-			if (self.options.match.length > 0 && !runStatus.hasExclusive) {
-				// Ensure results are empty
-				results = [];
-				runStatus.handleExceptions({
-					exception: new AvaError('Couldn\'t find any matching tests'),
-					file: undefined
-				});
-			}
+				if (this.options.match.length > 0 && !runStatus.hasExclusive) {
+					results = [];
 
-			runStatus.processResults(results);
-			return runStatus;
-		});
-};
+					const err = new AvaError('Couldn\'t find any matching tests');
+					this._handleError(runStatus, err);
+				}
+
+				runStatus.processResults(results);
+
+				return runStatus;
+			});
+	}
+}
+
+module.exports = Api;