From 02f0986f19397f437a1e415732bc573e9fb0791d Mon Sep 17 00:00:00 2001 From: Ivo Gabe de Wolff Date: Fri, 27 May 2016 19:30:58 +0200 Subject: [PATCH 01/13] Generate type definitions that allow chaining --- package.json | 3 +- index.d.ts => types/base.d.ts | 118 +---- types/generate.js | 114 +++++ types/generated.d.ts | 821 ++++++++++++++++++++++++++++++++++ 4 files changed, 950 insertions(+), 106 deletions(-) rename index.d.ts => types/base.d.ts (52%) create mode 100644 types/generate.js create mode 100644 types/generated.d.ts diff --git a/package.json b/package.json index 72156fa58..4438cb2f1 100644 --- a/package.json +++ b/package.json @@ -33,6 +33,7 @@ } ], "bin": "cli.js", + "typings": "types/generated.d.ts", "engines": { "node": ">=0.10.0" }, @@ -44,7 +45,7 @@ "files": [ "lib", "*.js", - "index.d.ts" + "types/generated.d.ts" ], "keywords": [ "test", diff --git a/index.d.ts b/types/base.d.ts similarity index 52% rename from index.d.ts rename to types/base.d.ts index c949a124d..8d7c5fb3d 100644 --- a/index.d.ts +++ b/types/base.d.ts @@ -1,113 +1,20 @@ +export default test; + +export type ErrorValidator + = (new (...args: any[]) => any) + | RegExp + | string + | ((error: any) => boolean); + export interface Observable { subscribe(observer: (value: {}) => void): void; } export type Test = (t: TestContext) => Promise | Iterator | Observable | void; export type ContextualTest = (t: ContextualTestContext) => Promise | Iterator | 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 AfterRunner extends Runner { - always: Runner; -} -export interface ContextualRunner { - (name: string, run: ContextualTest): void; - (run: ContextualTest): void; - skip: ContextualRunner; - cb: ContextualCallbackRunner; -} -export interface ContextualAfterRunner extends ContextualRunner { - always: ContextualRunner; -} -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: AfterRunner; - export const beforeEach: ContextualRunner; - export const afterEach: ContextualAfterRunner; - - 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. @@ -159,12 +66,10 @@ export interface AssertContext { notDeepEqual(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. */ - /** - * DEPRECATED, use `deepEqual`. Assert that value is deep equal to expected. - */ - same(value: U, expected: U, message?: string): void; + same(value: U, expected: U, message?: string): void; /** * DEPRECATED use `notDeepEqual`. Assert that value is not deep equal to expected. */ @@ -210,3 +115,6 @@ export interface ContextualTestContext extends TestContext { export interface ContextualCallbackTestContext extends CallbackTestContext { context: any; } + +export function test(name: string, run: ContextualTest): void; +export function test(run: ContextualTest): void; diff --git a/types/generate.js b/types/generate.js new file mode 100644 index 000000000..9c33b2098 --- /dev/null +++ b/types/generate.js @@ -0,0 +1,114 @@ +// 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`. + +var path = require('path'); +var fs = require('fs'); + +var base = fs.readFileSync(path.join(__dirname, 'base.d.ts')).toString(); + +// All suported function names +var allParts = ['serial', 'before', 'after', 'skip', 'todo', 'failing', 'only', 'beforeEach', 'afterEach', 'cb', 'always']; + +var 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) { + var output = 'export namespace ' + ['test'].concat(prefix).join('.') + ' {\n'; + + var children = ''; + var empty = true; + for (var i = 0; i < allParts.length; i++) { + var part = allParts[i]; + var parts = prefix.concat([part]); + + if (prefix.indexOf(part) !== -1 || !verify(parts, true)) { + // Function already in prefix or not allowed here + 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)) { + empty = false; + if (!isSorted(parts)) { + output += '\t' + 'export const ' + part + ': typeof test.' + parts.sort().join('.') + ';\n'; + continue; + } else if (parts.indexOf('todo') !== -1) { + output += '\t' + writeFunction(part, 'name: string', 'void'); + } else { + var type = testType(parts); + output += '\t' + writeFunction(part, 'name: string, implementation: ' + type); + output += '\t' + writeFunction(part, 'implementation: ' + type); + } + } + + children += generatePrefixed(parts); + } + if (empty) { + output = ''; + } else { + output += '}\n'; + } + return output + children; +} +function writeFunction(name, args) { + return 'export function ' + name + '(' + args + '): void;\n'; +} + +function verify(parts, asPrefix) { + var has = arrayHas(parts); + if (has('only') + has('skip') + has('todo') > 1) return false; + var 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')) { + if (!asPrefix) return false; + } else if (!verify(parts.concat(['after'])) && !verify(parts.concat(['afterEach']))) { + // If `after` nor `afterEach` cannot be added to this prefix, + // `always` is not allowed here. + return false; + } + } + + return true; +} +// Checks that an array is sorted +function isSorted(a) { + for (var 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) { + var has = arrayHas(parts); + var type = 'Test'; + if (has('cb')) type = 'Callback' + type; + if (!has('beforeEach') && !has('afterEach')) type = 'Contextual' + type; + return type; +} +function arrayHas(parts) { + return function(part) { + return parts.indexOf(part) !== -1; + } +} diff --git a/types/generated.d.ts b/types/generated.d.ts new file mode 100644 index 000000000..2e881bd95 --- /dev/null +++ b/types/generated.d.ts @@ -0,0 +1,821 @@ +export default test; + +export type ErrorValidator + = (new (...args: any[]) => any) + | RegExp + | string + | ((error: any) => boolean); + +export interface Observable { + subscribe(observer: (value: {}) => void): void; +} + +export type Test = (t: TestContext) => Promise | Iterator | Observable | void; +export type ContextualTest = (t: ContextualTestContext) => Promise | Iterator | Observable | void; +export type CallbackTest = (t: CallbackTestContext) => void; +export type ContextualCallbackTest = (t: ContextualCallbackTestContext) => void; + +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(value: U, expected: U, message?: string): void; + /** + * Assert that value is not equal to expected. + */ + not(value: U, expected: U, message?: string): void; + /** + * Assert that value is deep equal to expected. + */ + deepEqual(value: U, expected: U, message?: string): void; + /** + * Assert that value is not deep equal to expected. + */ + notDeepEqual(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(value: U, expected: U, message?: string): void; + /** + * DEPRECATED use `notDeepEqual`. Assert that value is not deep equal to expected. + */ + notSame(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; + throws(value: () => void, error?: ErrorValidator, message?: string): any; + /** + * Assert that function doesn't throw an error or promise resolves. + */ + notThrows(value: Promise, message?: string): Promise; + 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; +} + +export function test(name: string, run: ContextualTest): void; +export function test(run: ContextualTest): void; +export namespace test { + export function serial(name: string, implementation: ContextualTest): void; + export function serial(implementation: ContextualTest): void; + export function before(name: string, implementation: ContextualTest): void; + export function before(implementation: ContextualTest): void; + export function after(name: string, implementation: ContextualTest): void; + export function after(implementation: ContextualTest): void; + export function skip(name: string, implementation: ContextualTest): void; + export function skip(implementation: ContextualTest): void; + export function todo(name: string): void; + export function failing(name: string, implementation: ContextualTest): void; + export function failing(implementation: ContextualTest): void; + export function only(name: string, implementation: ContextualTest): void; + export function only(implementation: ContextualTest): void; + export function beforeEach(name: string, implementation: Test): void; + export function beforeEach(implementation: Test): void; + export function afterEach(name: string, implementation: Test): void; + export function afterEach(implementation: Test): void; + export function cb(name: string, implementation: ContextualCallbackTest): void; + export function cb(implementation: ContextualCallbackTest): void; +} +export namespace test.serial { + export const before: typeof test.before.serial; + export const after: typeof test.after.serial; + export function skip(name: string, implementation: ContextualTest): void; + export function skip(implementation: ContextualTest): void; + export function todo(name: string): void; + export const failing: typeof test.failing.serial; + export const only: typeof test.only.serial; + export const beforeEach: typeof test.beforeEach.serial; + export const afterEach: typeof test.afterEach.serial; + export const cb: typeof test.cb.serial; +} +export namespace test.serial.skip { + export const before: typeof test.before.serial.skip; + export const after: typeof test.after.serial.skip; + export const failing: typeof test.failing.serial.skip; + export const beforeEach: typeof test.beforeEach.serial.skip; + export const afterEach: typeof test.afterEach.serial.skip; + export const cb: typeof test.cb.serial.skip; +} +export namespace test.serial.todo { + export const before: typeof test.before.serial.todo; + export const after: typeof test.after.serial.todo; + export const failing: typeof test.failing.serial.todo; + export const beforeEach: typeof test.beforeEach.serial.todo; + export const afterEach: typeof test.afterEach.serial.todo; + export const cb: typeof test.cb.serial.todo; +} +export namespace test.before { + export function serial(name: string, implementation: ContextualTest): void; + export function serial(implementation: ContextualTest): void; + export function skip(name: string, implementation: ContextualTest): void; + export function skip(implementation: ContextualTest): void; + export function todo(name: string): void; + export function failing(name: string, implementation: ContextualTest): void; + export function failing(implementation: ContextualTest): void; + export function cb(name: string, implementation: ContextualCallbackTest): void; + export function cb(implementation: ContextualCallbackTest): void; +} +export namespace test.before.serial { + export function skip(name: string, implementation: ContextualTest): void; + export function skip(implementation: ContextualTest): void; + export function todo(name: string): void; + export const failing: typeof test.before.failing.serial; + export const cb: typeof test.before.cb.serial; +} +export namespace test.before.serial.skip { + export const failing: typeof test.before.failing.serial.skip; + export const cb: typeof test.before.cb.serial.skip; +} +export namespace test.before.serial.todo { + export const failing: typeof test.before.failing.serial.todo; + export const cb: typeof test.before.cb.serial.todo; +} +export namespace test.before.skip { + export const serial: typeof test.before.serial.skip; + export const failing: typeof test.before.failing.skip; + export const cb: typeof test.before.cb.skip; +} +export namespace test.before.todo { + export const serial: typeof test.before.serial.todo; + export const failing: typeof test.before.failing.todo; + export const cb: typeof test.before.cb.todo; +} +export namespace test.before.failing { + export function serial(name: string, implementation: ContextualTest): void; + export function serial(implementation: ContextualTest): void; + export function skip(name: string, implementation: ContextualTest): void; + export function skip(implementation: ContextualTest): void; + export function todo(name: string): void; + export const cb: typeof test.before.cb.failing; +} +export namespace test.before.failing.serial { + export function skip(name: string, implementation: ContextualTest): void; + export function skip(implementation: ContextualTest): void; + export function todo(name: string): void; + export const cb: typeof test.before.cb.failing.serial; +} +export namespace test.before.failing.serial.skip { + export const cb: typeof test.before.cb.failing.serial.skip; +} +export namespace test.before.failing.serial.todo { + export const cb: typeof test.before.cb.failing.serial.todo; +} +export namespace test.before.failing.skip { + export const serial: typeof test.before.failing.serial.skip; + export const cb: typeof test.before.cb.failing.skip; +} +export namespace test.before.failing.todo { + export const serial: typeof test.before.failing.serial.todo; + export const cb: typeof test.before.cb.failing.todo; +} +export namespace test.before.cb { + export function serial(name: string, implementation: ContextualCallbackTest): void; + export function serial(implementation: ContextualCallbackTest): void; + export function skip(name: string, implementation: ContextualCallbackTest): void; + export function skip(implementation: ContextualCallbackTest): void; + export function todo(name: string): void; + export function failing(name: string, implementation: ContextualCallbackTest): void; + export function failing(implementation: ContextualCallbackTest): void; +} +export namespace test.before.cb.serial { + export function skip(name: string, implementation: ContextualCallbackTest): void; + export function skip(implementation: ContextualCallbackTest): void; + export function todo(name: string): void; + export const failing: typeof test.before.cb.failing.serial; +} +export namespace test.before.cb.serial.skip { + export const failing: typeof test.before.cb.failing.serial.skip; +} +export namespace test.before.cb.serial.todo { + export const failing: typeof test.before.cb.failing.serial.todo; +} +export namespace test.before.cb.skip { + export const serial: typeof test.before.cb.serial.skip; + export const failing: typeof test.before.cb.failing.skip; +} +export namespace test.before.cb.todo { + export const serial: typeof test.before.cb.serial.todo; + export const failing: typeof test.before.cb.failing.todo; +} +export namespace test.before.cb.failing { + export function serial(name: string, implementation: ContextualCallbackTest): void; + export function serial(implementation: ContextualCallbackTest): void; + export function skip(name: string, implementation: ContextualCallbackTest): void; + export function skip(implementation: ContextualCallbackTest): void; + export function todo(name: string): void; +} +export namespace test.before.cb.failing.serial { + export function skip(name: string, implementation: ContextualCallbackTest): void; + export function skip(implementation: ContextualCallbackTest): void; + export function todo(name: string): void; +} +export namespace test.before.cb.failing.skip { + export const serial: typeof test.before.cb.failing.serial.skip; +} +export namespace test.before.cb.failing.todo { + export const serial: typeof test.before.cb.failing.serial.todo; +} +export namespace test.after { + export function serial(name: string, implementation: ContextualTest): void; + export function serial(implementation: ContextualTest): void; + export function skip(name: string, implementation: ContextualTest): void; + export function skip(implementation: ContextualTest): void; + export function todo(name: string): void; + export function failing(name: string, implementation: ContextualTest): void; + export function failing(implementation: ContextualTest): void; + export function cb(name: string, implementation: ContextualCallbackTest): void; + export function cb(implementation: ContextualCallbackTest): void; +} +export namespace test.after.serial { + export function skip(name: string, implementation: ContextualTest): void; + export function skip(implementation: ContextualTest): void; + export function todo(name: string): void; + export const failing: typeof test.after.failing.serial; + export const cb: typeof test.after.cb.serial; +} +export namespace test.after.serial.skip { + export const failing: typeof test.after.failing.serial.skip; + export const cb: typeof test.after.cb.serial.skip; +} +export namespace test.after.serial.todo { + export const failing: typeof test.after.failing.serial.todo; + export const cb: typeof test.after.cb.serial.todo; +} +export namespace test.after.skip { + export const serial: typeof test.after.serial.skip; + export const failing: typeof test.after.failing.skip; + export const cb: typeof test.after.cb.skip; +} +export namespace test.after.todo { + export const serial: typeof test.after.serial.todo; + export const failing: typeof test.after.failing.todo; + export const cb: typeof test.after.cb.todo; +} +export namespace test.after.failing { + export function serial(name: string, implementation: ContextualTest): void; + export function serial(implementation: ContextualTest): void; + export function skip(name: string, implementation: ContextualTest): void; + export function skip(implementation: ContextualTest): void; + export function todo(name: string): void; + export const cb: typeof test.after.cb.failing; +} +export namespace test.after.failing.serial { + export function skip(name: string, implementation: ContextualTest): void; + export function skip(implementation: ContextualTest): void; + export function todo(name: string): void; + export const cb: typeof test.after.cb.failing.serial; +} +export namespace test.after.failing.serial.skip { + export const cb: typeof test.after.cb.failing.serial.skip; +} +export namespace test.after.failing.serial.todo { + export const cb: typeof test.after.cb.failing.serial.todo; +} +export namespace test.after.failing.skip { + export const serial: typeof test.after.failing.serial.skip; + export const cb: typeof test.after.cb.failing.skip; +} +export namespace test.after.failing.todo { + export const serial: typeof test.after.failing.serial.todo; + export const cb: typeof test.after.cb.failing.todo; +} +export namespace test.after.cb { + export function serial(name: string, implementation: ContextualCallbackTest): void; + export function serial(implementation: ContextualCallbackTest): void; + export function skip(name: string, implementation: ContextualCallbackTest): void; + export function skip(implementation: ContextualCallbackTest): void; + export function todo(name: string): void; + export function failing(name: string, implementation: ContextualCallbackTest): void; + export function failing(implementation: ContextualCallbackTest): void; +} +export namespace test.after.cb.serial { + export function skip(name: string, implementation: ContextualCallbackTest): void; + export function skip(implementation: ContextualCallbackTest): void; + export function todo(name: string): void; + export const failing: typeof test.after.cb.failing.serial; +} +export namespace test.after.cb.serial.skip { + export const failing: typeof test.after.cb.failing.serial.skip; +} +export namespace test.after.cb.serial.todo { + export const failing: typeof test.after.cb.failing.serial.todo; +} +export namespace test.after.cb.skip { + export const serial: typeof test.after.cb.serial.skip; + export const failing: typeof test.after.cb.failing.skip; +} +export namespace test.after.cb.todo { + export const serial: typeof test.after.cb.serial.todo; + export const failing: typeof test.after.cb.failing.todo; +} +export namespace test.after.cb.failing { + export function serial(name: string, implementation: ContextualCallbackTest): void; + export function serial(implementation: ContextualCallbackTest): void; + export function skip(name: string, implementation: ContextualCallbackTest): void; + export function skip(implementation: ContextualCallbackTest): void; + export function todo(name: string): void; +} +export namespace test.after.cb.failing.serial { + export function skip(name: string, implementation: ContextualCallbackTest): void; + export function skip(implementation: ContextualCallbackTest): void; + export function todo(name: string): void; +} +export namespace test.after.cb.failing.skip { + export const serial: typeof test.after.cb.failing.serial.skip; +} +export namespace test.after.cb.failing.todo { + export const serial: typeof test.after.cb.failing.serial.todo; +} +export namespace test.skip { + export const serial: typeof test.serial.skip; + export const before: typeof test.before.skip; + export const after: typeof test.after.skip; + export const failing: typeof test.failing.skip; + export const beforeEach: typeof test.beforeEach.skip; + export const afterEach: typeof test.afterEach.skip; + export const cb: typeof test.cb.skip; +} +export namespace test.todo { + export const serial: typeof test.serial.todo; + export const before: typeof test.before.todo; + export const after: typeof test.after.todo; + export const failing: typeof test.failing.todo; + export const beforeEach: typeof test.beforeEach.todo; + export const afterEach: typeof test.afterEach.todo; + export const cb: typeof test.cb.todo; +} +export namespace test.failing { + export function serial(name: string, implementation: ContextualTest): void; + export function serial(implementation: ContextualTest): void; + export const before: typeof test.before.failing; + export const after: typeof test.after.failing; + export function skip(name: string, implementation: ContextualTest): void; + export function skip(implementation: ContextualTest): void; + export function todo(name: string): void; + export function only(name: string, implementation: ContextualTest): void; + export function only(implementation: ContextualTest): void; + export const beforeEach: typeof test.beforeEach.failing; + export const afterEach: typeof test.afterEach.failing; + export const cb: typeof test.cb.failing; +} +export namespace test.failing.serial { + export const before: typeof test.before.failing.serial; + export const after: typeof test.after.failing.serial; + export function skip(name: string, implementation: ContextualTest): void; + export function skip(implementation: ContextualTest): void; + export function todo(name: string): void; + export const only: typeof test.failing.only.serial; + export const beforeEach: typeof test.beforeEach.failing.serial; + export const afterEach: typeof test.afterEach.failing.serial; + export const cb: typeof test.cb.failing.serial; +} +export namespace test.failing.serial.skip { + export const before: typeof test.before.failing.serial.skip; + export const after: typeof test.after.failing.serial.skip; + export const beforeEach: typeof test.beforeEach.failing.serial.skip; + export const afterEach: typeof test.afterEach.failing.serial.skip; + export const cb: typeof test.cb.failing.serial.skip; +} +export namespace test.failing.serial.todo { + export const before: typeof test.before.failing.serial.todo; + export const after: typeof test.after.failing.serial.todo; + export const beforeEach: typeof test.beforeEach.failing.serial.todo; + export const afterEach: typeof test.afterEach.failing.serial.todo; + export const cb: typeof test.cb.failing.serial.todo; +} +export namespace test.failing.skip { + export const serial: typeof test.failing.serial.skip; + export const before: typeof test.before.failing.skip; + export const after: typeof test.after.failing.skip; + export const beforeEach: typeof test.beforeEach.failing.skip; + export const afterEach: typeof test.afterEach.failing.skip; + export const cb: typeof test.cb.failing.skip; +} +export namespace test.failing.todo { + export const serial: typeof test.failing.serial.todo; + export const before: typeof test.before.failing.todo; + export const after: typeof test.after.failing.todo; + export const beforeEach: typeof test.beforeEach.failing.todo; + export const afterEach: typeof test.afterEach.failing.todo; + export const cb: typeof test.cb.failing.todo; +} +export namespace test.failing.only { + export function serial(name: string, implementation: ContextualTest): void; + export function serial(implementation: ContextualTest): void; + export const cb: typeof test.cb.failing.only; +} +export namespace test.failing.only.serial { + export const cb: typeof test.cb.failing.only.serial; +} +export namespace test.only { + export function serial(name: string, implementation: ContextualTest): void; + export function serial(implementation: ContextualTest): void; + export const failing: typeof test.failing.only; + export const cb: typeof test.cb.only; +} +export namespace test.only.serial { + export const failing: typeof test.failing.only.serial; + export const cb: typeof test.cb.only.serial; +} +export namespace test.beforeEach { + export function serial(name: string, implementation: Test): void; + export function serial(implementation: Test): void; + export function skip(name: string, implementation: Test): void; + export function skip(implementation: Test): void; + export function todo(name: string): void; + export function failing(name: string, implementation: Test): void; + export function failing(implementation: Test): void; + export function cb(name: string, implementation: CallbackTest): void; + export function cb(implementation: CallbackTest): void; +} +export namespace test.beforeEach.serial { + export function skip(name: string, implementation: Test): void; + export function skip(implementation: Test): void; + export function todo(name: string): void; + export const failing: typeof test.beforeEach.failing.serial; + export const cb: typeof test.beforeEach.cb.serial; +} +export namespace test.beforeEach.serial.skip { + export const failing: typeof test.beforeEach.failing.serial.skip; + export const cb: typeof test.beforeEach.cb.serial.skip; +} +export namespace test.beforeEach.serial.todo { + export const failing: typeof test.beforeEach.failing.serial.todo; + export const cb: typeof test.beforeEach.cb.serial.todo; +} +export namespace test.beforeEach.skip { + export const serial: typeof test.beforeEach.serial.skip; + export const failing: typeof test.beforeEach.failing.skip; + export const cb: typeof test.beforeEach.cb.skip; +} +export namespace test.beforeEach.todo { + export const serial: typeof test.beforeEach.serial.todo; + export const failing: typeof test.beforeEach.failing.todo; + export const cb: typeof test.beforeEach.cb.todo; +} +export namespace test.beforeEach.failing { + export function serial(name: string, implementation: Test): void; + export function serial(implementation: Test): void; + export function skip(name: string, implementation: Test): void; + export function skip(implementation: Test): void; + export function todo(name: string): void; + export const cb: typeof test.beforeEach.cb.failing; +} +export namespace test.beforeEach.failing.serial { + export function skip(name: string, implementation: Test): void; + export function skip(implementation: Test): void; + export function todo(name: string): void; + export const cb: typeof test.beforeEach.cb.failing.serial; +} +export namespace test.beforeEach.failing.serial.skip { + export const cb: typeof test.beforeEach.cb.failing.serial.skip; +} +export namespace test.beforeEach.failing.serial.todo { + export const cb: typeof test.beforeEach.cb.failing.serial.todo; +} +export namespace test.beforeEach.failing.skip { + export const serial: typeof test.beforeEach.failing.serial.skip; + export const cb: typeof test.beforeEach.cb.failing.skip; +} +export namespace test.beforeEach.failing.todo { + export const serial: typeof test.beforeEach.failing.serial.todo; + export const cb: typeof test.beforeEach.cb.failing.todo; +} +export namespace test.beforeEach.cb { + export function serial(name: string, implementation: CallbackTest): void; + export function serial(implementation: CallbackTest): void; + export function skip(name: string, implementation: CallbackTest): void; + export function skip(implementation: CallbackTest): void; + export function todo(name: string): void; + export function failing(name: string, implementation: CallbackTest): void; + export function failing(implementation: CallbackTest): void; +} +export namespace test.beforeEach.cb.serial { + export function skip(name: string, implementation: CallbackTest): void; + export function skip(implementation: CallbackTest): void; + export function todo(name: string): void; + export const failing: typeof test.beforeEach.cb.failing.serial; +} +export namespace test.beforeEach.cb.serial.skip { + export const failing: typeof test.beforeEach.cb.failing.serial.skip; +} +export namespace test.beforeEach.cb.serial.todo { + export const failing: typeof test.beforeEach.cb.failing.serial.todo; +} +export namespace test.beforeEach.cb.skip { + export const serial: typeof test.beforeEach.cb.serial.skip; + export const failing: typeof test.beforeEach.cb.failing.skip; +} +export namespace test.beforeEach.cb.todo { + export const serial: typeof test.beforeEach.cb.serial.todo; + export const failing: typeof test.beforeEach.cb.failing.todo; +} +export namespace test.beforeEach.cb.failing { + export function serial(name: string, implementation: CallbackTest): void; + export function serial(implementation: CallbackTest): void; + export function skip(name: string, implementation: CallbackTest): void; + export function skip(implementation: CallbackTest): void; + export function todo(name: string): void; +} +export namespace test.beforeEach.cb.failing.serial { + export function skip(name: string, implementation: CallbackTest): void; + export function skip(implementation: CallbackTest): void; + export function todo(name: string): void; +} +export namespace test.beforeEach.cb.failing.skip { + export const serial: typeof test.beforeEach.cb.failing.serial.skip; +} +export namespace test.beforeEach.cb.failing.todo { + export const serial: typeof test.beforeEach.cb.failing.serial.todo; +} +export namespace test.afterEach { + export function serial(name: string, implementation: Test): void; + export function serial(implementation: Test): void; + export function skip(name: string, implementation: Test): void; + export function skip(implementation: Test): void; + export function todo(name: string): void; + export function failing(name: string, implementation: Test): void; + export function failing(implementation: Test): void; + export function cb(name: string, implementation: CallbackTest): void; + export function cb(implementation: CallbackTest): void; +} +export namespace test.afterEach.serial { + export function skip(name: string, implementation: Test): void; + export function skip(implementation: Test): void; + export function todo(name: string): void; + export const failing: typeof test.afterEach.failing.serial; + export const cb: typeof test.afterEach.cb.serial; +} +export namespace test.afterEach.serial.skip { + export const failing: typeof test.afterEach.failing.serial.skip; + export const cb: typeof test.afterEach.cb.serial.skip; +} +export namespace test.afterEach.serial.todo { + export const failing: typeof test.afterEach.failing.serial.todo; + export const cb: typeof test.afterEach.cb.serial.todo; +} +export namespace test.afterEach.skip { + export const serial: typeof test.afterEach.serial.skip; + export const failing: typeof test.afterEach.failing.skip; + export const cb: typeof test.afterEach.cb.skip; +} +export namespace test.afterEach.todo { + export const serial: typeof test.afterEach.serial.todo; + export const failing: typeof test.afterEach.failing.todo; + export const cb: typeof test.afterEach.cb.todo; +} +export namespace test.afterEach.failing { + export function serial(name: string, implementation: Test): void; + export function serial(implementation: Test): void; + export function skip(name: string, implementation: Test): void; + export function skip(implementation: Test): void; + export function todo(name: string): void; + export const cb: typeof test.afterEach.cb.failing; +} +export namespace test.afterEach.failing.serial { + export function skip(name: string, implementation: Test): void; + export function skip(implementation: Test): void; + export function todo(name: string): void; + export const cb: typeof test.afterEach.cb.failing.serial; +} +export namespace test.afterEach.failing.serial.skip { + export const cb: typeof test.afterEach.cb.failing.serial.skip; +} +export namespace test.afterEach.failing.serial.todo { + export const cb: typeof test.afterEach.cb.failing.serial.todo; +} +export namespace test.afterEach.failing.skip { + export const serial: typeof test.afterEach.failing.serial.skip; + export const cb: typeof test.afterEach.cb.failing.skip; +} +export namespace test.afterEach.failing.todo { + export const serial: typeof test.afterEach.failing.serial.todo; + export const cb: typeof test.afterEach.cb.failing.todo; +} +export namespace test.afterEach.cb { + export function serial(name: string, implementation: CallbackTest): void; + export function serial(implementation: CallbackTest): void; + export function skip(name: string, implementation: CallbackTest): void; + export function skip(implementation: CallbackTest): void; + export function todo(name: string): void; + export function failing(name: string, implementation: CallbackTest): void; + export function failing(implementation: CallbackTest): void; +} +export namespace test.afterEach.cb.serial { + export function skip(name: string, implementation: CallbackTest): void; + export function skip(implementation: CallbackTest): void; + export function todo(name: string): void; + export const failing: typeof test.afterEach.cb.failing.serial; +} +export namespace test.afterEach.cb.serial.skip { + export const failing: typeof test.afterEach.cb.failing.serial.skip; +} +export namespace test.afterEach.cb.serial.todo { + export const failing: typeof test.afterEach.cb.failing.serial.todo; +} +export namespace test.afterEach.cb.skip { + export const serial: typeof test.afterEach.cb.serial.skip; + export const failing: typeof test.afterEach.cb.failing.skip; +} +export namespace test.afterEach.cb.todo { + export const serial: typeof test.afterEach.cb.serial.todo; + export const failing: typeof test.afterEach.cb.failing.todo; +} +export namespace test.afterEach.cb.failing { + export function serial(name: string, implementation: CallbackTest): void; + export function serial(implementation: CallbackTest): void; + export function skip(name: string, implementation: CallbackTest): void; + export function skip(implementation: CallbackTest): void; + export function todo(name: string): void; +} +export namespace test.afterEach.cb.failing.serial { + export function skip(name: string, implementation: CallbackTest): void; + export function skip(implementation: CallbackTest): void; + export function todo(name: string): void; +} +export namespace test.afterEach.cb.failing.skip { + export const serial: typeof test.afterEach.cb.failing.serial.skip; +} +export namespace test.afterEach.cb.failing.todo { + export const serial: typeof test.afterEach.cb.failing.serial.todo; +} +export namespace test.cb { + export function serial(name: string, implementation: ContextualCallbackTest): void; + export function serial(implementation: ContextualCallbackTest): void; + export const before: typeof test.before.cb; + export const after: typeof test.after.cb; + export function skip(name: string, implementation: ContextualCallbackTest): void; + export function skip(implementation: ContextualCallbackTest): void; + export function todo(name: string): void; + export function failing(name: string, implementation: ContextualCallbackTest): void; + export function failing(implementation: ContextualCallbackTest): void; + export function only(name: string, implementation: ContextualCallbackTest): void; + export function only(implementation: ContextualCallbackTest): void; + export const beforeEach: typeof test.beforeEach.cb; + export const afterEach: typeof test.afterEach.cb; +} +export namespace test.cb.serial { + export const before: typeof test.before.cb.serial; + export const after: typeof test.after.cb.serial; + export function skip(name: string, implementation: ContextualCallbackTest): void; + export function skip(implementation: ContextualCallbackTest): void; + export function todo(name: string): void; + export const failing: typeof test.cb.failing.serial; + export const only: typeof test.cb.only.serial; + export const beforeEach: typeof test.beforeEach.cb.serial; + export const afterEach: typeof test.afterEach.cb.serial; +} +export namespace test.cb.serial.skip { + export const before: typeof test.before.cb.serial.skip; + export const after: typeof test.after.cb.serial.skip; + export const failing: typeof test.cb.failing.serial.skip; + export const beforeEach: typeof test.beforeEach.cb.serial.skip; + export const afterEach: typeof test.afterEach.cb.serial.skip; +} +export namespace test.cb.serial.todo { + export const before: typeof test.before.cb.serial.todo; + export const after: typeof test.after.cb.serial.todo; + export const failing: typeof test.cb.failing.serial.todo; + export const beforeEach: typeof test.beforeEach.cb.serial.todo; + export const afterEach: typeof test.afterEach.cb.serial.todo; +} +export namespace test.cb.skip { + export const serial: typeof test.cb.serial.skip; + export const before: typeof test.before.cb.skip; + export const after: typeof test.after.cb.skip; + export const failing: typeof test.cb.failing.skip; + export const beforeEach: typeof test.beforeEach.cb.skip; + export const afterEach: typeof test.afterEach.cb.skip; +} +export namespace test.cb.todo { + export const serial: typeof test.cb.serial.todo; + export const before: typeof test.before.cb.todo; + export const after: typeof test.after.cb.todo; + export const failing: typeof test.cb.failing.todo; + export const beforeEach: typeof test.beforeEach.cb.todo; + export const afterEach: typeof test.afterEach.cb.todo; +} +export namespace test.cb.failing { + export function serial(name: string, implementation: ContextualCallbackTest): void; + export function serial(implementation: ContextualCallbackTest): void; + export const before: typeof test.before.cb.failing; + export const after: typeof test.after.cb.failing; + export function skip(name: string, implementation: ContextualCallbackTest): void; + export function skip(implementation: ContextualCallbackTest): void; + export function todo(name: string): void; + export function only(name: string, implementation: ContextualCallbackTest): void; + export function only(implementation: ContextualCallbackTest): void; + export const beforeEach: typeof test.beforeEach.cb.failing; + export const afterEach: typeof test.afterEach.cb.failing; +} +export namespace test.cb.failing.serial { + export const before: typeof test.before.cb.failing.serial; + export const after: typeof test.after.cb.failing.serial; + export function skip(name: string, implementation: ContextualCallbackTest): void; + export function skip(implementation: ContextualCallbackTest): void; + export function todo(name: string): void; + export const only: typeof test.cb.failing.only.serial; + export const beforeEach: typeof test.beforeEach.cb.failing.serial; + export const afterEach: typeof test.afterEach.cb.failing.serial; +} +export namespace test.cb.failing.serial.skip { + export const before: typeof test.before.cb.failing.serial.skip; + export const after: typeof test.after.cb.failing.serial.skip; + export const beforeEach: typeof test.beforeEach.cb.failing.serial.skip; + export const afterEach: typeof test.afterEach.cb.failing.serial.skip; +} +export namespace test.cb.failing.serial.todo { + export const before: typeof test.before.cb.failing.serial.todo; + export const after: typeof test.after.cb.failing.serial.todo; + export const beforeEach: typeof test.beforeEach.cb.failing.serial.todo; + export const afterEach: typeof test.afterEach.cb.failing.serial.todo; +} +export namespace test.cb.failing.skip { + export const serial: typeof test.cb.failing.serial.skip; + export const before: typeof test.before.cb.failing.skip; + export const after: typeof test.after.cb.failing.skip; + export const beforeEach: typeof test.beforeEach.cb.failing.skip; + export const afterEach: typeof test.afterEach.cb.failing.skip; +} +export namespace test.cb.failing.todo { + export const serial: typeof test.cb.failing.serial.todo; + export const before: typeof test.before.cb.failing.todo; + export const after: typeof test.after.cb.failing.todo; + export const beforeEach: typeof test.beforeEach.cb.failing.todo; + export const afterEach: typeof test.afterEach.cb.failing.todo; +} +export namespace test.cb.failing.only { + export function serial(name: string, implementation: ContextualCallbackTest): void; + export function serial(implementation: ContextualCallbackTest): void; +} +export namespace test.cb.only { + export function serial(name: string, implementation: ContextualCallbackTest): void; + export function serial(implementation: ContextualCallbackTest): void; + export const failing: typeof test.cb.failing.only; +} +export namespace test.cb.only.serial { + export const failing: typeof test.cb.failing.only.serial; +} From cf9a7b487450183064a06a1e6edc0b670bf5675a Mon Sep 17 00:00:00 2001 From: Ivo Gabe de Wolff Date: Fri, 27 May 2016 20:44:04 +0200 Subject: [PATCH 02/13] Add `notRegex` to TypeScript definitions --- types/base.d.ts | 4 ++++ types/generated.d.ts | 4 ++++ 2 files changed, 8 insertions(+) diff --git a/types/base.d.ts b/types/base.d.ts index 8d7c5fb3d..b0b314929 100644 --- a/types/base.d.ts +++ b/types/base.d.ts @@ -89,6 +89,10 @@ export interface AssertContext { * Assert that contents matches regex. */ regex(contents: string, regex: RegExp, message?: string): void; + /** + * Assert that contents does not match regex. + */ + notRegex(contents, regex, message?: string): void; /** * Assert that error is falsy. */ diff --git a/types/generated.d.ts b/types/generated.d.ts index 2e881bd95..6776229c9 100644 --- a/types/generated.d.ts +++ b/types/generated.d.ts @@ -89,6 +89,10 @@ export interface AssertContext { * Assert that contents matches regex. */ regex(contents: string, regex: RegExp, message?: string): void; + /** + * Assert that contents does not match regex. + */ + notRegex(contents, regex, message?: string): void; /** * Assert that error is falsy. */ From 724f1e4fb817344d390f4ca794df917a7f106e22 Mon Sep 17 00:00:00 2001 From: Ivo Gabe de Wolff Date: Fri, 27 May 2016 20:44:30 +0200 Subject: [PATCH 03/13] Change ava to AVA --- types/generate.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/types/generate.js b/types/generate.js index 9c33b2098..c6c82556b 100644 --- a/types/generate.js +++ b/types/generate.js @@ -1,5 +1,5 @@ // TypeScript definitions are generated here. -// ava allows chaining of function names, like `test.after.cb.always`. +// 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, From 4cf7bd51ddd134febcfd57492c9b43597f7f947f Mon Sep 17 00:00:00 2001 From: Ivo Gabe de Wolff Date: Sun, 29 May 2016 22:22:41 +0200 Subject: [PATCH 04/13] Address PR feedback & linting errors --- lib/runner.js | 3 ++ types/generate.js | 94 +++++++++++++++++++++++++---------------------- 2 files changed, 54 insertions(+), 43 deletions(-) diff --git a/lib/runner.js b/lib/runner.js index 250159372..8591ca333 100644 --- a/lib/runner.js +++ b/lib/runner.js @@ -198,3 +198,6 @@ Runner.prototype.run = function (options) { return Promise.resolve(this.tests.build(this._bail).run()).then(this._buildStats); }; + + +Runner.chainableMethods = chainableMethods.chainableMethods; diff --git a/types/generate.js b/types/generate.js index c6c82556b..7958ddccc 100644 --- a/types/generate.js +++ b/types/generate.js @@ -10,105 +10,113 @@ // `after.cb` is fully written, and `cb.after` is emitted as an alias // using `typeof after.cb`. -var path = require('path'); -var fs = require('fs'); +const path = require('path'); +const fs = require('fs'); +const runner = require('../lib/runner'); -var base = fs.readFileSync(path.join(__dirname, 'base.d.ts')).toString(); +const arrayHas = parts => part => parts.includes(part); + +const base = fs.readFileSync(path.join(__dirname, 'base.d.ts')).toString(); // All suported function names -var allParts = ['serial', 'before', 'after', 'skip', 'todo', 'failing', 'only', 'beforeEach', 'afterEach', 'cb', 'always']; +const allParts = Object.keys(runner.chainableMethods).filter(name => name !== 'test'); -var output = base + generatePrefixed([]); +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) { - var output = 'export namespace ' + ['test'].concat(prefix).join('.') + ' {\n'; - - var children = ''; - var empty = true; - for (var i = 0; i < allParts.length; i++) { - var part = allParts[i]; - var parts = prefix.concat([part]); - - if (prefix.indexOf(part) !== -1 || !verify(parts, true)) { + let output = ''; + let children = ''; + + for (const part of allParts) { + const parts = [...prefix, part]; + + if (prefix.includes(part) || !verify(parts, true)) { // Function already in prefix or not allowed here 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)) { - empty = false; if (!isSorted(parts)) { - output += '\t' + 'export const ' + part + ': typeof test.' + parts.sort().join('.') + ';\n'; + output += '\texport const ' + part + ': typeof test.' + parts.sort().join('.') + ';\n'; continue; - } else if (parts.indexOf('todo') !== -1) { + } else if (parts.includes('todo')) { output += '\t' + writeFunction(part, 'name: string', 'void'); } else { - var type = testType(parts); + const type = testType(parts); output += '\t' + writeFunction(part, 'name: string, implementation: ' + type); output += '\t' + writeFunction(part, 'implementation: ' + type); } } - + children += generatePrefixed(parts); } - if (empty) { - output = ''; - } else { - output += '}\n'; + if (output === '') { + return children; } - return output + children; + return 'export namespace ' + ['test'].concat(prefix).join('.') + ' {\n' + output + '}\n' + children; } + function writeFunction(name, args) { return 'export function ' + name + '(' + args + '): void;\n'; } function verify(parts, asPrefix) { - var has = arrayHas(parts); - if (has('only') + has('skip') + has('todo') > 1) return false; - var beforeAfterCount = has('before') + has('beforeEach') + has('after') + has('afterEach'); - if (beforeAfterCount > 1) return false; + 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('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')) { - if (!asPrefix) return false; + if (!asPrefix) { + return false; + } } else if (!verify(parts.concat(['after'])) && !verify(parts.concat(['afterEach']))) { // If `after` nor `afterEach` cannot be added to this prefix, // `always` is not allowed here. return false; } } - + return true; } + // Checks that an array is sorted function isSorted(a) { - for (var i = 1; i < a.length; i++) { + 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) { - var has = arrayHas(parts); - var type = 'Test'; - if (has('cb')) type = 'Callback' + type; - if (!has('beforeEach') && !has('afterEach')) type = 'Contextual' + type; - return type; -} -function arrayHas(parts) { - return function(part) { - return parts.indexOf(part) !== -1; + const has = arrayHas(parts); + let type = 'Test'; + if (has('cb')) { + type = 'Callback' + type; } + if (!has('beforeEach') && !has('afterEach')) { + type = 'Contextual' + type; + } + return type; } From a2750893c435fce143b9dfad7f652ccc7d3f6086 Mon Sep 17 00:00:00 2001 From: Ivo Gabe de Wolff Date: Wed, 1 Jun 2016 13:37:39 +0200 Subject: [PATCH 05/13] Address code review --- lib/runner.js | 3 +-- package.json | 3 ++- types/{generate.js => make.js} | 6 ++++-- 3 files changed, 7 insertions(+), 5 deletions(-) rename types/{generate.js => make.js} (95%) diff --git a/lib/runner.js b/lib/runner.js index 8591ca333..f39ed1070 100644 --- a/lib/runner.js +++ b/lib/runner.js @@ -199,5 +199,4 @@ Runner.prototype.run = function (options) { return Promise.resolve(this.tests.build(this._bail).run()).then(this._buildStats); }; - -Runner.chainableMethods = chainableMethods.chainableMethods; +Runner._chainableMethods = chainableMethods.chainableMethods; diff --git a/package.json b/package.json index 4438cb2f1..a9d7f5afe 100644 --- a/package.json +++ b/package.json @@ -40,7 +40,8 @@ "scripts": { "test": "xo && nyc --cache --reporter=lcov --reporter=text tap --no-cov --timeout=150 test/*.js test/reporters/*.js", "test-win": "tap --no-cov --reporter=classic --timeout=150 test/*.js test/reporters/*.js", - "visual": "node test/visual/run-visual-tests.js" + "visual": "node test/visual/run-visual-tests.js", + "make-ts": "node types/make" }, "files": [ "lib", diff --git a/types/generate.js b/types/make.js similarity index 95% rename from types/generate.js rename to types/make.js index 7958ddccc..f96fe3d14 100644 --- a/types/generate.js +++ b/types/make.js @@ -1,3 +1,5 @@ +'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. @@ -16,10 +18,10 @@ const runner = require('../lib/runner'); const arrayHas = parts => part => parts.includes(part); -const base = fs.readFileSync(path.join(__dirname, 'base.d.ts')).toString(); +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 allParts = Object.keys(runner._chainableMethods).filter(name => name !== 'test'); const output = base + generatePrefixed([]); fs.writeFileSync(path.join(__dirname, 'generated.d.ts'), output); From 7a3b4edf5bdc352316d2fb10e329c63d377af690 Mon Sep 17 00:00:00 2001 From: Ivo Gabe de Wolff Date: Wed, 8 Jun 2016 22:13:27 +0200 Subject: [PATCH 06/13] Add types/generated.d.ts to gitignore --- .gitignore | 1 + types/generated.d.ts | 825 ------------------------------------------- 2 files changed, 1 insertion(+), 825 deletions(-) delete mode 100644 types/generated.d.ts diff --git a/.gitignore b/.gitignore index 0fe5f8ea5..9c7dbb960 100644 --- a/.gitignore +++ b/.gitignore @@ -2,3 +2,4 @@ node_modules .nyc_output coverage bench/.results +types/generated.d.ts diff --git a/types/generated.d.ts b/types/generated.d.ts deleted file mode 100644 index 6776229c9..000000000 --- a/types/generated.d.ts +++ /dev/null @@ -1,825 +0,0 @@ -export default test; - -export type ErrorValidator - = (new (...args: any[]) => any) - | RegExp - | string - | ((error: any) => boolean); - -export interface Observable { - subscribe(observer: (value: {}) => void): void; -} - -export type Test = (t: TestContext) => Promise | Iterator | Observable | void; -export type ContextualTest = (t: ContextualTestContext) => Promise | Iterator | Observable | void; -export type CallbackTest = (t: CallbackTestContext) => void; -export type ContextualCallbackTest = (t: ContextualCallbackTestContext) => void; - -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(value: U, expected: U, message?: string): void; - /** - * Assert that value is not equal to expected. - */ - not(value: U, expected: U, message?: string): void; - /** - * Assert that value is deep equal to expected. - */ - deepEqual(value: U, expected: U, message?: string): void; - /** - * Assert that value is not deep equal to expected. - */ - notDeepEqual(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(value: U, expected: U, message?: string): void; - /** - * DEPRECATED use `notDeepEqual`. Assert that value is not deep equal to expected. - */ - notSame(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; - throws(value: () => void, error?: ErrorValidator, message?: string): any; - /** - * Assert that function doesn't throw an error or promise resolves. - */ - notThrows(value: Promise, message?: string): Promise; - 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, regex, 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; -} - -export function test(name: string, run: ContextualTest): void; -export function test(run: ContextualTest): void; -export namespace test { - export function serial(name: string, implementation: ContextualTest): void; - export function serial(implementation: ContextualTest): void; - export function before(name: string, implementation: ContextualTest): void; - export function before(implementation: ContextualTest): void; - export function after(name: string, implementation: ContextualTest): void; - export function after(implementation: ContextualTest): void; - export function skip(name: string, implementation: ContextualTest): void; - export function skip(implementation: ContextualTest): void; - export function todo(name: string): void; - export function failing(name: string, implementation: ContextualTest): void; - export function failing(implementation: ContextualTest): void; - export function only(name: string, implementation: ContextualTest): void; - export function only(implementation: ContextualTest): void; - export function beforeEach(name: string, implementation: Test): void; - export function beforeEach(implementation: Test): void; - export function afterEach(name: string, implementation: Test): void; - export function afterEach(implementation: Test): void; - export function cb(name: string, implementation: ContextualCallbackTest): void; - export function cb(implementation: ContextualCallbackTest): void; -} -export namespace test.serial { - export const before: typeof test.before.serial; - export const after: typeof test.after.serial; - export function skip(name: string, implementation: ContextualTest): void; - export function skip(implementation: ContextualTest): void; - export function todo(name: string): void; - export const failing: typeof test.failing.serial; - export const only: typeof test.only.serial; - export const beforeEach: typeof test.beforeEach.serial; - export const afterEach: typeof test.afterEach.serial; - export const cb: typeof test.cb.serial; -} -export namespace test.serial.skip { - export const before: typeof test.before.serial.skip; - export const after: typeof test.after.serial.skip; - export const failing: typeof test.failing.serial.skip; - export const beforeEach: typeof test.beforeEach.serial.skip; - export const afterEach: typeof test.afterEach.serial.skip; - export const cb: typeof test.cb.serial.skip; -} -export namespace test.serial.todo { - export const before: typeof test.before.serial.todo; - export const after: typeof test.after.serial.todo; - export const failing: typeof test.failing.serial.todo; - export const beforeEach: typeof test.beforeEach.serial.todo; - export const afterEach: typeof test.afterEach.serial.todo; - export const cb: typeof test.cb.serial.todo; -} -export namespace test.before { - export function serial(name: string, implementation: ContextualTest): void; - export function serial(implementation: ContextualTest): void; - export function skip(name: string, implementation: ContextualTest): void; - export function skip(implementation: ContextualTest): void; - export function todo(name: string): void; - export function failing(name: string, implementation: ContextualTest): void; - export function failing(implementation: ContextualTest): void; - export function cb(name: string, implementation: ContextualCallbackTest): void; - export function cb(implementation: ContextualCallbackTest): void; -} -export namespace test.before.serial { - export function skip(name: string, implementation: ContextualTest): void; - export function skip(implementation: ContextualTest): void; - export function todo(name: string): void; - export const failing: typeof test.before.failing.serial; - export const cb: typeof test.before.cb.serial; -} -export namespace test.before.serial.skip { - export const failing: typeof test.before.failing.serial.skip; - export const cb: typeof test.before.cb.serial.skip; -} -export namespace test.before.serial.todo { - export const failing: typeof test.before.failing.serial.todo; - export const cb: typeof test.before.cb.serial.todo; -} -export namespace test.before.skip { - export const serial: typeof test.before.serial.skip; - export const failing: typeof test.before.failing.skip; - export const cb: typeof test.before.cb.skip; -} -export namespace test.before.todo { - export const serial: typeof test.before.serial.todo; - export const failing: typeof test.before.failing.todo; - export const cb: typeof test.before.cb.todo; -} -export namespace test.before.failing { - export function serial(name: string, implementation: ContextualTest): void; - export function serial(implementation: ContextualTest): void; - export function skip(name: string, implementation: ContextualTest): void; - export function skip(implementation: ContextualTest): void; - export function todo(name: string): void; - export const cb: typeof test.before.cb.failing; -} -export namespace test.before.failing.serial { - export function skip(name: string, implementation: ContextualTest): void; - export function skip(implementation: ContextualTest): void; - export function todo(name: string): void; - export const cb: typeof test.before.cb.failing.serial; -} -export namespace test.before.failing.serial.skip { - export const cb: typeof test.before.cb.failing.serial.skip; -} -export namespace test.before.failing.serial.todo { - export const cb: typeof test.before.cb.failing.serial.todo; -} -export namespace test.before.failing.skip { - export const serial: typeof test.before.failing.serial.skip; - export const cb: typeof test.before.cb.failing.skip; -} -export namespace test.before.failing.todo { - export const serial: typeof test.before.failing.serial.todo; - export const cb: typeof test.before.cb.failing.todo; -} -export namespace test.before.cb { - export function serial(name: string, implementation: ContextualCallbackTest): void; - export function serial(implementation: ContextualCallbackTest): void; - export function skip(name: string, implementation: ContextualCallbackTest): void; - export function skip(implementation: ContextualCallbackTest): void; - export function todo(name: string): void; - export function failing(name: string, implementation: ContextualCallbackTest): void; - export function failing(implementation: ContextualCallbackTest): void; -} -export namespace test.before.cb.serial { - export function skip(name: string, implementation: ContextualCallbackTest): void; - export function skip(implementation: ContextualCallbackTest): void; - export function todo(name: string): void; - export const failing: typeof test.before.cb.failing.serial; -} -export namespace test.before.cb.serial.skip { - export const failing: typeof test.before.cb.failing.serial.skip; -} -export namespace test.before.cb.serial.todo { - export const failing: typeof test.before.cb.failing.serial.todo; -} -export namespace test.before.cb.skip { - export const serial: typeof test.before.cb.serial.skip; - export const failing: typeof test.before.cb.failing.skip; -} -export namespace test.before.cb.todo { - export const serial: typeof test.before.cb.serial.todo; - export const failing: typeof test.before.cb.failing.todo; -} -export namespace test.before.cb.failing { - export function serial(name: string, implementation: ContextualCallbackTest): void; - export function serial(implementation: ContextualCallbackTest): void; - export function skip(name: string, implementation: ContextualCallbackTest): void; - export function skip(implementation: ContextualCallbackTest): void; - export function todo(name: string): void; -} -export namespace test.before.cb.failing.serial { - export function skip(name: string, implementation: ContextualCallbackTest): void; - export function skip(implementation: ContextualCallbackTest): void; - export function todo(name: string): void; -} -export namespace test.before.cb.failing.skip { - export const serial: typeof test.before.cb.failing.serial.skip; -} -export namespace test.before.cb.failing.todo { - export const serial: typeof test.before.cb.failing.serial.todo; -} -export namespace test.after { - export function serial(name: string, implementation: ContextualTest): void; - export function serial(implementation: ContextualTest): void; - export function skip(name: string, implementation: ContextualTest): void; - export function skip(implementation: ContextualTest): void; - export function todo(name: string): void; - export function failing(name: string, implementation: ContextualTest): void; - export function failing(implementation: ContextualTest): void; - export function cb(name: string, implementation: ContextualCallbackTest): void; - export function cb(implementation: ContextualCallbackTest): void; -} -export namespace test.after.serial { - export function skip(name: string, implementation: ContextualTest): void; - export function skip(implementation: ContextualTest): void; - export function todo(name: string): void; - export const failing: typeof test.after.failing.serial; - export const cb: typeof test.after.cb.serial; -} -export namespace test.after.serial.skip { - export const failing: typeof test.after.failing.serial.skip; - export const cb: typeof test.after.cb.serial.skip; -} -export namespace test.after.serial.todo { - export const failing: typeof test.after.failing.serial.todo; - export const cb: typeof test.after.cb.serial.todo; -} -export namespace test.after.skip { - export const serial: typeof test.after.serial.skip; - export const failing: typeof test.after.failing.skip; - export const cb: typeof test.after.cb.skip; -} -export namespace test.after.todo { - export const serial: typeof test.after.serial.todo; - export const failing: typeof test.after.failing.todo; - export const cb: typeof test.after.cb.todo; -} -export namespace test.after.failing { - export function serial(name: string, implementation: ContextualTest): void; - export function serial(implementation: ContextualTest): void; - export function skip(name: string, implementation: ContextualTest): void; - export function skip(implementation: ContextualTest): void; - export function todo(name: string): void; - export const cb: typeof test.after.cb.failing; -} -export namespace test.after.failing.serial { - export function skip(name: string, implementation: ContextualTest): void; - export function skip(implementation: ContextualTest): void; - export function todo(name: string): void; - export const cb: typeof test.after.cb.failing.serial; -} -export namespace test.after.failing.serial.skip { - export const cb: typeof test.after.cb.failing.serial.skip; -} -export namespace test.after.failing.serial.todo { - export const cb: typeof test.after.cb.failing.serial.todo; -} -export namespace test.after.failing.skip { - export const serial: typeof test.after.failing.serial.skip; - export const cb: typeof test.after.cb.failing.skip; -} -export namespace test.after.failing.todo { - export const serial: typeof test.after.failing.serial.todo; - export const cb: typeof test.after.cb.failing.todo; -} -export namespace test.after.cb { - export function serial(name: string, implementation: ContextualCallbackTest): void; - export function serial(implementation: ContextualCallbackTest): void; - export function skip(name: string, implementation: ContextualCallbackTest): void; - export function skip(implementation: ContextualCallbackTest): void; - export function todo(name: string): void; - export function failing(name: string, implementation: ContextualCallbackTest): void; - export function failing(implementation: ContextualCallbackTest): void; -} -export namespace test.after.cb.serial { - export function skip(name: string, implementation: ContextualCallbackTest): void; - export function skip(implementation: ContextualCallbackTest): void; - export function todo(name: string): void; - export const failing: typeof test.after.cb.failing.serial; -} -export namespace test.after.cb.serial.skip { - export const failing: typeof test.after.cb.failing.serial.skip; -} -export namespace test.after.cb.serial.todo { - export const failing: typeof test.after.cb.failing.serial.todo; -} -export namespace test.after.cb.skip { - export const serial: typeof test.after.cb.serial.skip; - export const failing: typeof test.after.cb.failing.skip; -} -export namespace test.after.cb.todo { - export const serial: typeof test.after.cb.serial.todo; - export const failing: typeof test.after.cb.failing.todo; -} -export namespace test.after.cb.failing { - export function serial(name: string, implementation: ContextualCallbackTest): void; - export function serial(implementation: ContextualCallbackTest): void; - export function skip(name: string, implementation: ContextualCallbackTest): void; - export function skip(implementation: ContextualCallbackTest): void; - export function todo(name: string): void; -} -export namespace test.after.cb.failing.serial { - export function skip(name: string, implementation: ContextualCallbackTest): void; - export function skip(implementation: ContextualCallbackTest): void; - export function todo(name: string): void; -} -export namespace test.after.cb.failing.skip { - export const serial: typeof test.after.cb.failing.serial.skip; -} -export namespace test.after.cb.failing.todo { - export const serial: typeof test.after.cb.failing.serial.todo; -} -export namespace test.skip { - export const serial: typeof test.serial.skip; - export const before: typeof test.before.skip; - export const after: typeof test.after.skip; - export const failing: typeof test.failing.skip; - export const beforeEach: typeof test.beforeEach.skip; - export const afterEach: typeof test.afterEach.skip; - export const cb: typeof test.cb.skip; -} -export namespace test.todo { - export const serial: typeof test.serial.todo; - export const before: typeof test.before.todo; - export const after: typeof test.after.todo; - export const failing: typeof test.failing.todo; - export const beforeEach: typeof test.beforeEach.todo; - export const afterEach: typeof test.afterEach.todo; - export const cb: typeof test.cb.todo; -} -export namespace test.failing { - export function serial(name: string, implementation: ContextualTest): void; - export function serial(implementation: ContextualTest): void; - export const before: typeof test.before.failing; - export const after: typeof test.after.failing; - export function skip(name: string, implementation: ContextualTest): void; - export function skip(implementation: ContextualTest): void; - export function todo(name: string): void; - export function only(name: string, implementation: ContextualTest): void; - export function only(implementation: ContextualTest): void; - export const beforeEach: typeof test.beforeEach.failing; - export const afterEach: typeof test.afterEach.failing; - export const cb: typeof test.cb.failing; -} -export namespace test.failing.serial { - export const before: typeof test.before.failing.serial; - export const after: typeof test.after.failing.serial; - export function skip(name: string, implementation: ContextualTest): void; - export function skip(implementation: ContextualTest): void; - export function todo(name: string): void; - export const only: typeof test.failing.only.serial; - export const beforeEach: typeof test.beforeEach.failing.serial; - export const afterEach: typeof test.afterEach.failing.serial; - export const cb: typeof test.cb.failing.serial; -} -export namespace test.failing.serial.skip { - export const before: typeof test.before.failing.serial.skip; - export const after: typeof test.after.failing.serial.skip; - export const beforeEach: typeof test.beforeEach.failing.serial.skip; - export const afterEach: typeof test.afterEach.failing.serial.skip; - export const cb: typeof test.cb.failing.serial.skip; -} -export namespace test.failing.serial.todo { - export const before: typeof test.before.failing.serial.todo; - export const after: typeof test.after.failing.serial.todo; - export const beforeEach: typeof test.beforeEach.failing.serial.todo; - export const afterEach: typeof test.afterEach.failing.serial.todo; - export const cb: typeof test.cb.failing.serial.todo; -} -export namespace test.failing.skip { - export const serial: typeof test.failing.serial.skip; - export const before: typeof test.before.failing.skip; - export const after: typeof test.after.failing.skip; - export const beforeEach: typeof test.beforeEach.failing.skip; - export const afterEach: typeof test.afterEach.failing.skip; - export const cb: typeof test.cb.failing.skip; -} -export namespace test.failing.todo { - export const serial: typeof test.failing.serial.todo; - export const before: typeof test.before.failing.todo; - export const after: typeof test.after.failing.todo; - export const beforeEach: typeof test.beforeEach.failing.todo; - export const afterEach: typeof test.afterEach.failing.todo; - export const cb: typeof test.cb.failing.todo; -} -export namespace test.failing.only { - export function serial(name: string, implementation: ContextualTest): void; - export function serial(implementation: ContextualTest): void; - export const cb: typeof test.cb.failing.only; -} -export namespace test.failing.only.serial { - export const cb: typeof test.cb.failing.only.serial; -} -export namespace test.only { - export function serial(name: string, implementation: ContextualTest): void; - export function serial(implementation: ContextualTest): void; - export const failing: typeof test.failing.only; - export const cb: typeof test.cb.only; -} -export namespace test.only.serial { - export const failing: typeof test.failing.only.serial; - export const cb: typeof test.cb.only.serial; -} -export namespace test.beforeEach { - export function serial(name: string, implementation: Test): void; - export function serial(implementation: Test): void; - export function skip(name: string, implementation: Test): void; - export function skip(implementation: Test): void; - export function todo(name: string): void; - export function failing(name: string, implementation: Test): void; - export function failing(implementation: Test): void; - export function cb(name: string, implementation: CallbackTest): void; - export function cb(implementation: CallbackTest): void; -} -export namespace test.beforeEach.serial { - export function skip(name: string, implementation: Test): void; - export function skip(implementation: Test): void; - export function todo(name: string): void; - export const failing: typeof test.beforeEach.failing.serial; - export const cb: typeof test.beforeEach.cb.serial; -} -export namespace test.beforeEach.serial.skip { - export const failing: typeof test.beforeEach.failing.serial.skip; - export const cb: typeof test.beforeEach.cb.serial.skip; -} -export namespace test.beforeEach.serial.todo { - export const failing: typeof test.beforeEach.failing.serial.todo; - export const cb: typeof test.beforeEach.cb.serial.todo; -} -export namespace test.beforeEach.skip { - export const serial: typeof test.beforeEach.serial.skip; - export const failing: typeof test.beforeEach.failing.skip; - export const cb: typeof test.beforeEach.cb.skip; -} -export namespace test.beforeEach.todo { - export const serial: typeof test.beforeEach.serial.todo; - export const failing: typeof test.beforeEach.failing.todo; - export const cb: typeof test.beforeEach.cb.todo; -} -export namespace test.beforeEach.failing { - export function serial(name: string, implementation: Test): void; - export function serial(implementation: Test): void; - export function skip(name: string, implementation: Test): void; - export function skip(implementation: Test): void; - export function todo(name: string): void; - export const cb: typeof test.beforeEach.cb.failing; -} -export namespace test.beforeEach.failing.serial { - export function skip(name: string, implementation: Test): void; - export function skip(implementation: Test): void; - export function todo(name: string): void; - export const cb: typeof test.beforeEach.cb.failing.serial; -} -export namespace test.beforeEach.failing.serial.skip { - export const cb: typeof test.beforeEach.cb.failing.serial.skip; -} -export namespace test.beforeEach.failing.serial.todo { - export const cb: typeof test.beforeEach.cb.failing.serial.todo; -} -export namespace test.beforeEach.failing.skip { - export const serial: typeof test.beforeEach.failing.serial.skip; - export const cb: typeof test.beforeEach.cb.failing.skip; -} -export namespace test.beforeEach.failing.todo { - export const serial: typeof test.beforeEach.failing.serial.todo; - export const cb: typeof test.beforeEach.cb.failing.todo; -} -export namespace test.beforeEach.cb { - export function serial(name: string, implementation: CallbackTest): void; - export function serial(implementation: CallbackTest): void; - export function skip(name: string, implementation: CallbackTest): void; - export function skip(implementation: CallbackTest): void; - export function todo(name: string): void; - export function failing(name: string, implementation: CallbackTest): void; - export function failing(implementation: CallbackTest): void; -} -export namespace test.beforeEach.cb.serial { - export function skip(name: string, implementation: CallbackTest): void; - export function skip(implementation: CallbackTest): void; - export function todo(name: string): void; - export const failing: typeof test.beforeEach.cb.failing.serial; -} -export namespace test.beforeEach.cb.serial.skip { - export const failing: typeof test.beforeEach.cb.failing.serial.skip; -} -export namespace test.beforeEach.cb.serial.todo { - export const failing: typeof test.beforeEach.cb.failing.serial.todo; -} -export namespace test.beforeEach.cb.skip { - export const serial: typeof test.beforeEach.cb.serial.skip; - export const failing: typeof test.beforeEach.cb.failing.skip; -} -export namespace test.beforeEach.cb.todo { - export const serial: typeof test.beforeEach.cb.serial.todo; - export const failing: typeof test.beforeEach.cb.failing.todo; -} -export namespace test.beforeEach.cb.failing { - export function serial(name: string, implementation: CallbackTest): void; - export function serial(implementation: CallbackTest): void; - export function skip(name: string, implementation: CallbackTest): void; - export function skip(implementation: CallbackTest): void; - export function todo(name: string): void; -} -export namespace test.beforeEach.cb.failing.serial { - export function skip(name: string, implementation: CallbackTest): void; - export function skip(implementation: CallbackTest): void; - export function todo(name: string): void; -} -export namespace test.beforeEach.cb.failing.skip { - export const serial: typeof test.beforeEach.cb.failing.serial.skip; -} -export namespace test.beforeEach.cb.failing.todo { - export const serial: typeof test.beforeEach.cb.failing.serial.todo; -} -export namespace test.afterEach { - export function serial(name: string, implementation: Test): void; - export function serial(implementation: Test): void; - export function skip(name: string, implementation: Test): void; - export function skip(implementation: Test): void; - export function todo(name: string): void; - export function failing(name: string, implementation: Test): void; - export function failing(implementation: Test): void; - export function cb(name: string, implementation: CallbackTest): void; - export function cb(implementation: CallbackTest): void; -} -export namespace test.afterEach.serial { - export function skip(name: string, implementation: Test): void; - export function skip(implementation: Test): void; - export function todo(name: string): void; - export const failing: typeof test.afterEach.failing.serial; - export const cb: typeof test.afterEach.cb.serial; -} -export namespace test.afterEach.serial.skip { - export const failing: typeof test.afterEach.failing.serial.skip; - export const cb: typeof test.afterEach.cb.serial.skip; -} -export namespace test.afterEach.serial.todo { - export const failing: typeof test.afterEach.failing.serial.todo; - export const cb: typeof test.afterEach.cb.serial.todo; -} -export namespace test.afterEach.skip { - export const serial: typeof test.afterEach.serial.skip; - export const failing: typeof test.afterEach.failing.skip; - export const cb: typeof test.afterEach.cb.skip; -} -export namespace test.afterEach.todo { - export const serial: typeof test.afterEach.serial.todo; - export const failing: typeof test.afterEach.failing.todo; - export const cb: typeof test.afterEach.cb.todo; -} -export namespace test.afterEach.failing { - export function serial(name: string, implementation: Test): void; - export function serial(implementation: Test): void; - export function skip(name: string, implementation: Test): void; - export function skip(implementation: Test): void; - export function todo(name: string): void; - export const cb: typeof test.afterEach.cb.failing; -} -export namespace test.afterEach.failing.serial { - export function skip(name: string, implementation: Test): void; - export function skip(implementation: Test): void; - export function todo(name: string): void; - export const cb: typeof test.afterEach.cb.failing.serial; -} -export namespace test.afterEach.failing.serial.skip { - export const cb: typeof test.afterEach.cb.failing.serial.skip; -} -export namespace test.afterEach.failing.serial.todo { - export const cb: typeof test.afterEach.cb.failing.serial.todo; -} -export namespace test.afterEach.failing.skip { - export const serial: typeof test.afterEach.failing.serial.skip; - export const cb: typeof test.afterEach.cb.failing.skip; -} -export namespace test.afterEach.failing.todo { - export const serial: typeof test.afterEach.failing.serial.todo; - export const cb: typeof test.afterEach.cb.failing.todo; -} -export namespace test.afterEach.cb { - export function serial(name: string, implementation: CallbackTest): void; - export function serial(implementation: CallbackTest): void; - export function skip(name: string, implementation: CallbackTest): void; - export function skip(implementation: CallbackTest): void; - export function todo(name: string): void; - export function failing(name: string, implementation: CallbackTest): void; - export function failing(implementation: CallbackTest): void; -} -export namespace test.afterEach.cb.serial { - export function skip(name: string, implementation: CallbackTest): void; - export function skip(implementation: CallbackTest): void; - export function todo(name: string): void; - export const failing: typeof test.afterEach.cb.failing.serial; -} -export namespace test.afterEach.cb.serial.skip { - export const failing: typeof test.afterEach.cb.failing.serial.skip; -} -export namespace test.afterEach.cb.serial.todo { - export const failing: typeof test.afterEach.cb.failing.serial.todo; -} -export namespace test.afterEach.cb.skip { - export const serial: typeof test.afterEach.cb.serial.skip; - export const failing: typeof test.afterEach.cb.failing.skip; -} -export namespace test.afterEach.cb.todo { - export const serial: typeof test.afterEach.cb.serial.todo; - export const failing: typeof test.afterEach.cb.failing.todo; -} -export namespace test.afterEach.cb.failing { - export function serial(name: string, implementation: CallbackTest): void; - export function serial(implementation: CallbackTest): void; - export function skip(name: string, implementation: CallbackTest): void; - export function skip(implementation: CallbackTest): void; - export function todo(name: string): void; -} -export namespace test.afterEach.cb.failing.serial { - export function skip(name: string, implementation: CallbackTest): void; - export function skip(implementation: CallbackTest): void; - export function todo(name: string): void; -} -export namespace test.afterEach.cb.failing.skip { - export const serial: typeof test.afterEach.cb.failing.serial.skip; -} -export namespace test.afterEach.cb.failing.todo { - export const serial: typeof test.afterEach.cb.failing.serial.todo; -} -export namespace test.cb { - export function serial(name: string, implementation: ContextualCallbackTest): void; - export function serial(implementation: ContextualCallbackTest): void; - export const before: typeof test.before.cb; - export const after: typeof test.after.cb; - export function skip(name: string, implementation: ContextualCallbackTest): void; - export function skip(implementation: ContextualCallbackTest): void; - export function todo(name: string): void; - export function failing(name: string, implementation: ContextualCallbackTest): void; - export function failing(implementation: ContextualCallbackTest): void; - export function only(name: string, implementation: ContextualCallbackTest): void; - export function only(implementation: ContextualCallbackTest): void; - export const beforeEach: typeof test.beforeEach.cb; - export const afterEach: typeof test.afterEach.cb; -} -export namespace test.cb.serial { - export const before: typeof test.before.cb.serial; - export const after: typeof test.after.cb.serial; - export function skip(name: string, implementation: ContextualCallbackTest): void; - export function skip(implementation: ContextualCallbackTest): void; - export function todo(name: string): void; - export const failing: typeof test.cb.failing.serial; - export const only: typeof test.cb.only.serial; - export const beforeEach: typeof test.beforeEach.cb.serial; - export const afterEach: typeof test.afterEach.cb.serial; -} -export namespace test.cb.serial.skip { - export const before: typeof test.before.cb.serial.skip; - export const after: typeof test.after.cb.serial.skip; - export const failing: typeof test.cb.failing.serial.skip; - export const beforeEach: typeof test.beforeEach.cb.serial.skip; - export const afterEach: typeof test.afterEach.cb.serial.skip; -} -export namespace test.cb.serial.todo { - export const before: typeof test.before.cb.serial.todo; - export const after: typeof test.after.cb.serial.todo; - export const failing: typeof test.cb.failing.serial.todo; - export const beforeEach: typeof test.beforeEach.cb.serial.todo; - export const afterEach: typeof test.afterEach.cb.serial.todo; -} -export namespace test.cb.skip { - export const serial: typeof test.cb.serial.skip; - export const before: typeof test.before.cb.skip; - export const after: typeof test.after.cb.skip; - export const failing: typeof test.cb.failing.skip; - export const beforeEach: typeof test.beforeEach.cb.skip; - export const afterEach: typeof test.afterEach.cb.skip; -} -export namespace test.cb.todo { - export const serial: typeof test.cb.serial.todo; - export const before: typeof test.before.cb.todo; - export const after: typeof test.after.cb.todo; - export const failing: typeof test.cb.failing.todo; - export const beforeEach: typeof test.beforeEach.cb.todo; - export const afterEach: typeof test.afterEach.cb.todo; -} -export namespace test.cb.failing { - export function serial(name: string, implementation: ContextualCallbackTest): void; - export function serial(implementation: ContextualCallbackTest): void; - export const before: typeof test.before.cb.failing; - export const after: typeof test.after.cb.failing; - export function skip(name: string, implementation: ContextualCallbackTest): void; - export function skip(implementation: ContextualCallbackTest): void; - export function todo(name: string): void; - export function only(name: string, implementation: ContextualCallbackTest): void; - export function only(implementation: ContextualCallbackTest): void; - export const beforeEach: typeof test.beforeEach.cb.failing; - export const afterEach: typeof test.afterEach.cb.failing; -} -export namespace test.cb.failing.serial { - export const before: typeof test.before.cb.failing.serial; - export const after: typeof test.after.cb.failing.serial; - export function skip(name: string, implementation: ContextualCallbackTest): void; - export function skip(implementation: ContextualCallbackTest): void; - export function todo(name: string): void; - export const only: typeof test.cb.failing.only.serial; - export const beforeEach: typeof test.beforeEach.cb.failing.serial; - export const afterEach: typeof test.afterEach.cb.failing.serial; -} -export namespace test.cb.failing.serial.skip { - export const before: typeof test.before.cb.failing.serial.skip; - export const after: typeof test.after.cb.failing.serial.skip; - export const beforeEach: typeof test.beforeEach.cb.failing.serial.skip; - export const afterEach: typeof test.afterEach.cb.failing.serial.skip; -} -export namespace test.cb.failing.serial.todo { - export const before: typeof test.before.cb.failing.serial.todo; - export const after: typeof test.after.cb.failing.serial.todo; - export const beforeEach: typeof test.beforeEach.cb.failing.serial.todo; - export const afterEach: typeof test.afterEach.cb.failing.serial.todo; -} -export namespace test.cb.failing.skip { - export const serial: typeof test.cb.failing.serial.skip; - export const before: typeof test.before.cb.failing.skip; - export const after: typeof test.after.cb.failing.skip; - export const beforeEach: typeof test.beforeEach.cb.failing.skip; - export const afterEach: typeof test.afterEach.cb.failing.skip; -} -export namespace test.cb.failing.todo { - export const serial: typeof test.cb.failing.serial.todo; - export const before: typeof test.before.cb.failing.todo; - export const after: typeof test.after.cb.failing.todo; - export const beforeEach: typeof test.beforeEach.cb.failing.todo; - export const afterEach: typeof test.afterEach.cb.failing.todo; -} -export namespace test.cb.failing.only { - export function serial(name: string, implementation: ContextualCallbackTest): void; - export function serial(implementation: ContextualCallbackTest): void; -} -export namespace test.cb.only { - export function serial(name: string, implementation: ContextualCallbackTest): void; - export function serial(implementation: ContextualCallbackTest): void; - export const failing: typeof test.cb.failing.only; -} -export namespace test.cb.only.serial { - export const failing: typeof test.cb.failing.only.serial; -} From 54a8324f334ec0c74787e5078a0d0fea33cefffd Mon Sep 17 00:00:00 2001 From: Ivo Gabe de Wolff Date: Wed, 15 Jun 2016 13:36:07 +0200 Subject: [PATCH 07/13] Add TS generation script as republish script --- package.json | 1 + 1 file changed, 1 insertion(+) diff --git a/package.json b/package.json index a9d7f5afe..5173e311e 100644 --- a/package.json +++ b/package.json @@ -41,6 +41,7 @@ "test": "xo && nyc --cache --reporter=lcov --reporter=text tap --no-cov --timeout=150 test/*.js test/reporters/*.js", "test-win": "tap --no-cov --reporter=classic --timeout=150 test/*.js test/reporters/*.js", "visual": "node test/visual/run-visual-tests.js", + "prepublish": "npm run make-ts", "make-ts": "node types/make" }, "files": [ From 984184bb1ed8e86c44b9f51876234b6700f9c6ad Mon Sep 17 00:00:00 2001 From: Ivo Gabe de Wolff Date: Thu, 16 Jun 2016 13:20:22 +0200 Subject: [PATCH 08/13] Support Node 4 in TS generation script --- types/make.js | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/types/make.js b/types/make.js index f96fe3d14..718118c22 100644 --- a/types/make.js +++ b/types/make.js @@ -16,7 +16,8 @@ const path = require('path'); const fs = require('fs'); const runner = require('../lib/runner'); -const arrayHas = parts => part => parts.includes(part); +const includes = (array, value ) => array.indexOf(value) !== -1; +const arrayHas = parts => part => includes(parts, part); const base = fs.readFileSync(path.join(__dirname, 'base.d.ts'), 'utf8'); @@ -33,9 +34,9 @@ function generatePrefixed(prefix) { let children = ''; for (const part of allParts) { - const parts = [...prefix, part]; + const parts = prefix.concat([part]); - if (prefix.includes(part) || !verify(parts, true)) { + if (includes(prefix, part) || !verify(parts, true)) { // Function already in prefix or not allowed here continue; } @@ -47,7 +48,7 @@ function generatePrefixed(prefix) { if (!isSorted(parts)) { output += '\texport const ' + part + ': typeof test.' + parts.sort().join('.') + ';\n'; continue; - } else if (parts.includes('todo')) { + } else if (includes(parts, 'todo')) { output += '\t' + writeFunction(part, 'name: string', 'void'); } else { const type = testType(parts); From ef6e73f3c2c9a87406e61586577f3efcd867b9cc Mon Sep 17 00:00:00 2001 From: Ivo Gabe de Wolff Date: Thu, 16 Jun 2016 15:44:02 +0200 Subject: [PATCH 09/13] Fix linting issue --- types/make.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/types/make.js b/types/make.js index 718118c22..e24cc7d04 100644 --- a/types/make.js +++ b/types/make.js @@ -16,7 +16,7 @@ const path = require('path'); const fs = require('fs'); const runner = require('../lib/runner'); -const includes = (array, value ) => array.indexOf(value) !== -1; +const includes = (array, value) => array.indexOf(value) !== -1; const arrayHas = parts => part => includes(parts, part); const base = fs.readFileSync(path.join(__dirname, 'base.d.ts'), 'utf8'); From 43cd1f8466384deecb2a68b907fe35f36f4dbcf6 Mon Sep 17 00:00:00 2001 From: Ivo Gabe de Wolff Date: Fri, 1 Jul 2016 22:58:24 +0200 Subject: [PATCH 10/13] Run TS generation script on old NodeJS versions using Babel --- package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/package.json b/package.json index 5173e311e..d8f1730ec 100644 --- a/package.json +++ b/package.json @@ -42,7 +42,7 @@ "test-win": "tap --no-cov --reporter=classic --timeout=150 test/*.js test/reporters/*.js", "visual": "node test/visual/run-visual-tests.js", "prepublish": "npm run make-ts", - "make-ts": "node types/make" + "make-ts": "node -e \"require('babel-register')({ presets: 'babel-preset-es2015' }); require('./types/make');\"" }, "files": [ "lib", From 8008357870eb77612d116f0b49112f287edcf12b Mon Sep 17 00:00:00 2001 From: Ivo Gabe de Wolff Date: Wed, 13 Jul 2016 08:49:15 +0200 Subject: [PATCH 11/13] Use babel-node --- package.json | 7 +++++-- types/make.js | 7 +++---- 2 files changed, 8 insertions(+), 6 deletions(-) diff --git a/package.json b/package.json index b4c8114a9..3c55cd867 100644 --- a/package.json +++ b/package.json @@ -42,7 +42,7 @@ "test-win": "tap --no-cov --reporter=classic --timeout=150 test/*.js test/reporters/*.js", "visual": "node test/visual/run-visual-tests.js", "prepublish": "npm run make-ts", - "make-ts": "node -e \"require('babel-register')({ presets: 'babel-preset-es2015' }); require('./types/make');\"" + "make-ts": "babel-node ./types/make" }, "files": [ "lib", @@ -156,6 +156,7 @@ "update-notifier": "^1.0.0" }, "devDependencies": { + "babel-cli": "^6.10.1", "babel-preset-react": "^6.5.0", "cli-table2": "^0.2.0", "coveralls": "^2.11.4", @@ -185,7 +186,9 @@ }, "overrides": [ { - "files": ["test/**/*.js"], + "files": [ + "test/**/*.js" + ], "rules": { "max-lines": 0 } diff --git a/types/make.js b/types/make.js index e24cc7d04..0fa222dac 100644 --- a/types/make.js +++ b/types/make.js @@ -16,8 +16,7 @@ const path = require('path'); const fs = require('fs'); const runner = require('../lib/runner'); -const includes = (array, value) => array.indexOf(value) !== -1; -const arrayHas = parts => part => includes(parts, part); +const arrayHas = parts => part => parts.includes(part); const base = fs.readFileSync(path.join(__dirname, 'base.d.ts'), 'utf8'); @@ -36,7 +35,7 @@ function generatePrefixed(prefix) { for (const part of allParts) { const parts = prefix.concat([part]); - if (includes(prefix, part) || !verify(parts, true)) { + if (prefix.includes(part) || !verify(parts, true)) { // Function already in prefix or not allowed here continue; } @@ -48,7 +47,7 @@ function generatePrefixed(prefix) { if (!isSorted(parts)) { output += '\texport const ' + part + ': typeof test.' + parts.sort().join('.') + ';\n'; continue; - } else if (includes(parts, 'todo')) { + } else if (prefix.includes(parts, 'todo')) { output += '\t' + writeFunction(part, 'name: string', 'void'); } else { const type = testType(parts); From d7c4fcb8a38282e68bf9263478038af11a99c937 Mon Sep 17 00:00:00 2001 From: Ivo Gabe de Wolff Date: Wed, 13 Jul 2016 08:50:03 +0200 Subject: [PATCH 12/13] Accept PromiseLike instead of Promise (#960) --- types/base.d.ts | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/types/base.d.ts b/types/base.d.ts index b0b314929..e1f4f974b 100644 --- a/types/base.d.ts +++ b/types/base.d.ts @@ -10,8 +10,8 @@ export interface Observable { subscribe(observer: (value: {}) => void): void; } -export type Test = (t: TestContext) => Promise | Iterator | Observable | void; -export type ContextualTest = (t: ContextualTestContext) => Promise | Iterator | Observable | void; +export type Test = (t: TestContext) => PromiseLike | Iterator | Observable | void; +export type ContextualTest = (t: ContextualTestContext) => PromiseLike | Iterator | Observable | void; export type CallbackTest = (t: CallbackTestContext) => void; export type ContextualCallbackTest = (t: ContextualCallbackTestContext) => void; @@ -78,12 +78,12 @@ export interface AssertContext { * 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; + throws(value: PromiseLike, error?: ErrorValidator, message?: string): Promise; throws(value: () => void, error?: ErrorValidator, message?: string): any; /** * Assert that function doesn't throw an error or promise resolves. */ - notThrows(value: Promise, message?: string): Promise; + notThrows(value: PromiseLike, message?: string): Promise; notThrows(value: () => void, message?: string): void; /** * Assert that contents matches regex. From 322445dcfa9e22a3997ad97c1bba9cf7d999df46 Mon Sep 17 00:00:00 2001 From: Ivo Gabe de Wolff Date: Wed, 13 Jul 2016 18:55:32 +0200 Subject: [PATCH 13/13] Configure babel-node --- package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/package.json b/package.json index 3c55cd867..c3d97a2f0 100644 --- a/package.json +++ b/package.json @@ -42,7 +42,7 @@ "test-win": "tap --no-cov --reporter=classic --timeout=150 test/*.js test/reporters/*.js", "visual": "node test/visual/run-visual-tests.js", "prepublish": "npm run make-ts", - "make-ts": "babel-node ./types/make" + "make-ts": "babel-node --presets=babel-preset-es2015 --plugins=transform-runtime types/make.js" }, "files": [ "lib",