@types/mocha

Version 10.0.8
Published 6 hours ago
95.9 kB
No dependencies
MIT license

Install

npm i @types/mocha

yarn add @types/mocha

pnpm add @types/mocha

Overview

TypeScript definitions for mocha

Index

Variables

variable after

var after: Mocha.HookFunction;

Execute after running tests.
- _Only available when invoked via the mocha CLI._
See Also
- https://mochajs.org/api/global.html#after

variable afterEach

var afterEach: Mocha.HookFunction;

Execute after each test case.
- _Only available when invoked via the mocha CLI._
See Also
- https://mochajs.org/api/global.html#afterEach

variable before

var before: Mocha.HookFunction;

Execute before running tests.
- _Only available when invoked via the mocha CLI._
See Also
- https://mochajs.org/api/global.html#before

variable beforeEach

var beforeEach: Mocha.HookFunction;

Execute before each test case.
- _Only available when invoked via the mocha CLI._
See Also
- https://mochajs.org/api/global.html#beforeEach

variable context

var context: Mocha.SuiteFunction;

Describe a "suite" containing nested suites and tests.
- _Only available when invoked via the mocha CLI._

variable describe

var describe: Mocha.SuiteFunction;

Describe a "suite" containing nested suites and tests.
- _Only available when invoked via the mocha CLI._

variable it

var it: Mocha.TestFunction;

Describes a test case.
- _Only available when invoked via the mocha CLI._

variable mocha

const mocha: BrowserMocha;

Mocha global.
- _Only supported in the browser._

variable setup

var setup: Mocha.HookFunction;

Execute before each test case.
- _Only available when invoked via the mocha CLI._
See Also
- https://mochajs.org/api/global.html#beforeEach

variable specify

var specify: Mocha.TestFunction;

Describes a test case.
- _Only available when invoked via the mocha CLI._

variable suite

var suite: Mocha.SuiteFunction;

Describe a "suite" containing nested suites and tests.
- _Only available when invoked via the mocha CLI._

variable suiteSetup

var suiteSetup: Mocha.HookFunction;

Execute before running tests.
- _Only available when invoked via the mocha CLI._
See Also
- https://mochajs.org/api/global.html#before

variable suiteTeardown

var suiteTeardown: Mocha.HookFunction;

Execute after running tests.
- _Only available when invoked via the mocha CLI._
See Also
- https://mochajs.org/api/global.html#after

variable teardown

var teardown: Mocha.HookFunction;

Execute after each test case.
- _Only available when invoked via the mocha CLI._
See Also
- https://mochajs.org/api/global.html#afterEach

variable test

var test: Mocha.TestFunction;

Describes a test case.
- _Only available when invoked via the mocha CLI._

variable xcontext

var xcontext: Mocha.PendingSuiteFunction;

Pending suite.
- _Only available when invoked via the mocha CLI._

variable xdescribe

var xdescribe: Mocha.PendingSuiteFunction;

Pending suite.
- _Only available when invoked via the mocha CLI._

variable xit

var xit: Mocha.PendingTestFunction;

Describes a pending test case.
- _Only available when invoked via the mocha CLI._

variable xspecify

var xspecify: Mocha.PendingTestFunction;

Describes a pending test case.
- _Only available when invoked via the mocha CLI._

Functions

function run

run: () => void;

Triggers root suite execution.
- _Only available if flag --delay is passed into Mocha._ - _Only available when invoked via the mocha CLI._
See Also
- https://mochajs.org/api/global.html#runWithSuite

Namespaces

namespace mocha

module 'mocha' {}

variable after

let after: HookFunction;

Execute after running tests.
- _Only available when invoked via the mocha CLI._
See Also
- https://mochajs.org/api/global.html#after

variable afterEach

let afterEach: HookFunction;

Execute after each test case.
- _Only available when invoked via the mocha CLI._
See Also
- https://mochajs.org/api/global.html#afterEach

variable before

let before: HookFunction;

Execute before running tests.
- _Only available when invoked via the mocha CLI._
See Also
- https://mochajs.org/api/global.html#before

variable beforeEach

let beforeEach: HookFunction;

Execute before each test case.
- _Only available when invoked via the mocha CLI._
See Also
- https://mochajs.org/api/global.html#beforeEach

variable describe

let describe: SuiteFunction;

Describe a "suite" containing nested suites and tests.
- _Only available when invoked via the mocha CLI._

variable it

let it: TestFunction;

Describes a test case.
- _Only available when invoked via the mocha CLI._

variable setup

let setup: HookFunction;

Execute before each test case.
- _Only available when invoked via the mocha CLI._
See Also
- https://mochajs.org/api/global.html#beforeEach

variable suite

let suite: SuiteFunction;

Describe a "suite" containing nested suites and tests.
- _Only available when invoked via the mocha CLI._

variable suiteSetup

let suiteSetup: HookFunction;

Execute before running tests.
- _Only available when invoked via the mocha CLI._
See Also
- https://mochajs.org/api/global.html#before

variable suiteTeardown

let suiteTeardown: HookFunction;

Execute after running tests.
- _Only available when invoked via the mocha CLI._
See Also
- https://mochajs.org/api/global.html#after

variable teardown

let teardown: HookFunction;

Execute after each test case.
- _Only available when invoked via the mocha CLI._
See Also
- https://mochajs.org/api/global.html#afterEach

variable test

let test: TestFunction;

Describes a test case.
- _Only available when invoked via the mocha CLI._

variable xdescribe

let xdescribe: PendingSuiteFunction;

Describe a pending suite.
- _Only available when invoked via the mocha CLI._

variable xit

let xit: PendingTestFunction;

Describes a pending test case.
- _Only available when invoked via the mocha CLI._

function run

run: () => void;

Triggers root suite execution.
- _Only available if flag --delay is passed into Mocha._ - _Only available when invoked via the mocha CLI._
See Also
- https://mochajs.org/api/global.html#runWithSuite

class Context

class Context {}

Test context
See Also
- https://mochajs.org/api/module-Context.html#~Context

property currentTest

currentTest?: Test;

property test

test?: Runnable;

method retries

retries: { (): number; (n: number): this };

Get the number of allowed retries on failed tests.
Set the number of allowed retries on failed tests.

method runnable

runnable: { (): Runnable; (runnable: Runnable): this };

Get the context Runnable.
Set the context Runnable.

method skip

skip: () => never;

Mark a test as skipped.

method slow

slow: { (): number; (ms: string | number): this };

Get test slowness threshold.
Set test slowness threshold.

method timeout

timeout: { (): number; (ms: string | number): this };

Get test timeout.
Set test timeout.

class Hook

class Hook extends Runnable {}

Initialize a new Hook with the given title and callback fn
See Also
- https://mochajs.org/api/Hook.html

property originalTitle

originalTitle?: string;

property type

type: string;

method error

error: { (): any; (err: any): void };

Get the test err.
See Also
- https://mochajs.org/api/Hook.html#error
Set the test err.
See Also
- https://mochajs.org/api/Hook.html#error

class Mocha

class Mocha {}

Mocha API
See Also
- https://mochajs.org/api/mocha

constructor

constructor(options?: Mocha.MochaOptions);

property files

files: string[];

property globalSetup

globalSetup: Mocha.HookFunction;

Configures one or more global setup fixtures. If given no parameters, unsets any previously-set fixtures.
See Also
- https://mochajs.org/api/mocha#globalSetup

property globalTeardown

globalTeardown: Mocha.HookFunction;

Configures one or more global teardown fixtures. If given no parameters, unsets any previously-set fixtures.
See Also
- https://mochajs.org/api/mocha#globalTeardown

property options

options: Mocha.MochaInstanceOptions;

property suite

suite: Mocha.Suite;

method addFile

addFile: (file: string) => this;

Add test file.
See Also
- https://mochajs.org/api/mocha#addFile

method allowUncaught

allowUncaught: () => boolean;

Enable uncaught errors to propagate (in browser).
See Also
- https://mochajs.org/api/mocha#allowUncaught

method asyncOnly

asyncOnly: () => this;

Makes all tests async (accepting a callback)
See Also
- https://mochajs.org/api/mocha#asyncOnly.

method bail

bail: (bail?: boolean) => this;

Enable or disable bailing on the first failure.
See Also
- https://mochajs.org/api/mocha#bail

method checkLeaks

checkLeaks: () => this;

Enable global leak checking.
See Also
- https://mochajs.org/api/mocha#checkLeaks

method cleanReferencesAfterRun

cleanReferencesAfterRun: (clean?: boolean) => this;

Enables or disables whether or not to dispose after each test run. Disable this to ensure you can run the test suite multiple times. If disabled, be sure to dispose mocha when you're done to prevent memory leaks.
See Also
- https://mochajs.org/api/mocha#cleanReferencesAfterRun

method delay

delay: () => boolean;

Delay root suite execution.
See Also
- https://mochajs.org/api/mocha#delay

method dispose

dispose: () => void;

Manually dispose this mocha instance. Mark this instance as disposed and unable to run more tests. It also removes function references to tests functions and hooks, so variables trapped in closures can be cleaned by the garbage collector.
See Also
- https://mochajs.org/api/mocha#dispose

method dryRun

dryRun: (dryRun?: boolean) => this;

Whether to activate dry-run mode.
Parameter dryRun
Whether to activate dry-run mode. Defaults to true.

method enableGlobalSetup

enableGlobalSetup: (enabled: boolean) => this;

Toggle execution of any global setup fixture(s)
See Also
- https://mochajs.org/api/mocha#enableGlobalSetup

method enableGlobalTeardown

enableGlobalTeardown: (enabled: boolean) => this;

Toggle execution of any global teardown fixture(s)
See Also
- https://mochajs.org/api/mocha#enableGlobalTeardown

method failZero

failZero: (failZero?: boolean) => this;

Fails test run if no tests encountered with exit-code 1.
See Also
- https://mochajs.org/api/mocha#failZero

method fgrep

fgrep: (str: string) => this;

Escape string and add it to grep as a RegExp.
See Also
- https://mochajs.org/api/mocha#fgrep

method forbidOnly

forbidOnly: () => boolean;

Tests marked only fail the suite
See Also
- https://mochajs.org/api/mocha#forbidOnly

method forbidPending

forbidPending: () => boolean;

Pending tests and tests marked skip fail the suite
See Also
- https://mochajs.org/api/mocha#forbidPending

method fullTrace

fullTrace: () => this;

Display long stack-trace on failing
See Also
- https://mochajs.org/api/mocha#fullTrace

method globals

globals: (globals: string | readonly string[]) => this;

Ignore globals array or string.
See Also
- https://mochajs.org/api/mocha#globals

method grep

grep: (re: string | RegExp) => this;

Add regexp to grep, if re is a string it is escaped.
See Also
- https://mochajs.org/api/mocha#grep

method growl

growl: () => this;

Enable growl support.
See Also
- https://mochajs.org/api/mocha#growl

method hasGlobalSetupFixtures

hasGlobalSetupFixtures: () => boolean;

Returns true if one or more global setup fixtures have been supplied
See Also
- https://mochajs.org/api/mocha#hasGlobalSetupFixtures

method hasGlobalTeardownFixtures

hasGlobalTeardownFixtures: () => boolean;

Returns true if one or more global teardown fixtures have been supplied
See Also
- https://mochajs.org/api/mocha#hasGlobalTeardownFixtures

method invert

invert: () => this;

Invert .grep() matches.
See Also
- https://mochajs.org/api/mocha#invert

method loadFiles

protected loadFiles: (fn?: () => void) => void;

Load registered files.
See Also
- https://mochajs.org/api/mocha#loadFiles

method loadFilesAsync

loadFilesAsync: () => Promise<void>;

Loads ESM (and CJS) test files asynchronously.
See Also
- https://mochajs.org/api/mocha#loadFilesAsync

method noHighlighting

noHighlighting: () => this;

Disable syntax highlighting (in browser).
See Also
- https://mochajs.org/api/mocha#noHighlighting

method parallelMode

parallelMode: (enabled?: boolean) => 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 Also
- https://mochajs.org/api/mocha#parallelMode

method reporter

reporter: {
    (reporter: Mocha.Reporter, reporterOptions?: any): this;
    (reporter?: string | Mocha.ReporterConstructor, reporterOptions?: any): this;
};

Set reporter to one of the built-in reporters.
See Also
- https://mochajs.org/api/mocha#reporter
Set reporter to the provided constructor, one of the built-in reporters, or loads a reporter from a module path. Defaults to "spec".
See Also
- https://mochajs.org/api/mocha#reporter

method retries

retries: (n: number) => this;

Set the number of times to retry failed tests.
See Also
- https://mochajs.org/api/mocha#retries

method rootHooks

rootHooks: (hooks: Mocha.RootHookObject) => this;

Assigns hooks to the root suite.
See Also
- https://mochajs.org/api/mocha#rootHooks

method run

run: (fn?: (failures: number) => void) => Mocha.Runner;

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 Also
- https://mochajs.org/api/mocha#run

method slow

slow: (slow: string | number) => this;

Set slowness threshold in milliseconds.
See Also
- https://mochajs.org/api/mocha#slow

method timeout

timeout: (timeout: string | number) => this;

Set the timeout in milliseconds.
See Also
- https://mochajs.org/api/mocha#timeout

method ui

ui: { (name: Mocha.Interface): this; (name?: string): this };

Set test UI to one of the built-in test interfaces.
See Also
- https://mochajs.org/api/mocha#ui
Set test UI to one of the built-in test interfaces or loads a test interface from a module path. Defaults to "bdd".
See Also
- https://mochajs.org/api/mocha#ui

method unloadFiles

unloadFiles: () => this;

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

class Runnable

class Runnable {}

Initialize a new Runnable with the given title and callback fn.
See Also
- https://mochajs.org/api/Runnable.html

constructor

constructor(title: string, fn?: Func | AsyncFunc);

property allowUncaught

allowUncaught?: boolean;

property async

async: boolean;

property body

body: string;

property callback

callback?: Done;

property ctx

ctx?: Context;

property duration

duration?: number;

property file

file?: string;

property fn

fn: Func | AsyncFunc;

property id

id: string;

property parent

parent?: Suite;

property pending

pending: boolean;

property state

state?: 'failed' | 'passed' | 'pending';

property sync

sync: boolean;

property timedOut

timedOut: boolean;

property timer

timer?: any;

property title

title: string;

method clearTimeout

clearTimeout: () => void;

Clear the timeout.
See Also
- https://mochajs.org/api/Runnable.html#clearTimeout

method currentRetry

protected currentRetry: { (): number; (n: number): void };

Set or get current retry
See Also
- https://mochajs.org/api/Runnable.html#currentRetry

method fullTitle

fullTitle: () => string;

Return the full title generated by recursively concatenating the parent's full title.

method globals

globals: { (): string[]; (globals: readonly string[]): void };

Get a list of whitelisted globals for this test run.
See Also
- https://mochajs.org/api/Runnable.html#globals
Set a list of whitelisted globals for this test run.
See Also
- https://mochajs.org/api/Runnable.html#globals

method inspect

inspect: () => string;

Inspect the runnable void of private properties.
See Also
- https://mochajs.org/api/Runnable.html#inspect

method isFailed

isFailed: () => boolean;

Return true if this Runnable has failed.

method isPassed

isPassed: () => boolean;

Return true if this Runnable has passed.

method isPending

isPending: () => boolean;

Check if this runnable or its parent suite is marked as pending.
See Also
- https://mochajs.org/api/Runnable.html#isPending

method resetTimeout

resetTimeout: () => void;

Reset the timeout.
See Also
- https://mochajs.org/api/Runnable.html#resetTimeout

method retries

retries: { (): number; (n: number): void };

Set or get number of retries.
See Also
- https://mochajs.org/api/Runnable.html#retries

method run

run: (fn: Done) => void;

Run the test and invoke fn(err).
See Also
- https://mochajs.org/api/Runnable.html#run

method skip

skip: () => never;

Halt and mark as pending.

method slow

slow: { (): number; (ms: string | number): this };

Get test slowness threshold.
See Also
- https://mochajs.org/api/Runnable.html#slow
Set test slowness threshold.
See Also
- https://mochajs.org/api/Runnable.html#slow

method timeout

timeout: { (): number; (ms: string | number): this };

Get test timeout.
See Also
- https://mochajs.org/api/Runnable.html#timeout
Set test timeout.
See Also
- https://mochajs.org/api/Runnable.html#timeout

method titlePath

titlePath: () => string[];

Return the title path generated by concatenating the parent's title path with the title.

class Runner

class Runner {}

Initialize a Runner for the given suite.
See Also
- https://mochajs.org/api/Mocha.Runner.html

constructor

constructor(suite: Suite, optionsOrDelay?: boolean | RunnerOptions);

Initialize a Runner at the Root Suite, which represents a hierarchy of Suites and Tests.
Parameter suite
Root suite
Parameter optionsOrDelay
Options. If boolean (deprecated), whether or not to delay execution of root suite until ready.

property allowUncaught

allowUncaught?: boolean;

property asyncOnly

asyncOnly?: boolean;

property checkLeaks

checkLeaks?: boolean;

property constants

static readonly constants: RunnerConstants;

property currentRunnable

currentRunnable?: Runnable;

property failures

failures: number;

property forbidOnly

forbidOnly?: boolean;

property forbidPending

forbidPending?: boolean;

property fullStackTrace

fullStackTrace?: boolean;

property started

started: boolean;

property stats

stats?: Stats;

property suite

suite: Suite;

property test

test?: Test;

property total

total: number;

method abort

abort: () => this;

Cleanly abort execution.
See Also
- https://mochajs.org/api/Mocha.Runner.html#.Runner#abort

method checkGlobals

protected checkGlobals: (test: Test) => void;

Check for global variable leaks.
See Also
- https://mochajs.org/api/Mocha.Runner.html#checkGlobals

method dispose

dispose: () => void;

Removes all event handlers set during a run on this instance. Remark: this does *not* clean/dispose the tests or suites themselves.
See Also
- https://mochajs.org/api/runner#dispose

method fail

protected fail: (test: Test, err: any) => void;

Fail the given test.
See Also
- https://mochajs.org/api/Mocha.Runner.html#fail

method failHook

protected failHook: (hook: Hook, 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 Also
- https://mochajs.org/api/Mocha.Runner.html#failHook

method globalProps

protected globalProps: () => string[];

Return a list of global properties.
See Also
- https://mochajs.org/api/Mocha.Runner.html#globalProps

method globals

globals: { (): string[]; (arr: readonly string[]): this };

Gets the allowed globals.
See Also
- https://mochajs.org/api/Mocha.Runner.html#.Runner#globals
Allow the given arr of globals.
See Also
- https://mochajs.org/api/Mocha.Runner.html#.Runner#globals

method grep

grep: (re: RegExp, invert: boolean) => this;

Run tests with full titles matching re. Updates runner.total with number of tests matched.
See Also
- https://mochajs.org/api/Mocha.Runner.html#.Runner#grep

method grepTotal

grepTotal: (suite: Suite) => number;

Returns the number of tests matching the grep search for the given suite.
See Also
- https://mochajs.org/api/Mocha.Runner.html#.Runner#grepTotal

method hook

protected hook: (name: string, fn: () => void) => void;

Run hook name callbacks and then invoke fn().
See Also
- https://mochajs.org/api/Mocha.Runner.html#hook

method hookDown

protected hookDown: (
    name: string,
    fn: (err?: any, errSuite?: Suite) => void
) => void;

Run hooks from the bottom up.
See Also
- https://mochajs.org/api/Mocha.Runner.html#hookDown

method hooks

protected hooks: (
    name: string,
    suites: Suite[],
    fn: (err?: any, errSuite?: Suite) => void
) => void;

Run hook name for the given array of suites in order, and callback fn(err, errSuite).
See Also
- https://mochajs.org/api/Mocha.Runner.html#hooks

method hookUp

protected hookUp: (
    name: string,
    fn: (err?: any, errSuite?: Suite) => void
) => void;

Run hooks from the top level down.
See Also
- https://mochajs.org/api/Mocha.Runner.html#hookUp

method immediately

protected static immediately: (callback: Function) => void;

Wrapper for setImmediate, process.nextTick, or browser polyfill.

method parents

protected parents: () => Suite[];

Return an array of parent Suites from closest to furthest.
See Also
- https://mochajs.org/api/Mocha.Runner.html#parents

method run

run: (fn?: (failures: number) => void) => this;

Run the root suite and invoke fn(failures) on completion.
See Also
- https://mochajs.org/api/Mocha.Runner.html#.Runner#run

method runSuite

protected runSuite: (suite: Suite, fn: (errSuite?: Suite) => void) => void;

Run the given suite and invoke the callback fn() when complete.
See Also
- https://mochajs.org/api/Mocha.Runner.html#runSuite

method runTest

protected runTest: (fn: Done) => any;

Run the current test and callback fn(err).
See Also
- https://mochajs.org/api/Mocha.Runner.html#runTest

method runTests

protected runTests: (suite: Suite, fn: (errSuite?: Suite) => void) => void;

Run tests in the given suite and invoke the callback fn() when complete.
See Also
- https://mochajs.org/api/Mocha.Runner.html#runTests

method uncaught

uncaught: (err: any) => void;

Handle uncaught exceptions.
See Also
- https://mochajs.org/api/Mocha.Runner.html#uncaught

class Suite

class Suite {}

Initialize a new Suite with the given title and ctx.
See Also
- https://mochajs.org/api/Mocha.Suite.html

constructor

constructor(title: string, parentContext?: Context);

property constants

static readonly constants: SuiteConstants;

property ctx

ctx: Context;

property delayed

delayed: boolean;

property file

file?: string;

property parent

parent: Suite;

property pending

pending: boolean;

property root

root: boolean;

property suites

suites: Suite[];

property tests

tests: Test[];

property title

title: string;

method addSuite

addSuite: (suite: Suite) => this;

Add a test suite.
See Also
- https://mochajs.org/api/Mocha.Suite.html#addSuite

method addTest

addTest: (test: Test) => this;

Add a test to this suite.
See Also
- https://mochajs.org/api/Mocha.Suite.html#addTest

method afterAll

afterAll: {
    (fn?: Func): this;
    (fn?: AsyncFunc): this;
    (title: string, fn?: Func): this;
    (title: string, fn?: AsyncFunc): this;
};

Run fn(test[, done]) after running tests.
See Also
- https://mochajs.org/api/Mocha.Suite.html#afterAll

method afterEach

afterEach: {
    (fn?: Func): this;
    (fn?: AsyncFunc): this;
    (title: string, fn?: Func): this;
    (title: string, fn?: AsyncFunc): this;
};

Run fn(test[, done]) after each test case.
See Also
- https://mochajs.org/api/Mocha.Suite.html#afterEach

method bail

bail: { (): boolean; (bail: boolean): this };

Get whether to bail after first error.
See Also
- https://mochajs.org/api/Mocha.Suite.html#bail
Set whether to bail after first error.
See Also
- https://mochajs.org/api/Mocha.Suite.html#bail

method beforeAll

beforeAll: {
    (fn?: Func): this;
    (fn?: AsyncFunc): this;
    (title: string, fn?: Func): this;
    (title: string, fn?: AsyncFunc): this;
};

Run fn(test[, done]) before running tests.
See Also
- https://mochajs.org/api/Mocha.Suite.html#beforeAll

method beforeEach

beforeEach: {
    (fn?: Func): this;
    (fn?: AsyncFunc): this;
    (title: string, fn?: Func): this;
    (title: string, fn?: AsyncFunc): this;
};

Run fn(test[, done]) before each test case.
See Also
- https://mochajs.org/api/Mocha.Suite.html#beforeEach

method clone

clone: () => Suite;

Return a clone of this Suite.
See Also
- https://mochajs.org/api/Mocha.Suite.html#clone

method create

static create: (parent: Suite, title: string) => Suite;

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 Also
- https://mochajs.org/api/mocha#.exports.create

method dispose

dispose: () => void;

Cleans all references from this suite and all child suites.
https://mochajs.org/api/suite#dispose

method eachTest

eachTest: (fn: (test: Test) => void) => this;

Iterates through each suite recursively to find all tests. Applies a function in the format fn(test).
See Also
- https://mochajs.org/api/Mocha.Suite.html#eachTest

method fullTitle

fullTitle: () => string;

Return the full title generated by recursively concatenating the parent's full title.
See Also
- https://mochajs.org/api/Mocha.Suite.html#.Suite#fullTitle

method isPending

isPending: () => boolean;

Check if this suite or its parent suite is marked as pending.
See Also
- https://mochajs.org/api/Mocha.Suite.html#isPending

method retries

retries: { (): number; (n: string | number): this };

Get number of times to retry a failed test.
See Also
- https://mochajs.org/api/Mocha.Suite.html#retries
Set number of times to retry a failed test.
See Also
- https://mochajs.org/api/Mocha.Suite.html#retries

method run

run: () => void;

This will run the root suite if we happen to be running in delayed mode.
See Also
- https://mochajs.org/api/Mocha.Suite.html#run

method slow

slow: { (): number; (ms: string | number): this };

Get slow ms.
See Also
- https://mochajs.org/api/Mocha.Suite.html#slow
Set slow ms or short-hand such as "2s".
See Also
- https://mochajs.org/api/Mocha.Suite.html#slow

method timeout

timeout: { (): number; (ms: string | number): this };

Get timeout ms.
See Also
- https://mochajs.org/api/Mocha.Suite.html#timeout
Set timeout ms or short-hand such as "2s".
See Also
- https://mochajs.org/api/Mocha.Suite.html#timeout

method titlePath

titlePath: () => string[];

Return the title path generated by recursively concatenating the parent's title path.
See Also
- https://mochajs.org/api/Mocha.Suite.html#.Suite#titlePath

method total

total: () => number;

Return the total number of tests.
See Also
- https://mochajs.org/api/Mocha.Suite.html#.Suite#total

class Test

class Test extends Runnable {}

Initialize a new Test with the given title and callback fn.
See Also
- https://mochajs.org/api/Test.html

property err

err?: Error;

property speed

speed?: 'slow' | 'medium' | 'fast';

property type

type: string;

method clone

clone: () => Test;

interface ExclusiveSuiteFunction

interface ExclusiveSuiteFunction {}

call signature

(title: string, fn: (this: Suite) => void): Suite;

[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._

call signature

(title: string): Suite;

[qunit] Describe a "suite" with the given title. Indicates this suite should be executed exclusively.
- _Only available when invoked via the mocha CLI._

interface ExclusiveTestFunction

interface ExclusiveTestFunction {}

call signature

(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._

call signature

(fn: AsyncFunc): 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._

call signature

(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._

call signature

(title: string, 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._

interface HookFunction

interface HookFunction {}

call signature

(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._

call signature

(fn: AsyncFunc): 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._

call signature

(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._

call signature

(name: string, 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._

interface InterfaceContributions

interface InterfaceContributions {}

Third-party declarations that want to add new entries to the Interface union can contribute names here.

property bdd

bdd: never;

property exports

exports: never;

property qunit

qunit: never;

property tdd

tdd: never;

interface MochaGlobals

interface MochaGlobals {}

Variables added to the global scope by Mocha when run in the CLI.

property after

after: HookFunction;

Execute after running tests.
- _Only available when invoked via the mocha CLI._
See Also
- https://mochajs.org/api/global.html#after

property afterEach

afterEach: HookFunction;

Execute after each test case.
- _Only available when invoked via the mocha CLI._
See Also
- https://mochajs.org/api/global.html#afterEach

property before

before: HookFunction;

Execute before running tests.
- _Only available when invoked via the mocha CLI._
See Also
- https://mochajs.org/api/global.html#before

property beforeEach

beforeEach: HookFunction;

Execute before each test case.
- _Only available when invoked via the mocha CLI._
See Also
- https://mochajs.org/api/global.html#beforeEach

property context

context: SuiteFunction;

Describe a "suite" containing nested suites and tests.
- _Only available when invoked via the mocha CLI._

property describe

describe: SuiteFunction;

Describe a "suite" containing nested suites and tests.
- _Only available when invoked via the mocha CLI._

property it

it: TestFunction;

Describes a test case.
- _Only available when invoked via the mocha CLI._

property run

run: typeof run;

property setup

setup: HookFunction;

Execute before each test case.
- _Only available when invoked via the mocha CLI._
See Also
- https://mochajs.org/api/global.html#beforeEach

property specify

specify: TestFunction;

Describes a test case.
- _Only available when invoked via the mocha CLI._

property suite

suite: SuiteFunction;

Describe a "suite" containing nested suites and tests.
- _Only available when invoked via the mocha CLI._

property suiteSetup

suiteSetup: HookFunction;

Execute before running tests.
- _Only available when invoked via the mocha CLI._
See Also
- https://mochajs.org/api/global.html#before

property suiteTeardown

suiteTeardown: HookFunction;

Execute after running tests.
- _Only available when invoked via the mocha CLI._
See Also
- https://mochajs.org/api/global.html#after

property teardown

teardown: HookFunction;

Execute after each test case.
- _Only available when invoked via the mocha CLI._
See Also
- https://mochajs.org/api/global.html#afterEach

property test

test: TestFunction;

Describes a test case.
- _Only available when invoked via the mocha CLI._

property xcontext

xcontext: PendingSuiteFunction;

Pending suite.
- _Only available when invoked via the mocha CLI._

property xdescribe

xdescribe: PendingSuiteFunction;

Pending suite.
- _Only available when invoked via the mocha CLI._

property xit

xit: PendingTestFunction;

Describes a pending test case.
- _Only available when invoked via the mocha CLI._

property xspecify

xspecify: PendingTestFunction;

Describes a pending test case.
- _Only available when invoked via the mocha CLI._

interface MochaInstanceOptions

interface MochaInstanceOptions extends MochaOptions {}

property files

files?: string[] | undefined;

interface MochaOptions

interface MochaOptions {}

Options to pass to Mocha.

property allowUncaught

allowUncaught?: boolean | undefined;

Propagate uncaught errors?

property asyncOnly

asyncOnly?: boolean | undefined;

Force done callback or promise?

property bail

bail?: boolean | undefined;

bail on the first test failure.

property checkLeaks

checkLeaks?: boolean | undefined;

Check for global variable leaks?

property color

color?: boolean | undefined;

Color TTY output from reporter

property delay

delay?: boolean | undefined;

Delay root suite execution?

property diff

diff?: boolean | undefined;

Show diff on failure?

property dryRun

dryRun?: boolean | undefined;

Report tests without running them?

property failZero

failZero?: boolean | undefined;

Fail test run if zero tests encountered.

property fgrep

fgrep?: string | undefined;

Test filter given string.

property forbidOnly

forbidOnly?: boolean | undefined;

Tests marked only fail the suite?

property forbidPending

forbidPending?: boolean | undefined;

Pending tests fail the suite?

property fullTrace

fullTrace?: boolean | undefined;

Full stacktrace upon failure?

property globals

globals?: string[] | undefined;

Variables expected in global scope.

property grep

grep?: string | RegExp | undefined;

Test filter given regular expression.

property growl

growl?: boolean | undefined;

Enable desktop notifications?

property inlineDiffs

inlineDiffs?: boolean | undefined;

Display inline diffs?

property invert

invert?: boolean | undefined;

Invert test filter matches?

property isWorker

isWorker?: boolean | undefined;

Should be true if Mocha process is running in a worker process.

property jobs

jobs?: number | undefined;

Max number of worker processes for parallel runs.

property noHighlighting

noHighlighting?: boolean | undefined;

Disable syntax highlighting?

property parallel

parallel?: boolean | undefined;

Run jobs in parallel

property reporter

reporter?: string | ReporterConstructor | undefined;

Reporter name or constructor.

property reporterOptions

reporterOptions?: any;

Reporter settings object.

property require

require?: string[] | undefined;

Pathname of rootHooks plugin for parallel runs.

property retries

retries?: number | undefined;

Number of times to retry failed tests.

property rootHooks

rootHooks?: RootHookObject | undefined;

Hooks to bootstrap the root suite with.

property slow

slow?: number | undefined;

Slow threshold value.

property timeout

timeout?: number | string | undefined;

Timeout threshold value.

property ui

ui?: Interface | undefined;

Interface name.

interface PendingSuiteFunction

interface PendingSuiteFunction {}

[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
[tdd] void

call signature

(title: string, fn: (this: Suite) => void): Suite | void;

interface PendingTestFunction

interface PendingTestFunction {}

call signature

(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._

call signature

(fn: AsyncFunc): 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._

call signature

(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._

call signature

(title: string, 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._

interface ReporterConstructor

interface ReporterConstructor {}

construct signature

new (runner: Runner, options: MochaOptions): reporters.Base;

interface ReporterContributions

interface ReporterContributions {}

Third-party declarations that want to add new entries to the Reporter union can contribute names here.

property "json-stream"

'json-stream': never;

property base

base: never;

property Base

Base: never;

property dot

dot: never;

property Dot

Dot: never;

property html

html: never;

property HTML

HTML: never;

property json

json: never;

property JSON

JSON: never;

property JSONStream

JSONStream: never;

property landing

landing: never;

property Landing

Landing: never;

property list

list: never;

property List

List: never;

property markdown

markdown: never;

property Markdown

Markdown: never;

property min

min: never;

property Min

Min: never;

property nyan

nyan: never;

property Nyan

Nyan: never;

property progress

progress: never;

property Progress

Progress: never;

property spec

spec: never;

property Spec

Spec: never;

property tap

tap: never;

property TAP

TAP: never;

property xunit

xunit: never;

property XUnit

XUnit: never;

interface RootHookObject

interface RootHookObject {}

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 Also
- https://mochajs.org/#root-hook-plugins

property afterAll

afterAll?: Func | AsyncFunc | Func[] | AsyncFunc[] | undefined;

In serial mode, run after all tests end, once only. In parallel mode, run after all tests end, for each file.

property afterEach

afterEach?: Func | AsyncFunc | Func[] | AsyncFunc[] | undefined;

In both modes, run after every test.

property beforeAll

beforeAll?: Func | AsyncFunc | Func[] | AsyncFunc[] | undefined;

In serial mode (Mocha's default), before all tests begin, once only. In parallel mode, run before all tests begin, for each file.

property beforeEach

beforeEach?: Func | AsyncFunc | Func[] | AsyncFunc[] | undefined;

In both modes, run before each test.

interface Runnable

interface Runnable extends NodeJS.EventEmitter {}

method addListener

addListener: {
    (event: 'error', listener: (error: any) => void): this;
    (event: string, listener: (...args: any[]) => void): this;
};

method emit

emit: {
    (name: 'error', error: any): boolean;
    (name: string, ...args: any[]): boolean;
};

method on

on: {
    (event: 'error', listener: (error: any) => void): this;
    (event: string, listener: (...args: any[]) => void): this;
};

method once

once: {
    (event: 'error', listener: (error: any) => void): this;
    (event: string, listener: (...args: any[]) => void): this;
};

method prependListener

prependListener: {
    (event: 'error', listener: (error: any) => void): this;
    (event: string, listener: (...args: any[]) => void): this;
};

method prependOnceListener

prependOnceListener: {
    (event: 'error', listener: (error: any) => void): this;
    (event: string, listener: (...args: any[]) => void): this;
};

method removeListener

removeListener: {
    (event: 'error', listener: (error: any) => void): this;
    (event: string, listener: (...args: any[]) => void): this;
};

interface Runnable

interface Runnable extends NodeJS.EventEmitter {}

method addListener

addListener: {
    (event: 'error', listener: (error: any) => void): this;
    (event: string, listener: (...args: any[]) => void): this;
};

method emit

emit: {
    (name: 'error', error: any): boolean;
    (name: string, ...args: any[]): boolean;
};

method on

on: {
    (event: 'error', listener: (error: any) => void): this;
    (event: string, listener: (...args: any[]) => void): this;
};

method once

once: {
    (event: 'error', listener: (error: any) => void): this;
    (event: string, listener: (...args: any[]) => void): this;
};

method prependListener

prependListener: {
    (event: 'error', listener: (error: any) => void): this;
    (event: string, listener: (...args: any[]) => void): this;
};

method prependOnceListener

prependOnceListener: {
    (event: 'error', listener: (error: any) => void): this;
    (event: string, listener: (...args: any[]) => void): this;
};

method removeListener

removeListener: {
    (event: 'error', listener: (error: any) => void): this;
    (event: string, listener: (...args: any[]) => void): this;
};

interface Runner

interface Runner {}

method addListener

addListener: {
    (event: 'waiting', listener: (rootSuite: Suite) => void): this;
    (event: 'start', listener: () => void): this;
    (event: 'end', listener: () => void): this;
    (event: 'suite', listener: (suite: Suite) => void): this;
    (event: 'suite end', listener: (suite: Suite) => void): this;
    (event: 'test', listener: (test: Test) => void): this;
    (event: 'test end', listener: (test: Test) => void): this;
    (event: 'hook', listener: (hook: Hook) => void): this;
    (event: 'hook end', listener: (hook: Hook) => void): this;
    (event: 'pass', listener: (test: Test) => void): this;
    (event: 'fail', listener: (test: Test, err: any) => void): this;
    (event: 'pending', listener: (test: Test) => void): this;
    (event: string, listener: (...args: any[]) => void): this;
};

method emit

emit: {
    (name: 'waiting', rootSuite: Suite): boolean;
    (name: 'start'): boolean;
    (name: 'end'): boolean;
    (name: 'suite', suite: Suite): boolean;
    (name: 'suite end', suite: Suite): boolean;
    (name: 'test', test: Test): boolean;
    (name: 'test end', test: Test): boolean;
    (name: 'hook', hook: Hook): boolean;
    (name: 'hook end', hook: Hook): boolean;
    (name: 'pass', test: Test): boolean;
    (name: 'fail', test: Test, err: any): boolean;
    (name: 'pending', test: Test): boolean;
    (name: string, ...args: any[]): boolean;
};

method on

on: {
    (event: 'waiting', listener: (rootSuite: Suite) => void): this;
    (event: 'start', listener: () => void): this;
    (event: 'end', listener: () => void): this;
    (event: 'suite', listener: (suite: Suite) => void): this;
    (event: 'suite end', listener: (suite: Suite) => void): this;
    (event: 'test', listener: (test: Test) => void): this;
    (event: 'test end', listener: (test: Test) => void): this;
    (event: 'hook', listener: (hook: Hook) => void): this;
    (event: 'hook end', listener: (hook: Hook) => void): this;
    (event: 'pass', listener: (test: Test) => void): this;
    (event: 'fail', listener: (test: Test, err: any) => void): this;
    (event: 'pending', listener: (test: Test) => void): this;
    (event: string, listener: (...args: any[]) => void): this;
};

method once

once: {
    (event: 'waiting', listener: (rootSuite: Suite) => void): this;
    (event: 'start', listener: () => void): this;
    (event: 'end', listener: () => void): this;
    (event: 'suite', listener: (suite: Suite) => void): this;
    (event: 'suite end', listener: (suite: Suite) => void): this;
    (event: 'test', listener: (test: Test) => void): this;
    (event: 'test end', listener: (test: Test) => void): this;
    (event: 'hook', listener: (hook: Hook) => void): this;
    (event: 'hook end', listener: (hook: Hook) => void): this;
    (event: 'pass', listener: (test: Test) => void): this;
    (event: 'fail', listener: (test: Test, err: any) => void): this;
    (event: 'pending', listener: (test: Test) => void): this;
    (event: string, listener: (...args: any[]) => void): this;
};

method prependListener

prependListener: {
    (event: 'waiting', listener: (rootSuite: Suite) => void): this;
    (event: 'start', listener: () => void): this;
    (event: 'end', listener: () => void): this;
    (event: 'suite', listener: (suite: Suite) => void): this;
    (event: 'suite end', listener: (suite: Suite) => void): this;
    (event: 'test', listener: (test: Test) => void): this;
    (event: 'test end', listener: (test: Test) => void): this;
    (event: 'hook', listener: (hook: Hook) => void): this;
    (event: 'hook end', listener: (hook: Hook) => void): this;
    (event: 'pass', listener: (test: Test) => void): this;
    (event: 'fail', listener: (test: Test, err: any) => void): this;
    (event: 'pending', listener: (test: Test) => void): this;
    (event: string, listener: (...args: any[]) => void): this;
};

method prependOnceListener

prependOnceListener: {
    (event: 'waiting', listener: (rootSuite: Suite) => void): this;
    (event: 'start', listener: () => void): this;
    (event: 'end', listener: () => void): this;
    (event: 'suite', listener: (suite: Suite) => void): this;
    (event: 'suite end', listener: (suite: Suite) => void): this;
    (event: 'test', listener: (test: Test) => void): this;
    (event: 'test end', listener: (test: Test) => void): this;
    (event: 'hook', listener: (hook: Hook) => void): this;
    (event: 'hook end', listener: (hook: Hook) => void): this;
    (event: 'pass', listener: (test: Test) => void): this;
    (event: 'fail', listener: (test: Test, err: any) => void): this;
    (event: 'pending', listener: (test: Test) => void): this;
    (event: string, listener: (...args: any[]) => void): this;
};

method removeListener

removeListener: {
    (event: 'waiting', listener: (rootSuite: Suite) => void): this;
    (event: 'start', listener: () => void): this;
    (event: 'end', listener: () => void): this;
    (event: 'suite', listener: (suite: Suite) => void): this;
    (event: 'suite end', listener: (suite: Suite) => void): this;
    (event: 'test', listener: (test: Test) => void): this;
    (event: 'test end', listener: (test: Test) => void): this;
    (event: 'hook', listener: (hook: Hook) => void): this;
    (event: 'hook end', listener: (hook: Hook) => void): this;
    (event: 'pass', listener: (test: Test) => void): this;
    (event: 'fail', listener: (test: Test, err: any) => void): this;
    (event: 'pending', listener: (test: Test) => void): this;
    (event: string, listener: (...args: any[]) => void): this;
};

interface Runner

interface Runner extends NodeJS.EventEmitter {}

method addListener

addListener: {
    (event: 'waiting', listener: (rootSuite: Suite) => void): this;
    (event: 'start', listener: () => void): this;
    (event: 'end', listener: () => void): this;
    (event: 'suite', listener: (suite: Suite) => void): this;
    (event: 'suite end', listener: (suite: Suite) => void): this;
    (event: 'test', listener: (test: Test) => void): this;
    (event: 'test end', listener: (test: Test) => void): this;
    (event: 'hook', listener: (hook: Hook) => void): this;
    (event: 'hook end', listener: (hook: Hook) => void): this;
    (event: 'pass', listener: (test: Test) => void): this;
    (event: 'fail', listener: (test: Test, err: any) => void): this;
    (event: 'pending', listener: (test: Test) => void): this;
    (event: string, listener: (...args: any[]) => void): this;
};

method emit

emit: {
    (name: 'waiting', rootSuite: Suite): boolean;
    (name: 'start'): boolean;
    (name: 'end'): boolean;
    (name: 'suite', suite: Suite): boolean;
    (name: 'suite end', suite: Suite): boolean;
    (name: 'test', test: Test): boolean;
    (name: 'test end', test: Test): boolean;
    (name: 'hook', hook: Hook): boolean;
    (name: 'hook end', hook: Hook): boolean;
    (name: 'pass', test: Test): boolean;
    (name: 'fail', test: Test, err: any): boolean;
    (name: 'pending', test: Test): boolean;
    (name: string, ...args: any[]): boolean;
};

method on

on: {
    (event: 'waiting', listener: (rootSuite: Suite) => void): this;
    (event: 'start', listener: () => void): this;
    (event: 'end', listener: () => void): this;
    (event: 'suite', listener: (suite: Suite) => void): this;
    (event: 'suite end', listener: (suite: Suite) => void): this;
    (event: 'test', listener: (test: Test) => void): this;
    (event: 'test end', listener: (test: Test) => void): this;
    (event: 'hook', listener: (hook: Hook) => void): this;
    (event: 'hook end', listener: (hook: Hook) => void): this;
    (event: 'pass', listener: (test: Test) => void): this;
    (event: 'fail', listener: (test: Test, err: any) => void): this;
    (event: 'pending', listener: (test: Test) => void): this;
    (event: string, listener: (...args: any[]) => void): this;
};

method once

once: {
    (event: 'waiting', listener: (rootSuite: Suite) => void): this;
    (event: 'start', listener: () => void): this;
    (event: 'end', listener: () => void): this;
    (event: 'suite', listener: (suite: Suite) => void): this;
    (event: 'suite end', listener: (suite: Suite) => void): this;
    (event: 'test', listener: (test: Test) => void): this;
    (event: 'test end', listener: (test: Test) => void): this;
    (event: 'hook', listener: (hook: Hook) => void): this;
    (event: 'hook end', listener: (hook: Hook) => void): this;
    (event: 'pass', listener: (test: Test) => void): this;
    (event: 'fail', listener: (test: Test, err: any) => void): this;
    (event: 'pending', listener: (test: Test) => void): this;
    (event: string, listener: (...args: any[]) => void): this;
};

method prependListener

prependListener: {
    (event: 'waiting', listener: (rootSuite: Suite) => void): this;
    (event: 'start', listener: () => void): this;
    (event: 'end', listener: () => void): this;
    (event: 'suite', listener: (suite: Suite) => void): this;
    (event: 'suite end', listener: (suite: Suite) => void): this;
    (event: 'test', listener: (test: Test) => void): this;
    (event: 'test end', listener: (test: Test) => void): this;
    (event: 'hook', listener: (hook: Hook) => void): this;
    (event: 'hook end', listener: (hook: Hook) => void): this;
    (event: 'pass', listener: (test: Test) => void): this;
    (event: 'fail', listener: (test: Test, err: any) => void): this;
    (event: 'pending', listener: (test: Test) => void): this;
    (event: string, listener: (...args: any[]) => void): this;
};

method prependOnceListener

prependOnceListener: {
    (event: 'waiting', listener: (rootSuite: Suite) => void): this;
    (event: 'start', listener: () => void): this;
    (event: 'end', listener: () => void): this;
    (event: 'suite', listener: (suite: Suite) => void): this;
    (event: 'suite end', listener: (suite: Suite) => void): this;
    (event: 'test', listener: (test: Test) => void): this;
    (event: 'test end', listener: (test: Test) => void): this;
    (event: 'hook', listener: (hook: Hook) => void): this;
    (event: 'hook end', listener: (hook: Hook) => void): this;
    (event: 'pass', listener: (test: Test) => void): this;
    (event: 'fail', listener: (test: Test, err: any) => void): this;
    (event: 'pending', listener: (test: Test) => void): this;
    (event: string, listener: (...args: any[]) => void): this;
};

method removeListener

removeListener: {
    (event: 'waiting', listener: (rootSuite: Suite) => void): this;
    (event: 'start', listener: () => void): this;
    (event: 'end', listener: () => void): this;
    (event: 'suite', listener: (suite: Suite) => void): this;
    (event: 'suite end', listener: (suite: Suite) => void): this;
    (event: 'test', listener: (test: Test) => void): this;
    (event: 'test end', listener: (test: Test) => void): this;
    (event: 'hook', listener: (hook: Hook) => void): this;
    (event: 'hook end', listener: (hook: Hook) => void): this;
    (event: 'pass', listener: (test: Test) => void): this;
    (event: 'fail', listener: (test: Test, err: any) => void): this;
    (event: 'pending', listener: (test: Test) => void): this;
    (event: string, listener: (...args: any[]) => void): this;
};

interface Runner

interface Runner extends NodeJS.EventEmitter {}

method addListener

addListener: {
    (event: 'waiting', listener: (rootSuite: Suite) => void): this;
    (event: 'start', listener: () => void): this;
    (event: 'end', listener: () => void): this;
    (event: 'suite', listener: (suite: Suite) => void): this;
    (event: 'suite end', listener: (suite: Suite) => void): this;
    (event: 'test', listener: (test: Test) => void): this;
    (event: 'test end', listener: (test: Test) => void): this;
    (event: 'hook', listener: (hook: Hook) => void): this;
    (event: 'hook end', listener: (hook: Hook) => void): this;
    (event: 'pass', listener: (test: Test) => void): this;
    (event: 'fail', listener: (test: Test, err: any) => void): this;
    (event: 'pending', listener: (test: Test) => void): this;
    (event: string, listener: (...args: any[]) => void): this;
};

method emit

emit: {
    (name: 'waiting', rootSuite: Suite): boolean;
    (name: 'start'): boolean;
    (name: 'end'): boolean;
    (name: 'suite', suite: Suite): boolean;
    (name: 'suite end', suite: Suite): boolean;
    (name: 'test', test: Test): boolean;
    (name: 'test end', test: Test): boolean;
    (name: 'hook', hook: Hook): boolean;
    (name: 'hook end', hook: Hook): boolean;
    (name: 'pass', test: Test): boolean;
    (name: 'fail', test: Test, err: any): boolean;
    (name: 'pending', test: Test): boolean;
    (name: string, ...args: any[]): boolean;
};

method on

on: {
    (event: 'waiting', listener: (rootSuite: Suite) => void): this;
    (event: 'start', listener: () => void): this;
    (event: 'end', listener: () => void): this;
    (event: 'suite', listener: (suite: Suite) => void): this;
    (event: 'suite end', listener: (suite: Suite) => void): this;
    (event: 'test', listener: (test: Test) => void): this;
    (event: 'test end', listener: (test: Test) => void): this;
    (event: 'hook', listener: (hook: Hook) => void): this;
    (event: 'hook end', listener: (hook: Hook) => void): this;
    (event: 'pass', listener: (test: Test) => void): this;
    (event: 'fail', listener: (test: Test, err: any) => void): this;
    (event: 'pending', listener: (test: Test) => void): this;
    (event: string, listener: (...args: any[]) => void): this;
};

method once

once: {
    (event: 'waiting', listener: (rootSuite: Suite) => void): this;
    (event: 'start', listener: () => void): this;
    (event: 'end', listener: () => void): this;
    (event: 'suite', listener: (suite: Suite) => void): this;
    (event: 'suite end', listener: (suite: Suite) => void): this;
    (event: 'test', listener: (test: Test) => void): this;
    (event: 'test end', listener: (test: Test) => void): this;
    (event: 'hook', listener: (hook: Hook) => void): this;
    (event: 'hook end', listener: (hook: Hook) => void): this;
    (event: 'pass', listener: (test: Test) => void): this;
    (event: 'fail', listener: (test: Test, err: any) => void): this;
    (event: 'pending', listener: (test: Test) => void): this;
    (event: string, listener: (...args: any[]) => void): this;
};

method prependListener

prependListener: {
    (event: 'waiting', listener: (rootSuite: Suite) => void): this;
    (event: 'start', listener: () => void): this;
    (event: 'end', listener: () => void): this;
    (event: 'suite', listener: (suite: Suite) => void): this;
    (event: 'suite end', listener: (suite: Suite) => void): this;
    (event: 'test', listener: (test: Test) => void): this;
    (event: 'test end', listener: (test: Test) => void): this;
    (event: 'hook', listener: (hook: Hook) => void): this;
    (event: 'hook end', listener: (hook: Hook) => void): this;
    (event: 'pass', listener: (test: Test) => void): this;
    (event: 'fail', listener: (test: Test, err: any) => void): this;
    (event: 'pending', listener: (test: Test) => void): this;
    (event: string, listener: (...args: any[]) => void): this;
};

method prependOnceListener

prependOnceListener: {
    (event: 'waiting', listener: (rootSuite: Suite) => void): this;
    (event: 'start', listener: () => void): this;
    (event: 'end', listener: () => void): this;
    (event: 'suite', listener: (suite: Suite) => void): this;
    (event: 'suite end', listener: (suite: Suite) => void): this;
    (event: 'test', listener: (test: Test) => void): this;
    (event: 'test end', listener: (test: Test) => void): this;
    (event: 'hook', listener: (hook: Hook) => void): this;
    (event: 'hook end', listener: (hook: Hook) => void): this;
    (event: 'pass', listener: (test: Test) => void): this;
    (event: 'fail', listener: (test: Test, err: any) => void): this;
    (event: 'pending', listener: (test: Test) => void): this;
    (event: string, listener: (...args: any[]) => void): this;
};

method removeListener

removeListener: {
    (event: 'waiting', listener: (rootSuite: Suite) => void): this;
    (event: 'start', listener: () => void): this;
    (event: 'end', listener: () => void): this;
    (event: 'suite', listener: (suite: Suite) => void): this;
    (event: 'suite end', listener: (suite: Suite) => void): this;
    (event: 'test', listener: (test: Test) => void): this;
    (event: 'test end', listener: (test: Test) => void): this;
    (event: 'hook', listener: (hook: Hook) => void): this;
    (event: 'hook end', listener: (hook: Hook) => void): this;
    (event: 'pass', listener: (test: Test) => void): this;
    (event: 'fail', listener: (test: Test, err: any) => void): this;
    (event: 'pending', listener: (test: Test) => void): this;
    (event: string, listener: (...args: any[]) => void): this;
};

interface Runner

interface Runner extends NodeJS.EventEmitter {}

method addListener

addListener: {
    (event: 'waiting', listener: (rootSuite: Suite) => void): this;
    (event: 'start', listener: () => void): this;
    (event: 'end', listener: () => void): this;
    (event: 'suite', listener: (suite: Suite) => void): this;
    (event: 'suite end', listener: (suite: Suite) => void): this;
    (event: 'test', listener: (test: Test) => void): this;
    (event: 'test end', listener: (test: Test) => void): this;
    (event: 'hook', listener: (hook: Hook) => void): this;
    (event: 'hook end', listener: (hook: Hook) => void): this;
    (event: 'pass', listener: (test: Test) => void): this;
    (event: 'fail', listener: (test: Test, err: any) => void): this;
    (event: 'pending', listener: (test: Test) => void): this;
    (event: string, listener: (...args: any[]) => void): this;
};

method emit

emit: {
    (name: 'waiting', rootSuite: Suite): boolean;
    (name: 'start'): boolean;
    (name: 'end'): boolean;
    (name: 'suite', suite: Suite): boolean;
    (name: 'suite end', suite: Suite): boolean;
    (name: 'test', test: Test): boolean;
    (name: 'test end', test: Test): boolean;
    (name: 'hook', hook: Hook): boolean;
    (name: 'hook end', hook: Hook): boolean;
    (name: 'pass', test: Test): boolean;
    (name: 'fail', test: Test, err: any): boolean;
    (name: 'pending', test: Test): boolean;
    (name: string, ...args: any[]): boolean;
};

method on

on: {
    (event: 'waiting', listener: (rootSuite: Suite) => void): this;
    (event: 'start', listener: () => void): this;
    (event: 'end', listener: () => void): this;
    (event: 'suite', listener: (suite: Suite) => void): this;
    (event: 'suite end', listener: (suite: Suite) => void): this;
    (event: 'test', listener: (test: Test) => void): this;
    (event: 'test end', listener: (test: Test) => void): this;
    (event: 'hook', listener: (hook: Hook) => void): this;
    (event: 'hook end', listener: (hook: Hook) => void): this;
    (event: 'pass', listener: (test: Test) => void): this;
    (event: 'fail', listener: (test: Test, err: any) => void): this;
    (event: 'pending', listener: (test: Test) => void): this;
    (event: string, listener: (...args: any[]) => void): this;
};

method once

once: {
    (event: 'waiting', listener: (rootSuite: Suite) => void): this;
    (event: 'start', listener: () => void): this;
    (event: 'end', listener: () => void): this;
    (event: 'suite', listener: (suite: Suite) => void): this;
    (event: 'suite end', listener: (suite: Suite) => void): this;
    (event: 'test', listener: (test: Test) => void): this;
    (event: 'test end', listener: (test: Test) => void): this;
    (event: 'hook', listener: (hook: Hook) => void): this;
    (event: 'hook end', listener: (hook: Hook) => void): this;
    (event: 'pass', listener: (test: Test) => void): this;
    (event: 'fail', listener: (test: Test, err: any) => void): this;
    (event: 'pending', listener: (test: Test) => void): this;
    (event: string, listener: (...args: any[]) => void): this;
};

method prependListener

prependListener: {
    (event: 'waiting', listener: (rootSuite: Suite) => void): this;
    (event: 'start', listener: () => void): this;
    (event: 'end', listener: () => void): this;
    (event: 'suite', listener: (suite: Suite) => void): this;
    (event: 'suite end', listener: (suite: Suite) => void): this;
    (event: 'test', listener: (test: Test) => void): this;
    (event: 'test end', listener: (test: Test) => void): this;
    (event: 'hook', listener: (hook: Hook) => void): this;
    (event: 'hook end', listener: (hook: Hook) => void): this;
    (event: 'pass', listener: (test: Test) => void): this;
    (event: 'fail', listener: (test: Test, err: any) => void): this;
    (event: 'pending', listener: (test: Test) => void): this;
    (event: string, listener: (...args: any[]) => void): this;
};

method prependOnceListener

prependOnceListener: {
    (event: 'waiting', listener: (rootSuite: Suite) => void): this;
    (event: 'start', listener: () => void): this;
    (event: 'end', listener: () => void): this;
    (event: 'suite', listener: (suite: Suite) => void): this;
    (event: 'suite end', listener: (suite: Suite) => void): this;
    (event: 'test', listener: (test: Test) => void): this;
    (event: 'test end', listener: (test: Test) => void): this;
    (event: 'hook', listener: (hook: Hook) => void): this;
    (event: 'hook end', listener: (hook: Hook) => void): this;
    (event: 'pass', listener: (test: Test) => void): this;
    (event: 'fail', listener: (test: Test, err: any) => void): this;
    (event: 'pending', listener: (test: Test) => void): this;
    (event: string, listener: (...args: any[]) => void): this;
};

method removeListener

removeListener: {
    (event: 'waiting', listener: (rootSuite: Suite) => void): this;
    (event: 'start', listener: () => void): this;
    (event: 'end', listener: () => void): this;
    (event: 'suite', listener: (suite: Suite) => void): this;
    (event: 'suite end', listener: (suite: Suite) => void): this;
    (event: 'test', listener: (test: Test) => void): this;
    (event: 'test end', listener: (test: Test) => void): this;
    (event: 'hook', listener: (hook: Hook) => void): this;
    (event: 'hook end', listener: (hook: Hook) => void): this;
    (event: 'pass', listener: (test: Test) => void): this;
    (event: 'fail', listener: (test: Test, err: any) => void): this;
    (event: 'pending', listener: (test: Test) => void): this;
    (event: string, listener: (...args: any[]) => void): this;
};

interface Runner

interface Runner extends NodeJS.EventEmitter {}

method addListener

addListener: {
    (event: 'waiting', listener: (rootSuite: Suite) => void): this;
    (event: 'start', listener: () => void): this;
    (event: 'end', listener: () => void): this;
    (event: 'suite', listener: (suite: Suite) => void): this;
    (event: 'suite end', listener: (suite: Suite) => void): this;
    (event: 'test', listener: (test: Test) => void): this;
    (event: 'test end', listener: (test: Test) => void): this;
    (event: 'hook', listener: (hook: Hook) => void): this;
    (event: 'hook end', listener: (hook: Hook) => void): this;
    (event: 'pass', listener: (test: Test) => void): this;
    (event: 'fail', listener: (test: Test, err: any) => void): this;
    (event: 'pending', listener: (test: Test) => void): this;
    (event: string, listener: (...args: any[]) => void): this;
};

method emit

emit: {
    (name: 'waiting', rootSuite: Suite): boolean;
    (name: 'start'): boolean;
    (name: 'end'): boolean;
    (name: 'suite', suite: Suite): boolean;
    (name: 'suite end', suite: Suite): boolean;
    (name: 'test', test: Test): boolean;
    (name: 'test end', test: Test): boolean;
    (name: 'hook', hook: Hook): boolean;
    (name: 'hook end', hook: Hook): boolean;
    (name: 'pass', test: Test): boolean;
    (name: 'fail', test: Test, err: any): boolean;
    (name: 'pending', test: Test): boolean;
    (name: string, ...args: any[]): boolean;
};

method on

on: {
    (event: 'waiting', listener: (rootSuite: Suite) => void): this;
    (event: 'start', listener: () => void): this;
    (event: 'end', listener: () => void): this;
    (event: 'suite', listener: (suite: Suite) => void): this;
    (event: 'suite end', listener: (suite: Suite) => void): this;
    (event: 'test', listener: (test: Test) => void): this;
    (

@types/mocha

Install

Overview

Index

Variables

Functions

Namespaces

Variables

variable after

See Also

variable afterEach

See Also

variable before

See Also

variable beforeEach

See Also

variable context

variable describe

variable it

variable mocha

variable setup

See Also

variable specify

variable suite

variable suiteSetup

See Also

variable suiteTeardown

See Also

variable teardown

See Also

variable test

variable xcontext

variable xdescribe

variable xit

variable xspecify

Functions

function run

See Also

Namespaces

namespace mocha

variable after

See Also

variable afterEach

See Also

variable before

See Also

variable beforeEach

See Also

variable describe

variable it

variable setup

See Also

variable suite

variable suiteSetup

See Also

variable suiteTeardown

See Also

variable teardown

See Also

variable test

variable xdescribe

variable xit

function run

See Also

class Context

See Also

property currentTest

property test

method retries

method runnable

method skip

method slow

method timeout

class Hook

See Also

property originalTitle

property type

method error

See Also

See Also