// Type definitions for mocha 8.0 // Project: https://mochajs.org // Definitions by: Kazi Manzur Rashid // otiai10 // Vadim Macagon // Andrew Bradley // Dmitrii Sorin // 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): 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; /** * 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): 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): 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", listener: (hook: Hook) => void): this; prependListener(event: "hook end", listener: (hook: Hook) => void): this; prependOnceListener(event: "hook end", listener: (hook: Hook) => void): this; emit(name: "hook end", hook: Hook): boolean; } // #endregion Runner "hook end" event // #region Runner "pass" event interface Runner extends NodeJS.EventEmitter { on(event: "pass", listener: (test: Test) => void): this; once(event: "pass", listener: (test: Test) => void): this; addListener(event: "pass", listener: (test: Test) => void): this; removeListener(event: "pass", listener: (test: Test) => void): this; prependListener(event: "pass", listener: (test: Test) => void): this; prependOnceListener(event: "pass", listener: (test: Test) => void): this; emit(name: "pass", test: Test): boolean; } // #endregion Runner "pass" event // #region Runner "fail" event interface Runner extends NodeJS.EventEmitter { on(event: "fail", listener: (test: Test, err: any) => void): this; once(event: "fail", listener: (test: Test, err: any) => void): this; addListener(event: "fail", listener: (test: Test, err: any) => void): this; removeListener(event: "fail", listener: (test: Test, err: any) => void): this; prependListener(event: "fail", listener: (test: Test, err: any) => void): this; prependOnceListener(event: "fail", listener: (test: Test, err: any) => void): this; emit(name: "fail", test: Test, err: any): boolean; } // #endregion Runner "fail" event // #region Runner "pending" event interface Runner extends NodeJS.EventEmitter { on(event: "pending", listener: (test: Test) => void): this; once(event: "pending", listener: (test: Test) => void): this; addListener(event: "pending", listener: (test: Test) => void): this; removeListener(event: "pending", listener: (test: Test) => void): this; prependListener(event: "pending", listener: (test: Test) => void): this; prependOnceListener(event: "pending", listener: (test: Test) => void): this; emit(name: "pending", test: Test): boolean; } // #endregion Runner "pending" event // #region Runner untyped events interface Runner 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 Runner untyped events interface SuiteConstants { readonly EVENT_FILE_POST_REQUIRE: 'post-require'; readonly EVENT_FILE_PRE_REQUIRE: 'pre-require'; readonly EVENT_FILE_REQUIRE: 'require'; readonly EVENT_ROOT_SUITE_RUN: 'run'; readonly HOOK_TYPE_AFTER_ALL: 'afterAll'; readonly HOOK_TYPE_AFTER_EACH: 'afterEach'; readonly HOOK_TYPE_BEFORE_ALL: 'beforeAll'; readonly HOOK_TYPE_BEFORE_EACH: 'beforeEach'; readonly EVENT_SUITE_ADD_HOOK_AFTER_ALL: 'afterAll'; readonly EVENT_SUITE_ADD_HOOK_AFTER_EACH: 'afterEach'; readonly EVENT_SUITE_ADD_HOOK_BEFORE_ALL: 'beforeAll'; readonly EVENT_SUITE_ADD_HOOK_BEFORE_EACH: 'beforeEach'; readonly EVENT_SUITE_ADD_SUITE: 'suite'; readonly EVENT_SUITE_ADD_TEST: 'test'; } /** * Initialize a new `Suite` with the given `title` and `ctx`. * * @see https://mochajs.org/api/Mocha.Suite.html */ class Suite { private _beforeEach; private _beforeAll; private _afterEach; private _afterAll; private _timeout; private _slow; private _bail; private _retries; private _onlyTests; private _onlySuites; static readonly constants: SuiteConstants; constructor(title: string, parentContext?: Context); ctx: Context; suites: Suite[]; tests: Test[]; pending: boolean; file?: string; root: boolean; delayed: boolean; parent: Suite | undefined; title: string; /** * Create a new `Suite` with the given `title` and parent `Suite`. When a suite * with the same title is already present, that suite is returned to provide * nicer reporter and more flexible meta-testing. * * @see https://mochajs.org/api/mocha#.exports.create */ static create(parent: Suite, title: string): Suite; /** * Return a clone of this `Suite`. * * @see https://mochajs.org/api/Mocha.Suite.html#clone */ clone(): Suite; /** * Get timeout `ms`. * * @see https://mochajs.org/api/Mocha.Suite.html#timeout */ timeout(): number; /** * Set timeout `ms` or short-hand such as "2s". * * @see https://mochajs.org/api/Mocha.Suite.html#timeout */ timeout(ms: string | number): this; /** * Get number of times to retry a failed test. * * @see https://mochajs.org/api/Mocha.Suite.html#retries */ retries(): number; /** * Set number of times to retry a failed test. * * @see https://mochajs.org/api/Mocha.Suite.html#retries */ retries(n: string | number): this; /** * Get slow `ms`. * * @see https://mochajs.org/api/Mocha.Suite.html#slow */ slow(): number; /** * Set slow `ms` or short-hand such as "2s". * * @see https://mochajs.org/api/Mocha.Suite.html#slow */ slow(ms: string | number): this; /** * Get whether to bail after first error. * * @see https://mochajs.org/api/Mocha.Suite.html#bail */ bail(): boolean; /** * Set whether to bail after first error. * * @see https://mochajs.org/api/Mocha.Suite.html#bail */ bail(bail: boolean): this; /** * Check if this suite or its parent suite is marked as pending. * * @see https://mochajs.org/api/Mocha.Suite.html#isPending */ isPending(): boolean; /** * Run `fn(test[, done])` before running tests. * * @see https://mochajs.org/api/Mocha.Suite.html#beforeAll */ beforeAll(fn?: Func): this; /** * Run `fn(test[, done])` before running tests. * * @see https://mochajs.org/api/Mocha.Suite.html#beforeAll */ beforeAll(fn?: AsyncFunc): this; /** * Run `fn(test[, done])` before running tests. * * @see https://mochajs.org/api/Mocha.Suite.html#beforeAll */ beforeAll(title: string, fn?: Func): this; /** * Run `fn(test[, done])` before running tests. * * @see https://mochajs.org/api/Mocha.Suite.html#beforeAll */ beforeAll(title: string, fn?: AsyncFunc): this; /** * Run `fn(test[, done])` after running tests. * * @see https://mochajs.org/api/Mocha.Suite.html#afterAll */ afterAll(fn?: Func): this; /** * Run `fn(test[, done])` after running tests. * * @see https://mochajs.org/api/Mocha.Suite.html#afterAll */ afterAll(fn?: AsyncFunc): this; /** * Run `fn(test[, done])` after running tests. * * @see https://mochajs.org/api/Mocha.Suite.html#afterAll */ afterAll(title: string, fn?: Func): this; /** * Run `fn(test[, done])` after running tests. * * @see https://mochajs.org/api/Mocha.Suite.html#afterAll */ afterAll(title: string, fn?: AsyncFunc): this; /** * Run `fn(test[, done])` before each test case. * * @see https://mochajs.org/api/Mocha.Suite.html#beforeEach */ beforeEach(fn?: Func): this; /** * Run `fn(test[, done])` before each test case. * * @see https://mochajs.org/api/Mocha.Suite.html#beforeEach */ beforeEach(fn?: AsyncFunc): this; /** * Run `fn(test[, done])` before each test case. * * @see https://mochajs.org/api/Mocha.Suite.html#beforeEach */ beforeEach(title: string, fn?: Func): this; /** * Run `fn(test[, done])` before each test case. * * @see https://mochajs.org/api/Mocha.Suite.html#beforeEach */ beforeEach(title: string, fn?: AsyncFunc): this; /** * Run `fn(test[, done])` after each test case. * * @see https://mochajs.org/api/Mocha.Suite.html#afterEach */ afterEach(fn?: Func): this; /** * Run `fn(test[, done])` after each test case. * * @see https://mochajs.org/api/Mocha.Suite.html#afterEach */ afterEach(fn?: AsyncFunc): this; /** * Run `fn(test[, done])` after each test case. * * @see https://mochajs.org/api/Mocha.Suite.html#afterEach */ afterEach(title: string, fn?: Func): this; /** * Run `fn(test[, done])` after each test case. * * @see https://mochajs.org/api/Mocha.Suite.html#afterEach */ afterEach(title: string, fn?: AsyncFunc): this; /** * Add a test `suite`. * * @see https://mochajs.org/api/Mocha.Suite.html#addSuite */ addSuite(suite: Suite): this; /** * Add a `test` to this suite. * * @see https://mochajs.org/api/Mocha.Suite.html#addTest */ addTest(test: Test): this; /** * Return the full title generated by recursively concatenating the parent's * full title. * * @see https://mochajs.org/api/Mocha.Suite.html#.Suite#fullTitle */ fullTitle(): string; /** * Return the title path generated by recursively concatenating the parent's * title path. * * @see https://mochajs.org/api/Mocha.Suite.html#.Suite#titlePath */ titlePath(): string[]; /** * Return the total number of tests. * * @see https://mochajs.org/api/Mocha.Suite.html#.Suite#total */ total(): number; /** * Iterates through each suite recursively to find all tests. Applies a * function in the format `fn(test)`. * * @see https://mochajs.org/api/Mocha.Suite.html#eachTest */ eachTest(fn: (test: Test) => void): this; /** * This will run the root suite if we happen to be running in delayed mode. * * @see https://mochajs.org/api/Mocha.Suite.html#run */ run(): void; /** * Generic hook-creator. */ protected _createHook(title: string, fn?: Func | AsyncFunc): Hook; } // #region Suite "beforeAll" event interface Suite extends NodeJS.EventEmitter { on(event: "beforeAll", listener: (hook: Hook) => void): this; once(event: "beforeAll", listener: (hook: Hook) => void): this; addListener(event: "beforeAll", listener: (hook: Hook) => void): this; removeListener(event: "beforeAll", listener: (hook: Hook) => void): this; prependListener(event: "beforeAll", listener: (hook: Hook) => void): this; prependOnceListener(event: "beforeAll", listener: (hook: Hook) => void): this; emit(name: "beforeAll", hook: Hook): boolean; } // #endregion Suite "beforeAll" event // #region Suite "afterAll" event interface Suite extends NodeJS.EventEmitter { on(event: "afterAll", listener: (hook: Hook) => void): this; once(event: "afterAll", listener: (hook: Hook) => void): this; addListener(event: "afterAll", listener: (hook: Hook) => void): this; removeListener(event: "afterAll", listener: (hook: Hook) => void): this; prependListener(event: "afterAll", listener: (hook: Hook) => void): this; prependOnceListener(event: "afterAll", listener: (hook: Hook) => void): this; emit(name: "afterAll", hook: Hook): boolean; } // #endregion Suite "afterAll" event // #region Suite "beforeEach" event interface Suite extends NodeJS.EventEmitter { on(event: "beforeEach", listener: (hook: Hook) => void): this; once(event: "beforeEach", listener: (hook: Hook) => void): this; addListener(event: "beforeEach", listener: (hook: Hook) => void): this; removeListener(event: "beforeEach", listener: (hook: Hook) => void): this; prependListener(event: "beforeEach", listener: (hook: Hook) => void): this; prependOnceListener(event: "beforeEach", listener: (hook: Hook) => void): this; emit(name: "beforeEach", hook: Hook): boolean; } // #endregion Suite "beforeEach" event // #region Suite "afterEach" event interface Suite extends NodeJS.EventEmitter { on(event: "afterEach", listener: (hook: Hook) => void): this; once(event: "afterEach", listener: (hook: Hook) => void): this; addListener(event: "afterEach", listener: (hook: Hook) => void): this; removeListener(event: "afterEach", listener: (hook: Hook) => void): this; prependListener(event: "afterEach", listener: (hook: Hook) => void): this; prependOnceListener(event: "afterEach", listener: (hook: Hook) => void): this; emit(name: "afterEach", hook: Hook): boolean; } // #endregion Suite "afterEach" event // #region Suite "suite" event interface Suite 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 Suite "suite" event // #region Suite "test" event interface Suite { 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 Suite "test" event // #region Suite "run" event interface Suite extends NodeJS.EventEmitter { on(event: "run", listener: () => void): this; once(event: "run", listener: () => void): this; addListener(event: "run", listener: () => void): this; removeListener(event: "run", listener: () => void): this; prependListener(event: "run", listener: () => void): this; prependOnceListener(event: "run", listener: () => void): this; emit(name: "run"): boolean; } // #endregion Suite "run" event // #region Suite "pre-require" event interface Suite extends NodeJS.EventEmitter { on(event: "pre-require", listener: (context: MochaGlobals, file: string, mocha: Mocha) => void): this; once(event: "pre-require", listener: (context: MochaGlobals, file: string, mocha: Mocha) => void): this; addListener(event: "pre-require", listener: (context: MochaGlobals, file: string, mocha: Mocha) => void): this; removeListener(event: "pre-require", listener: (context: MochaGlobals, file: string, mocha: Mocha) => void): this; prependListener(event: "pre-require", listener: (context: MochaGlobals, file: string, mocha: Mocha) => void): this; prependOnceListener(event: "pre-require", listener: (context: MochaGlobals, file: string, mocha: Mocha) => void): this; emit(name: "pre-require", context: MochaGlobals, file: string, mocha: Mocha): boolean; } // #endregion Suite "pre-require" event // #region Suite "require" event interface Suite extends NodeJS.EventEmitter { on(event: "require", listener: (module: any, file: string, mocha: Mocha) => void): this; once(event: "require", listener: (module: any, file: string, mocha: Mocha) => void): this; addListener(event: "require", listener: (module: any, file: string, mocha: Mocha) => void): this; removeListener(event: "require", listener: (module: any, file: string, mocha: Mocha) => void): this; prependListener(event: "require", listener: (module: any, file: string, mocha: Mocha) => void): this; prependOnceListener(event: "require", listener: (module: any, file: string, mocha: Mocha) => void): this; emit(name: "require", module: any, file: string, mocha: Mocha): boolean; } // #endregion Suite "require" event // #region Suite "post-require" event interface Suite extends NodeJS.EventEmitter { on(event: "post-require", listener: (context: MochaGlobals, file: string, mocha: Mocha) => void): this; once(event: "post-require", listener: (context: MochaGlobals, file: string, mocha: Mocha) => void): this; addListener(event: "post-require", listener: (context: MochaGlobals, file: string, mocha: Mocha) => void): this; removeListener(event: "post-require", listener: (context: MochaGlobals, file: string, mocha: Mocha) => void): this; prependListener(event: "post-require", listener: (context: MochaGlobals, file: string, mocha: Mocha) => void): this; prependOnceListener(event: "post-require", listener: (context: MochaGlobals, file: string, mocha: Mocha) => void): this; emit(name: "post-require", context: MochaGlobals, file: string, mocha: Mocha): boolean; } // #endregion Suite "post-require" event // #region Suite untyped events interface Suite 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 Runner untyped events /** * Initialize a new `Hook` with the given `title` and callback `fn` * * @see https://mochajs.org/api/Hook.html */ class Hook extends Runnable { private _error; type: "hook"; originalTitle?: string; // added by Runner /** * Get the test `err`. * * @see https://mochajs.org/api/Hook.html#error */ error(): any; /** * Set the test `err`. * * @see https://mochajs.org/api/Hook.html#error */ error(err: any): void; } /** * An alternative way to define root hooks that works with parallel runs. * * Root hooks work with any interface, but the property names do not change. * In other words, if you are using the tdd interface, suiteSetup maps to beforeAll, and setup maps to beforeEach. * * As with other hooks, `this` refers to to the current context object. * * @see https://mochajs.org/#root-hook-plugins */ interface RootHookObject { /** * In serial mode, run after all tests end, once only. * In parallel mode, run after all tests end, for each file. */ afterAll?: Func | AsyncFunc | Func[] | AsyncFunc[]; /** * In serial mode (Mocha's default), before all tests begin, once only. * In parallel mode, run before all tests begin, for each file. */ beforeAll?: Func | AsyncFunc | Func[] | AsyncFunc[]; /** * In both modes, run after every test. */ afterEach?: Func | AsyncFunc | Func[] | AsyncFunc[]; /** * In both modes, run before each test. */ beforeEach?: Func | AsyncFunc | Func[] | AsyncFunc[]; } /** * Initialize a new `Test` with the given `title` and callback `fn`. * * @see https://mochajs.org/api/Test.html */ class Test extends Runnable { type: "test"; speed?: "slow" | "medium" | "fast"; // added by reporters err?: Error; // added by reporters clone(): Test; } /** * Test statistics */ interface Stats { suites: number; tests: number; passes: number; pending: number; failures: number; start?: Date; end?: Date; duration?: number; } type TestInterface = (suite: Suite) => void; interface ReporterConstructor { new (runner: Runner, options: MochaOptions): reporters.Base; } type Done = (err?: any) => void; /** * Callback function used for tests and hooks. */ type Func = (this: Context, done: Done) => void; /** * Async callback function used for tests and hooks. */ type AsyncFunc = (this: Context) => PromiseLike; /** * Options to pass to Mocha. */ interface MochaOptions { /** Test interfaces ("bdd", "tdd", "exports", etc.). */ ui?: Interface; /** * Reporter constructor, built-in reporter name, or reporter module path. Defaults to * `"spec"`. */ reporter?: string | ReporterConstructor; /** Options to pass to the reporter. */ reporterOptions?: any; /** Array of accepted globals. */ globals?: string[]; /** timeout in milliseconds or time string like '1s'. */ timeout?: number | string; /** number of times to retry failed tests. */ retries?: number; /** bail on the first test failure. */ bail?: boolean; /** milliseconds to wait before considering a test slow. */ slow?: number; /** check for global variable leaks. */ checkLeaks?: boolean; /** display the full stack trace on failure. */ fullStackTrace?: boolean; /** string or regexp to filter tests with. */ grep?: string | RegExp; /** Enable growl support. */ growl?: boolean; /** Color TTY output from reporter */ color?: boolean; /** Use inline diffs rather than +/-. */ inlineDiffs?: boolean; /** Do not show diffs at all. */ hideDiff?: boolean; /** Run job in parallel */ parallel?: boolean; /** Max number of worker processes for parallel runs */ jobs?: number; /** Assigns hooks to the root suite */ rootHooks?: RootHookObject; asyncOnly?: boolean; delay?: boolean; forbidOnly?: boolean; forbidPending?: boolean; noHighlighting?: boolean; allowUncaught?: boolean; fullTrace?: boolean; } interface MochaInstanceOptions extends MochaOptions { files?: string[]; } /** * Variables added to the global scope by Mocha when run in the CLI. */ interface MochaGlobals { /** * Execute before running tests. * * - _Only available when invoked via the mocha CLI._ * * @see https://mochajs.org/api/global.html#before */ before: HookFunction; /** * Execute after running tests. * * - _Only available when invoked via the mocha CLI._ * * @see https://mochajs.org/api/global.html#after */ after: HookFunction; /** * Execute before each test case. * * - _Only available when invoked via the mocha CLI._ * * @see https://mochajs.org/api/global.html#beforeEach */ beforeEach: HookFunction; /** * Execute after each test case. * * - _Only available when invoked via the mocha CLI._ * * @see https://mochajs.org/api/global.html#afterEach */ afterEach: HookFunction; /** * Describe a "suite" containing nested suites and tests. * * - _Only available when invoked via the mocha CLI._ */ describe: SuiteFunction; /** * Describe a "suite" containing nested suites and tests. * * - _Only available when invoked via the mocha CLI._ */ context: SuiteFunction; /** * Pending suite. * * - _Only available when invoked via the mocha CLI._ */ xdescribe: PendingSuiteFunction; /** * Pending suite. * * - _Only available when invoked via the mocha CLI._ */ xcontext: PendingSuiteFunction; /** * Describes a test case. * * - _Only available when invoked via the mocha CLI._ */ it: TestFunction; /** * Describes a test case. * * - _Only available when invoked via the mocha CLI._ */ specify: TestFunction; /** * Describes a pending test case. * * - _Only available when invoked via the mocha CLI._ */ xit: PendingTestFunction; /** * Describes a pending test case. * * - _Only available when invoked via the mocha CLI._ */ xspecify: PendingTestFunction; /** * Execute before running tests. * * - _Only available when invoked via the mocha CLI._ * * @see https://mochajs.org/api/global.html#before */ suiteSetup: HookFunction; /** * Execute after running tests. * * - _Only available when invoked via the mocha CLI._ * * @see https://mochajs.org/api/global.html#after */ suiteTeardown: HookFunction; /** * Execute before each test case. * * - _Only available when invoked via the mocha CLI._ * * @see https://mochajs.org/api/global.html#beforeEach */ setup: HookFunction; /** * Execute after each test case. * * - _Only available when invoked via the mocha CLI._ * * @see https://mochajs.org/api/global.html#afterEach */ teardown: HookFunction; /** * Describe a "suite" containing nested suites and tests. * * - _Only available when invoked via the mocha CLI._ */ suite: SuiteFunction; /** * Describes a test case. * * - _Only available when invoked via the mocha CLI._ */ test: TestFunction; run: typeof run; } /** * Third-party declarations that want to add new entries to the `Reporter` union can * contribute names here. */ interface ReporterContributions { Base: never; base: never; Dot: never; dot: never; TAP: never; tap: never; JSON: never; json: never; HTML: never; html: never; List: never; list: never; Min: never; min: never; Spec: never; spec: never; Nyan: never; nyan: never; XUnit: never; xunit: never; Markdown: never; markdown: never; Progress: never; progress: never; Landing: never; landing: never; JSONStream: never; "json-stream": never; } type Reporter = keyof ReporterContributions; /** * Third-party declarations that want to add new entries to the `Interface` union can * contribute names here. */ interface InterfaceContributions { bdd: never; tdd: never; qunit: never; exports: never; } type Interface = keyof InterfaceContributions; } // #region Test interface augmentations /** * 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 */ declare function run(): void; /** * Execute before running tests. * * - _Only available when invoked via the mocha CLI._ * * @see https://mochajs.org/api/global.html#before */ declare var before: Mocha.HookFunction; /** * Execute before running tests. * * - _Only available when invoked via the mocha CLI._ * * @see https://mochajs.org/api/global.html#before */ declare var suiteSetup: Mocha.HookFunction; /** * Execute after running tests. * * - _Only available when invoked via the mocha CLI._ * * @see https://mochajs.org/api/global.html#after */ declare var after: Mocha.HookFunction; /** * Execute after running tests. * * - _Only available when invoked via the mocha CLI._ * * @see https://mochajs.org/api/global.html#after */ declare var suiteTeardown: Mocha.HookFunction; /** * Execute before each test case. * * - _Only available when invoked via the mocha CLI._ * * @see https://mochajs.org/api/global.html#beforeEach */ declare var beforeEach: Mocha.HookFunction; /** * Execute before each test case. * * - _Only available when invoked via the mocha CLI._ * * @see https://mochajs.org/api/global.html#beforeEach */ declare var setup: Mocha.HookFunction; /** * Execute after each test case. * * - _Only available when invoked via the mocha CLI._ * * @see https://mochajs.org/api/global.html#afterEach */ declare var afterEach: Mocha.HookFunction; /** * Execute after each test case. * * - _Only available when invoked via the mocha CLI._ * * @see https://mochajs.org/api/global.html#afterEach */ declare var teardown: Mocha.HookFunction; /** * Describe a "suite" containing nested suites and tests. * * - _Only available when invoked via the mocha CLI._ */ declare var describe: Mocha.SuiteFunction; /** * Describe a "suite" containing nested suites and tests. * * - _Only available when invoked via the mocha CLI._ */ declare var context: Mocha.SuiteFunction; /** * Describe a "suite" containing nested suites and tests. * * - _Only available when invoked via the mocha CLI._ */ declare var suite: Mocha.SuiteFunction; /** * Pending suite. * * - _Only available when invoked via the mocha CLI._ */ declare var xdescribe: Mocha.PendingSuiteFunction; /** * Pending suite. * * - _Only available when invoked via the mocha CLI._ */ declare var xcontext: Mocha.PendingSuiteFunction; /** * Describes a test case. * * - _Only available when invoked via the mocha CLI._ */ declare var it: Mocha.TestFunction; /** * Describes a test case. * * - _Only available when invoked via the mocha CLI._ */ declare var specify: Mocha.TestFunction; /** * Describes a test case. * * - _Only available when invoked via the mocha CLI._ */ declare var test: Mocha.TestFunction; /** * Describes a pending test case. * * - _Only available when invoked via the mocha CLI._ */ declare var xit: Mocha.PendingTestFunction; /** * Describes a pending test case. * * - _Only available when invoked via the mocha CLI._ */ declare var xspecify: Mocha.PendingTestFunction; // #endregion Test interface augmentations // #region Reporter augmentations // Forward declaration for `HTMLLIElement` from lib.dom.d.ts. // Required by Mocha.reporters.HTML. // NOTE: Mocha *must not* have a direct dependency on DOM types. // tslint:disable-next-line no-empty-interface interface HTMLLIElement { } // Augments the DOM `Window` object when lib.dom.d.ts is loaded. // tslint:disable-next-line no-empty-interface interface Window extends Mocha.MochaGlobals { } declare namespace NodeJS { // Forward declaration for `NodeJS.EventEmitter` from node.d.ts. // Required by Mocha.Runnable, Mocha.Runner, and Mocha.Suite. // NOTE: Mocha *must not* have a direct dependency on @types/node. // tslint:disable-next-line no-empty-interface interface EventEmitter { } // Augments NodeJS's `global` object when node.d.ts is loaded // tslint:disable-next-line no-empty-interface interface Global extends Mocha.MochaGlobals { } } // #endregion Reporter augmentations // #region Browser augmentations /** * Mocha global. * * - _Only supported in the browser._ */ declare const mocha: BrowserMocha; interface BrowserMocha extends Mocha { /** * Function to allow assertion libraries to throw errors directly into mocha. * This is useful when running tests in a browser because window.onerror will * only receive the 'message' attribute of the Error. * * - _Only supported in the browser._ */ throwError(err: any): never; /** * Setup mocha with the given settings options. * * - _Only supported in the browser._ */ setup(opts?: Mocha.Interface | Mocha.MochaOptions): this; } // #endregion Browser augmentations declare module "mocha" { export = Mocha; } declare module "mocha/lib/ms" { export = milliseconds; /** * Parse the given `str` and return milliseconds. * * @see {@link https://mochajs.org/api/module-milliseconds.html} * @see {@link https://mochajs.org/api/module-milliseconds.html#~parse} */ function milliseconds(val: string): number; /** * Format for `ms`. * * @see {@link https://mochajs.org/api/module-milliseconds.html} * @see {@link https://mochajs.org/api/module-milliseconds.html#~format} */ function milliseconds(val: number): string; } declare module "mocha/lib/interfaces/common" { export = common; function common(suites: Mocha.Suite[], context: Mocha.MochaGlobals, mocha: Mocha): common.CommonFunctions; namespace common { interface CommonFunctions { /** * This is only present if flag --delay is passed into Mocha. It triggers * root suite execution. */ runWithSuite(suite: Mocha.Suite): () => void; /** * Execute before running tests. */ before(fn?: Mocha.Func | Mocha.AsyncFunc): void; /** * Execute before running tests. */ before(name: string, fn?: Mocha.Func | Mocha.AsyncFunc): void; /** * Execute after running tests. */ after(fn?: Mocha.Func | Mocha.AsyncFunc): void; /** * Execute after running tests. */ after(name: string, fn?: Mocha.Func | Mocha.AsyncFunc): void; /** * Execute before each test case. */ beforeEach(fn?: Mocha.Func | Mocha.AsyncFunc): void; /** * Execute before each test case. */ beforeEach(name: string, fn?: Mocha.Func | Mocha.AsyncFunc): void; /** * Execute after each test case. */ afterEach(fn?: Mocha.Func | Mocha.AsyncFunc): void; /** * Execute after each test case. */ afterEach(name: string, fn?: Mocha.Func | Mocha.AsyncFunc): void; suite: SuiteFunctions; test: TestFunctions; } interface CreateOptions { /** Title of suite */ title: string; /** Suite function */ fn?: (this: Mocha.Suite) => void; /** Is suite pending? */ pending?: boolean; /** Filepath where this Suite resides */ file?: string; /** Is suite exclusive? */ isOnly?: boolean; } interface SuiteFunctions { /** * Create an exclusive Suite; convenience function */ only(opts: CreateOptions): Mocha.Suite; /** * Create a Suite, but skip it; convenience function */ skip(opts: CreateOptions): Mocha.Suite; /** * Creates a suite. */ create(opts: CreateOptions): Mocha.Suite; } interface TestFunctions { /** * Exclusive test-case. */ only(mocha: Mocha, test: Mocha.Test): Mocha.Test; /** * Pending test case. */ skip(title: string): void; /** * Number of retry attempts */ retries(n: number): void; } } }