mocha (master)

# disableTimeouts(value)

Given option/command value, disable timeouts if applicable

Parameters

# require()

private method

This wrapper executable checks for known node flags and appends them when found, before invoking the "real" executable (lib/cli/cli.js)

# trimV8Option(value)

If value begins with v8- and is not explicitly v8-options, remove prefix

Parameters

# Date()

Save timer references to avoid Sinon interfering (see GH-237).

# global.Mocha()

Expose mocha.

# mocha()

Create a Mocha instance.

Returns

undefined

# Mocha.process()

Expose the process shim. https://github.com/mochajs/mocha/pull/916

# mocha.run()

Run mocha, returning the Runner.

# Mocha.Runner.immediately()

High-performance override of Runner.immediately.

# mocha.setup()

Setup mocha with the given setting options.

# mocha.throwError()

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.

# mocha.ui()

Override ui to ensure that the ui functions are initialized. Normally this would happen in Mocha.prototype.loadFiles.

# process.listenerCount()

Implements listenerCount for 'uncaughtException'.

# process.on()

Implements uncaughtException listener.

# process.removeListener()

Remove uncaughtException listener. Revert to original onerror handler if previously defined.

# process.stdout()

Shim process.stdout.

# module.exports()

Loads files from disk (see FILES above) to be shown as data. Used for embedding sources directly into pages

# API_ENDPOINT()

The OC API endpoint

# BLOCKED_CATEGORIES()

Add a few Categories exposed by Open Collective to help moderation

# BLOCKED_STRINGS()

In addition to the blocklist, any account slug matching this regex will not be displayed on the website.

# getAllOrders(slug)

Retrieves donation data from OC Handles pagination

Parameters

# module.exports()

Return the output of mocha --help for display

# addSauceLabsTestName(testName, cfg)

Adds a name for the tests, reflected in SauceLabs' UI. Returns new Karma config. Does not add a test name if the sauceLabs prop of cfg is falsy (which would imply that we're not running tests on SauceLabs).

Parameters

# addSauceTests(cfg, sauceLabs)

Adds Saucelabs-specific config to a Karma config object. If sauceLabs parameter is falsy, just return a clone of the cfg parameter.

Parameters

# addStandardDependencies(cfg)

Returns a new Karma config containing standard dependencies for our tests. Most suites use this.

Parameters

# chooseTestSuite(cfg, value)

Returns a new Karma config to run with specific configuration (which cannot be run with other configurations) as specified by value. Known values: - bdd - bdd-specific tests - tdd - tdd-specific tests - qunit - qunit-specific tests - esm - ESM-specific tests Since we can't change Mocha's interface on-the-fly, tests for specific interfaces must be run in isolation.

Parameters

# createBundleDir(cfg, bundleDirPath)

Creates dir bundleDirPath if it does not exist; returns new Karma config containing bundleDirPath for rollup plugin. If this fails, the rollup plugin will use a temp dir.

Parameters

# highlight(js)

private method

Highlight the given string of js.

Parameters

Returns

string

# highlightTags(name)

private method

Highlight the contents of tag name.

Parameters

# parseQuery(qs)

private method

Parse the given qs.

Parameters

Returns

Object<string, string>

# debug()

Contains CLI entry point and public API for programmatic usage in Node.js. - Option parsing is handled by {@link https://npm.im/yargs yargs}. - If executed via node, this module will run {@linkcode module:lib/cli.main main()}.

# exports.main(argv, mochaArgs)

• Accepts an Array of arguments - Modifies {@link https://nodejs.org/api/modules.html#modules_module_paths Node.js' search path} for easy loading of consumer modules - Sets {@linkcode https://nodejs.org/api/errors.html#errors_error_stacktracelimit Error.stackTraceLimit} to Infinity

Parameters

# module.exports(opts)

private method

Smash together an array of test files in the correct order

Parameters

# exports.init()

private method

Exports Yargs commands

# exports.CONFIG_FILES()

private method

These are the valid config files, in order of precedence; e.g., if .mocharc.js is present, then .mocharc.yaml and the rest will be ignored. The user should still be able to explicitly specify a file.

# exports.findConfig(cwd)

Find ("find up") config file starting at cwd

Parameters

# exports.loadConfig(filepath)

private method

Loads and parses, based on file extension, a config file. "JSON" files may have comments.

Parameters

# fs()

private method

Responsible for loading / finding Mocha's "rc" files.

# parsers()

Parsers for various config filetypes. Each accepts a filepath and returns an object (but could throw)

# fs()

private method

Command module for "init" command

# fs()

private method

Contains lookupFiles, which takes some globs/dirs/options and returns a list of files.

# hasMatchingExtname(pathname, exts)

private method

Determines if pathname has a matching file extension. Supports multi-part extensions.

Parameters

Returns

boolean

`true` if file extension matches.

# isHiddenOnUnix(pathname)

private method

Determines if pathname would be a "hidden" file (or directory) on UN*X.

Parameters

Returns

boolean

whether pathname would be considered a hidden file.

# lookupFiles(filepath, extensions, recursive)

Lookup file names at the given path.

Parameters

Returns

string[]

An array of paths.

# debugFlags()

private method

These flags are considered "debug" flags.

# exports.impliesNoTimeouts(flag)

private method

Returns true if the flag is a "debug-like" flag. These require timeouts to be suppressed, or pausing the debugger on breakpoints will cause test failures.

Parameters

# exports.isNodeFlag(flag, bareword)

private method

Mocha has historical support for various node and V8 flags which might not appear in process.allowedNodeEnvironmentFlags. These include: - --preserve-symlinks - --harmony-* - --gc-global - --trace-* - --es-staging - --use-strict - --v8-* (but not --v8-options)

Parameters

# exports.unparseNodeFlags(opts)

private method

All non-strictly-boolean arguments to node--those with values--must specify those values using =, e.g., --inspect=0.0.0.0. Unparse these arguments using yargs-unparser (which would result in --inspect 0.0.0.0), then supply = where we have values. There's probably an easier or more robust way to do this; fixes welcome

Parameters

# nodeFlags()

private method

Some settings and code related to Mocha's handling of Node.js/V8 flags.

# exports.ONE_AND_DONE_ARGS()

private method

A Set of all one-and-done options

# exports.ONE_AND_DONES()

private method

Handlers for one-and-done options

# Mocha()

private method

Contains "command" code for "one-and-dones"--options passed to Mocha which cause it to just dump some info and exit. See {@link module:lib/cli/one-and-dones.ONE_AND_DONE_ARGS ONE_AND_DONE_ARGS} for more info.

# showKeys(obj)

private method

Dumps a sorted list of the enumerable, lower-case keys of some object to STDOUT.

Parameters

# configuration()

private method

This is the config pulled from the yargs property of Mocha's package.json, but it also disables camel case expansion as to avoid outputting non-canonical keynames, as we need to do some lookups.

# fs()

private method

Main entry point for handling filesystem-based configuration, whether that's a config file or package.json or whatever.

# globOptions()

private method

This is a really fancy way to: - array-type options: ensure unique values and evtl. split comma-delimited lists - boolean/number/string- options: use last element when given multiple times This is passed as the coerce option to yargs-parser

# loadOptions(argv)

Priority list: 1. Command-line args 2. RC file (.mocharc.c?js, .mocharc.ya?ml, mocharc.json) 3. mocha prop of package.json 4. default configuration (lib/mocharc.json) If a {@link module:lib/cli/one-and-dones.ONE_AND_DONE_ARGS "one-and-done" option} is present in the argv array, no external config files will be read.

Parameters

# loadPkgRc(args, args.config)

Given path to package.json in args.package, attempt to load config from mocha prop.

Parameters

# loadRc(args, args.config)

Given path to config file in args.config, attempt to load & parse config file.

Parameters

# nargOpts()

private method

We do not have a case when multiple arguments are ever allowed after a flag (e.g., --foo bar baz quux), so we fix the number of arguments to 1 across the board of non-boolean options. This is passed as the narg option to yargs-parser

# parse(args, defaultValues, configObjects)

private method

Wrapper around yargs-parser which applies our settings

Parameters

# YARGS_PARSER_CONFIG()

private method

Base yargs parser configuration

# exitMocha(code)

private method

Exits Mocha when Mocha itself has finished execution, regardless of what the tests or code under test is doing.

Parameters

# exitMochaLater(code)

private method

Exits Mocha when tests + code under test has finished execution (default)

Parameters

# exports.handleRequires(requires)

private method

require() the modules as required by --require <require>. Returns array of mochaHooks exports, if any.

Parameters

# exports.list(str)

private method

Coerce a comma-delimited string (or array thereof) into a flattened array of strings

Parameters

# exports.runMocha(mocha, opts)

private method

Actually run tests. Delegates to one of four different functions: - singleRun: run tests in serial & exit - watchRun: run tests in serial, rerunning as files change - parallelRun: run tests in parallel & exit - watchParallelRun: run tests in parallel, rerunning as files change

Parameters

# exports.validateLegacyPlugin(opts, pluginType, map)

private method

Used for --reporter and --ui. Ensures there's only one, and asserts that it actually exists. This must be run after requires are processed (see {@link handleRequires}), as it'll prevent interfaces from loading otherwise.

Parameters

# fs()

private method

Helper scripts for the run command

# parallelRun(mocha, options, fileCollectParams)

private method

Collect files and run tests (using BufferedRunner). This is async for consistency.

Parameters

# pluginId()

This should be a unique identifier; either a string (present in map), or a resolvable (via require.resolve) module ID/path.

# singleRun(mocha, opts, opts.exit, fileCollectParams)

private method

Collect and load test files, then run mocha instance.

Parameters

# exports.aliases()

private method

Option aliases keyed by canonical option name. Arrays used to reduce

# exports.isMochaFlag(flag)

private method

Returns true if the provided flag is known to Mocha.

Parameters

# TYPES()

private method

Dictionary of yargs option types to list of options having said type

# GROUPS()

Logical option groups

# symbols()

private method

Definition for Mocha's default ("run tests") command

# blastCache(watcher)

private method

Blast all of the watched files out of require.cache

Parameters

# createRerunner(mocha, watcher, opts, opts.beforeRun)

private method

Create an object that allows you to rerun tests on the mocha instance.

Parameters

# createWatcher(mocha, opts, opts.beforeRun, opts.watchFiles, opts.watchIgnore, opts.fileCollectParams)

private method

Bootstraps a chokidar watcher. Handles keyboard input & signals

Parameters

# eraseLine()

private method

Erases the line on stdout

# exports.watchParallelRun(mocha, opts, opts.watchFiles, opts.watchIgnore, fileCollectParams)

private method

Run Mocha in parallel "watch" mode

Parameters

# exports.watchRun(mocha, opts, opts.watchFiles, opts.watchIgnore, fileCollectParams)

private method

Run Mocha in "watch" mode

Parameters

# getWatchedFiles(watcher)

private method

Return the list of absolute paths watched by a chokidar watcher.

Parameters

Returns

string[]

- List of absolute paths

# hideCursor()

private method

Hide the cursor.

# showCursor()

private method

Show the cursor.

# Context()

private method

Initialize a new Context.

# Context.retries(n)

private method

Set or get a number of allowed retries on failed tests

Parameters

Returns

Context

self

# Context.runnable(runnable)

private method

Set or get the context Runnable to runnable.

Parameters

Returns

Context

context

# Context.skip()

private method

Mark a test as skipped.

# Context.slow(ms)

private method

Set or get test slowness threshold ms.

Parameters

Returns

Context

self

# Context.timeout(ms)

private method

Set or get test timeout ms.

Parameters

Returns

Context

self

# module.exports()

Expose Context.

# constants()

When Mocha throws exceptions (or rejects Promises), it attempts to assign a code property to the Error object, for easier handling. These are the potential values of code.

# createFatalError(message)

Creates an error object to be thrown when an unrecoverable error occurs.

Parameters

# createForbiddenExclusivityError(mocha)

Creates an error object to be thrown when .only() is used with --forbid-only.

Parameters

# createInvalidArgumentTypeError(message, argument, expected)

Creates an error object to be thrown when an argument did not use the supported type

Parameters

# createInvalidArgumentValueError(message, argument, value, reason)

Creates an error object to be thrown when an argument did not use the supported value

Parameters

# createInvalidExceptionError(message)

Creates an error object to be thrown when an exception was caught, but the Error is falsy or undefined.

Parameters

# createInvalidInterfaceError(message, ui)

Creates an error object to be thrown when the interface specified in the options was not found.

Parameters

# createInvalidLegacyPluginError(message, pluginType, pluginId)

Dynamically creates a plugin-type-specific error based on plugin type

Parameters

# createInvalidPluginDefinitionError(msg, pluginDef)

Creates an error object to be thrown when a plugin definition is invalid

Parameters

# createInvalidPluginError(message, pluginType, pluginId)

DEPRECATED. Use {@link createInvalidLegacyPluginError} instead Dynamically creates a plugin-type-specific error based on plugin type

Parameters

# createInvalidPluginImplementationError(msg, opts, opts.pluginDef, opts.pluginImpl)

Creates an error object to be thrown when a plugin implementation (user code) is invalid

Parameters

# createInvalidReporterError(message, reporter)

Creates an error object to be thrown when the reporter specified in the options was not found.

Parameters

# createMissingArgumentError(message, argument, expected)

Creates an error object to be thrown when an argument is missing.

Parameters

# createMochaInstanceAlreadyDisposedError(message, cleanReferencesAfterRun, instance)

Creates an error object to be thrown when a mocha object's run method is executed while it is already disposed.

Parameters

# createMochaInstanceAlreadyRunningError(message)

Creates an error object to be thrown when a mocha object's run method is called while a test run is in progress.

Parameters

# createMultipleDoneError(runnable, originalErr)

Creates an error object to be thrown when done() is called multiple times in a test

Parameters

# createNoFilesMatchPatternError(message, pattern)

Creates an error object to be thrown when no files to be tested could be found using specified pattern.

Parameters

# createTimeoutError(msg, timeout, file)

Creates an error object to be thrown when a runnable exceeds its allowed run time.

Parameters

# createUnparsableFileError(message, filename)

Creates an error object to be thrown when file is unparsable

Parameters

# createUnsupportedError(message)

Creates an error object to be thrown when a behavior, option, or parameter is unsupported.

Parameters

# deprecate(msg)

private method

Show a deprecation warning. Each distinct message is only displayed once. Ignores empty messages.

Parameters

# emitWarning()

process.emitWarning or a polyfill

# FATAL()

An unrecoverable error.

# FORBIDDEN_EXCLUSIVITY()

Use of only() w/ --forbid-only results in this error.

# INSTANCE_ALREADY_DISPOSED()

Invalid state transition occurring in Mocha instance

# INSTANCE_ALREADY_RUNNING()

Invalid state transition occurring in Mocha instance

# INVALID_ARG_TYPE()

The type of an argument to a function call is invalid

# INVALID_ARG_VALUE()

The value of an argument to a function call is invalid

# INVALID_EXCEPTION()

Something was thrown, but it wasn't an Error

# INVALID_INTERFACE()

An interface (e.g., Mocha.interfaces) is unknown or invalid

# INVALID_PLUGIN_DEFINITION()

To be thrown when a builtin or third-party plugin definition (the definition of mochaHooks) is invalid

# INVALID_PLUGIN_IMPLEMENTATION()

To be thrown when a user-defined plugin implementation (e.g., mochaHooks) is invalid

# INVALID_REPORTER()

A reporter (.e.g, Mocha.reporters) is unknown or invalid

# isMochaError(err)

Returns true if an error came out of Mocha. Can suffer from false negatives, but not false positives.

Parameters

# MOCHA_ERRORS()

private method

A set containing all string values of all Mocha error constants, for use by {@link isMochaError}.

# MULTIPLE_DONE()

done() was called twice in a Test or Hook callback

# NO_FILES_MATCH_PATTERN()

No files matched the pattern provided by the user

# TIMEOUT()

When a runnable exceeds its allowed run time.

# UNPARSABLE_FILE()

Input file is not able to be parsed

# UNSUPPORTED()

Known, but unsupported behavior of some kind

# warn(msg)

private method

Show a generic warning. Ignores empty messages.

Parameters

# Hook(title, fn)

Initialize a new Hook with the given title and callback fn

Parameters

# Hook.error(err)

Get or set the test err.

Parameters

Returns

Error

# Hook.reset()

Resets the state for a next run.

# inherits()

Inherit from Runnable.prototype.

# module.exports()

Expose Hook.

# serialize()

private method

Returns an object suitable for IPC. Functions are represented by keys beginning with $$.

# bddInterface(suite)

BDD-style interface: describe('Array', function() { describe('#indexOf()', function() { it('should return -1 when not present', function() { // ... }); it('should return the index when present', function() { // ... }); }); });

Parameters

# context.describe()

Describe a "suite" with the given title and callback fn containing nested suites and/or tests.

# context.describe.only()

Exclusive suite.

# context.it()

Describe a specification or test-case with the given title and callback fn acting as a thunk.

# context.it.only()

Exclusive test-case.

# context.xdescribe()

Pending describe.

# context.xit()

Pending test case.

# after(name, fn)

Execute after running tests.

Parameters

# afterEach(name, fn)

Execute after each test case.

Parameters

# before(name, fn)

Execute before running tests.

Parameters

# beforeEach(name, fn)

Execute before each test case.

Parameters

# create(opts, opts.title, opts.fn, opts.pending, opts.file, opts.isOnly)

Creates a suite.

Parameters

# module.exports(suites, context, mocha)

private method

Functions common to more than one interface.

Parameters

Returns

Object

An object containing common functions.

# only(opts)

Create an exclusive Suite; convenience function See docstring for create() below.

Parameters

# only(mocha, test)

Exclusive test-case.

Parameters

# runWithSuite(suite)

This is only present if flag --delay is passed into Mocha. It triggers root suite execution.

Parameters

Returns

Function

A function which runs the root suite

# shouldBeTested(suite)

private method

Check if the suite should be tested.

Parameters

# skip(opts)

Create a Suite, but skip it; convenience function See docstring for create() below.

Parameters

# skip(title)

Pending test case.

Parameters

# Suite()

# module.exports(suite)

Exports-style (as Node.js module) interface: exports.Array = { '#indexOf()': { 'should return -1 when the value is not present': function() { }, 'should return the correct index when the value is present': function() { } } };

Parameters

# context.suite()

Describe a "suite" with the given title.

# context.suite.only()

Exclusive Suite.

# context.test()

Describe a specification or test-case with the given title and callback fn acting as a thunk.

# context.test.only()

Exclusive test-case.

# qUnitInterface(suite)

QUnit-style interface: suite('Array'); test('#length', function() { var arr = [1,2,3]; ok(arr.length == 3); }); test('#indexOf()', function() { var arr = [1,2,3]; ok(arr.indexOf(1) == 0); ok(arr.indexOf(2) == 1); ok(arr.indexOf(3) == 2); }); suite('String'); test('#length', function() { ok('foo'.length == 3); });

Parameters

# context.suite()

Describe a "suite" with the given title and callback fn containing nested suites and/or tests.

# context.suite.only()

Exclusive test-case.

# context.suite.skip()

Pending suite.

# context.test()

Describe a specification or test-case with the given title and callback fn acting as a thunk.

# context.test.only()

Exclusive test-case.

# module.exports(suite)

TDD-style interface: suite('Array', function() { suite('#indexOf()', function() { suiteSetup(function() { }); test('should return -1 when not present', function() { }); test('should return the index when present', function() { }); suiteTeardown(function() { }); }); });

Parameters

# _runGlobalFixtures(fixtureFns, context)

private method

Run global fixtures sequentially with context context

Parameters

# delay()

# DISPOSED()

private method

Mocha instance is disposed and can no longer be used.

# enableGlobalSetup(enabled)

Toggle execution of any global setup fixture(s)

Parameters

# enableGlobalTeardown(enabled)

Toggle execution of any global teardown fixture(s)

Parameters

# exports.reporters()

# exports.Runner()

# exports.utils()

private method

Expose internals.

# globalSetup(setupFns)

Configures one or more global setup fixtures. If given no parameters, unsets any previously-set fixtures.

Parameters

# globalTeardown(teardownFns)

Configures one or more global teardown fixtures. If given no parameters, unsets any previously-set fixtures.

Parameters

# hasGlobalSetupFixtures()

Returns true if one or more global setup fixtures have been supplied.

# INIT()

private method

Initial state of the mocha instance

# lazyLoadFiles(enable)

Disables implicit call to {@link Mocha#loadFiles} in {@link Mocha#run}. This setting is used by watch mode, parallel mode, and for loading ESM files.

Parameters

# Mocha(options, options.allowUncaught, options.asyncOnly, options.bail, options.checkLeaks, options.color, options.delay, options.diff, options.dryRun, options.failZero, options.fgrep, options.forbidOnly, options.forbidPending, options.fullTrace, options.global, options.grep, options.inlineDiffs, options.invert, options.noHighlighting, options.reporter, options.reporterOption, options.retries, options.slow, options.timeout, options.ui, options.parallel, options.jobs, options.rootHooks, options.require, options.isWorker)

Constructs a new Mocha instance with options.

Parameters

# Mocha._guardRunningStateTransition()

private method

Throws an error if mocha is in the wrong state to be able to transition to a "running" state.

# Mocha.addFile(file)

Parameters

# Mocha.allowUncaught(allowUncaught)

Enables or disables uncaught errors to propagate.

Parameters

Returns

Mocha

this

# Mocha.asyncOnly(asyncOnly)

Forces all tests to either accept a done callback or return a promise.

Parameters

Returns

Mocha

this

# Mocha.bail(bail)

Enables or disables bailing on the first failure.

Parameters

# Mocha.checkLeaks(checkLeaks)

Enables or disables checking for global variables leaked while running tests.

Parameters

Returns

Mocha

this

# Mocha.cleanReferencesAfterRun(cleanReferencesAfterRun)

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.

Parameters

Returns

Mocha

this

# Mocha.color(color)

Enables or disables TTY color output by screen-oriented reporters.

Parameters

Returns

Mocha

this

# Mocha.diff(diff)

Enables or disables reporter to include diff in test failure output.

Parameters

Returns

Mocha

this

# Mocha.dispose()

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.

# Mocha.dryRun(dryRun)

Enables or disables running tests in dry-run mode.

Parameters

Returns

Mocha

this

# Mocha.failZero(failZero)

Fails test run if no tests encountered with exit-code 1.

Parameters

Returns

Mocha

this

# Mocha.fgrep(str)

Sets grep filter after escaping RegExp special characters.

Parameters

# Mocha.forbidOnly(forbidOnly)

Causes tests marked only to fail the suite.

Parameters

# Mocha.forbidPending(forbidPending)

Causes pending tests and tests marked skip to fail the suite.

Parameters

# Mocha.fullTrace(fullTrace)

Displays full stack trace upon test failure.

Parameters

Returns

Mocha

this

# Mocha.global(global)

Specifies whitelist of variable names to be expected in global scope.

Parameters

Returns

Mocha

this

# Mocha.grep(re)

Parameters

Returns

Mocha

this

# Mocha.hasGlobalTeardownFixtures()

Returns true if one or more global teardown fixtures have been supplied.

# Mocha.inlineDiffs(inlineDiffs)

Enables or disables reporter to use inline diffs (rather than +/-) in test failure output.

Parameters

Returns

Mocha

this

# Mocha.invert()

Inverts grep matches.

Returns

Mocha

this

# Mocha.loadFiles(fn)

private method

Loads files prior to execution. Does not support ES Modules.

Parameters

# Mocha.loadFilesAsync(options, options.esmDecorator)

Loads files prior to execution. Supports Node ES Modules.

Parameters

# Mocha.noHighlighting()

Disables syntax highlighting (in browser).

Returns

Mocha

this

# Mocha.reporter(reporterName, reporterOptions)

Sets reporter to reporter, defaults to "spec".

Parameters

# Mocha.retries(retry)

Sets the number of times to retry failed tests.

Parameters

Returns

Mocha

this

# Mocha.run(fn)

Runs root suite and invokes fn() when complete.

Parameters

# Mocha.slow(msecs)

Sets slowness threshold value.

Parameters

Returns

Mocha

this

# Mocha.timeout(msecs)

Parameters

Returns

Mocha

this

# Mocha.ui(ui)

Sets test UI name, defaults to "bdd".

Parameters

# Mocha.unloadFile(file)

private method

Removes a previously loaded file from Node's require cache.

Parameters

# Mocha.unloadFiles()

Unloads files from Node's require cache.

# mochaStates()

private method

A Mocha instance is a finite state machine. These are the states it can be in.

# Object.defineProperty()

Mocha version as specified by "package.json".

# parallelMode(enable)

Toggles parallel mode. Must be run before calling {@link Mocha#run}. Changes the Runner class to use; also enables lazy file loading if not already done so. Warning: when passed false and lazy loading has been enabled via any means (including calling parallelMode(true)), this method will not disable lazy loading. Lazy loading is a prerequisite for parallel mode, but parallel mode is not a prerequisite for lazy loading!

Parameters

# REFERENCES_CLEANED()

private method

Mocha instance is done running tests and references to test functions and hooks are cleaned. You can reset this state by unloading the test files.

# rootHooks(hooks)

Assigns hooks to the root suite

Parameters

# runGlobalSetup(context)

Run any global setup fixtures sequentially, if any. This is automatically called by {@link Mocha#run} unless the runGlobalSetup option is false; see {@link Mocha#enableGlobalSetup}. The context object this function resolves with should be consumed by {@link Mocha#runGlobalTeardown}.

Parameters

# runGlobalTeardown(context)

Run any global teardown fixtures sequentially, if any. This is automatically called by {@link Mocha#run} unless the runGlobalTeardown option is false; see {@link Mocha#enableGlobalTeardown}. Should be called with context object returned by {@link Mocha#runGlobalSetup}, if applicable.

Parameters

# RUNNING()

private method

Mocha instance is running tests

# this._lazyLoadFiles()

private method

Whether or not to call {@link Mocha#loadFiles} implicitly when calling {@link Mocha#run}. If this is true, then it's up to the consumer to call {@link Mocha#loadFiles} or {@link Mocha#loadFilesAsync}.

# this._runnerClass()

private method

The class which we'll instantiate in {@link Mocha#run}. Defaults to {@link Runner} in serial mode; changes in parallel mode.

# this.isWorker()

private method

It's useful for a Mocha instance to know if it's running in a worker process. We could derive this via other means, but it's helpful to have a flag to refer to.

# utils.isBrowser()

To require local UIs and reporters when running in node.

# ...args()

private method

Instantiates a {@link WorkerPool}.

# BufferedWorkerPool()

private method

A wrapper around a third-party worker pool implementation.

# constructor(opts)

Creates an underlying worker pool instance; determines max worker count

Parameters

# optionsCache()

A mapping of Mocha Options objects to serialized values. This is helpful because we tend to same the same options over and over over IPC.

# resetOptionsCache()

private method

Resets internal cache of serialized options objects. For testing/debugging

# run(filepath, options)

private method

Adds a test file run to the worker pool queue for execution by a worker process. Handles serialization/deserialization.

Parameters

# serializeOptions(opts)

private method

Given Mocha options object opts, serialize into a format suitable for transmission over IPC.

Parameters

# stats()

private method

Returns stats about the state of the worker processes in the pool. Used for debugging.

# terminate(force)

private method

Terminates all workers in the pool.

Parameters

# WORKER_POOL_DEFAULT_OPTS()

These options are passed into the workerpool module.

# exports.unloadFile(file)

Deletes a file from the require cache.

Parameters

# _bindSigIntListener(pool)

private method

Listen on Process.SIGINT; terminate pool if caught. Returns the listener for later call to process.removeListener().

Parameters

# _createFileRunner(pool, options)

private method

Returns a mapping function to enqueue a file in the worker pool and return results of its execution.

Parameters

# DEBUG_STATS_INTERVAL()

The interval at which we will display stats for worker processes in debug mode

# debugInterval()

This is an interval that outputs stats about the worker pool every so often

# DENY_OPTIONS()

List of options to not serialize for transmission to workers

# emitEvent(event, failureCount)

Emits event and sets BAILING state, if necessary.

Parameters

# isParallelMode()

If this class is the Runner in use, then this is going to return true. For use by reporters.

# linkEvent(event)

Given an event, recursively find any objects in its data that have ID's, and create object references to already-seen objects.

Parameters

# linkPartialObjects(value)

Toggle partial object linking behavior; used for building object references from unique ID's.

Parameters

# ParallelBufferedRunner()

This Runner delegates tests runs to worker threads. Does not execute any {@link Runnable}s by itself!

# pool()

# run(callback, opts, opts.files, opts.options)

Runs Mocha tests by creating a thread pool, then delegating work to the worker threads. Each worker receives one file, and as workers become available, they take a file from the queue and run it. The worker thread execution is treated like an RPC--it returns a Promise containing serialized information about the run. The information is processed as it's received, and emitted to a {@link Reporter}, which is likely listening for these events.

Parameters

# sigIntListener()

Listener on Process.SIGINT which tries to cleanly terminate the worker pool.

# workerReporter(path)

Configures an alternate reporter for worker processes to use. Subclasses using worker processes should implement this.

Parameters

# constructor(runner)

Calls {@link ParallelBuffered#createListeners}

Parameters

# createListener(eventName)

Returns a new listener which saves event data in memory to {@link ParallelBuffered#events}. Listeners are indexed by eventName and stored in {@link ParallelBuffered#listeners}. This is a defensive measure, so that we don't a) leak memory or b) remove other listeners that may not be associated with this reporter. Subclasses could override this behavior.

Parameters

# createListeners(runner)

Creates event listeners (using {@link ParallelBuffered#createListener}) for each reporter-relevant event emitted by a {@link Runner}. This array is drained when {@link ParallelBuffered#done} is called by {@link Runner#run}. Subclasses could override this behavior.

Parameters

# done(failures, callback)

Calls the {@link Mocha#run} callback (callback) with the test failure count and the array of {@link BufferedEvent} objects. Resets the array. This is called directly by Runner#run and should not be called by any other consumer. Subclasses could override this.

Parameters

# EVENT_NAMES()

List of events to listen to; these will be buffered and sent when Mocha#run is complete (via {@link ParallelBuffered#done}).

# module.exports()

Serializable event data from a Runner. Keys of the data property beginning with __ will be converted into a function which returns the value upon deserialization.

# ONCE_EVENT_NAMES()

Like {@link EVENT_NAMES}, except we expect these events to only be emitted by the Runner once.

# ParallelBuffered()

The ParallelBuffered reporter is used by each worker process in "parallel" mode, by default. Instead of reporting to to STDOUT, etc., it retains a list of events it receives and hands these off to the callback passed into {@link Mocha#run}. That callback will then return the data to the main process.

# this.events()

Retained list of events emitted from the {@link Runner} instance.

# this.listeners()

Map of Runner event names to listeners (for later teardown)

# ...args(args)

Instantiates a new {@link SerializableWorkerResult}.

Parameters

# ...args(args)

In case you hated using new (I do).

Parameters

# _deserializeError(value)

Used internally by {@link SerializableEvent.deserialize}; creates an Error from an Error-like (serialized) object

Parameters

# _deserializeObject(parent, key)

Used internally by {@link SerializableEvent.deserialize}; recursively deserializes an object in-place.

Parameters

# _serialize(pairs, parent, key, seenObjects)

Used internally by {@link SerializableEvent#serialize}.

Parameters

# constructor(events, failureCount)

Creates instance props; of note, the __type prop. Note that the failure count is redundant and could be derived from the list of events; but since we're already doing the work, might as well use it.

Parameters

# constructor(eventName, originalValue, originalError)

Constructs a SerializableEvent, throwing if we receive unexpected data. Practically, events emitted from Runner have a minumum of zero (0) arguments-- (for example, {@link Runnable.constants.EVENT_RUN_BEGIN}) and a maximum of two (2) (for example, {@link Runnable.constants.EVENT_TEST_FAIL}, where the second argument is an Error). The first argument, if present, is a {@link Runnable}. This constructor's arguments adhere to this convention.

Parameters

# deserialize(obj)

Deserializes a {@link SerializedWorkerResult} into something reporters can use; calls {@link SerializableEvent.deserialize} on each item in its events prop.

Parameters

# deserialize(obj)

Deserialize value returned from a worker into something more useful. Does not return the same object.

Parameters

# deserialize(value)

"Deserializes" a "message" received over IPC. This could be expanded with other objects that need deserialization, but at present time we only care about {@link SerializableWorkerResult} objects.

Parameters

# isSerializedWorkerResult(value)

Returns true if this is a {@link SerializedWorkerResult} or a {@link SerializableWorkerResult}.

Parameters

# Object.defineProperty()

Symbol-like value needed to distinguish when attempting to deserialize this object (once it's been received over IPC).

# Object.defineProperty()

An error, if present.

# Object.defineProperty()

The raw value. We don't want this value sent via IPC; making it non-enumerable will do that.

# SerializableEvent()

private method

Represents an event, emitted by a {@link Runner}, which is to be transmitted over IPC. Due to the contents of the event data, it's not possible to send them verbatim. When received by the main process--and handled by reporters--these objects are expected to contain {@link Runnable} instances. This class provides facilities to perform the translation via serialization and deserialization.

# SerializableWorkerResult()

private method

The serializable result of a test file run from a worker.

# serialize()

Serializes each {@link SerializableEvent} in our events prop; makes this object read-only.

# serialize()

Modifies this object in place (for theoretical memory consumption & performance reasons); serializes SerializableEvent#originalValue (placing the result in SerializableEvent#data) and SerializableEvent#error. Freezes this object. The result is an object that can be transmitted over IPC. If this quickly becomes unmaintainable, we will want to move towards immutable objects post-haste.

# serialize(value)

"Serializes" a value for transmission over IPC as a message. If value is an object and has a serialize() method, call that method; otherwise return the object and hope for the best.

Parameters

# this.eventName()

The event name.

# this.events()

All relevant events emitted from the {@link Runner}.

# this.failureCount()

The number of failures in this run

# bootstrap(argv)

Initializes some stuff on the first call to {@link run}. Handles --require and --ui. Does not handle --reporter, as only the Buffered reporter is used. This function only runs once per worker; it overwrites itself with a no-op before returning.

Parameters

# run(filepath, serializedOptions)

Runs a single test file in a worker thread.

Parameters

# module.exports()

# Pending(message)

Initialize a new Pending error with the given message.

Parameters

# constructor(opts)

Initializes plugin names, plugin map, etc.

Parameters

# create(opts)

Constructs a {@link PluginLoader}

Parameters

# finalize()

Call the finalize() function of each known plugin definition on the plugins found by [load()]{@link PluginLoader#load}. Output suitable for passing as input into {@link Mocha} constructor.

# load(requiredModule)

Inspects a module's exports for known plugins and keeps them in memory.

Parameters

# MochaPlugins()

Built-in plugin definitions.

# PluginLoader()

private method

Contains a registry of [plugin definitions]{@link PluginDefinition} and discovers plugin implementations in user-supplied code. - [load()]{@link #load} should be called for all required modules - The result of [finalize()]{@link #finalize} should be merged into the options for the [Mocha]{@link Mocha} constructor.

# register(pluginDef)

Register a plugin

Parameters

# this.ignoredExportNames()

Set of ignored plugins by export name

# this.knownExportNames()

Cache of known exportName values for checking conflicts

# this.knownOptionNames()

Cache of known optionName values for checking conflicts

# this.loaded()

Map of user-supplied plugin implementations

# this.registered()

Map of registered plugin defs

# Base(runner, options)

Constructs a new Base reporter instance.

Parameters

# Base.epilogue()

Outputs common epilogue used by many of the bundled reporters.

# color(type, str)

private method

Color str with the given type, allowing colors to be disabled, as well as user-defined color schemes.

Parameters

Returns

string

# colorLines(name, str)

private method

Colors lines for str, using the color name.

Parameters

Returns

string

# consoleLog()

Save log references to avoid tests interfering (see GH-3604).

# diff()

Module dependencies.

# errorDiff(actual, expected)

private method

Returns character diff for err.

Parameters

Returns

string

the diff

# exports.colors()

Default color map.

# exports.cursor()

Expose some basic cursor interactions that are common among reporters.

# exports.inlineDiffs()

Inline diffs instead of +/-

# exports.list(failures)

Outputs the given failures as a list.

Parameters

# exports.maxDiffSize()

Truncate diffs longer than this value to avoid slow performance

# exports.symbols()

Default symbol map.

# exports.useColors()

Enable coloring by default, except in the browser interface.

# exports.window()

Expose term window size, with some defaults for when stderr is not a tty.

# generateDiff(actual, expected)

Returns a diff between 2 strings with coloured ANSI output.

Parameters

Returns

string

Diff

# getFullErrorStack(err, seen)

private method

Traverses err.cause and returns all stack traces

Parameters

Returns

FullErrorStack

# inlineDiff(actual, expected)

private method

Returns inline diff between 2 strings with coloured ANSI output.

Parameters

Returns

string

Diff

# isatty()

Check if both stdio streams are associated with a tty.

# module.exports()

Expose Base.

# objToString()

Object#toString reference.

# pad(str, len)

private method

Pads the given str to len.

Parameters

Returns

string

# sameType(a, b)

private method

Checks that a / b have the same type.

Parameters

Returns

boolean

# unifiedDiff(actual, expected)

private method

Returns unified diff between two strings with coloured ANSI output.

Parameters

Returns

string

The diff.

# Base()

Module dependencies.

# Doc(runner, options)

Constructs a new Doc reporter instance.

Parameters

# module.exports()

Expose Doc.

# Base()

Module dependencies.

# Dot(runner, options)

Constructs a new Dot reporter instance.

Parameters

# e()

Inherit from Base.prototype.

# module.exports()

Expose Dot.

# Base()

Module dependencies.

# Date()

Save timer references to avoid Sinon interfering (see GH-237).

# error(msg)

Display error msg.

Parameters

# fragment(html)

Return a DOM fragment from html.

Parameters

# hideSuitesWithout(classname)

Check for suites that do not have elements with classname, and hide them.

Parameters

# HTML(runner, options)

Constructs a new HTML reporter instance.

Parameters

# HTML.addCodeToggle(el, contents)

Adds code toggle functionality for the provided test's list element.

Parameters

# HTML.suiteURL(suite)

Provide suite URL.

Parameters

# HTML.testURL(test)

Provide test URL.

Parameters

# makeUrl(s)

Makes a URL, preserving querystring ("search") parameters.

Parameters

Returns

string

A new URL.

# module.exports()

Expose HTML.

# on()

Listen on event with callback fn.

# statsTemplate()

Stats template.

# text(el, contents)

Set an element's text contents.

Parameters

# unhide()

Unhide .hidden suites.

# Base()

Module dependencies.

# clean(test)

private method

Returns an object literal representation of test free of cyclic properties, etc.

Parameters

Returns

Object

object containing pared-down test instance data

# JSONStream(runner, options)

Constructs a new JSONStream reporter instance.

Parameters

# module.exports()

Expose JSONStream.

# writeEvent(event)

private method

Writes Mocha event to reporter output stream.

Parameters

# Base()

Module dependencies.

# clean(test)

private method

Return a plain-object representation of test free of cyclic properties etc.

Parameters

Returns

Object

# cleanCycles(obj)

private method

Replaces any circular references inside obj with '[object Object]'

Parameters

Returns

Object

# errorJSON(err)

private method

Transform an Error object into a JSON object.

Parameters

Returns

Object

# JSONReporter(runner, options)

Constructs a new JSON reporter instance.

Parameters

# module.exports()

Expose JSON.

# Base()

Module dependencies.

# Base.colors()

Airplane crash color.

# Base.colors.plane()

Airplane color.

# Base.colors.runway()

Runway color.

# e()

Inherit from Base.prototype.

# Landing(runner, options)

Constructs a new Landing reporter instance.

Parameters

# module.exports()

Expose Landing.

# Base()

Module dependencies.

# e()

Inherit from Base.prototype.

# List(runner, options)

Constructs a new List reporter instance.

Parameters

# module.exports()

Expose List.

# Base()

Module dependencies.

# Markdown(runner, options)

Constructs a new Markdown reporter instance.

Parameters

# module.exports()

Expose Markdown.

# SUITE_PREFIX()

Constants

# Base()

Module dependencies.

# e()

Inherit from Base.prototype.

# Min(runner, options)

Constructs a new Min reporter instance.

Parameters

# module.exports()

Expose Min.

# Base()

Module dependencies.

# e()

Inherit from Base.prototype.

# module.exports()

Expose Dot.

# NyanCat(runner, options)

Constructs a new Nyan reporter instance.

Parameters

# NyanCat.appendRainbow()

private method

Append the rainbow.

# NyanCat.cursorDown(n)

private method

Move cursor down n.

Parameters

# NyanCat.cursorUp(n)

private method

Move cursor up n.

Parameters

# NyanCat.draw()

private method

Draw the nyan cat

# NyanCat.drawNyanCat()

private method

Draw the nyan cat

# NyanCat.drawRainbow()

private method

Draw the rainbow.

# NyanCat.drawScoreboard()

private method

Draw the "scoreboard" showing the number of passes, failures and pending tests.

# NyanCat.face()

private method

Draw nyan cat face.

Returns

string

# NyanCat.generateColors()

private method

Generate rainbow colors.

Returns

Array

# NyanCat.rainbowify(str)

private method

Apply rainbow to the given str.

Parameters

Returns

string

# Base()

Module dependencies.

# Base.colors.progress()

General progress bar color.

# e()

Inherit from Base.prototype.

# module.exports()

Expose Progress.

# Progress(runner, options)

Constructs a new Progress reporter instance.

Parameters

# Base()

Module dependencies.

# e()

Inherit from Base.prototype.

# module.exports()

Expose Spec.

# Spec(runner, options)

Constructs a new Spec reporter instance.

Parameters

# createProducer(tapVersion)

private method

Returns a tapVersion-appropriate TAP producer instance, if possible.

Parameters

# e()

Inherit from Base.prototype.

# inherits()

Inherit from TAPProducer.prototype.

# inherits()

Inherit from TAPProducer.prototype.

# module.exports()

Expose TAP.

# println(format, varArgs)

private method

Writes newline-terminated formatted string to reporter output stream.

Parameters

# TAP(runner, options)

Constructs a new TAP reporter instance.

Parameters

# TAP12Producer()

private method

# TAP13Producer()

private method

# TAPProducer()

private method

# TAPProducer.writeEpilogue(stats)

Writes the summary epilogue to reporter output stream.

Parameters

# TAPProducer.writeFail(n, test, err)

Writes that test failed to reporter output stream.

Parameters

# TAPProducer.writePass(n, test)

Writes that test passed to reporter output stream.

Parameters

# TAPProducer.writePending(n, test)

Writes that test was skipped to reporter output stream.

Parameters

# TAPProducer.writePlan(ntests)

Writes the plan to reporter output stream.

Parameters

# TAPProducer.writeVersion()

Writes the TAP version to reporter output stream.

# this.writeFail()

Writes that test failed to reporter output stream, with error formatting.

# this.writeFail()

Writes that test failed to reporter output stream, with error formatting.

# this.writeVersion()

Writes the TAP version to reporter output stream.

# title(test)

private method

Returns a TAP-safe title of test.

Parameters

Returns

String

title with any hash character removed

# util()

Module dependencies.

# Base()

Module dependencies.

# Date()

Save timer references to avoid Sinon interfering (see GH-237).

# e()

Inherit from Base.prototype.

# module.exports()

Expose XUnit.

# tag(name, attrs, close, content)

HTML tag helper.

Parameters

Returns

string

# XUnit(runner, options)

Constructs a new XUnit reporter instance.

Parameters

# XUnit.done(failures, fn)

Override done to close the stream (if it's a file).

Parameters

# XUnit.test(test)

Output tag for the given test.

Parameters

# XUnit.write(line)

Write out the given line.

Parameters

# Date()

private method

Save timer references to avoid Sinon interfering (see GH-237).

# Runnable(title, fn)

Initialize a new Runnable with the given title and callback fn.

Parameters

# Runnable._timeoutError(ms)

private method

Instantiates a "timeout" error

Parameters

# Runnable.clearTimeout()

private method

Clear the timeout.

# Runnable.currentRetry()

private method

Set or get current retry

# Runnable.fullTitle()

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

Returns

string

# Runnable.globals(globals)

private method

Set or get a list of whitelisted globals for this test run.

Parameters

# Runnable.isFailed()

private method

Return true if this Runnable has failed.

Returns

boolean

# Runnable.isPassed()

private method

Return true if this Runnable has passed.

Returns

boolean

# Runnable.isPending()

private method

Check if this runnable or its parent suite is marked as pending.

# Runnable.reset()

Resets the state initially or for a next run.

# Runnable.resetTimeout()

private method

Reset the timeout.

# Runnable.retries()

private method

Set or get number of retries.

# Runnable.run(fn)

private method

Run the test and invoke fn(err).

Parameters

# Runnable.skip()

Halt and mark as pending.

# Runnable.slow(ms)

private method

Set or get slow ms.

Parameters

Returns

Runnable|number

ms or Runnable instance.

# Runnable.timeout(ms)

private method

Parameters

# Runnable.titlePath()

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

Returns

string[]

# Runnable.toValueOrError(value)

private method

Given value, return identity if truthy, otherwise create an "invalid exception" error and return that.

Parameters

# SED()

Value of state prop when a Runnable has passed

# STATE_FAILED()

Value of state prop when a Runnable has failed

# STATE_PENDING()

Value of state prop when a Runnable has been skipped by user

# utils.inherits()

Inherit from EventEmitter.prototype.

# constructor(suite, opts, opts.cleanReferencesAfterRun, opts.delay, opts.dryRun, opts.failZero)

Initialize a Runner at the Root {@link Suite}, which represents a hierarchy of {@link Suite|Suites} and {@link Test|Tests}.

Parameters

# EVENT_DELAY_BEGIN()

Emitted when Root {@link Suite} execution has been delayed via delay option

# EVENT_DELAY_END()

Emitted when delayed Root {@link Suite} execution is triggered by user via global.run()

# EVENT_HOOK_BEGIN()

Emitted when {@link Hook} execution begins

# EVENT_HOOK_END()

Emitted when {@link Hook} execution ends

# EVENT_RUN_BEGIN()

Emitted when Root {@link Suite} execution begins (all files have been parsed and hooks/tests are ready for execution)

# EVENT_RUN_END()

Emitted when Root {@link Suite} execution ends

# EVENT_SUITE_BEGIN()

Emitted when {@link Suite} execution begins

# EVENT_SUITE_END()

Emitted when {@link Suite} execution ends

# EVENT_TEST_BEGIN()

Emitted when {@link Test} execution begins

# EVENT_TEST_END()

Emitted when {@link Test} execution ends

# EVENT_TEST_FAIL()

Emitted when {@link Test} execution fails

# EVENT_TEST_PENDING()

Emitted when {@link Test} becomes pending

# EVENT_TEST_RETRY()

Emitted when {@link Test} execution has failed, but will retry

# EventEmitter()

private method

Module dependencies.

# filterLeaks(ok, globals)

private method

Filter leaks with the given globals flagged as ok.

Parameters

Returns

Array

# globals()

private method

Non-enumerable globals.

# isError(err, err.message)

private method

Check if argument is an instance of Error object or a duck-typed equivalent.

Parameters

# isParallelMode()

Returns true if Mocha is running in parallel mode. For reporters. Subclasses should return an appropriate value.

# module.exports()

Node.js' EventEmitter

# Runner._addEventListener(target, eventName, fn)

private method

Replacement for target.on(eventName, listener) that does bookkeeping to remove them when this runner instance is disposed.

Parameters

# Runner._removeEventListener(target, eventName, listener)

private method

Replacement for target.removeListener(eventName, listener) that also updates the bookkeeping.

Parameters

# Runner._uncaught(err)

private method

Handle uncaught exceptions within runner. This function is bound to the instance as Runner#uncaught at instantiation time. It's intended to be listening on the Process.uncaughtException event. In order to not leak EE listeners, we need to ensure no more than a single uncaughtException listener exists per Runner. The only way to do this--because this function needs the context (and we don't have lambdas)--is to use Function.prototype.bind. We need strict equality to unregister and only unregister the one listener we set from the Process.uncaughtException event; would be poor form to just remove everything. See {@link Runner#run} for where the event listener is registered and unregistered.

Parameters

# Runner.abort()

Cleanly abort execution.

Returns

Runner

Runner instance.

# Runner.checkGlobals()

private method

Check for global variable leaks.

# Runner.dispose()

Removes all event handlers set during a run on this instance. Remark: this does not clean/dispose the tests or suites themselves.

# Runner.fail(test, err, force)

private method

Fail the given test. If test is a hook, failures work in the following pattern: - If bail, run corresponding after each and after hooks, 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

Parameters

# Runner.globalProps()

private method

Return a list of global properties.

Returns

Array

# Runner.globals(arr)

Allow the given arr of globals.

Parameters

Returns

Runner

Runner instance.

# Runner.grep(re, invert)

Run tests with full titles matching re. Updates runner.total with number of tests matched.

Parameters

Returns

Runner

Runner instance.

# Runner.grepTotal(suite)

Returns the number of tests matching the grep search for the given suite.

Parameters

Returns

number

# Runner.hook(name, fn)

private method

Run hook name callbacks and then invoke fn().

Parameters

# Runner.hookDown(name, fn)

private method

Run 'beforeEach' hooks from top level down.

Parameters

# Runner.hooks(name, suites, fn)

private method

Run hook name for the given array of suites in order, and callback fn(err, errSuite).

Parameters

# Runner.hookUp(name, fn)

private method

Run 'afterEach' hooks from bottom up.

Parameters

# Runner.immediately(fn)

private method

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

Parameters

# Runner.linkPartialObjects(value)

Toggle partial object linking behavior; used for building object references from unique ID's. Does nothing in serial mode, because the object references already exist. Subclasses can implement this (e.g., ParallelBufferedRunner)

Parameters

# Runner.parents()

private method

Return an array of parent Suites from closest to furthest.

Returns

Array

# Runner.run(fn, opts, opts.files, opts.options)

Run the root suite and invoke fn(failures) on completion.