ava 3.7.1 → 3.9.0

package/index.d.ts

@@ -45,6 +45,9 @@ export interface Assertions {
 	/** Assert that `actual` is [deeply equal](https://github.com/concordancejs/concordance#comparison-details) to `expected`. */
 	deepEqual: DeepEqualAssertion;
 
+	/** Assert that `actual` is like `expected`. */
+	like: LikeAssertion;
+
 	/** Fail the test. */
 	fail: FailAssertion;
 
@@ -125,6 +128,14 @@ export interface DeepEqualAssertion {
 	skip(actual: any, expected: any, message?: string): void;
 }
 
+export interface LikeAssertion {
+	/** Assert that `value` is like `selector`. */
+	(value: any, selector: Record<string, unknown>, message?: string): void;
+
+	/** Skip this assertion. */
+	skip(value: any, selector: any, message?: string): void;
+}
+
 export interface FailAssertion {
 	/** Fail the test. */
 	(message?: string): void;
@@ -313,6 +324,7 @@ export interface ExecutionContext<Context = unknown> extends Assertions {
 
 	log: LogFn;
 	plan: PlanFn;
+	teardown: TeardownFn;
 	timeout: TimeoutFn;
 	try: TryFn<Context>;
 }
@@ -344,6 +356,11 @@ export interface TimeoutFn {
 	(ms: number): void;
 }
 
+export interface TeardownFn {
+	/** Declare a function to be run after the test has ended. */
+	(fn: () => void): void;
+}
+
 export interface TryFn<Context = unknown> {
 	/**
 	 * Attempt to run some assertions. The result must be explicitly committed or discarded or else
@@ -416,7 +433,7 @@ export interface CbExecutionContext<Context = unknown> extends ExecutionContext<
 	end(error?: any): void;
 }
 
-export type ImplementationResult = PromiseLike<void> | Subscribable | void;
+export type ImplementationResult = PromiseLike<void> | Subscribable | void; // eslint-disable-line @typescript-eslint/no-invalid-void-type
 export type Implementation<Context = unknown> = (t: ExecutionContext<Context>) => ImplementationResult;
 export type CbImplementation<Context = unknown> = (t: CbExecutionContext<Context>) => ImplementationResult;
 

package/lib/api.js

@@ -16,6 +16,7 @@ const isCi = require('./is-ci');
 const RunStatus = require('./run-status');
 const fork = require('./fork');
 const serializeError = require('./serialize-error');
+const {getApplicableLineNumbers} = require('./line-numbers');
 
 function resolveModules(modules) {
 	return arrify(modules).map(name => {
@@ -118,7 +119,11 @@ class Api extends Emittery {
 				if (filter.length === 0) {
 					selectedFiles = testFiles;
 				} else {
-					selectedFiles = globs.applyTestFileFilter({cwd: this.options.projectDir, filter, testFiles});
+					selectedFiles = globs.applyTestFileFilter({
+						cwd: this.options.projectDir,
+						filter: filter.map(({pattern}) => pattern),
+						testFiles
+					});
 				}
 			}
 		} catch (error) {
@@ -209,9 +214,11 @@ class Api extends Emittery {
 					return;
 				}
 
+				const lineNumbers = getApplicableLineNumbers(globs.normalizeFileForMatching(apiOptions.projectDir, file), filter);
 				const options = {
 					...apiOptions,
 					providerStates,
+					lineNumbers,
 					recordNewSnapshots: !isCi,
 					// If we're looking for matches, run every single test process in exclusive-only mode
 					runOnlyExclusive: apiOptions.match.length > 0 || runtimeOptions.runOnlyExclusive === true
@@ -223,7 +230,7 @@ class Api extends Emittery {
 				}
 
 				const worker = fork(file, options, apiOptions.nodeArguments);
-				runStatus.observeWorker(worker, file);
+				runStatus.observeWorker(worker, file, {selectingLines: lineNumbers.length > 0});
 
 				pendingWorkers.add(worker);
 				worker.promise.then(() => {

package/lib/assert.js

@@ -3,11 +3,11 @@ const concordance = require('concordance');
 const isError = require('is-error');
 const isPromise = require('is-promise');
 const concordanceOptions = require('./concordance-options').default;
-const concordanceDiffOptions = require('./concordance-options').diff;
+const {CIRCULAR_SELECTOR, isLikeSelector, selectComparable} = require('./like-selector');
 const snapshotManager = require('./snapshot-manager');
 
 function formatDescriptorDiff(actualDescriptor, expectedDescriptor, options) {
-	options = {...options, ...concordanceDiffOptions};
+	options = {...options, ...concordanceOptions};
 	return {
 		label: 'Difference:',
 		formatted: concordance.diffDescriptors(actualDescriptor, expectedDescriptor, options)
@@ -242,7 +242,8 @@ class Assertions {
 		fail = notImplemented,
 		skip = notImplemented,
 		compareWithSnapshot = notImplemented,
-		powerAssert
+		powerAssert,
+		experiments = {}
 	} = {}) {
 		const withSkip = assertionFn => {
 			assertionFn.skip = skip;
@@ -387,6 +388,61 @@ class Assertions {
 			}
 		});
 
+		this.like = withSkip((actual, selector, message) => {
+			if (!experiments.likeAssertion) {
+				fail(new AssertionError({
+					assertion: 'like',
+					improperUsage: true,
+					message: 'You must enable the `likeAssertion` experiment in order to use `t.like()`'
+				}));
+				return;
+			}
+
+			if (!checkMessage('like', message)) {
+				return;
+			}
+
+			if (!isLikeSelector(selector)) {
+				fail(new AssertionError({
+					assertion: 'like',
+					improperUsage: true,
+					message: '`t.like()` selector must be a non-empty object',
+					values: [formatWithLabel('Called with:', selector)]
+				}));
+				return;
+			}
+
+			let comparable;
+			try {
+				comparable = selectComparable(actual, selector);
+			} catch (error) {
+				if (error === CIRCULAR_SELECTOR) {
+					fail(new AssertionError({
+						assertion: 'like',
+						improperUsage: true,
+						message: '`t.like()` selector must not contain circular references',
+						values: [formatWithLabel('Called with:', selector)]
+					}));
+					return;
+				}
+
+				throw error;
+			}
+
+			const result = concordance.compare(comparable, selector, concordanceOptions);
+			if (result.pass) {
+				pass();
+			} else {
+				const actualDescriptor = result.actual || concordance.describe(comparable, concordanceOptions);
+				const expectedDescriptor = result.expected || concordance.describe(selector, concordanceOptions);
+				fail(new AssertionError({
+					assertion: 'like',
+					message,
+					values: [formatDescriptorDiff(actualDescriptor, expectedDescriptor)]
+				}));
+			}
+		});
+
 		this.throws = withSkip((...args) => {
 			// Since arrow functions do not support 'arguments', we are using rest
 			// operator, so we can determine the total number of arguments passed
@@ -491,16 +547,16 @@ class Assertions {
 						savedError,
 						values: [formatWithLabel(`${wasReturned ? 'Returned promise' : 'Promise'} resolved with:`, value)]
 					});
-				}, reason => {
+				}, error => {
 					assertExpectations({
 						assertion: 'throwsAsync',
-						actual: reason,
+						actual: error,
 						expectations,
 						message,
 						prefix: `${wasReturned ? 'Returned promise' : 'Promise'} rejected with`,
 						savedError
 					});
-					return reason;
+					return error;
 				});
 
 				pending(intermediate);

package/lib/cli.js

@@ -120,7 +120,7 @@ exports.run = async () => { // eslint-disable-line complexity
 		})
 		.command('* [<pattern>...]', 'Run tests', yargs => yargs.options(FLAGS).positional('pattern', {
 			array: true,
-			describe: 'Glob patterns to select what test files to run. Leave empty if you want AVA to run all test files instead',
+			describe: 'Glob patterns to select what test files to run. Leave empty if you want AVA to run all test files instead. Add a colon and specify line numbers of specific tests to run',
 			type: 'string'
 		}))
 		.command(
@@ -143,7 +143,7 @@ exports.run = async () => { // eslint-disable-line complexity
 				}
 			}).positional('pattern', {
 				demand: true,
-				describe: 'Glob patterns to select a single test file to debug',
+				describe: 'Glob patterns to select a single test file to debug. Add a colon and specify line numbers of specific tests to run',
 				type: 'string'
 			}),
 			argv => {
@@ -163,6 +163,7 @@ exports.run = async () => { // eslint-disable-line complexity
 			})
 		.example('$0')
 		.example('$0 test.js')
+		.example('$0 test.js:4,7-9')
 		.help();
 
 	const combined = {...conf};
@@ -258,14 +259,14 @@ exports.run = async () => { // eslint-disable-line complexity
 
 	const ciParallelVars = require('ci-parallel-vars');
 	const Api = require('./api');
-	const VerboseReporter = require('./reporters/verbose');
-	const MiniReporter = require('./reporters/mini');
+	const DefaultReporter = require('./reporters/default');
 	const TapReporter = require('./reporters/tap');
 	const Watcher = require('./watcher');
 	const normalizeExtensions = require('./extensions');
-	const {normalizeGlobs, normalizePatterns} = require('./globs');
+	const {normalizeGlobs, normalizePattern} = require('./globs');
 	const normalizeNodeArguments = require('./node-arguments');
 	const validateEnvironmentVariables = require('./environment-variables');
+	const {splitPatternAndLineNumbers} = require('./line-numbers');
 	const providerManager = require('./provider-manager');
 
 	let pkg;
@@ -349,7 +350,12 @@ exports.run = async () => { // eslint-disable-line complexity
 	const match = combined.match === '' ? [] : arrify(combined.match);
 
 	const input = debug ? debug.files : (argv.pattern || []);
-	const filter = normalizePatterns(input.map(fileOrPattern => path.relative(projectDir, path.resolve(process.cwd(), fileOrPattern))));
+	const filter = input
+		.map(pattern => splitPatternAndLineNumbers(pattern))
+		.map(({pattern, ...rest}) => ({
+			pattern: normalizePattern(path.relative(projectDir, path.resolve(process.cwd(), pattern))),
+			...rest
+		}));
 
 	const api = new Api({
 		cacheEnabled: combined.cache !== false,
@@ -384,25 +390,32 @@ exports.run = async () => { // eslint-disable-line complexity
 			reportStream: process.stdout,
 			stdStream: process.stderr
 		});
-	} else if (debug !== null || combined.verbose || isCi || !process.stdout.isTTY) {
-		reporter = new VerboseReporter({
-			projectDir,
-			reportStream: process.stdout,
-			stdStream: process.stderr,
-			watching: combined.watch
-		});
 	} else {
-		reporter = new MiniReporter({
+		reporter = new DefaultReporter({
 			projectDir,
 			reportStream: process.stdout,
 			stdStream: process.stderr,
-			watching: combined.watch
+			watching: combined.watch,
+			verbose: debug !== null || combined.verbose || isCi || !process.stdout.isTTY
 		});
 	}
 
 	api.on('run', plan => {
 		reporter.startRun(plan);
 
+		if (process.env.AVA_EMIT_RUN_STATUS_OVER_IPC === 'I\'ll find a payphone baby / Take some time to talk to you') {
+			if (process.versions.node >= '12.16.0') {
+				plan.status.on('stateChange', evt => {
+					process.send(evt);
+				});
+			} else {
+				const v8 = require('v8');
+				plan.status.on('stateChange', evt => {
+					process.send([...v8.serialize(evt)]);
+				});
+			}
+		}
+
 		plan.status.on('stateChange', evt => {
 			if (evt.type === 'interrupt') {
 				reporter.endRun();

package/lib/code-excerpt.js

@@ -19,7 +19,7 @@ module.exports = (source, options = {}) => {
 	let contents;
 	try {
 		contents = fs.readFileSync(file, 'utf8');
-	} catch (_) {
+	} catch {
 		return null;
 	}
 

package/lib/concordance-options.js

@@ -135,5 +135,4 @@ exports.default = {
 	theme
 };
 
-exports.diff = {maxDepth: 1, plugins, theme};
 exports.snapshotManager = {plugins, theme: plainTheme};

package/lib/fork.js

@@ -48,7 +48,9 @@ module.exports = (file, options, execArgv = process.execArgv) => {
 	let forcedExit = false;
 	const send = evt => {
 		if (subprocess.connected && !finished && !forcedExit) {
-			subprocess.send({ava: evt});
+			subprocess.send({ava: evt}, () => {
+				// Disregard errors.
+			});
 		}
 	};
 

package/lib/globs.js

@@ -4,7 +4,7 @@ const globby = require('globby');
 const ignoreByDefault = require('ignore-by-default');
 const picomatch = require('picomatch');
 const slash = require('slash');
-const {levels: providerLevels} = require('./provider-manager');
+const providerManager = require('./provider-manager');
 
 const defaultIgnorePatterns = [...ignoreByDefault.directories(), '**/node_modules'];
 const defaultPicomatchIgnorePatterns = [
@@ -23,23 +23,27 @@ const defaultIgnoredByWatcherPatterns = [
 
 const buildExtensionPattern = extensions => extensions.length === 1 ? extensions[0] : `{${extensions.join(',')}}`;
 
-function normalizePatterns(patterns) {
+function normalizePattern(pattern) {
 	// Always use `/` in patterns, harmonizing matching across platforms
 	if (process.platform === 'win32') {
-		patterns = patterns.map(pattern => slash(pattern));
+		pattern = slash(pattern);
 	}
 
-	return patterns.map(pattern => {
-		if (pattern.startsWith('./')) {
-			return pattern.slice(2);
-		}
+	if (pattern.startsWith('./')) {
+		return pattern.slice(2);
+	}
 
-		if (pattern.startsWith('!./')) {
-			return `!${pattern.slice(3)}`;
-		}
+	if (pattern.startsWith('!./')) {
+		return `!${pattern.slice(3)}`;
+	}
 
-		return pattern;
-	});
+	return pattern;
+}
+
+exports.normalizePattern = normalizePattern;
+
+function normalizePatterns(patterns) {
+	return patterns.map(pattern => normalizePattern(pattern));
 }
 
 exports.normalizePatterns = normalizePatterns;
@@ -85,7 +89,7 @@ function normalizeGlobs({extensions, files: filePatterns, ignoredByWatcher: igno
 	}
 
 	for (const {level, main} of providers) {
-		if (level >= providerLevels.pathRewrites) {
+		if (level >= providerManager.levels.pathRewrites) {
 			({filePatterns, ignoredByWatcherPatterns} = main.updateGlobs({filePatterns, ignoredByWatcherPatterns}));
 		}
 	}

package/lib/like-selector.js

@@ -0,0 +1,37 @@
+'use strict';
+function isLikeSelector(selector) {
+	return selector !== null &&
+		typeof selector === 'object' &&
+		Reflect.getPrototypeOf(selector) === Object.prototype &&
+		Reflect.ownKeys(selector).length > 0;
+}
+
+exports.isLikeSelector = isLikeSelector;
+
+const CIRCULAR_SELECTOR = new Error('Encountered a circular selector');
+exports.CIRCULAR_SELECTOR = CIRCULAR_SELECTOR;
+
+function selectComparable(lhs, selector, circular = new Set()) {
+	if (circular.has(selector)) {
+		throw CIRCULAR_SELECTOR;
+	}
+
+	circular.add(selector);
+
+	if (lhs === null || typeof lhs !== 'object') {
+		return lhs;
+	}
+
+	const comparable = {};
+	for (const [key, rhs] of Object.entries(selector)) {
+		if (isLikeSelector(rhs)) {
+			comparable[key] = selectComparable(Reflect.get(lhs, key), rhs, circular);
+		} else {
+			comparable[key] = Reflect.get(lhs, key);
+		}
+	}
+
+	return comparable;
+}
+
+exports.selectComparable = selectComparable;

package/lib/line-numbers.js

@@ -0,0 +1,64 @@
+'use strict';
+
+const picomatch = require('picomatch');
+const flatten = require('lodash/flatten');
+
+const NUMBER_REGEX = /^\d+$/;
+const RANGE_REGEX = /^(?<startGroup>\d+)-(?<endGroup>\d+)$/;
+const LINE_NUMBERS_REGEX = /^(?:\d+(?:-\d+)?,?)+$/;
+const DELIMITER = ':';
+
+const distinctArray = array => [...new Set(array)];
+const sortNumbersAscending = array => {
+	const sorted = [...array];
+	sorted.sort((a, b) => a - b);
+	return sorted;
+};
+
+const parseNumber = string => Number.parseInt(string, 10);
+const removeAllWhitespace = string => string.replace(/\s/g, '');
+const range = (start, end) => new Array(end - start + 1).fill(start).map((element, index) => element + index);
+
+const parseLineNumbers = suffix => sortNumbersAscending(distinctArray(flatten(
+	suffix.split(',').map(part => {
+		if (NUMBER_REGEX.test(part)) {
+			return parseNumber(part);
+		}
+
+		const {groups: {startGroup, endGroup}} = RANGE_REGEX.exec(part);
+		const start = parseNumber(startGroup);
+		const end = parseNumber(endGroup);
+
+		if (start > end) {
+			return range(end, start);
+		}
+
+		return range(start, end);
+	})
+)));
+
+function splitPatternAndLineNumbers(pattern) {
+	const parts = pattern.split(DELIMITER);
+	if (parts.length === 1) {
+		return {pattern, lineNumbers: null};
+	}
+
+	const suffix = removeAllWhitespace(parts.pop());
+	if (!LINE_NUMBERS_REGEX.test(suffix)) {
+		return {pattern, lineNumbers: null};
+	}
+
+	return {pattern: parts.join(DELIMITER), lineNumbers: parseLineNumbers(suffix)};
+}
+
+exports.splitPatternAndLineNumbers = splitPatternAndLineNumbers;
+
+function getApplicableLineNumbers(normalizedFilePath, filter) {
+	return sortNumbersAscending(distinctArray(flatten(
+		filter
+			.filter(({pattern, lineNumbers}) => lineNumbers && picomatch.isMatch(normalizedFilePath, pattern))
+			.map(({lineNumbers}) => lineNumbers)
+	)));
+}
+
+exports.getApplicableLineNumbers = getApplicableLineNumbers;

package/lib/load-config.js

@@ -7,7 +7,7 @@ const pkgConf = require('pkg-conf');
 
 const NO_SUCH_FILE = Symbol('no ava.config.js file');
 const MISSING_DEFAULT_EXPORT = Symbol('missing default export');
-const EXPERIMENTS = new Set();
+const EXPERIMENTS = new Set(['likeAssertion', 'reverseTeardowns']);
 
 // *Very* rudimentary support for loading ava.config.js files containing an `export default` statement.
 const evaluateJsConfig = configFile => {

package/lib/reporters/beautify-stack.js

@@ -0,0 +1,73 @@
+'use strict';
+const StackUtils = require('stack-utils');
+
+const stackUtils = new StackUtils({
+	ignoredPackages: [
+		'@ava/babel',
+		'@ava/require-precompiled',
+		'@ava/typescript',
+		'append-transform',
+		'ava',
+		'empower-core',
+		'esm',
+		'nyc'
+	],
+	internals: [
+		// AVA internals, which ignoredPackages don't ignore when we run our own unit tests.
+		/\/ava\/(?:lib\/|lib\/worker\/)?[\w-]+\.js:\d+:\d+\)?$/,
+		// Only ignore Node.js internals that really are not useful for debugging.
+		...StackUtils.nodeInternals().filter(regexp => !/\(internal/.test(regexp.source)),
+		/\(internal\/process\/task_queues\.js:\d+:\d+\)$/,
+		/\(internal\/modules\/cjs\/.+?\.js:\d+:\d+\)$/,
+		/async Promise\.all \(index/,
+		/new Promise \(<anonymous>\)/
+	]
+});
+
+/*
+ * Given a string value of the format generated for the `stack` property of a
+ * V8 error object, return a string that contains only stack frame information
+ * for frames that have relevance to the consumer.
+ *
+ * For example, given the following string value:
+ *
+ * ```
+ * Error
+ *     at inner (/home/ava/ex.js:7:12)
+ *     at /home/ava/ex.js:12:5
+ *     at outer (/home/ava/ex.js:13:4)
+ *     at Object.<anonymous> (/home/ava/ex.js:14:3)
+ *     at Module._compile (module.js:570:32)
+ *     at Object.Module._extensions..js (module.js:579:10)
+ *     at Module.load (module.js:487:32)
+ *     at tryModuleLoad (module.js:446:12)
+ *     at Function.Module._load (module.js:438:3)
+ *     at Module.runMain (module.js:604:10)
+ * ```
+ *
+ * ...this function returns the following string value:
+ *
+ * ```
+ * inner (/home/ava/ex.js:7:12)
+ * /home/ava/ex.js:12:5
+ * outer (/home/ava/ex.js:13:4)
+ * Object.<anonymous> (/home/ava/ex.js:14:3)
+ * Module._compile (module.js:570:32)
+ * Object.Module._extensions..js (module.js:579:10)
+ * Module.load (module.js:487:32)
+ * tryModuleLoad (module.js:446:12)
+ * Function.Module._load (module.js:438:3)
+ * Module.runMain (module.js:604:10)
+ * ```
+ */
+module.exports = stack => {
+	if (!stack) {
+		return [];
+	}
+
+	return stackUtils.clean(stack)
+		.trim()
+		.split('\n')
+		.map(line => line.trim())
+		.filter(line => line !== '');
+};

package/lib/reporters/colors.js

@@ -11,6 +11,7 @@ module.exports = {
 	duration: chalk.gray.dim,
 	errorSource: chalk.gray,
 	errorStack: chalk.gray,
+	errorStackInternal: chalk.gray.dim,
 	stack: chalk.red,
 	information: chalk.magenta
 };