ava 2.0.0 → 2.4.0

package/eslint-plugin-helper.js

@@ -4,15 +4,34 @@ const normalizeExtensions = require('./lib/extensions');
 const {hasExtension, normalizeGlobs, classify} = require('./lib/globs');
 const loadConfig = require('./lib/load-config');
 
-const cache = new Map();
+const configCache = new Map();
+const helperCache = new Map();
 
-function load(projectDir) {
-	if (cache.has(projectDir)) {
-		return cache.get(projectDir);
+function load(projectDir, overrides) {
+	const cacheKey = `${JSON.stringify(overrides)}\n${projectDir}`;
+	if (helperCache.has(cacheKey)) {
+		return helperCache.get(cacheKey);
+	}
+
+	let conf;
+	let babelConfig;
+	if (configCache.has(projectDir)) {
+		({conf, babelConfig} = configCache.get(projectDir));
+	} else {
+		conf = loadConfig({resolveFrom: projectDir});
+		babelConfig = babelPipeline.validate(conf.babel);
+		configCache.set(projectDir, {conf, babelConfig});
+	}
+
+	if (overrides) {
+		conf = {...conf, ...overrides};
+		if (overrides.extensions) {
+			// Ignore extensions from the Babel config. Assume all extensions are
+			// provided in the override.
+			babelConfig = null;
+		}
 	}
 
-	const conf = loadConfig(projectDir);
-	const babelConfig = babelPipeline.validate(conf.babel);
 	const extensions = normalizeExtensions(conf.extensions || [], babelConfig);
 	const globs = {cwd: projectDir, ...normalizeGlobs(conf.files, conf.helpers, conf.sources, extensions.all)};
 
@@ -30,7 +49,7 @@ function load(projectDir) {
 			return classify(`${importPath}.${globs.extensions[0]}`, globs);
 		}
 	});
-	cache.set(projectDir, helper);
+	helperCache.set(cacheKey, helper);
 	return helper;
 }
 

package/index.d.ts

@@ -1,3 +1,5 @@
+/// <reference types="node"/>
+
 export interface ObservableLike {
 	subscribe(observer: (value: unknown) => void): void;
 	[Symbol.observable](): ObservableLike;
@@ -23,6 +25,13 @@ export type ThrowsExpectation = {
 	name?: string;
 };
 
+export type CommitDiscardOptions = {
+	/**
+	 * Whether the logs should be included in those of the parent test.
+	 */
+	retainLogs?: boolean
+}
+
 /** Options that can be passed to the `t.snapshot()` assertion. */
 export type SnapshotOptions = {
 	/** If provided and not an empty string, used to select the snapshot to compare the `expected` value against. */
@@ -351,7 +360,7 @@ export interface TruthyAssertion {
 }
 
 /** The `t` value passed to test & hook implementations. */
-export interface ExecutionContext<Context = {}> extends Assertions {
+export interface ExecutionContext<Context = unknown> extends Assertions {
 	/** Test context, shared with hooks. */
 	context: Context;
 
@@ -361,6 +370,7 @@ export interface ExecutionContext<Context = {}> extends Assertions {
 	log: LogFn;
 	plan: PlanFn;
 	timeout: TimeoutFn;
+	try: TryFn<Context>;
 }
 
 export interface LogFn {
@@ -390,8 +400,71 @@ export interface TimeoutFn {
 	(ms: number): void;
 }
 
+export interface TryFn<Context = unknown> {
+	/**
+	 * Requires opt-in. Attempt to run some assertions. The result must be explicitly committed or discarded or else
+	 * the test will fail. A macro may be provided. The title may help distinguish attempts from
+	 * one another.
+	 */
+	<Args extends any[]>(title: string, fn: EitherMacro<Args, Context>, ...args: Args): Promise<TryResult>;
+
+	/**
+	* Requires opt-in. Attempt to run some assertions. The result must be explicitly committed or discarded or else
+	 * the test will fail. A macro may be provided. The title may help distinguish attempts from
+	 * one another.
+	 */
+	<Args extends any[]>(title: string, fn: [EitherMacro<Args, Context>, ...EitherMacro<Args, Context>[]], ...args: Args): Promise<TryResult[]>;
+
+	/**
+	* Requires opt-in. Attempt to run some assertions. The result must be explicitly committed or discarded or else
+	* the test will fail. A macro may be provided.
+	*/
+	<Args extends any[]>(fn: EitherMacro<Args, Context>, ...args: Args): Promise<TryResult>;
+
+	/**
+	* Requires opt-in. Attempt to run some assertions. The result must be explicitly committed or discarded or else
+	* the test will fail. A macro may be provided.
+	*/
+	<Args extends any[]>(fn: [EitherMacro<Args, Context>, ...EitherMacro<Args, Context>[]], ...args: Args): Promise<TryResult[]>;
+}
+
+export interface AssertionError extends Error {}
+
+export interface TryResult {
+	/**
+	* Title of the attempt, helping you tell attempts aparts.
+	*/
+	title: string;
+
+	/**
+	* Indicates whether all assertions passed, or at least one failed.
+	*/
+	passed: boolean;
+
+	/**
+	* Errors raised for each failed assertion.
+	*/
+	errors: AssertionError[];
+
+	/**
+	 * Logs created during the attempt using `t.log()`. Contains formatted values.
+	 */
+	logs: string[];
+
+	/**
+	 * Commit the attempt. Counts as one assertion for the plan count. If the
+	 * attempt failed, calling this will also cause your test to fail.
+	 */
+	commit(options?: CommitDiscardOptions): void;
+
+	/**
+	 * Discard the attempt.
+	 */
+	discard(options?: CommitDiscardOptions): void;
+}
+
 /** The `t` value passed to implementations for tests & hooks declared with the `.cb` modifier. */
-export interface CbExecutionContext<Context = {}> extends ExecutionContext<Context> {
+export interface CbExecutionContext<Context = unknown> extends ExecutionContext<Context> {
 	/**
 	 * End the test. If `error` is [truthy](https://developer.mozilla.org/en-US/docs/Glossary/Truthy) the test or hook
 	 * will fail.
@@ -400,14 +473,14 @@ export interface CbExecutionContext<Context = {}> extends ExecutionContext<Conte
 }
 
 export type ImplementationResult = PromiseLike<void> | ObservableLike | void;
-export type Implementation<Context = {}> = (t: ExecutionContext<Context>) => ImplementationResult;
-export type CbImplementation<Context = {}> = (t: CbExecutionContext<Context>) => ImplementationResult;
+export type Implementation<Context = unknown> = (t: ExecutionContext<Context>) => ImplementationResult;
+export type CbImplementation<Context = unknown> = (t: CbExecutionContext<Context>) => ImplementationResult;
 
 /** A reusable test or hook implementation. */
-export type UntitledMacro<Args extends any[], Context = {}> = (t: ExecutionContext<Context>, ...args: Args) => ImplementationResult;
+export type UntitledMacro<Args extends any[], Context = unknown> = (t: ExecutionContext<Context>, ...args: Args) => ImplementationResult;
 
 /** A reusable test or hook implementation. */
-export type Macro<Args extends any[], Context = {}> = UntitledMacro<Args, Context> & {
+export type Macro<Args extends any[], Context = unknown> = UntitledMacro<Args, Context> & {
 	/**
 	 * Implement this function to generate a test (or hook) title whenever this macro is used. `providedTitle` contains
 	 * the title provided when the test or hook was declared. Also receives the remaining test arguments.
@@ -421,10 +494,10 @@ export type EitherMacro<Args extends any[], Context> = Macro<Args, Context> | Un
 export type OneOrMoreMacros<Args extends any[], Context> = EitherMacro<Args, Context> | [EitherMacro<Args, Context>, ...EitherMacro<Args, Context>[]];
 
 /** A reusable test or hook implementation, for tests & hooks declared with the `.cb` modifier. */
-export type UntitledCbMacro<Args extends any[], Context = {}> = (t: CbExecutionContext<Context>, ...args: Args) => ImplementationResult
+export type UntitledCbMacro<Args extends any[], Context = unknown> = (t: CbExecutionContext<Context>, ...args: Args) => ImplementationResult
 
 /** A reusable test or hook implementation, for tests & hooks declared with the `.cb` modifier. */
-export type CbMacro<Args extends any[], Context = {}> = UntitledCbMacro<Args, Context> & {
+export type CbMacro<Args extends any[], Context = unknown> = UntitledCbMacro<Args, Context> & {
 	title?: (providedTitle: string | undefined, ...args: Args) => string;
 }
 
@@ -433,7 +506,7 @@ export type EitherCbMacro<Args extends any[], Context> = CbMacro<Args, Context>
 /** Alias for a single macro, or an array of macros, used for tests & hooks declared with the `.cb` modifier. */
 export type OneOrMoreCbMacros<Args extends any[], Context> = EitherCbMacro<Args, Context> | [EitherCbMacro<Args, Context>, ...EitherCbMacro<Args, Context>[]];
 
-export interface TestInterface<Context = {}> {
+export interface TestInterface<Context = unknown> {
 	/** Declare a concurrent test. */
 	(title: string, implementation: Implementation<Context>): void;
 
@@ -470,7 +543,7 @@ export interface TestInterface<Context = {}> {
 	meta: MetaInterface;
 }
 
-export interface AfterInterface<Context = {}> {
+export interface AfterInterface<Context = unknown> {
 	/** Declare a hook that is run once, after all tests have passed. */
 	(implementation: Implementation<Context>): void;
 
@@ -492,7 +565,7 @@ export interface AfterInterface<Context = {}> {
 	skip: HookSkipInterface<Context>;
 }
 
-export interface AlwaysInterface<Context = {}> {
+export interface AlwaysInterface<Context = unknown> {
 	/** Declare a hook that is run once, after all tests are done. */
 	(implementation: Implementation<Context>): void;
 
@@ -511,7 +584,7 @@ export interface AlwaysInterface<Context = {}> {
 	skip: HookSkipInterface<Context>;
 }
 
-export interface BeforeInterface<Context = {}> {
+export interface BeforeInterface<Context = unknown> {
 	/** Declare a hook that is run once, before all tests. */
 	(implementation: Implementation<Context>): void;
 
@@ -530,7 +603,7 @@ export interface BeforeInterface<Context = {}> {
 	skip: HookSkipInterface<Context>;
 }
 
-export interface CbInterface<Context = {}> {
+export interface CbInterface<Context = unknown> {
 	/** Declare a test that must call `t.end()` when it's done. */
 	(title: string, implementation: CbImplementation<Context>): void;
 
@@ -553,7 +626,7 @@ export interface CbInterface<Context = {}> {
 	skip: CbSkipInterface<Context>;
 }
 
-export interface CbFailingInterface<Context = {}> {
+export interface CbFailingInterface<Context = unknown> {
 	/** Declare a test that must call `t.end()` when it's done. The test is expected to fail. */
 	(title: string, implementation: CbImplementation<Context>): void;
 
@@ -573,7 +646,7 @@ export interface CbFailingInterface<Context = {}> {
 	skip: CbSkipInterface<Context>;
 }
 
-export interface CbOnlyInterface<Context = {}> {
+export interface CbOnlyInterface<Context = unknown> {
 	/**
 	 * Declare a test that must call `t.end()` when it's done. Only this test and others declared with `.only()` are run.
 	 */
@@ -592,7 +665,7 @@ export interface CbOnlyInterface<Context = {}> {
 	<T extends any[]>(macros: OneOrMoreCbMacros<T, Context>, ...rest: T): void;
 }
 
-export interface CbSkipInterface<Context = {}> {
+export interface CbSkipInterface<Context = unknown> {
 	/** Skip this test. */
 	(title: string, implementation: CbImplementation<Context>): void;
 
@@ -603,7 +676,7 @@ export interface CbSkipInterface<Context = {}> {
 	<T extends any[]>(macros: OneOrMoreCbMacros<T, Context>, ...rest: T): void;
 }
 
-export interface FailingInterface<Context = {}> {
+export interface FailingInterface<Context = unknown> {
 	/** Declare a concurrent test. The test is expected to fail. */
 	(title: string, implementation: Implementation<Context>): void;
 
@@ -623,7 +696,7 @@ export interface FailingInterface<Context = {}> {
 	skip: SkipInterface<Context>;
 }
 
-export interface HookCbInterface<Context = {}> {
+export interface HookCbInterface<Context = unknown> {
 	/** Declare a hook that must call `t.end()` when it's done. */
 	(implementation: CbImplementation<Context>): void;
 
@@ -644,7 +717,7 @@ export interface HookCbInterface<Context = {}> {
 	skip: HookCbSkipInterface<Context>;
 }
 
-export interface HookCbSkipInterface<Context = {}> {
+export interface HookCbSkipInterface<Context = unknown> {
 	/** Skip this hook. */
 	(implementation: CbImplementation<Context>): void;
 
@@ -658,7 +731,7 @@ export interface HookCbSkipInterface<Context = {}> {
 	<T extends any[]>(macros: OneOrMoreCbMacros<T, Context>, ...rest: T): void;
 }
 
-export interface HookSkipInterface<Context = {}> {
+export interface HookSkipInterface<Context = unknown> {
 	/** Skip this hook. */
 	(implementation: Implementation<Context>): void;
 
@@ -672,7 +745,7 @@ export interface HookSkipInterface<Context = {}> {
 	<T extends any[]>(macros: OneOrMoreMacros<T, Context>, ...rest: T): void;
 }
 
-export interface OnlyInterface<Context = {}> {
+export interface OnlyInterface<Context = unknown> {
 	/** Declare a test. Only this test and others declared with `.only()` are run. */
 	(title: string, implementation: Implementation<Context>): void;
 
@@ -689,7 +762,7 @@ export interface OnlyInterface<Context = {}> {
 	<T extends any[]>(macros: OneOrMoreMacros<T, Context>, ...rest: T): void;
 }
 
-export interface SerialInterface<Context = {}> {
+export interface SerialInterface<Context = unknown> {
 	/** Declare a serial test. */
 	(title: string, implementation: Implementation<Context>): void;
 
@@ -724,7 +797,7 @@ export interface SerialInterface<Context = {}> {
 	todo: TodoDeclaration;
 }
 
-export interface SkipInterface<Context = {}> {
+export interface SkipInterface<Context = unknown> {
 	/** Skip this test. */
 	(title: string, implementation: Implementation<Context>): void;
 

package/lib/api.js

@@ -51,6 +51,7 @@ class Api extends Emittery {
 	}
 
 	async run(files = [], runtimeOptions = {}) {
+		let setupOrGlobError;
 		files = files.map(file => path.resolve(this.options.resolveTestsFrom, file));
 
 		const apiOptions = this.options;
@@ -106,9 +107,12 @@ class Api extends Emittery {
 			}
 		};
 
+		let precompiler;
+		let helpers;
+
 		try {
-			const precompiler = await this._setupPrecompiler();
-			let helpers = [];
+			precompiler = await this._setupPrecompiler(); // eslint-disable-line require-atomic-updates
+			helpers = [];
 			if (files.length === 0 || precompiler.enabled) {
 				let found;
 				if (precompiler.enabled) {
@@ -122,7 +126,12 @@ class Api extends Emittery {
 					({tests: files} = found);
 				}
 			}
+		} catch (error) {
+			files = [];
+			setupOrGlobError = error;
+		}
 
+		try {
 			if (this.options.parallelRuns) {
 				const {currentIndex, totalRuns} = this.options.parallelRuns;
 				const fileCount = files.length;
@@ -140,6 +149,7 @@ class Api extends Emittery {
 
 			await this.emit('run', {
 				clearLogOnNextRun: runtimeOptions.clearLogOnNextRun === true,
+				experiments: Object.keys(apiOptions.experiments),
 				failFastEnabled: failFast,
 				filePathPrefix: commonPathPrefix(files),
 				files,
@@ -150,6 +160,10 @@ class Api extends Emittery {
 				status: runStatus
 			});
 
+			if (setupOrGlobError) {
+				throw setupOrGlobError;
+			}
+
 			// Bail out early if no files were found.
 			if (files.length === 0) {
 				return runStatus;
@@ -310,7 +324,7 @@ class Api extends Emittery {
 		const forkExecArgv = execArgv.slice();
 		let flagName = '--inspect';
 		const oldValue = forkExecArgv[inspectArgIndex];
-		if (oldValue.indexOf('brk') > 0) {
+		if (oldValue.includes('brk')) {
 			flagName += '-brk';
 		}
 

package/lib/assert.js

@@ -53,25 +53,21 @@ class AssertionError extends Error {
 		// Reserved for power-assert statements
 		this.statements = [];
 
-		if (opts.stack) {
-			this.stack = opts.stack;
+		if (opts.savedError) {
+			this.savedError = opts.savedError;
 		} else {
-			const limitBefore = Error.stackTraceLimit;
-			Error.stackTraceLimit = Infinity;
-			Error.captureStackTrace(this);
-			Error.stackTraceLimit = limitBefore;
+			this.savedError = getErrorWithLongStackTrace();
 		}
 	}
 }
 exports.AssertionError = AssertionError;
 
-function getStack() {
+function getErrorWithLongStackTrace() {
 	const limitBefore = Error.stackTraceLimit;
 	Error.stackTraceLimit = Infinity;
-	const obj = {};
-	Error.captureStackTrace(obj, getStack);
+	const err = new Error();
 	Error.stackTraceLimit = limitBefore;
-	return obj.stack;
+	return err;
 }
 
 function validateExpectations(assertion, expectations, numArgs) { // eslint-disable-line complexity
@@ -143,12 +139,12 @@ function validateExpectations(assertion, expectations, numArgs) { // eslint-disa
 
 // Note: this function *must* throw exceptions, since it can be used
 // as part of a pending assertion for promises.
-function assertExpectations({assertion, actual, expectations, message, prefix, stack}) {
+function assertExpectations({assertion, actual, expectations, message, prefix, savedError}) {
 	if (!isError(actual)) {
 		throw new AssertionError({
 			assertion,
 			message,
-			stack,
+			savedError,
 			values: [formatWithLabel(`${prefix} exception that is not an error:`, actual)]
 		});
 	}
@@ -159,7 +155,7 @@ function assertExpectations({assertion, actual, expectations, message, prefix, s
 		throw new AssertionError({
 			assertion,
 			message,
-			stack,
+			savedError,
 			actualStack,
 			values: [
 				formatWithLabel(`${prefix} unexpected exception:`, actual),
@@ -172,7 +168,7 @@ function assertExpectations({assertion, actual, expectations, message, prefix, s
 		throw new AssertionError({
 			assertion,
 			message,
-			stack,
+			savedError,
 			actualStack,
 			values: [
 				formatWithLabel(`${prefix} unexpected exception:`, actual),
@@ -185,7 +181,7 @@ function assertExpectations({assertion, actual, expectations, message, prefix, s
 		throw new AssertionError({
 			assertion,
 			message,
-			stack,
+			savedError,
 			actualStack,
 			values: [
 				formatWithLabel(`${prefix} unexpected exception:`, actual),
@@ -198,7 +194,7 @@ function assertExpectations({assertion, actual, expectations, message, prefix, s
 		throw new AssertionError({
 			assertion,
 			message,
-			stack,
+			savedError,
 			actualStack,
 			values: [
 				formatWithLabel(`${prefix} unexpected exception:`, actual),
@@ -211,7 +207,7 @@ function assertExpectations({assertion, actual, expectations, message, prefix, s
 		throw new AssertionError({
 			assertion,
 			message,
-			stack,
+			savedError,
 			actualStack,
 			values: [
 				formatWithLabel(`${prefix} unexpected exception:`, actual),
@@ -224,7 +220,7 @@ function assertExpectations({assertion, actual, expectations, message, prefix, s
 		throw new AssertionError({
 			assertion,
 			message,
-			stack,
+			savedError,
 			actualStack,
 			values: [
 				formatWithLabel(`${prefix} unexpected exception:`, actual),
@@ -480,14 +476,14 @@ class Assertions {
 			}
 
 			const handlePromise = (promise, wasReturned) => {
-				// Record stack before it gets lost in the promise chain.
-				const stack = getStack();
+				// Create an error object to record the stack before it gets lost in the promise chain.
+				const savedError = getErrorWithLongStackTrace();
 				// Handle "promise like" objects by casting to a real Promise.
 				const intermediate = Promise.resolve(promise).then(value => { // eslint-disable-line promise/prefer-await-to-then
 					throw new AssertionError({
 						assertion: 'throwsAsync',
 						message,
-						stack,
+						savedError,
 						values: [formatWithLabel(`${wasReturned ? 'Returned promise' : 'Promise'} resolved with:`, value)]
 					});
 				}, reason => {
@@ -497,7 +493,7 @@ class Assertions {
 						expectations,
 						message,
 						prefix: `${wasReturned ? 'Returned promise' : 'Promise'} rejected with`,
-						stack
+						savedError
 					});
 					return reason;
 				});
@@ -587,14 +583,14 @@ class Assertions {
 			}
 
 			const handlePromise = (promise, wasReturned) => {
-				// Record stack before it gets lost in the promise chain.
-				const stack = getStack();
+				// Create an error object to record the stack before it gets lost in the promise chain.
+				const savedError = getErrorWithLongStackTrace();
 				// Handle "promise like" objects by casting to a real Promise.
 				const intermediate = Promise.resolve(promise).then(noop, error => { // eslint-disable-line promise/prefer-await-to-then
 					throw new AssertionError({
 						assertion: 'notThrowsAsync',
 						message,
-						actualStack: stack,
+						savedError,
 						values: [formatWithLabel(`${wasReturned ? 'Returned promise' : 'Promise'} rejected with:`, error)]
 					});
 				});

package/lib/babel-pipeline.js

@@ -58,6 +58,26 @@ function validate(conf) {
 	};
 }
 
+function enableParserPlugins(api) {
+	api.assertVersion(7);
+
+	return {
+		name: 'ava-babel-pipeline-enable-parser-plugins',
+		manipulateOptions(_, parserOpts) {
+			parserOpts.plugins.push(
+				'asyncGenerators',
+				'bigInt',
+				'classPrivateProperties',
+				'classProperties',
+				'dynamicImport',
+				'numericSeparator',
+				'objectRestSpread',
+				'optionalCatchBinding'
+			);
+		}
+	};
+}
+
 // Compare actual values rather than file paths, which should be
 // more reliable.
 function makeValueChecker(ref) {
@@ -118,7 +138,12 @@ function hashPartialTestConfig({babelrc, config, options: {plugins, presets}}, p
 		inputs.push(config, stripBomBuf(fs.readFileSync(config)));
 	}
 
-	for (const {file: {resolved: filename}} of [...plugins, ...presets]) {
+	for (const item of [...plugins, ...presets]) {
+		if (!item.file) {
+			continue;
+		}
+
+		const {file: {resolved: filename}} = item;
 		if (pluginAndPresetHashes.has(filename)) {
 			inputs.push(pluginAndPresetHashes.get(filename));
 			continue;
@@ -168,9 +193,6 @@ function build(projectDir, cacheDir, userOptions, compileEnhancements) {
 	const pluginAndPresetHashes = new Map();
 
 	const ensureStage4 = wantsStage4(userOptions, projectDir);
-	const containsAsyncGenerators = makeValueChecker('@babel/plugin-syntax-async-generators');
-	const containsObjectRestSpread = makeValueChecker('@babel/plugin-syntax-object-rest-spread');
-	const containsOptionalCatchBinding = makeValueChecker('@babel/plugin-syntax-optional-catch-binding');
 	const containsStage4 = makeValueChecker('../stage-4');
 	const containsTransformTestFiles = makeValueChecker('@ava/babel-preset-transform-test-files');
 
@@ -193,17 +215,7 @@ function build(projectDir, cacheDir, userOptions, compileEnhancements) {
 		}
 
 		const {options: testOptions} = partialTestConfig;
-		if (!testOptions.plugins.some(containsAsyncGenerators)) { // TODO: Remove once Babel can parse this syntax unaided.
-			testOptions.plugins.unshift(createConfigItem('@babel/plugin-syntax-async-generators', 'plugin'));
-		}
-
-		if (!testOptions.plugins.some(containsObjectRestSpread)) { // TODO: Remove once Babel can parse this syntax unaided.
-			testOptions.plugins.unshift(createConfigItem('@babel/plugin-syntax-object-rest-spread', 'plugin'));
-		}
-
-		if (!testOptions.plugins.some(containsOptionalCatchBinding)) { // TODO: Remove once Babel can parse this syntax unaided.
-			testOptions.plugins.unshift(createConfigItem('@babel/plugin-syntax-optional-catch-binding', 'plugin'));
-		}
+		testOptions.plugins.push(enableParserPlugins);
 
 		if (ensureStage4 && !testOptions.presets.some(containsStage4)) {
 			// Apply last.

package/lib/cli.js

@@ -1,5 +1,6 @@
 'use strict';
 const path = require('path');
+const fs = require('fs');
 const del = require('del');
 const updateNotifier = require('update-notifier');
 const figures = require('figures');
@@ -7,7 +8,7 @@ const arrify = require('arrify');
 const meow = require('meow');
 const Promise = require('bluebird');
 const isCi = require('is-ci');
-const loadConf = require('./load-config');
+const loadConfig = require('./load-config');
 
 // Bluebird specific
 Promise.longStackTraces();
@@ -18,10 +19,17 @@ function exit(message) {
 }
 
 exports.run = async () => { // eslint-disable-line complexity
+	const {flags: {config: configFile}} = meow({ // Process the --config flag first
+		autoHelp: false, // --help should get picked up by the next meow invocation.
+		flags: {
+			config: {type: 'string'}
+		}
+	});
+
 	let conf = {};
 	let confError = null;
 	try {
-		conf = loadConf();
+		conf = loadConfig({configFile});
 	} catch (error) {
 		confError = error;
 	}
@@ -35,7 +43,7 @@ exports.run = async () => { // eslint-disable-line complexity
 		  --match, -m             Only run tests with matching title (Can be repeated)
 		  --update-snapshots, -u  Update snapshots
 		  --fail-fast             Stop after first test failure
-		  --timeout, -T           Set global timeout
+		  --timeout, -T           Set global timeout (milliseconds or human-readable, e.g. 10s, 2m)
 		  --serial, -s            Run tests serially
 		  --concurrency, -c       Max number of test files running at the same time (Default: CPU cores)
 		  --verbose, -v           Enable verbose output
@@ -43,6 +51,8 @@ exports.run = async () => { // eslint-disable-line complexity
 		  --color                 Force color output
 		  --no-color              Disable color output
 		  --reset-cache           Reset AVA's compilation cache and exit
+		  --config                JavaScript file for AVA to read its config from, instead of using package.json
+		                          or ava.config.js files
 
 		Examples
 		  ava
@@ -204,12 +214,31 @@ exports.run = async () => { // eslint-disable-line complexity
 
 	const match = arrify(conf.match);
 	const resolveTestsFrom = cli.input.length === 0 ? projectDir : process.cwd();
+
+	const files = cli.input.map(file => path.relative(resolveTestsFrom, path.resolve(process.cwd(), file)));
+
+	for (const file of cli.input) {
+		try {
+			const stats = fs.statSync(file);
+			if (!stats.isFile()) {
+				exit(`${file} is not a test file.`);
+			}
+		} catch (error) {
+			if (error.code === 'ENOENT') {
+				exit(`${file} does not exist.`);
+			} else {
+				exit(`Error accessing ${file}\n\n${chalk.gray((error && error.stack) || error)}`);
+			}
+		}
+	}
+
 	const api = new Api({
 		babelConfig,
 		cacheEnabled: conf.cache !== false,
 		color: conf.color,
 		compileEnhancements: conf.compileEnhancements !== false,
 		concurrency: conf.concurrency ? parseInt(conf.concurrency, 10) : 0,
+		experiments: conf.nonSemVerExperiments,
 		extensions,
 		failFast: conf.failFast,
 		failWithoutAssertions: conf.failWithoutAssertions !== false,
@@ -259,8 +288,6 @@ exports.run = async () => { // eslint-disable-line complexity
 		});
 	});
 
-	const files = cli.input.map(file => path.relative(resolveTestsFrom, path.resolve(process.cwd(), file)));
-
 	if (conf.watch) {
 		const watcher = new Watcher({
 			api,