cypress
Version:
Cypress is a next generation front end testing tool built for the modern web
1,612 lines (1,418 loc) • 87.8 kB
TypeScript
// Type definitions for mocha 8.0
// Project: https://mochajs.org
// Definitions by: Kazi Manzur Rashid <https://github.com/kazimanzurrashid>
// otiai10 <https://github.com/otiai10>
// Vadim Macagon <https://github.com/enlight>
// Andrew Bradley <https://github.com/cspotcode>
// Dmitrii Sorin <https://github.com/1999>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.1
/**
* Mocha API
*
* @see https://mochajs.org/api/mocha
*/
declare class Mocha {
private _growl;
private _reporter;
private _ui;
constructor(options?: Mocha.MochaOptions);
suite: Mocha.Suite;
files: string[];
options: Mocha.MochaInstanceOptions;
/**
* Enable or disable bailing on the first failure.
*
* @see https://mochajs.org/api/mocha#bail
*/
bail(bail?: boolean): this;
/**
* Add test `file`.
*
* @see https://mochajs.org/api/mocha#addFile
*/
addFile(file: string): this;
/**
* Set reporter to one of the built-in reporters.
*
* @see https://mochajs.org/api/mocha#reporter
*/
reporter(reporter: Mocha.Reporter, reporterOptions?: any): this;
/**
* Set reporter to the provided constructor, one of the built-in reporters, or loads a reporter
* from a module path. Defaults to `"spec"`.
*
* @see https://mochajs.org/api/mocha#reporter
*/
reporter(reporter?: string | Mocha.ReporterConstructor, reporterOptions?: any): this;
/**
* Set test UI to one of the built-in test interfaces.
*
* @see https://mochajs.org/api/mocha#ui
*/
ui(name: Mocha.Interface): this;
/**
* Set test UI to one of the built-in test interfaces or loads a test interface from a module
* path. Defaults to `"bdd"`.
*
* @see https://mochajs.org/api/mocha#ui
*/
ui(name?: string): this;
/**
* Escape string and add it to grep as a RegExp.
*
* @see https://mochajs.org/api/mocha#fgrep
*/
fgrep(str: string): this;
/**
* Add regexp to grep, if `re` is a string it is escaped.
*
* @see https://mochajs.org/api/mocha#grep
*/
grep(re: string | RegExp): this;
/**
* Invert `.grep()` matches.
*
* @see https://mochajs.org/api/mocha#invert
*/
invert(): this;
/**
* Enable global leak checking.
*
* @see https://mochajs.org/api/mocha#checkLeaks
*/
checkLeaks(): this;
/**
* Display long stack-trace on failing
*
* @see https://mochajs.org/api/mocha#fullTrace
*/
fullTrace(): this;
/**
* Enable growl support.
*
* @see https://mochajs.org/api/mocha#growl
*/
growl(): this;
/**
* Ignore `globals` array or string.
*
* @see https://mochajs.org/api/mocha#globals
*/
globals(globals: string | ReadonlyArray<string>): this;
/**
* Set the timeout in milliseconds.
*
* @see https://mochajs.org/api/mocha#timeout
*/
timeout(timeout: string | number): this;
/**
* Set the number of times to retry failed tests.
*
* @see https://mochajs.org/api/mocha#retries
*/
retries(n: number): this;
/**
* Set slowness threshold in milliseconds.
*
* @see https://mochajs.org/api/mocha#slow
*/
slow(slow: string | number): this;
/**
* Makes all tests async (accepting a callback)
*
* @see https://mochajs.org/api/mocha#asyncOnly.
*/
asyncOnly(): this;
/**
* Disable syntax highlighting (in browser).
*
* @see https://mochajs.org/api/mocha#noHighlighting
*/
noHighlighting(): this;
/**
* Enable uncaught errors to propagate (in browser).
*
* @see https://mochajs.org/api/mocha#allowUncaught
*/
allowUncaught(): boolean;
/**
* Delay root suite execution.
*
* @see https://mochajs.org/api/mocha#delay
*/
delay(): boolean;
/**
* Tests marked only fail the suite
*
* @see https://mochajs.org/api/mocha#forbidOnly
*/
forbidOnly(): boolean;
/**
* Pending tests and tests marked skip fail the suite
*
* @see https://mochajs.org/api/mocha#forbidPending
*/
forbidPending(): boolean;
/**
* Run tests and invoke `fn()` when complete.
*
* Note that `run` relies on Node's `require` to execute
* the test interface functions and will be subject to the
* cache - if the files are already in the `require` cache,
* they will effectively be skipped. Therefore, to run tests
* multiple times or to run tests in files that are already
* in the `require` cache, make sure to clear them from the
* cache first in whichever manner best suits your needs.
*
* @see https://mochajs.org/api/mocha#run
*/
run(fn?: (failures: number) => void): Mocha.Runner;
/**
* Loads ESM (and CJS) test files asynchronously.
*
* @see https://mochajs.org/api/mocha#loadFilesAsync
*/
loadFilesAsync(): Promise<void>;
/**
* Load registered files.
*
* @see https://mochajs.org/api/mocha#loadFiles
*/
protected loadFiles(fn?: () => void): void;
/**
* Unloads `files` from Node's `require` cache.
*
* This allows required files to be "freshly" reloaded, providing the ability
* to reuse a Mocha instance programmatically.
* Note: does not clear ESM module files from the cache
*/
unloadFiles(): this;
/**
* Toggles parallel mode.
*
* Must be run before calling `run`. Changes the `Runner` class to
* use; also enables lazy file loading if not already done so.
*
* @see https://mochajs.org/api/mocha#parallelMode
*/
parallelMode(enabled?: boolean): this;
/**
* Assigns hooks to the root suite.
*
* @see https://mochajs.org/api/mocha#rootHooks
*/
rootHooks(hooks: Mocha.RootHookObject): this;
}
declare namespace Mocha {
namespace utils {
/**
* Compute a slug from the given `str`.
*
* @see https://mochajs.org/api/module-utils.html#.slug
*/
function slug(str: string): string;
/**
* Strip the function definition from `str`, and re-indent for pre whitespace.
*
* @see https://mochajs.org/api/module-utils.html#.clean
*/
function clean(str: string): string;
/**
* Highlight the given string of `js`.
*/
function highlight(js: string): string;
/**
* Takes some variable and asks `Object.prototype.toString()` what it thinks it is.
*/
function type(value: any): string;
/**
* Stringify `value`. Different behavior depending on type of value:
*
* - If `value` is undefined or null, return `'[undefined]'` or `'[null]'`, respectively.
* - If `value` is not an object, function or array, return result of `value.toString()` wrapped in double-quotes.
* - If `value` is an *empty* object, function, or array, returns `'{}'`, `'[Function]'`, or `'[]'` respectively.
* - If `value` has properties, call canonicalize} on it, then return result of `JSON.stringify()`
*
* @see https://mochajs.org/api/module-utils.html#.stringify
*/
function stringify(value: any): string;
/**
* Return a new Thing that has the keys in sorted order. Recursive.
*
* If the Thing...
* - has already been seen, return string `'[Circular]'`
* - is `undefined`, return string `'[undefined]'`
* - is `null`, return value `null`
* - is some other primitive, return the value
* - is not a primitive or an `Array`, `Object`, or `Function`, return the value of the Thing's `toString()` method
* - is a non-empty `Array`, `Object`, or `Function`, return the result of calling this function again.
* - is an empty `Array`, `Object`, or `Function`, returns `'[]'`, `'{}'`, or `'[Function]'` respectively.
*
* @see https://mochajs.org/api/module-utils.html#.canonicalize
*/
function canonicalize(value: any, stack: any[], typeHint: string): any;
/**
* Lookup file names at the given `path`.
*
* @see https://mochajs.org/api/Mocha.utils.html#.exports.lookupFiles
*/
function lookupFiles(filepath: string, extensions?: string[], recursive?: boolean): string[];
/**
* Generate an undefined error with a message warning the user.
*
* @see https://mochajs.org/api/module-utils.html#.undefinedError
*/
function undefinedError(): Error;
/**
* Generate an undefined error if `err` is not defined.
*
* @see https://mochajs.org/api/module-utils.html#.getError
*/
function getError(err: Error | undefined): Error;
/**
* When invoking this function you get a filter function that get the Error.stack as an
* input, and return a prettify output. (i.e: strip Mocha and internal node functions from
* stack trace).
*
* @see https://mochajs.org/api/module-utils.html#.stackTraceFilter
*/
function stackTraceFilter(): (stack: string) => string;
}
namespace interfaces {
function bdd(suite: Suite): void;
function tdd(suite: Suite): void;
function qunit(suite: Suite): void;
function exports(suite: Suite): void;
}
// #region Test interface augmentations
interface HookFunction {
/**
* [bdd, qunit, tdd] Describe a "hook" to execute the given callback `fn`. The name of the
* function is used as the name of the hook.
*
* - _Only available when invoked via the mocha CLI._
*/
(fn: Func): void;
/**
* [bdd, qunit, tdd] Describe a "hook" to execute the given callback `fn`. The name of the
* function is used as the name of the hook.
*
* - _Only available when invoked via the mocha CLI._
*/
(fn: AsyncFunc): void;
/**
* [bdd, qunit, tdd] Describe a "hook" to execute the given `title` and callback `fn`.
*
* - _Only available when invoked via the mocha CLI._
*/
(name: string, fn?: Func): void;
/**
* [bdd, qunit, tdd] Describe a "hook" to execute the given `title` and callback `fn`.
*
* - _Only available when invoked via the mocha CLI._
*/
(name: string, fn?: AsyncFunc): void;
}
interface SuiteFunction {
/**
* [bdd, tdd] Describe a "suite" with the given `title` and callback `fn` containing
* nested suites.
*
* - _Only available when invoked via the mocha CLI._
*/
(title: string, fn: (this: Suite) => void): Suite;
/**
* [qunit] Describe a "suite" with the given `title`.
*
* - _Only available when invoked via the mocha CLI._
*/
(title: string): Suite;
/**
* [bdd, tdd, qunit] Indicates this suite should be executed exclusively.
*
* - _Only available when invoked via the mocha CLI._
*/
only: ExclusiveSuiteFunction;
/**
* [bdd, tdd] Indicates this suite should not be executed.
*
* - _Only available when invoked via the mocha CLI._
*/
skip: PendingSuiteFunction;
}
interface ExclusiveSuiteFunction {
/**
* [bdd, tdd] Describe a "suite" with the given `title` and callback `fn` containing
* nested suites. Indicates this suite should be executed exclusively.
*
* - _Only available when invoked via the mocha CLI._
*/
(title: string, fn: (this: Suite) => void): Suite;
/**
* [qunit] Describe a "suite" with the given `title`. Indicates this suite should be executed
* exclusively.
*
* - _Only available when invoked via the mocha CLI._
*/
(title: string): Suite;
}
/**
* [bdd, tdd] Describe a "suite" with the given `title` and callback `fn` containing
* nested suites. Indicates this suite should not be executed.
*
* - _Only available when invoked via the mocha CLI._
*
* @returns [bdd] `Suite`
* @returns [tdd] `void`
*/
interface PendingSuiteFunction {
(title: string, fn: (this: Suite) => void): Suite | void;
}
interface TestFunction {
/**
* Describe a specification or test-case with the given callback `fn` acting as a thunk.
* The name of the function is used as the name of the test.
*
* - _Only available when invoked via the mocha CLI._
*/
(fn: Func): Test;
/**
* Describe a specification or test-case with the given callback `fn` acting as a thunk.
* The name of the function is used as the name of the test.
*
* - _Only available when invoked via the mocha CLI._
*/
(fn: AsyncFunc): Test;
/**
* Describe a specification or test-case with the given `title` and callback `fn` acting
* as a thunk.
*
* - _Only available when invoked via the mocha CLI._
*/
(title: string, fn?: Func): Test;
/**
* Describe a specification or test-case with the given `title` and callback `fn` acting
* as a thunk.
*
* - _Only available when invoked via the mocha CLI._
*/
(title: string, fn?: AsyncFunc): Test;
/**
* Indicates this test should be executed exclusively.
*
* - _Only available when invoked via the mocha CLI._
*/
only: ExclusiveTestFunction;
/**
* Indicates this test should not be executed.
*
* - _Only available when invoked via the mocha CLI._
*/
skip: PendingTestFunction;
/**
* Number of attempts to retry.
*
* - _Only available when invoked via the mocha CLI._
*/
retries(n: number): void;
}
interface ExclusiveTestFunction {
/**
* [bdd, tdd, qunit] Describe a specification or test-case with the given callback `fn`
* acting as a thunk. The name of the function is used as the name of the test. Indicates
* this test should be executed exclusively.
*
* - _Only available when invoked via the mocha CLI._
*/
(fn: Func): Test;
/**
* [bdd, tdd, qunit] Describe a specification or test-case with the given callback `fn`
* acting as a thunk. The name of the function is used as the name of the test. Indicates
* this test should be executed exclusively.
*
* - _Only available when invoked via the mocha CLI._
*/
(fn: AsyncFunc): Test;
/**
* [bdd, tdd, qunit] Describe a specification or test-case with the given `title` and
* callback `fn` acting as a thunk. Indicates this test should be executed exclusively.
*
* - _Only available when invoked via the mocha CLI._
*/
(title: string, fn?: Func): Test;
/**
* [bdd, tdd, qunit] Describe a specification or test-case with the given `title` and
* callback `fn` acting as a thunk. Indicates this test should be executed exclusively.
*
* - _Only available when invoked via the mocha CLI._
*/
(title: string, fn?: AsyncFunc): Test;
}
interface PendingTestFunction {
/**
* [bdd, tdd, qunit] Describe a specification or test-case with the given callback `fn`
* acting as a thunk. The name of the function is used as the name of the test. Indicates
* this test should not be executed.
*
* - _Only available when invoked via the mocha CLI._
*/
(fn: Func): Test;
/**
* [bdd, tdd, qunit] Describe a specification or test-case with the given callback `fn`
* acting as a thunk. The name of the function is used as the name of the test. Indicates
* this test should not be executed.
*
* - _Only available when invoked via the mocha CLI._
*/
(fn: AsyncFunc): Test;
/**
* [bdd, tdd, qunit] Describe a specification or test-case with the given `title` and
* callback `fn` acting as a thunk. Indicates this test should not be executed.
*
* - _Only available when invoked via the mocha CLI._
*/
(title: string, fn?: Func): Test;
/**
* [bdd, tdd, qunit] Describe a specification or test-case with the given `title` and
* callback `fn` acting as a thunk. Indicates this test should not be executed.
*
* - _Only available when invoked via the mocha CLI._
*/
(title: string, fn?: AsyncFunc): Test;
}
/**
* Execute after each test case.
*
* - _Only available when invoked via the mocha CLI._
*
* @see https://mochajs.org/api/global.html#afterEach
*/
let afterEach: HookFunction;
/**
* Execute after running tests.
*
* - _Only available when invoked via the mocha CLI._
*
* @see https://mochajs.org/api/global.html#after
*/
let after: HookFunction;
/**
* Execute before each test case.
*
* - _Only available when invoked via the mocha CLI._
*
* @see https://mochajs.org/api/global.html#beforeEach
*/
let beforeEach: HookFunction;
/**
* Execute before running tests.
*
* - _Only available when invoked via the mocha CLI._
*
* @see https://mochajs.org/api/global.html#before
*/
let before: HookFunction;
/**
* Describe a "suite" containing nested suites and tests.
*
* - _Only available when invoked via the mocha CLI._
*/
let describe: SuiteFunction;
/**
* Describes a test case.
*
* - _Only available when invoked via the mocha CLI._
*/
let it: TestFunction;
/**
* Describes a pending test case.
*
* - _Only available when invoked via the mocha CLI._
*/
let xit: PendingTestFunction;
/**
* Execute before each test case.
*
* - _Only available when invoked via the mocha CLI._
*
* @see https://mochajs.org/api/global.html#beforeEach
*/
let setup: HookFunction;
/**
* Execute before running tests.
*
* - _Only available when invoked via the mocha CLI._
*
* @see https://mochajs.org/api/global.html#before
*/
let suiteSetup: HookFunction;
/**
* Execute after running tests.
*
* - _Only available when invoked via the mocha CLI._
*
* @see https://mochajs.org/api/global.html#after
*/
let suiteTeardown: HookFunction;
/**
* Describe a "suite" containing nested suites and tests.
*
* - _Only available when invoked via the mocha CLI._
*/
let suite: SuiteFunction;
/**
* Execute after each test case.
*
* - _Only available when invoked via the mocha CLI._
*
* @see https://mochajs.org/api/global.html#afterEach
*/
let teardown: HookFunction;
/**
* Describes a test case.
*
* - _Only available when invoked via the mocha CLI._
*/
let test: TestFunction;
/**
* Triggers root suite execution.
*
* - _Only available if flag --delay is passed into Mocha._
* - _Only available when invoked via the mocha CLI._
*
* @see https://mochajs.org/api/global.html#runWithSuite
*/
function run(): void;
// #endregion Test interface augmentations
namespace reporters {
/**
* Initialize a new `Base` reporter.
*
* All other reporters generally inherit from this reporter, providing stats such as test duration,
* number of tests passed / failed, etc.
*
* @see https://mochajs.org/api/Mocha.reporters.Base.html
*/
class Base {
constructor(runner: Runner, options?: MochaOptions);
/**
* Test run statistics
*/
stats: Stats;
/**
* Test failures
*/
failures: Test[];
/**
* The configured runner
*/
runner: Runner;
/**
* Output common epilogue used by many of the bundled reporters.
*
* @see https://mochajs.org/api/Mocha.reporters.Base.html#.Base#epilogue
*/
epilogue(): void;
done?(failures: number, fn?: (failures: number) => void): void;
}
namespace Base {
/**
* Enables coloring by default
*
* @see https://mochajs.org/api/module-base#.useColors
*/
let useColors: boolean;
/**
* Inline diffs instead of +/-
*
* @see https://mochajs.org/api/module-base#.inlineDiffs
*/
let inlineDiffs: boolean;
/**
* Default color map
*
* @see https://mochajs.org/api/module-base#.colors
*/
const colors: ColorMap;
/**
* Default color map
*
* @see https://mochajs.org/api/module-base#.colors
*/
interface ColorMap {
// added by Base
pass: number;
fail: number;
"bright pass": number;
"bright fail": number;
"bright yellow": number;
pending: number;
suite: number;
"error title": number;
"error message": number;
"error stack": number;
checkmark: number;
fast: number;
medium: number;
slow: number;
green: number;
light: number;
"diff gutter": number;
"diff added": number;
"diff removed": number;
// added by Progress
progress: number;
// added by Landing
plane: number;
"plane crash": number;
runway: number;
[key: string]: number;
}
/**
* Default symbol map
*
* @see https://mochajs.org/api/module-base#.symbols
*/
const symbols: SymbolMap;
/**
* Default symbol map
*
* @see https://mochajs.org/api/module-base#.symbols
*/
interface SymbolMap {
ok: string;
err: string;
dot: string;
comma: string;
bang: string;
[key: string]: string;
}
/**
* Color `str` with the given `type` (from `colors`)
*
* @see https://mochajs.org/api/module-base#.color
*/
function color(type: string, str: string): string;
/**
* Expose terminal window size
*
* @see https://mochajs.org/api/module-base#.window
*/
const window: {
width: number;
};
/**
* ANSI TTY control sequences common among reporters.
*
* @see https://mochajs.org/api/module-base#.cursor
*/
namespace cursor {
/**
* Hides the cursor
*/
function hide(): void;
/**
* Shows the cursor
*/
function show(): void;
/**
* Deletes the current line
*/
function deleteLine(): void;
/**
* Moves to the beginning of the line
*/
function beginningOfLine(): void;
/**
* Clears the line and moves to the beginning of the line.
*/
function CR(): void;
}
/**
* Returns a diff between two strings with colored ANSI output.
*
* @see https://mochajs.org/api/module-base#.generateDiff
*/
function generateDiff(actual: string, expected: string): string;
/**
* Output the given `failures` as a list.
*
* @see https://mochajs.org/api/Mocha.reporters.Base.html#.exports.list1
*/
function list(failures: Test[]): void;
}
/**
* Initialize a new `Dot` matrix test reporter.
*
* @see https://mochajs.org/api/Mocha.reporters.Dot.html
*/
class Dot extends Base {
}
/**
* Initialize a new `Doc` reporter.
*
* @see https://mochajs.org/api/Mocha.reporters.Doc.html
*/
class Doc extends Base {
}
/**
* Initialize a new `TAP` test reporter.
*
* @see https://mochajs.org/api/Mocha.reporters.TAP.html
*/
class TAP extends Base {
}
/**
* Initialize a new `JSON` reporter
*
* @see https://mochajs.org/api/Mocha.reporters.JSON.html
*/
class JSON extends Base {
}
/**
* Initialize a new `HTML` reporter.
*
* - _This reporter cannot be used on the console._
*
* @see https://mochajs.org/api/Mocha.reporters.HTML.html
*/
class HTML extends Base {
/**
* Provide suite URL.
*
* @see https://mochajs.org/api/Mocha.reporters.HTML.html#suiteURL
*/
suiteURL(suite: Suite): string;
/**
* Provide test URL.
*
* @see https://mochajs.org/api/Mocha.reporters.HTML.html#testURL
*/
testURL(test: Test): string;
/**
* Adds code toggle functionality for the provided test's list element.
*
* @see https://mochajs.org/api/Mocha.reporters.HTML.html#addCodeToggle
*/
addCodeToggle(el: HTMLLIElement, contents: string): void;
}
/**
* Initialize a new `List` test reporter.
*
* @see https://mochajs.org/api/Mocha.reporters.List.html
*/
class List extends Base {
}
/**
* Initialize a new `Min` minimal test reporter (best used with --watch).
*
* @see https://mochajs.org/api/Mocha.reporters.Min.html
*/
class Min extends Base {
}
/**
* Initialize a new `Spec` test reporter.
*
* @see https://mochajs.org/api/Mocha.reporters.Spec.html
*/
class Spec extends Base {
}
/**
* Initialize a new `NyanCat` test reporter.
*
* @see https://mochajs.org/api/Mocha.reporters.Nyan.html
*/
class Nyan extends Base {
private colorIndex;
private numberOfLines;
private rainbowColors;
private scoreboardWidth;
private tick;
private trajectories;
private trajectoryWidthMax;
private draw;
private drawScoreboard;
private appendRainbow;
private drawRainbow;
private drawNyanCat;
private face;
private cursorUp;
private cursorDown;
private generateColors;
private rainbowify;
}
/**
* Initialize a new `XUnit` test reporter.
*
* @see https://mochajs.org/api/Mocha.reporters.XUnit.html
*/
class XUnit extends Base {
constructor(runner: Runner, options?: XUnit.MochaOptions);
/**
* Override done to close the stream (if it's a file).
*
* @see https://mochajs.org/api/Mocha.reporters.XUnit.html#done
*/
done(failures: number, fn: (failures: number) => void): void;
/**
* Write out the given line.
*
* @see https://mochajs.org/api/Mocha.reporters.XUnit.html#write
*/
write(line: string): void;
/**
* Output tag for the given `test.`
*
* @see https://mochajs.org/api/Mocha.reporters.XUnit.html#test
*/
test(test: Test): void;
}
namespace XUnit {
interface MochaOptions extends Mocha.MochaOptions {
reporterOptions?: ReporterOptions;
}
interface ReporterOptions {
output?: string;
suiteName?: string;
}
}
/**
* Initialize a new `Markdown` test reporter.
*
* @see https://mochajs.org/api/Mocha.reporters.Markdown.html
*/
class Markdown extends Base {
}
/**
* Initialize a new `Progress` bar test reporter.
*
* @see https://mochajs.org/api/Mocha.reporters.Progress.html
*/
class Progress extends Base {
constructor(runner: Runner, options?: Progress.MochaOptions);
}
namespace Progress {
interface MochaOptions extends Mocha.MochaOptions {
reporterOptions?: ReporterOptions;
}
interface ReporterOptions {
open?: string;
complete?: string;
incomplete?: string;
close?: string;
verbose?: boolean;
}
}
/**
* Initialize a new `Landing` reporter.
*
* @see https://mochajs.org/api/Mocha.reporters.Landing.html
*/
class Landing extends Base {
}
/**
* Initialize a new `JSONStream` test reporter.
*
* @see https://mochajs.org/api/Mocha.reporters.JSONStream.html
*/
class JSONStream extends Base {
}
// value-only aliases
const base: typeof Base;
const dot: typeof Dot;
const doc: typeof Doc;
const tap: typeof TAP;
const json: typeof JSON;
const html: typeof HTML;
const list: typeof List;
const spec: typeof Spec;
const nyan: typeof Nyan;
const xunit: typeof XUnit;
const markdown: typeof Markdown;
const progress: typeof Progress;
const landing: typeof Landing;
// NOTE: not possible to type this correctly:
// const "json-stream": typeof JSONStream;
}
/**
* Initialize a new `Runnable` with the given `title` and callback `fn`.
*
* @see https://mochajs.org/api/Runnable.html
*/
class Runnable {
private _slow;
private _retries;
private _currentRetry;
private _timeout;
private _timeoutError;
constructor(title: string, fn?: Func | AsyncFunc);
title: string;
fn: Func | AsyncFunc | undefined;
body: string;
async: boolean;
sync: boolean;
timedOut: boolean;
pending: boolean;
duration?: number;
parent?: Suite;
state?: "failed" | "passed";
timer?: any;
ctx?: Context;
callback?: Done;
allowUncaught?: boolean;
file?: string;
/**
* Get test timeout.
*
* @see https://mochajs.org/api/Runnable.html#timeout
*/
timeout(): number;
/**
* Set test timeout.
*
* @see https://mochajs.org/api/Runnable.html#timeout
*/
timeout(ms: string | number): this;
/**
* Get test slowness threshold.
*
* @see https://mochajs.org/api/Runnable.html#slow
*/
slow(): number;
/**
* Set test slowness threshold.
*
* @see https://mochajs.org/api/Runnable.html#slow
*/
slow(ms: string | number): this;
/**
* Halt and mark as pending.
*/
skip(): never;
/**
* Check if this runnable or its parent suite is marked as pending.
*
* @see https://mochajs.org/api/Runnable.html#isPending
*/
isPending(): boolean;
/**
* Return `true` if this Runnable has failed.
*/
isFailed(): boolean;
/**
* Return `true` if this Runnable has passed.
*/
isPassed(): boolean;
/**
* Set or get number of retries.
*
* @see https://mochajs.org/api/Runnable.html#retries
*/
retries(): number;
/**
* Set or get number of retries.
*
* @see https://mochajs.org/api/Runnable.html#retries
*/
retries(n: number): void;
/**
* Set or get current retry
*
* @see https://mochajs.org/api/Runnable.html#currentRetry
*/
protected currentRetry(): number;
/**
* Set or get current retry
*
* @see https://mochajs.org/api/Runnable.html#currentRetry
*/
protected currentRetry(n: number): void;
/**
* Return the full title generated by recursively concatenating the parent's full title.
*/
fullTitle(): string;
/**
* Return the title path generated by concatenating the parent's title path with the title.
*/
titlePath(): string[];
/**
* Clear the timeout.
*
* @see https://mochajs.org/api/Runnable.html#clearTimeout
*/
clearTimeout(): void;
/**
* Inspect the runnable void of private properties.
*
* @see https://mochajs.org/api/Runnable.html#inspect
*/
inspect(): string;
/**
* Reset the timeout.
*
* @see https://mochajs.org/api/Runnable.html#resetTimeout
*/
resetTimeout(): void;
/**
* Get a list of whitelisted globals for this test run.
*
* @see https://mochajs.org/api/Runnable.html#globals
*/
globals(): string[];
/**
* Set a list of whitelisted globals for this test run.
*
* @see https://mochajs.org/api/Runnable.html#globals
*/
globals(globals: ReadonlyArray<string>): void;
/**
* Run the test and invoke `fn(err)`.
*
* @see https://mochajs.org/api/Runnable.html#run
*/
run(fn: Done): void;
}
// #region Runnable "error" event
interface Runnable extends NodeJS.EventEmitter {
on(event: "error", listener: (error: any) => void): this;
once(event: "error", listener: (error: any) => void): this;
addListener(event: "error", listener: (error: any) => void): this;
removeListener(event: "error", listener: (error: any) => void): this;
prependListener(event: "error", listener: (error: any) => void): this;
prependOnceListener(event: "error", listener: (error: any) => void): this;
emit(name: "error", error: any): boolean;
}
// #endregion Runnable "error" event
// #region Runnable untyped events
interface Runnable extends NodeJS.EventEmitter {
on(event: string, listener: (...args: any[]) => void): this;
once(event: string, listener: (...args: any[]) => void): this;
addListener(event: string, listener: (...args: any[]) => void): this;
removeListener(event: string, listener: (...args: any[]) => void): this;
prependListener(event: string, listener: (...args: any[]) => void): this;
prependOnceListener(event: string, listener: (...args: any[]) => void): this;
emit(name: string, ...args: any[]): boolean;
}
// #endregion Runnable untyped events
/**
* Test context
*
* @see https://mochajs.org/api/module-Context.html#~Context
*/
class Context {
private _runnable;
test?: Runnable;
currentTest?: Test;
/**
* Get the context `Runnable`.
*/
runnable(): Runnable;
/**
* Set the context `Runnable`.
*/
runnable(runnable: Runnable): this;
/**
* Get test timeout.
*/
timeout(): number;
/**
* Set test timeout.
*/
timeout(ms: string | number): this;
/**
* Get test slowness threshold.
*/
slow(): number;
/**
* Set test slowness threshold.
*/
slow(ms: string | number): this;
/**
* Mark a test as skipped.
*/
skip(): never;
/**
* Get the number of allowed retries on failed tests.
*/
retries(): number;
/**
* Set the number of allowed retries on failed tests.
*/
retries(n: number): this;
[key: string]: any;
}
interface RunnerConstants {
readonly EVENT_HOOK_BEGIN: 'hook';
readonly EVENT_HOOK_END: 'hook end';
readonly EVENT_RUN_BEGIN: 'start';
readonly EVENT_DELAY_BEGIN: 'waiting';
readonly EVENT_DELAY_END: 'ready';
readonly EVENT_RUN_END: 'end';
readonly EVENT_SUITE_BEGIN: 'suite';
readonly EVENT_SUITE_END: 'suite end';
readonly EVENT_TEST_BEGIN: 'test';
readonly EVENT_TEST_END: 'test end';
readonly EVENT_TEST_FAIL: 'fail';
readonly EVENT_TEST_PASS: 'pass';
readonly EVENT_TEST_PENDING: 'pending';
readonly EVENT_TEST_RETRY: 'retry';
}
/**
* Initialize a `Runner` for the given `suite`.
*
* @see https://mochajs.org/api/Mocha.Runner.html
*/
class Runner {
private _globals;
private _abort;
private _delay;
private _defaultGrep;
private next;
private hookErr;
private prevGlobalsLength;
private nextSuite;
static readonly constants: RunnerConstants;
constructor(suite: Suite, delay: boolean);
suite: Suite;
started: boolean;
total: number;
failures: number;
asyncOnly?: boolean;
allowUncaught?: boolean;
fullStackTrace?: boolean;
forbidOnly?: boolean;
forbidPending?: boolean;
checkLeaks?: boolean;
test?: Test;
currentRunnable?: Runnable;
stats?: Stats; // added by reporters
/**
* Run tests with full titles matching `re`. Updates runner.total
* with number of tests matched.
*
* @see https://mochajs.org/api/Mocha.Runner.html#.Runner#grep
*/
grep(re: RegExp, invert: boolean): this;
/**
* Returns the number of tests matching the grep search for the
* given suite.
*
* @see https://mochajs.org/api/Mocha.Runner.html#.Runner#grepTotal
*/
grepTotal(suite: Suite): number;
/**
* Gets the allowed globals.
*
* @see https://mochajs.org/api/Mocha.Runner.html#.Runner#globals
*/
globals(): string[];
/**
* Allow the given `arr` of globals.
*
* @see https://mochajs.org/api/Mocha.Runner.html#.Runner#globals
*/
globals(arr: ReadonlyArray<string>): this;
/**
* Run the root suite and invoke `fn(failures)` on completion.
*
* @see https://mochajs.org/api/Mocha.Runner.html#.Runner#run
*/
run(fn?: (failures: number) => void): this;
/**
* Cleanly abort execution.
*
* @see https://mochajs.org/api/Mocha.Runner.html#.Runner#abort
*/
abort(): this;
/**
* Handle uncaught exceptions.
*
* @see https://mochajs.org/api/Mocha.Runner.html#uncaught
*/
uncaught(err: any): void;
/**
* Wrapper for setImmediate, process.nextTick, or browser polyfill.
*/
protected static immediately(callback: Function): void;
/**
* Return a list of global properties.
*
* @see https://mochajs.org/api/Mocha.Runner.html#globalProps
*/
protected globalProps(): string[];
/**
* Check for global variable leaks.
*
* @see https://mochajs.org/api/Mocha.Runner.html#checkGlobals
*/
protected checkGlobals(test: Test): void;
/**
* Fail the given `test`.
*
* @see https://mochajs.org/api/Mocha.Runner.html#fail
*/
protected fail(test: Test, err: any): void;
/**
* Fail the given `hook` with `err`.
*
* Hook failures work in the following pattern:
* - If bail, then exit
* - Failed `before` hook skips all tests in a suite and subsuites,
* but jumps to corresponding `after` hook
* - Failed `before each` hook skips remaining tests in a
* suite and jumps to corresponding `after each` hook,
* which is run only once
* - Failed `after` hook does not alter
* execution order
* - Failed `after each` hook skips remaining tests in a
* suite and subsuites, but executes other `after each`
* hooks
*
* @see https://mochajs.org/api/Mocha.Runner.html#failHook
*/
protected failHook(hook: Hook, err: any): void;
/**
* Run hook `name` callbacks and then invoke `fn()`.
*
* @see https://mochajs.org/api/Mocha.Runner.html#hook
*/
protected hook(name: string, fn: () => void): void;
/**
* Run hook `name` for the given array of `suites`
* in order, and callback `fn(err, errSuite)`.
*
* @see https://mochajs.org/api/Mocha.Runner.html#hooks
*/
protected hooks(name: string, suites: Suite[], fn: (err?: any, errSuite?: Suite) => void): void;
/**
* Run hooks from the top level down.
*
* @see https://mochajs.org/api/Mocha.Runner.html#hookUp
*/
protected hookUp(name: string, fn: (err?: any, errSuite?: Suite) => void): void;
/**
* Run hooks from the bottom up.
*
* @see https://mochajs.org/api/Mocha.Runner.html#hookDown
*/
protected hookDown(name: string, fn: (err?: any, errSuite?: Suite) => void): void;
/**
* Return an array of parent Suites from closest to furthest.
*
* @see https://mochajs.org/api/Mocha.Runner.html#parents
*/
protected parents(): Suite[];
/**
* Run the current test and callback `fn(err)`.
*
* @see https://mochajs.org/api/Mocha.Runner.html#runTest
*/
protected runTest(fn: Done): any;
/**
* Run tests in the given `suite` and invoke the callback `fn()` when complete.
*
* @see https://mochajs.org/api/Mocha.Runner.html#runTests
*/
protected runTests(suite: Suite, fn: (errSuite?: Suite) => void): void;
/**
* Run the given `suite` and invoke the callback `fn()` when complete.
*
* @see https://mochajs.org/api/Mocha.Runner.html#runSuite
*/
protected runSuite(suite: Suite, fn: (errSuite?: Suite) => void): void;
}
// #region Runner "waiting" event
interface Runner {
on(event: "waiting", listener: (rootSuite: Suite) => void): this;
once(event: "waiting", listener: (rootSuite: Suite) => void): this;
addListener(event: "waiting", listener: (rootSuite: Suite) => void): this;
removeListener(event: "waiting", listener: (rootSuite: Suite) => void): this;
prependListener(event: "waiting", listener: (rootSuite: Suite) => void): this;
prependOnceListener(event: "waiting", listener: (rootSuite: Suite) => void): this;
emit(name: "waiting", rootSuite: Suite): boolean;
}
// #endregion Runner "waiting" event
// #region Runner "start" event
interface Runner extends NodeJS.EventEmitter {
on(event: "start", listener: () => void): this;
once(event: "start", listener: () => void): this;
addListener(event: "start", listener: () => void): this;
removeListener(event: "start", listener: () => void): this;
prependListener(event: "start", listener: () => void): this;
prependOnceListener(event: "start", listener: () => void): this;
emit(name: "start"): boolean;
}
// #endregion Runner "start" event
// #region Runner "end" event
interface Runner extends NodeJS.EventEmitter {
on(event: "end", listener: () => void): this;
once(event: "end", listener: () => void): this;
addListener(event: "end", listener: () => void): this;
removeListener(event: "end", listener: () => void): this;
prependListener(event: "end", listener: () => void): this;
prependOnceListener(event: "end", listener: () => void): this;
emit(name: "end"): boolean;
}
// #endregion Runner "end" event
// #region Runner "suite" event
interface Runner extends NodeJS.EventEmitter {
on(event: "suite", listener: (suite: Suite) => void): this;
once(event: "suite", listener: (suite: Suite) => void): this;
addListener(event: "suite", listener: (suite: Suite) => void): this;
removeListener(event: "suite", listener: (suite: Suite) => void): this;
prependListener(event: "suite", listener: (suite: Suite) => void): this;
prependOnceListener(event: "suite", listener: (suite: Suite) => void): this;
emit(name: "suite", suite: Suite): boolean;
}
// #endregion Runner "suite" event
// #region Runner "suite end" event
interface Runner extends NodeJS.EventEmitter {
on(event: "suite end", listener: (suite: Suite) => void): this;
once(event: "suite end", listener: (suite: Suite) => void): this;
addListener(event: "suite end", listener: (suite: Suite) => void): this;
removeListener(event: "suite end", listener: (suite: Suite) => void): this;
prependListener(event: "suite end", listener: (suite: Suite) => void): this;
prependOnceListener(event: "suite end", listener: (suite: Suite) => void): this;
emit(name: "suite end", suite: Suite): boolean;
}
// #endregion Runner "suite end" event
// #region Runner "test" event
interface Runner extends NodeJS.EventEmitter {
on(event: "test", listener: (test: Test) => void): this;
once(event: "test", listener: (test: Test) => void): this;
addListener(event: "test", listener: (test: Test) => void): this;
removeListener(event: "test", listener: (test: Test) => void): this;
prependListener(event: "test", listener: (test: Test) => void): this;
prependOnceListener(event: "test", listener: (test: Test) => void): this;
emit(name: "test", test: Test): boolean;
}
// #endregion Runner "test" event
// #region Runner "test end" event
interface Runner extends NodeJS.EventEmitter {
on(event: "test end", listener: (test: Test) => void): this;
once(event: "test end", listener: (test: Test) => void): this;
addListener(event: "test end", listener: (test: Test) => void): this;
removeListener(event: "test end", listener: (test: Test) => void): this;
prependListener(event: "test end", listener: (test: Test) => void): this;
prependOnceListener(event: "test end", listener: (test: Test) => void): this;
emit(name: "test end", test: Test): boolean;
}
// #endregion Runner "test end" event
// #region Runner "hook" event
interface Runner extends NodeJS.EventEmitter {
on(event: "hook", listener: (hook: Hook) => void): this;
once(event: "hook", listener: (hook: Hook) => void): this;
addListener(event: "hook", listener: (hook: Hook) => void): this;
removeListener(event: "hook", listener: (hook: Hook) => void): this;
prependListener(event: "hook", listener: (hook: Hook) => void): this;
prependOnceListener(event: "hook", listener: (hook: Hook) => void): this;
emit(name: "hook", hook: Hook): boolean;
}
// #endregion Runner "hook" event
// #region Runner "hook end" event
interface Runner extends NodeJS.EventEmitter {
on(event: "hook end", listener: (hook: Hook) => void): this;
once(event: "hook end", listener: (hook: Hook) => void): this;
addListener(event: "hook end", listener: (hook: Hook) => void): this;
removeListener(event: "hook end", list