orionsoft-react-scripts
Version:
Orionsoft Configuration and scripts for Create React App.
420 lines (352 loc) • 11.8 kB
TypeScript
declare module 'testcheck' {
/**
* Optional arguments to `check` and `sample`.
*/
export interface Options {
// Number of times to run `check` or `sample`.
times?: number;
// The maximum "size" to provide to sized generators. Default: 200
maxSize?: number;
// The seed to use for the random number generator. Default: Random
seed?: number;
}
/**
* The result of running `check`.
*/
export interface Result {
// True of the check passed.
result: boolean;
// The number of generated checks ran.
'num-tests': number;
// The seed used for this check.
seed?: number;
// The arguments generated when and if this check failed.
fail?: Array<any>;
// The size used when and if this check failed
'failing-size'?: number;
/**
* When a check fails, the failing arguments shrink to find the smallest
* value that fails.
*/
shrunk?: {
// True if the check passed, otherwise false.
result: boolean;
// The smallest arguments with this result.
smallest: Array<any>;
// The depth of the shrunk result.
depth: number;
// The number of nodes shrunk to result in this smallest failing value.
'total-nodes-visited': number;
}
}
/**
* Generators of values.
*
* Generator is an opaque type. It has no public methods or properties.
*/
export interface Generator<T> {}
/**
* Given a property to check, return the result of the check.
*
* A "property" is a Generator of booleans which should always generate true.
* If the property generates a false value, check will shrink the generator
* and return a Result which includes the `shrunk` key.
*
* If no options are provided, they default to:
*
* {times: 100, maxSize: 200, seed: <Random>}
*
*/
export function check(property: Generator<boolean>, options?: Options): Result;
/**
* Creates a "property" as needed by `check`.
*
* Accepts an array of value generators, the results of which become the
* arguments of the property function. The property function should return
* true if the property is upheld, or false if it fails.
*
* var numGoUp = property([gen.int, gen.posInt], (a, b) => a + b > a);
* check(numGoUp, {times: 1000});
*
*/
export function property(
argGens: Array<Generator<any>>,
propertyFn: (...args: any[]) => boolean
): Generator<boolean>;
/**
* Handy tool for checking the output of your generators. Given a generator,
* it returns an array of the results of the generator.
*
* var results = sample(gen.int, { seed: 123 });
* // [ 0, 1, 1, 2, 3, 3, -6, 1, -3, -8 ]
*
* If no options are provided, they default to:
*
* {times: 10, maxSize: 200, seed: <Random>}
*
*/
export function sample<T>(gen: Generator<T>, options?: Options): Array<T>;
// Generator Builders
// ------------------
export var gen: {
/**
* Creates a new Generator which ensures that all values Generated adhere to
* the given `predicate`.
*
* Care is needed to ensure there is a high chance the predicate will pass.
* By default, `suchThat` will try 10 times to generate a satisfactory
* value. If no value adheres to the predicate, an exception will throw. You
* can pass an optional third argument to change the number of times tried.
* Note that each retry will increase the size of the generator.
*/
suchThat: <T>(
predicate: (value: T) => boolean,
generator: Generator<T>,
maxTries?: number // default 10
) => Generator<T>;
/**
* Creates a new Generator of collections (Arrays or Objects) which are
* not empty.
*/
notEmpty: <T>(
generator: Generator<T>,
maxTries?: number
) => Generator<T>;
/**
* Creates a new Generator which is the mapped result of another generator.
*
* var genSquares = gen.map(n => n * n, gen.posInt);
*
*/
map: <T, S>(
mapper: (value: T) => S,
generator: Generator<T>
) => Generator<S>;
/**
* Creates a new Generator which passes the result of `generator` into the
* `binder` function which should return a new Generator. This allows you to
* create new Generators that depend on the values of other Generators.
* For example, to create a Generator which first generates an array of
* integers, and then chooses a random element from that array:
*
* gen.bind(gen.notEmpty(gen.array(gen.int))), gen.returnOneOf)
*
*/
bind: <T, S>(
generator: Generator<T>,
binder: (value: T) => Generator<S>
) => Generator<S>;
/**
* Creates a Generator that relies on a size. Size allows for the "shrinking"
* of Generators. Larger "size" should result in a larger generated value.
*
* For example, `gen.int` is shrinkable because it is implemented as:
*
* var gen.int = gen.sized(size => gen.intWithin(-size, size))
*
*/
sized: <T>(sizedGenFn: (size: number) => Generator<T>) => Generator<T>;
/**
* Given an explicit size, and a Generator that relies on size, returns a new
* Generator which always uses the provided size and is not shrinkable.
*/
resized: <T>(size: number, generator: Generator<T>) => Generator<T>;
/**
* Given a shrinkable Generator, return a new Generator which will never
* shrink. This can be useful when shrinking is taking a long time or is not
* applicable to the domain.
*/
noShrink: <T>(generator: Generator<T>) => Generator<T>;
/**
* Given a shrinkable Generator, return a new Generator which will always
* consider shrinking, even if the property passes (up to one
* additional level).
*/
shrink: <T>(generator: Generator<T>) => Generator<T>;
// Simple Generators
// -----------------
/**
* Creates a Generator which will always generate the provided value.
*
* var alwaysThree = gen.return(3);
*
*/
return: <T>(value: T) => Generator<T>;
/**
* Creates a Generator which will always generate one of the provided values.
*
* var alphabetSoup = gen.returnOneOf(['a', 'b', 'c']);
*
*/
returnOneOf: <T>(values: T[]) => Generator<T>;
/**
* Creates a Generator which will generate values from one of the
* provided generators.
*
* var numOrBool = gen.oneOf([gen.int, gen.boolean])
*
*/
oneOf: <T>(generators: Generator<T>[]) => Generator<T>;
/**
* Similar to `oneOf`, except provides probablistic "weights" to
* each generator.
*
* var numOrRarelyBool = gen.oneOf([[99, gen.int], [1, gen.boolean]])
*/
oneOfWeighted: <T>(
generators: Array</*number, Generator<T>*/any>[]
) => Generator<T>;
/**
* Given a function which takes a generator and returns a generator (such as
* `gen.array` or `gen.object`), and a Generator to use as values, creates
* potentially nested values.
*
* gen.nested(gen.array, gen.int)
* // [ [ 0, [ -2 ], 1, [] ]
*
*/
nested: <C, T>(
collectionGenFn: (valueGen: Generator<T>) => Generator<C>,
valueGen: Generator<T>
) => Generator<C>;
// Collections: Arrays and Objects
// -------------------------------
/**
* Generates Arrays of values. There are a few forms `gen.array` can be used:
*
* - Generate Arrays of random lengths (ex. arrays of integers)
*
* gen.array(gen.int)
*
* - Generate Arrays of specific lengths (ex. length of 5)
*
* gen.array(gen.int, 5)
*
* - Generate Arrays of random lengths within a specific range
* (ex. between 2 and 10)
*
* gen.array(gen.int, 2, 10)
*
* - Generate Arrays of specific lengths with different kinds of values at
* each index (e.g. tuples). (ex. tuples of [int, bool] like `[3, true]`)
*
* gen.array([ gen.int, gen.boolean ])
*
*/
array: {
<T>(valueGen: Generator<T>): Generator<Array<T>>;
<T>(valueGen: Generator<T>, length: number): Generator<Array<T>>;
<T>(valueGen: Generator<T>, min: number, max: number): Generator<Array<T>>;
(genTuple: Array<Generator<any>>): Generator<Array<any>>;
}
/**
* Generates Objects of values. There are a few forms `gen.object` can be used:
*
* - Generate Objects with random keys (alpha-numeric keys, up to 16 chars)
*
* gen.object(gen.int)
*
* - Generate Objects with a specified kind of key and value,
* (ex. numeric keys)
*
* gen.object(gen.int, gen.int)
*
* - Generate Objects with specific keys with different kinds of values at
* each key (e.g. records). (ex. a 2d point like `{ x: 3, y: 5 }`)
*
* gen.object({ x: gen.posInt, y: gen.posInt })
*
*/
object: {
<T>(valueGen: Generator<T>): Generator<{[key: string]: T}>;
<T>(keyGen: Generator<string>, valueGen: Generator<T>): Generator<{[key: string]: T}>;
(genMap: {[key: string]: Generator<any>}): Generator<{[key: string]: any}>;
}
/**
* Generates either an Array or an Object with values of the provided kind.
*/
arrayOrObject: <T>(
valueGen: Generator<T>
) => Generator<{[key: string]: T; [key: number]: T}>;
// JS Primitives
// -------------
NaN: Generator<number>;
undefined: Generator<void>;
null: Generator<void>;
boolean: Generator<boolean>;
/**
* A sized, shrinkable generator producing integers.
*/
int: Generator<number>;
/**
* Only positive integers (0 through +Inf)
*/
posInt: Generator<number>;
/**
* Only negative integers (0 through -Inf)
*/
negInt: Generator<number>;
/**
* Only strictly positive integers (1 through +Inf)
*/
strictPosInt: Generator<number>;
/**
* Only strictly negative integers (1 through -Inf)
*/
strictNegInt: Generator<number>;
/**
* Generates an integer within the provided (inclusive) range.
* The resulting Generator is not shrinkable.
*/
intWithin: (min: number, max: number) => Generator<number>;
/**
* Generates ascii characters (code 0 through 255).
*/
char: Generator<string>;
/**
* Generates printable ascii characters (code 32 through 126).
*/
asciiChar: Generator<string>;
/**
* Generates ascii characters matching /a-zA-Z0-9/
*/
alphaNumChar: Generator<string>;
/**
* Generates strings. Note: strings of arbitrary characters may result in
* Unicode characters and non-printable characters.
*/
string: Generator<string>;
/**
* Generates strings of printable Ascii characters.
*/
asciiString: Generator<string>;
/**
* Generates strings of [a-zA-Z0-9]*
*/
alphaNumString: Generator<string>;
// JSON
/**
* Generates JSON primitives: strings, numbers, booleans and null.
*/
JSONPrimitive: Generator<any>;
/**
* Generates JSON values: primitives, or (possibly nested) arrays or objects.
*/
JSONValue: Generator<any>;
/**
* Generates JSON objects where each key is a JSON value.
*/
JSON: Generator<{[key: string]: any}>;
// JS
// --
/**
* Generates any primitive JS value:
* strings, numbers, booleans, null, undefined, or NaN.
*/
primitive: Generator<any>;
/**
* Generates any JS value (possibly nested).
*/
any: Generator<any>;
}
}