ava 0.15.0 → 0.17.0

package/types/make.js

@@ -0,0 +1,166 @@
+'use strict';
+
+// TypeScript definitions are generated here.
+// AVA allows chaining of function names, like `test.after.cb.always`.
+// The order of these names is not important.
+// Writing these definitions by hand is hard. Because of chaining,
+// the number of combinations grows fast (2^n). To reduce this number,
+// illegal combinations are filtered out in `verify`.
+// The order of the options is not important. We could generate full
+// definitions for each possible order, but that would give a very big
+// output. Instead, we write an alias for different orders. For instance,
+// `after.cb` is fully written, and `cb.after` is emitted as an alias
+// using `typeof after.cb`.
+
+const path = require('path');
+const fs = require('fs');
+const runner = require('../lib/runner');
+
+const arrayHas = parts => part => parts.includes(part);
+
+const base = fs.readFileSync(path.join(__dirname, 'base.d.ts'), 'utf8');
+
+// All suported function names
+const allParts = Object.keys(runner._chainableMethods).filter(name => name !== 'test');
+
+const output = base + generatePrefixed([]);
+fs.writeFileSync(path.join(__dirname, 'generated.d.ts'), output);
+
+// Generates type definitions, for the specified prefix
+// The prefix is an array of function names
+function generatePrefixed(prefix) {
+	let output = '';
+	let children = '';
+
+	for (const part of allParts) {
+		const parts = prefix.concat([part]);
+
+		if (prefix.includes(part) || !verify(parts, true)) {
+			// Function already in prefix or not allowed here
+			continue;
+		}
+
+		// If `parts` is not sorted, we alias it to the sorted chain.
+		if (!isSorted(parts)) {
+			const chain = parts.sort().join('.');
+			if (exists(parts)) {
+				output += '\texport const ' + part + ': typeof test.' + chain + ';\n';
+			}
+			continue;
+		}
+
+		// Check that `part` is a valid function name.
+		// `always` is a valid prefix, for instance of `always.after`,
+		// but not a valid function name.
+		if (verify(parts, false)) {
+			if (prefix.includes(parts, 'todo')) {
+				output += '\t' + writeFunction(part, 'name: string', 'void');
+			} else {
+				const type = testType(parts);
+				output += '\t' + writeFunction(part, 'name: string, implementation: ' + type);
+				output += '\t' + writeFunction(part, 'implementation: ' + type);
+				output += '\t' + writeFunction(part, 'name: string, implementation: Macros<' + type + 'Context>, ...args: any[]');
+				output += '\t' + writeFunction(part, 'implementation: Macros<' + type + 'Context>, ...args: any[]');
+			}
+		}
+
+		children += generatePrefixed(parts);
+	}
+
+	if (output === '') {
+		return children;
+	}
+
+	return 'export namespace ' + ['test'].concat(prefix).join('.') + ' {\n' + output + '}\n' + children;
+}
+
+function writeFunction(name, args) {
+	return 'export function ' + name + '(' + args + '): void;\n';
+}
+
+// Checks whether a chain is a valid function name (when `asPrefix === false`)
+// or a valid prefix that could contain members.
+// For instance, `test.always` is not a valid function name, but it is a valid
+// prefix of `test.always.after`.
+function verify(parts, asPrefix) {
+	const has = arrayHas(parts);
+
+	if (has('only') + has('skip') + has('todo') > 1) {
+		return false;
+	}
+
+	const beforeAfterCount = has('before') + has('beforeEach') + has('after') + has('afterEach');
+
+	if (beforeAfterCount > 1) {
+		return false;
+	}
+
+	if (beforeAfterCount === 1) {
+		if (has('only')) {
+			return false;
+		}
+	}
+
+	if (has('always')) {
+		// `always` can only be used with `after` or `afterEach`.
+		// Without it can still be a valid prefix
+		if (has('after') || has('afterEach')) {
+			return true;
+		}
+		if (!verify(parts.concat(['after']), false) && !verify(parts.concat(['afterEach']), false)) {
+			// If `after` nor `afterEach` cannot be added to this prefix,
+			// `always` is not allowed here.
+			return false;
+		}
+		// Only allowed as a prefix
+		return asPrefix;
+	}
+
+	return true;
+}
+
+// Checks whether a chain is a valid function name or a valid prefix with some member
+function exists(parts) {
+	if (verify(parts, false)) {
+		// valid function name
+		return true;
+	}
+	if (!verify(parts, true)) {
+		// not valid prefix
+		return false;
+	}
+	// valid prefix, check whether it has members
+	for (const prefix of allParts) {
+		if (!parts.includes(prefix) && exists(parts.concat([prefix]))) {
+			return true;
+		}
+	}
+	return false;
+}
+
+// Checks that an array is sorted
+function isSorted(a) {
+	for (let i = 1; i < a.length; i++) {
+		if (a[i - 1] >= a[i]) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+// Returns the type name of for the test implementation
+function testType(parts) {
+	const has = arrayHas(parts);
+	let type = 'Test';
+
+	if (has('cb')) {
+		type = 'Callback' + type;
+	}
+
+	if (!has('before') && !has('after')) {
+		type = 'Contextual' + type;
+	}
+
+	return type;
+}

package/index.d.ts

@@ -1,206 +0,0 @@
-export interface Observable {
-	subscribe(observer: (value: {}) => void): void;
-}
-
-export type Test = (t: TestContext) => Promise<void> | Iterator<any> | Observable | void;
-export type ContextualTest = (t: ContextualTestContext) => Promise<void> | Iterator<any> | Observable | void;
-export type SerialTest = (t: TestContext) => void;
-export type ContextualSerialTest = (t: ContextualTestContext) => void;
-export type CallbackTest = (t: CallbackTestContext) => void;
-export type ContextualCallbackTest = (t: ContextualCallbackTestContext) => void;
-
-export interface Runner {
-	(name: string, run: Test): void;
-	(run: Test): void;
-	skip: Runner;
-	cb: CallbackRunner;
-}
-export interface ContextualRunner {
-	(name: string, run: ContextualTest): void;
-	(run: ContextualTest): void;
-	skip: ContextualRunner;
-	cb: ContextualCallbackRunner;
-}
-export interface SerialRunner {
-	(name: string, run: SerialTest): void;
-	(run: SerialTest): void;
-	skip: SerialRunner;
-}
-export interface ContextualSerialRunner {
-	(name: string, run: ContextualSerialTest): void;
-	(run: ContextualSerialTest): void;
-	skip: ContextualSerialRunner;
-}
-export interface CallbackRunner {
-	(name: string, run: CallbackTest): void;
-	(run: CallbackTest): void;
-	skip: CallbackRunner;
-}
-export interface ContextualCallbackRunner {
-	(name: string, run: ContextualCallbackTest): void;
-	(run: ContextualCallbackTest): void;
-	skip: ContextualCallbackRunner;
-}
-
-export function test(name: string, run: ContextualTest): void;
-export function test(run: ContextualTest): void;
-export namespace test {
-	export const before: Runner;
-	export const after: Runner;
-	export const beforeEach: ContextualRunner;
-	export const afterEach: ContextualRunner;
-
-	export const skip: typeof test;
-	export const only: typeof test;
-
-	export function serial(name: string, run: ContextualSerialTest): void;
-	export function serial(run: ContextualSerialTest): void;
-	export function failing(name: string, run: ContextualCallbackTest): void;
-	export function failing(run: ContextualCallbackTest): void;
-	export function cb(name: string, run: ContextualCallbackTest): void;
-	export function cb(run: ContextualCallbackTest): void;
-	export function todo(name: string): void;
-}
-export namespace test.serial {
-	export const before: SerialRunner;
-	export const after: SerialRunner;
-	export const beforeEach: ContextualSerialRunner;
-	export const afterEach: ContextualSerialRunner;
-
-	export const skip: typeof test.serial;
-	export const only: typeof test.serial;
-
-	export function cb(name: string, run: ContextualCallbackTest): void;
-	export function cb(run: ContextualCallbackTest): void;
-}
-export namespace test.failing {
-	export const before: CallbackRunner;
-	export const after: CallbackRunner;
-	export const beforeEach: ContextualCallbackRunner;
-	export const afterEach: ContextualCallbackRunner;
-
-	export const skip: typeof test.cb;
-	export const only: typeof test.cb;
-
-	export function cb(name: string, run: ContextualCallbackTest): void;
-	export function cb(run: ContextualCallbackTest): void;
-}
-export namespace test.cb {
-	export const before: CallbackRunner;
-	export const after: CallbackRunner;
-	export const beforeEach: ContextualCallbackRunner;
-	export const afterEach: ContextualCallbackRunner;
-
-	export const skip: typeof test.cb;
-	export const only: typeof test.cb;
-}
-export default test;
-
-export type ErrorValidator
-	= (new (...args: any[]) => any)
-	| RegExp
-	| string
-	| ((error: any) => boolean);
-
-export interface AssertContext {
-	/**
-	 * Passing assertion.
-	 */
-	pass(message?: string): void;
-	/**
-	 * Failing assertion.
-	 */
-	fail(message?: string): void;
-	/**
-	 * Assert that value is truthy.
-	 */
-	truthy(value: any, message?: string): void;
-	/**
-	 * Assert that value is falsy.
-	 */
-	falsy(value: any, message?: string): void;
-	/**
-	 * DEPRECATED, use `truthy`. Assert that value is truthy.
-	 */
-	ok(value: any, message?: string): void;
-	/**
-	 * DEPRECATED, use `falsy`. Assert that value is falsy.
-	 */
-	notOk(value: any, 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.
-	 * @param error Can be a constructor, regex, error message or validation function.
-	 */
-	 /**
- 	 * DEPRECATED, use `deepEqual`. Assert that value is deep equal to expected.
- 	 */
- 	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: Promise<{}>, error?: ErrorValidator, message?: string): Promise<any>;
-	throws(value: () => void, error?: ErrorValidator, message?: string): any;
-	/**
-	 * Assert that function doesn't throw an error or promise resolves.
-	 */
-	notThrows<U>(value: Promise<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 error is falsy.
-	 */
-	ifError(error: any, message?: string): void;
-}
-export interface TestContext extends AssertContext {
-	/**
-	 * Plan how many assertion there are in the test.
-	 * The test will fail if the actual assertion count doesn't match planned assertions.
-	 */
-	plan(count: number): void;
-
-	skip: AssertContext;
-}
-export interface CallbackTestContext extends TestContext {
-	/**
-	 * End the test.
-	 */
-	end(): void;
-}
-export interface ContextualTestContext extends TestContext {
-	context: any;
-}
-export interface ContextualCallbackTestContext extends CallbackTestContext {
-	context: any;
-}

package/lib/ava-files.js

@@ -1,262 +0,0 @@
-var fs = require('fs');
-var path = require('path');
-var Promise = require('bluebird');
-var slash = require('slash');
-var globby = require('globby');
-var flatten = require('arr-flatten');
-var defaultIgnore = require('ignore-by-default').directories();
-var multimatch = require('multimatch');
-
-function defaultExcludePatterns() {
-	return [
-		'!**/node_modules/**',
-		'!**/fixtures/**',
-		'!**/helpers/**'
-	];
-}
-
-function defaultIncludePatterns() {
-	return [
-		'test.js',
-		'test-*.js',
-		'test',
-		'**/__tests__',
-		'**/*.test.js'
-	];
-}
-
-function AvaFiles(files, sources) {
-	if (!(this instanceof AvaFiles)) {
-		throw new TypeError('Class constructor AvaFiles cannot be invoked without \'new\'');
-	}
-
-	if (!files || !files.length) {
-		files = defaultIncludePatterns();
-	}
-
-	this.excludePatterns = defaultExcludePatterns();
-
-	this.files = files;
-	this.sources = sources || [];
-}
-
-AvaFiles.prototype.findTestFiles = function () {
-	return handlePaths(this.files, this.excludePatterns, {
-		cache: Object.create(null),
-		statCache: Object.create(null),
-		realpathCache: Object.create(null),
-		symlinks: Object.create(null)
-	});
-};
-
-function getDefaultIgnorePatterns() {
-	return defaultIgnore.map(function (dir) {
-		return dir + '/**/*';
-	});
-}
-
-// Used on paths before they're passed to multimatch to harmonize matching
-// across platforms.
-var matchable = process.platform === 'win32' ? slash : function (path) {
-	return path;
-};
-
-AvaFiles.prototype.makeSourceMatcher = function () {
-	var mixedPatterns = [];
-	var defaultIgnorePatterns = getDefaultIgnorePatterns();
-	var overrideDefaultIgnorePatterns = [];
-
-	var hasPositivePattern = false;
-	this.sources.forEach(function (pattern) {
-		mixedPatterns.push(pattern);
-		// TODO: why not just pattern[0] !== '!'
-		if (!hasPositivePattern && pattern[0] !== '!') {
-			hasPositivePattern = true;
-		}
-
-		// Extract patterns that start with an ignored directory. These need to be
-		// rematched separately.
-		if (defaultIgnore.indexOf(pattern.split('/')[0]) >= 0) {
-			overrideDefaultIgnorePatterns.push(pattern);
-		}
-	});
-
-	// Same defaults as used for Chokidar.
-	if (!hasPositivePattern) {
-		mixedPatterns = ['package.json', '**/*.js'].concat(mixedPatterns);
-	}
-
-	return function (path) {
-		path = matchable(path);
-
-		// Ignore paths outside the current working directory. They can't be matched
-		// to a pattern.
-		if (/^\.\.\//.test(path)) {
-			return false;
-		}
-
-		var isSource = multimatch(path, mixedPatterns).length === 1;
-		if (!isSource) {
-			return false;
-		}
-
-		var isIgnored = multimatch(path, defaultIgnorePatterns).length === 1;
-		if (!isIgnored) {
-			return true;
-		}
-
-		var isErroneouslyIgnored = multimatch(path, overrideDefaultIgnorePatterns).length === 1;
-		if (isErroneouslyIgnored) {
-			return true;
-		}
-
-		return false;
-	};
-};
-
-AvaFiles.prototype.makeTestMatcher = function () {
-	var excludePatterns = this.excludePatterns;
-	var initialPatterns = this.files.concat(excludePatterns);
-
-	return function (filepath) {
-		// Like in api.js, tests must be .js files and not start with _
-		if (path.extname(filepath) !== '.js' || path.basename(filepath)[0] === '_') {
-			return false;
-		}
-
-		// Check if the entire path matches a pattern.
-		if (multimatch(matchable(filepath), initialPatterns).length === 1) {
-			return true;
-		}
-
-		// Check if the path contains any directory components.
-		var dirname = path.dirname(filepath);
-		if (dirname === '.') {
-			return false;
-		}
-
-		// Compute all possible subpaths. Note that the dirname is assumed to be
-		// relative to the working directory, without a leading `./`.
-		var subpaths = dirname.split(/[\\\/]/).reduce(function (subpaths, component) {
-			var parent = subpaths[subpaths.length - 1];
-			if (parent) {
-				// Always use / to makes multimatch consistent across platforms.
-				subpaths.push(parent + '/' + component);
-			} else {
-				subpaths.push(component);
-			}
-			return subpaths;
-		}, []);
-
-		// Check if any of the possible subpaths match a pattern. If so, generate a
-		// new pattern with **/*.js.
-		var recursivePatterns = subpaths.filter(function (subpath) {
-			return multimatch(subpath, initialPatterns).length === 1;
-		}).map(function (subpath) {
-			// Always use / to makes multimatch consistent across platforms.
-			return subpath + '/**/*.js';
-		});
-
-		// See if the entire path matches any of the subpaths patterns, taking the
-		// excludePatterns into account. This mimicks the behavior in api.js
-		return multimatch(matchable(filepath), recursivePatterns.concat(excludePatterns)).length === 1;
-	};
-};
-
-AvaFiles.prototype.getChokidarPatterns = function () {
-	var paths = [];
-	var ignored = [];
-
-	this.sources.forEach(function (pattern) {
-		if (pattern[0] === '!') {
-			ignored.push(pattern.slice(1));
-		} else {
-			paths.push(pattern);
-		}
-	});
-
-	// Allow source patterns to override the default ignore patterns. Chokidar
-	// ignores paths that match the list of ignored patterns. It uses anymatch
-	// under the hood, which supports negation patterns. For any source pattern
-	// that starts with an ignored directory, ensure the corresponding negation
-	// pattern is added to the ignored paths.
-	var overrideDefaultIgnorePatterns = paths.filter(function (pattern) {
-		return defaultIgnore.indexOf(pattern.split('/')[0]) >= 0;
-	}).map(function (pattern) {
-		return '!' + pattern;
-	});
-	ignored = getDefaultIgnorePatterns().concat(ignored, overrideDefaultIgnorePatterns);
-
-	if (paths.length === 0) {
-		paths = ['package.json', '**/*.js'];
-	}
-	paths = paths.concat(this.files);
-
-	return {
-		paths: paths,
-		ignored: ignored
-	};
-};
-
-function handlePaths(files, excludePatterns, globOptions) {
-	// convert pinkie-promise to Bluebird promise
-	files = Promise.resolve(globby(files.concat(excludePatterns), globOptions));
-
-	var searchedParents = Object.create(null);
-	var foundFiles = Object.create(null);
-
-	function alreadySearchingParent(dir) {
-		if (searchedParents[dir]) {
-			return true;
-		}
-
-		var parentDir = path.dirname(dir);
-
-		if (parentDir === dir) {
-			// We have reached the root path.
-			return false;
-		}
-
-		return alreadySearchingParent(parentDir);
-	}
-
-	return files
-		.map(function (file) {
-			if (fs.statSync(file).isDirectory()) {
-				if (alreadySearchingParent(file)) {
-					return null;
-				}
-
-				searchedParents[file] = true;
-
-				var pattern = path.join(file, '**', '*.js');
-
-				if (process.platform === 'win32') {
-					// Always use / in patterns, harmonizing matching across platforms.
-					pattern = slash(pattern);
-				}
-
-				return handlePaths([pattern], excludePatterns, globOptions);
-			}
-
-			// globby returns slashes even on Windows. Normalize here so the file
-			// paths are consistently platform-accurate as tests are run.
-			return path.normalize(file);
-		})
-		.then(flatten)
-		.filter(function (file) {
-			return file && path.extname(file) === '.js' && path.basename(file)[0] !== '_';
-		})
-		.map(function (file) {
-			return path.resolve(file);
-		})
-		.filter(function (file) {
-			var alreadyFound = foundFiles[file];
-			foundFiles[file] = true;
-			return !alreadyFound;
-		});
-}
-
-module.exports = AvaFiles;
-module.exports.defaultIncludePatterns = defaultIncludePatterns;
-module.exports.defaultExcludePatterns = defaultExcludePatterns;

package/lib/send.js

@@ -1,16 +0,0 @@
-'use strict';
-
-// utility to send messages to processes
-module.exports = function (ps, name, data) {
-	if (typeof ps === 'string') {
-		data = name || {};
-		name = ps;
-		ps = process;
-	}
-
-	ps.send({
-		name: 'ava-' + name,
-		data: data,
-		ava: true
-	});
-};