ava 0.15.0 → 0.17.0

package/cli.js

@@ -1,203 +1,28 @@
 #!/usr/bin/env node
 'use strict';
 
+var path = require('path');
 var debug = require('debug')('ava');
 
 // Prefer the local installation of AVA.
 var resolveCwd = require('resolve-cwd');
 var 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 chalk = require('chalk');
-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 Api = require('./api');
-
-// Bluebird specific
-Promise.longStackTraces();
-
-var conf = pkgConf.sync('ava', {
-	defaults: {
-		babel: 'default'
-	}
-});
-
-// check for valid babel config shortcuts (can be either "default" or "inherit")
-var isValidShortcut = ['default', 'inherit'].indexOf(conf.babel) !== -1;
-
-if (!conf.babel || (typeof conf.babel === 'string' && !isValidShortcut)) {
-	var message = '';
-	message += 'Unexpected Babel configuration for AVA. ';
-	message += 'See ' + chalk.underline('https://github.com/avajs/ava#es2015-support') + ' for allowed values.';
-
-	console.log('\n  ' + colors.error(figures.cross) + ' ' + 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,
-	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 (files.length === 0) {
-	files = [
-		'test.js',
-		'test-*.js',
-		'test'
-	];
-}
+	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
+// 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,218 @@
+/* @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);
+
+/**
+ * Asertion 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;
+	// DEPRECATED, use `truthy`. Assert that value is truthy.
+	ok(value: mixed, message?: string): void;
+	// DEPRECATED, use `falsy`. Assert that value is falsy.
+	notOk(value: mixed, message?: string): void;
+	// Assert that value is true.
+	true(value: boolean, message?: string): void;
+	// Assert that value is false.
+	false(value: boolean, 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.
+	// DEPRECATED, use `deepEqual`. Assert that value is deep equal to expected.
+	// @param error Can be a constructor, regex, error message or validation function.
+	same<U>(value: U, expected: U, message?: string): void;
+	// DEPRECATED use `notDeepEqual`. Assert that value is not deep equal to expected.
+	notSame<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<mixed>;
+	throws(value: () => void, error?: ErrorValidator, message?: string): mixed;
+	// Assert that function doesn't throw an error or promise resolves.
+	notThrows<U>(value: PromiseLike<U>, message?: string): Promise<U>;
+	notThrows(value: () => void, message?: string): void;
+	// Assert that contents matches regex.
+	regex(contents: string, regex: RegExp, 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 Types
+ */
+
+type Test                   = (t: TestContext)                   => SpecialReturnTypes | void;
+type CallbackTest           = (t: CallbackTestContext)           => void;
+type ContextualTest         = (t: ContextualTestContext)         => SpecialReturnTypes | void;
+type ContextualCallbackTest = (t: ContextualCallbackTestContext) => void;
+
+/**
+ * Macro Types
+ */
+
+type Macro<T> = {
+	(t: T, ...args: Array<any>): void;
+	title?: (providedTitle: string, ...args: Array<any>) => string;
+};
+
+type Macros<T> =
+	| Macro<T>
+	| Array<Macro<T>>;
+
+/**
+ * Method Types
+ */
+
+type TestMethod = {
+	(              implementation: Test): void;
+	(name: string, implementation: Test): void;
+	(              implementation: Macros<TestContext>, ...args: Array<any>): void;
+	(name: string, implementation: Macros<TestContext>, ...args: Array<any>): 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;
+	(              implementation: Macros<CallbackTestContext>, ...args: Array<any>): void;
+	(name: string, implementation: Macros<CallbackTestContext>, ...args: Array<any>): 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;
+	(              implementation: Macros<ContextualTestContext>, ...args: Array<any>): void;
+	(name: string, implementation: Macros<ContextualTestContext>, ...args: Array<any>): 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;
+	(              implementation: Macros<ContextualCallbackTestContext>, ...args: Array<any>): void;
+	(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: Array<any>): 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;
+	(              run: Macros<ContextualTestContext>, ...args: Array<any>): void;
+	(name: string, run: Macros<ContextualTestContext>, ...args: Array<any>): void;
+
+	beforeEach : TestMethod;
+	afterEach  : TestMethod;
+	serial     : ContextualTestMethod;
+	before     : ContextualTestMethod;
+	after      : ContextualTestMethod;
+	skip       : ContextualTestMethod;
+	todo       : ContextualTestMethod;
+	failing    : ContextualTestMethod;
+	only       : ContextualTestMethod;
+	cb         : ContextualCallbackTestMethod;
+	always     : ContextualTestMethod;
+};

package/lib/assert.js

@@ -1,10 +1,11 @@
 'use strict';
 var util = require('util');
 var assert = require('core-assert');
-var deepEqual = require('not-so-shallow');
+var deepEqual = require('lodash.isequal');
 var observableToPromise = require('observable-to-promise');
 var isObservable = require('is-observable');
 var isPromise = require('is-promise');
+
 var x = module.exports;
 
 Object.defineProperty(x, 'AssertionError', {value: assert.AssertionError});
@@ -101,9 +102,9 @@ x.throws = function (fn, err, msg) {
 		assert.throws(function () {
 			try {
 				fn();
-			} catch (error) {
-				result = error;
-				throw error;
+			} catch (err) {
+				result = err;
+				throw err;
 			}
 		}, err, msg);
 
@@ -142,18 +143,22 @@ x.regex = function (contents, regex, msg) {
 	test(regex.test(contents), create(regex, contents, '===', msg, x.regex));
 };
 
-x.ifError = x.error = function (err, msg) {
+x.notRegex = function (contents, regex, msg) {
+	test(!regex.test(contents), create(regex, contents, '!==', msg, x.notRegex));
+};
+
+x.ifError = function (err, msg) {
 	test(!err, create(err, 'Error', '!==', msg, x.ifError));
 };
 
 /*
  * deprecated APIs
  */
-x.doesNotThrow = util.deprecate(x.notThrows, getDeprecationNotice('doesNotThrow()', 'notThrows()'));
 x.ok = util.deprecate(x.truthy, getDeprecationNotice('ok()', 'truthy()'));
 x.notOk = util.deprecate(x.falsy, getDeprecationNotice('notOk()', 'falsy()'));
 x.same = util.deprecate(x.deepEqual, getDeprecationNotice('same()', 'deepEqual()'));
 x.notSame = util.deprecate(x.notDeepEqual, getDeprecationNotice('notSame()', 'notDeepEqual()'));
+x.error = util.deprecate(x.ifError, getDeprecationNotice('error()', 'ifError()'));
 
 function getDeprecationNotice(oldApi, newApi) {
 	return 'DEPRECATION NOTICE: ' + oldApi + ' has been renamed to ' + newApi + ' and will eventually be removed. See https://github.com/avajs/ava-codemods to help upgrade your codebase automatically.';