ava 0.16.0 → 0.18.2

package/cli.js

@@ -1,191 +1,27 @@
 #!/usr/bin/env node
 'use strict';
-
-var path = require('path');
-var debug = require('debug')('ava');
+const path = require('path');
+const debug = require('debug')('ava');
 
 // Prefer the local installation of AVA.
-var resolveCwd = require('resolve-cwd');
-var localCLI = resolveCwd('ava/cli');
+const resolveCwd = require('resolve-cwd');
+const localCLI = resolveCwd('ava/cli');
 
-if (localCLI && localCLI !== __filename) {
+// Use `path.relative()` to detect local AVA installation,
+// because __filename's case is inconsistent on Windows
+// see https://github.com/nodejs/node/issues/6624
+if (localCLI && path.relative(localCLI, __filename) !== '') {
 	debug('Using local install of AVA');
-	require(localCLI);
-	return;
-}
-
-if (debug.enabled) {
-	require('time-require');
-}
-
-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 colors = require('./lib/colors');
-var verboseReporter = require('./lib/reporters/verbose');
-var miniReporter = require('./lib/reporters/mini');
-var tapReporter = require('./lib/reporters/tap');
-var Logger = require('./lib/logger');
-var Watcher = require('./lib/watcher');
-var babelConfig = require('./lib/babel-config');
-var Api = require('./api');
-
-// Bluebird specific
-Promise.longStackTraces();
-
-var conf = pkgConf.sync('ava');
-
-var pkgDir = path.dirname(pkgConf.filepath(conf));
-
-try {
-	conf.babel = babelConfig.validate(conf.babel);
-} catch (err) {
-	console.log('\n  ' + err.message);
-	process.exit(1);
-}
-
-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',
-	'  --require, -r      Module to preload (Can be repeated)',
-	'  --tap, -t          Generate TAP output',
-	'  --verbose, -v      Enable verbose output',
-	'  --no-cache         Disable the transpiler cache',
-	'  --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: [
-		'_',
-		'require',
-		'timeout',
-		'source',
-		'match',
-		'concurrency'
-	],
-	boolean: [
-		'fail-fast',
-		'verbose',
-		'serial',
-		'tap',
-		'watch'
-	],
-	default: conf,
-	alias: {
-		t: 'tap',
-		v: 'verbose',
-		r: 'require',
-		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)
-) {
-	console.error('  ' + colors.error(figures.cross) + ' The TAP reporter is not available when using watch mode.');
-	process.exit(1);
-}
-
-var api = new Api({
-	failFast: cli.flags.failFast,
-	serial: cli.flags.serial,
-	require: arrify(cli.flags.require),
-	cacheEnabled: cli.flags.cache !== false,
-	explicitTitles: cli.flags.watch,
-	match: arrify(cli.flags.match),
-	babelConfig: conf.babel,
-	resolveTestsFrom: cli.input.length === 0 ? pkgDir : process.cwd(),
-	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();
+	require(localCLI); // eslint-disable-line import/no-dynamic-require
 } 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 (debug.enabled) {
+		require('time-require'); // eslint-disable-line import/no-unassigned-import
+	}
 
-if (cli.flags.watch) {
 	try {
-		var watcher = new Watcher(logger, api, files, arrify(cli.flags.source));
-		watcher.observeStdin(process.stdin);
+		require('./lib/cli').run();
 	} 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;
-		}
+		console.error(`\n  ${err.message}`);
+		process.exit(1);
 	}
-} 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/index.js

@@ -1,101 +1,8 @@
 'use strict';
-var path = require('path');
-var chalk = require('chalk');
-var serializeError = require('./lib/serialize-error');
-var globals = require('./lib/globals');
-var Runner = require('./lib/runner');
-var send = require('./lib/send');
 
-var opts = globals.options;
-var runner = new Runner({
-	serial: opts.serial,
-	bail: opts.failFast,
-	match: opts.match
-});
-
-// 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 xo/no-process-exit
+// Ensure the same AVA install is loaded by the test file as by the test worker
+if (process.env.AVA_PATH && process.env.AVA_PATH !== __dirname) {
+	module.exports = require(process.env.AVA_PATH); // eslint-disable-line import/no-dynamic-require
+} else {
+	module.exports = require('./lib/main');
 }
-
-// note that test files have require('ava')
-require('./lib/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/index.js.flow

@@ -0,0 +1,201 @@
+/* @flow */
+
+/**
+ * Misc Setup Types
+ */
+
+type PromiseLike<R> = {
+	then<U>(
+		onFulfill?: (value: R) => Promise<U> | U,
+		onReject?: (error: any) => Promise<U> | U
+	): Promise<U>;
+}
+
+type ObservableLike = {
+	subscribe(observer: (value: {}) => void): void;
+};
+
+type SpecialReturnTypes =
+	| PromiseLike<any>
+	| Iterator<any>
+	| ObservableLike;
+
+type Constructor = Class<{
+	constructor(...args: Array<any>): any
+}>;
+
+type ErrorValidator =
+	| Constructor
+	| RegExp
+	| string
+	| ((error: any) => boolean);
+
+/**
+ * Assertion Types
+ */
+
+type AssertContext = {
+	// Passing assertion.
+	pass(message?: string): void;
+	// Failing assertion.
+	fail(message?: string): void;
+	// Assert that value is truthy.
+	truthy(value: mixed, message?: string): void;
+	// Assert that value is falsy.
+	falsy(value: mixed, message?: string): void;
+	// Assert that value is true.
+	true(value: mixed, message?: string): void;
+	// Assert that value is false.
+	false(value: mixed, message?: string): void;
+	// Assert that value is equal to expected.
+	is<U>(value: U, expected: U, message?: string): void;
+	// Assert that value is not equal to expected.
+	not<U>(value: U, expected: U, message?: string): void;
+	// Assert that value is deep equal to expected.
+	deepEqual<U>(value: U, expected: U, message?: string): void;
+	// Assert that value is not deep equal to expected.
+	notDeepEqual<U>(value: U, expected: U, message?: string): void;
+	// Assert that function throws an error or promise rejects.
+	// @param error Can be a constructor, regex, error message or validation function.
+	throws: {
+		(value: PromiseLike<mixed>, error?: ErrorValidator, message?: string): Promise<Error>;
+		(value: () => mixed, error?: ErrorValidator, message?: string): Error;
+	};
+	// Assert that function doesn't throw an error or promise resolves.
+	notThrows: {
+		<U>(value: PromiseLike<U>, message?: string): Promise<U>;
+		(value: () => mixed, message?: string): void;
+	};
+	// Assert that contents matches regex.
+	regex(contents: string, regex: RegExp, message?: string): void;
+	// Assert that contents matches a snapshot.
+	snapshot(contents: any, message?: string): void;
+	// Assert that contents does not match regex.
+	notRegex(contents: string, regex: RegExp, message?: string): void;
+	// Assert that error is falsy.
+	ifError(error: any, message?: string): void;
+};
+
+/**
+ * Context Types
+ */
+
+type TestContext = AssertContext & {
+	plan(count: number): void;
+	skip: AssertContext;
+};
+type CallbackTestContext           = TestContext         & { end(): void; };
+type ContextualTestContext         = TestContext         & { context: any; };
+type ContextualCallbackTestContext = CallbackTestContext & { context: any; };
+
+/**
+ * Test Implementations
+ */
+
+type TestFunction<T, R> = {
+	(t: T, ...args: Array<any>): R;
+	title?: (providedTitle: string, ...args: Array<any>) => string;
+};
+
+type TestImplementation<T, R> =
+	| TestFunction<T, R>
+	| Array<TestFunction<T, R>>;
+
+type Test                   = TestImplementation<TestContext, SpecialReturnTypes | void>;
+type CallbackTest           = TestImplementation<CallbackTestContext, void>;
+type ContextualTest         = TestImplementation<ContextualTestContext, SpecialReturnTypes | void>;
+type ContextualCallbackTest = TestImplementation<ContextualCallbackTestContext, void>;
+
+
+/**
+ * Method Types
+ */
+
+type TestMethod = {
+	(              implementation: Test): void;
+	(name: string, implementation: Test): void;
+
+	serial     : TestMethod;
+	before     : TestMethod;
+	after      : TestMethod;
+	skip       : TestMethod;
+	todo       : TestMethod;
+	failing    : TestMethod;
+	only       : TestMethod;
+	beforeEach : TestMethod;
+	afterEach  : TestMethod;
+	cb         : CallbackTestMethod;
+	always     : TestMethod;
+};
+
+type CallbackTestMethod = {
+	(              implementation: CallbackTest): void;
+	(name: string, implementation: CallbackTest): void;
+
+	serial     : CallbackTestMethod;
+	before     : CallbackTestMethod;
+	after      : CallbackTestMethod;
+	skip       : CallbackTestMethod;
+	todo       : CallbackTestMethod;
+	failing    : CallbackTestMethod;
+	only       : CallbackTestMethod;
+	beforeEach : CallbackTestMethod;
+	afterEach  : CallbackTestMethod;
+	cb         : CallbackTestMethod;
+	always     : CallbackTestMethod;
+};
+
+type ContextualTestMethod = {
+	(              implementation: ContextualTest): void;
+	(name: string, implementation: ContextualTest): void;
+
+	serial     : ContextualTestMethod;
+	before     : ContextualTestMethod;
+	after      : ContextualTestMethod;
+	skip       : ContextualTestMethod;
+	todo       : ContextualTestMethod;
+	failing    : ContextualTestMethod;
+	only       : ContextualTestMethod;
+	beforeEach : ContextualTestMethod;
+	afterEach  : ContextualTestMethod;
+	cb         : ContextualCallbackTestMethod;
+	always     : ContextualTestMethod;
+};
+
+type ContextualCallbackTestMethod = {
+	(              implementation: ContextualCallbackTest): void;
+	(name: string, implementation: ContextualCallbackTest): void;
+
+	serial     : ContextualCallbackTestMethod;
+	before     : ContextualCallbackTestMethod;
+	after      : ContextualCallbackTestMethod;
+	skip       : ContextualCallbackTestMethod;
+	todo       : ContextualCallbackTestMethod;
+	failing    : ContextualCallbackTestMethod;
+	only       : ContextualCallbackTestMethod;
+	beforeEach : ContextualCallbackTestMethod;
+	afterEach  : ContextualCallbackTestMethod;
+	cb         : ContextualCallbackTestMethod;
+	always     : ContextualCallbackTestMethod;
+};
+
+/**
+ * Public API
+ */
+
+declare module.exports: {
+	(              run: ContextualTest): void;
+	(name: string, run: ContextualTest): void;
+
+	beforeEach : TestMethod;
+	afterEach  : TestMethod;
+	serial     : ContextualTestMethod;
+	before     : ContextualTestMethod;
+	after      : ContextualTestMethod;
+	skip       : ContextualTestMethod;
+	todo       : ContextualTestMethod;
+	failing    : ContextualTestMethod;
+	only       : ContextualTestMethod;
+	cb         : ContextualCallbackTestMethod;
+	always     : ContextualTestMethod;
+};