8029

pending completion

Build # 8029

Build Type

Pull #4360

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/mochajs/mocha/commit/<a class=hub.com/mochajs/mocha/commit/<a class="double-link" href="https://git"><a class=hub.com/mochajs/mocha/commit/<a class="double-link" href="https://git"><a class=hub.com/mochajs/mocha/commit/<a class="double-link" href="https://git"><a class=hub.com/mochajs/mocha/commit/b25f793342dd45ec20a7e053f8430766bb0fa34c">b25f79334">&lt;a href=&quot;https://github.com/mochajs/mocha/commit/</a><a class="double-link" href="https://github.com/mochajs/mocha/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/mochajs/mocha/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/mochajs/mocha/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/mochajs/mocha/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/mochajs/mocha/commit/b25f793342dd45ec20a7e053f8430766bb0fa34c">b25f79334</a><a href="https://github.com/mochajs/mocha/commit/b25f793342dd45ec20a7e053f8430766bb0fa34c">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/mochajs/mocha/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/mochajs/mocha/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/mochajs/mocha/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/mochajs/mocha/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/mochajs/mocha/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/mochajs/mocha/commit/b25f793342dd45ec20a7e053f8430766bb0fa34c&quot;&gt;b25f79334&lt;/a&gt;&lt;a href=&quot;https://github.com/mochajs/mocha/commit/b25f793342dd45ec20a7e053f8430766bb0fa34c&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/mochajs/mocha/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/mochajs/mocha/commit/&amp;amp;lt;a class=&amp;amp;quot;double-link&amp;amp;quot; href=&amp;amp;quot;htt... (continued)

Pull Request Pull Request #4360: implementation of global setup/teardown; closes #4308

Run Details

1308 of 1486 branches covered (88.02%)

300 of 300 new or added lines in 10 files covered. (100.0%)

3422 of 3642 relevant lines covered (93.96%)

979.71 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.0

/lib/errors.js

'use strict';

var format = require('util').format;
const {deprecate} = require('./utils');

/**
 * Factory functions to create throwable error objects
 * @module Errors
 */

/**
 * When Mocha throw exceptions (or otherwise errors), it attempts to assign a
 * `code` property to the `Error` object, for easier handling.  These are the
 * potential values of `code`.
 */
var constants = {
  /**
   * An unrecoverable error.
   */
  FATAL: 'ERR_MOCHA_FATAL',

  /**
   * The type of an argument to a function call is invalid
   */
  INVALID_ARG_TYPE: 'ERR_MOCHA_INVALID_ARG_TYPE',

  /**
   * The value of an argument to a function call is invalid
   */
  INVALID_ARG_VALUE: 'ERR_MOCHA_INVALID_ARG_VALUE',

  /**
   * Something was thrown, but it wasn't an `Error`
   */
  INVALID_EXCEPTION: 'ERR_MOCHA_INVALID_EXCEPTION',

  /**
   * An interface (e.g., `Mocha.interfaces`) is unknown or invalid
   */
  INVALID_INTERFACE: 'ERR_MOCHA_INVALID_INTERFACE',

  /**
   * A reporter (.e.g, `Mocha.reporters`) is unknown or invalid
   */
  INVALID_REPORTER: 'ERR_MOCHA_INVALID_REPORTER',

  /**
   * `done()` was called twice in a `Test` or `Hook` callback
   */
  MULTIPLE_DONE: 'ERR_MOCHA_MULTIPLE_DONE',

  /**
   * No files matched the pattern provided by the user
   */
  NO_FILES_MATCH_PATTERN: 'ERR_MOCHA_NO_FILES_MATCH_PATTERN',

  /**
   * Known, but unsupported behavior of some kind
   */
  UNSUPPORTED: 'ERR_MOCHA_UNSUPPORTED',

  /**
   * Invalid state transition occurring in `Mocha` instance
   */
  INSTANCE_ALREADY_RUNNING: 'ERR_MOCHA_INSTANCE_ALREADY_RUNNING',

  /**
   * Invalid state transition occurring in `Mocha` instance
   */
  INSTANCE_ALREADY_DISPOSED: 'ERR_MOCHA_INSTANCE_ALREADY_DISPOSED',

  /**
   * Use of `only()` w/ `--forbid-only` results in this error.
   */
  FORBIDDEN_EXCLUSIVITY: 'ERR_MOCHA_FORBIDDEN_EXCLUSIVITY',

  /**
   * To be thrown when a user-defined plugin implementation (e.g., `mochaHooks`) is invalid
   */
  INVALID_PLUGIN_IMPLEMENTATION: 'ERR_MOCHA_INVALID_PLUGIN_IMPLEMENTATION',

  /**
   * To be thrown when a builtin or third-party plugin definition (the _definition_ of `mochaHooks`) is invalid
   */
  INVALID_PLUGIN_DEFINITION: 'ERR_MOCHA_INVALID_PLUGIN_DEFINITION'
};

/**
 * Creates an error object to be thrown when no files to be tested could be found using specified pattern.
 *
 * @public
 * @param {string} message - Error message to be displayed.
 * @param {string} pattern - User-specified argument value.
 * @returns {Error} instance detailing the error condition
 */
function createNoFilesMatchPatternError(message, pattern) {
  var err = new Error(message);
  err.code = constants.NO_FILES_MATCH_PATTERN;
  err.pattern = pattern;
  return err;
}

/**
 * Creates an error object to be thrown when the reporter specified in the options was not found.
 *
 * @public
 * @param {string} message - Error message to be displayed.
 * @param {string} reporter - User-specified reporter value.
 * @returns {Error} instance detailing the error condition
 */
function createInvalidReporterError(message, reporter) {
  var err = new TypeError(message);
  err.code = constants.INVALID_REPORTER;
  err.reporter = reporter;
  return err;
}

/**
 * Creates an error object to be thrown when the interface specified in the options was not found.
 *
 * @public
 * @param {string} message - Error message to be displayed.
 * @param {string} ui - User-specified interface value.
 * @returns {Error} instance detailing the error condition
 */
function createInvalidInterfaceError(message, ui) {
  var err = new Error(message);
  err.code = constants.INVALID_INTERFACE;
  err.interface = ui;
  return err;
}

/**
 * Creates an error object to be thrown when a behavior, option, or parameter is unsupported.
 *
 * @public
 * @param {string} message - Error message to be displayed.
 * @returns {Error} instance detailing the error condition
 */
function createUnsupportedError(message) {
  var err = new Error(message);
  err.code = constants.UNSUPPORTED;
  return err;
}

/**
 * Creates an error object to be thrown when an argument is missing.
 *
 * @public
 * @param {string} message - Error message to be displayed.
 * @param {string} argument - Argument name.
 * @param {string} expected - Expected argument datatype.
 * @returns {Error} instance detailing the error condition
 */
function createMissingArgumentError(message, argument, expected) {
  return createInvalidArgumentTypeError(message, argument, expected);
}

/**
 * Creates an error object to be thrown when an argument did not use the supported type
 *
 * @public
 * @param {string} message - Error message to be displayed.
 * @param {string} argument - Argument name.
 * @param {string} expected - Expected argument datatype.
 * @returns {Error} instance detailing the error condition
 */
function createInvalidArgumentTypeError(message, argument, expected) {
  var err = new TypeError(message);
  err.code = constants.INVALID_ARG_TYPE;
  err.argument = argument;
  err.expected = expected;
  err.actual = typeof argument;
  return err;
}

/**
 * Creates an error object to be thrown when an argument did not use the supported value
 *
 * @public
 * @param {string} message - Error message to be displayed.
 * @param {string} argument - Argument name.
 * @param {string} value - Argument value.
 * @param {string} [reason] - Why value is invalid.
 * @returns {Error} instance detailing the error condition
 */
function createInvalidArgumentValueError(message, argument, value, reason) {
  var err = new TypeError(message);
  err.code = constants.INVALID_ARG_VALUE;
  err.argument = argument;
  err.value = value;
  err.reason = typeof reason !== 'undefined' ? reason : 'is invalid';
  return err;
}

/**
 * Creates an error object to be thrown when an exception was caught, but the `Error` is falsy or undefined.
 *
 * @public
 * @param {string} message - Error message to be displayed.
 * @returns {Error} instance detailing the error condition
 */
function createInvalidExceptionError(message, value) {
  var err = new Error(message);
  err.code = constants.INVALID_EXCEPTION;
  err.valueType = typeof value;
  err.value = value;
  return err;
}

/**
 * Creates an error object to be thrown when an unrecoverable error occurs.
 *
 * @public
 * @param {string} message - Error message to be displayed.
 * @returns {Error} instance detailing the error condition
 */
function createFatalError(message, value) {
  var err = new Error(message);
  err.code = constants.FATAL;
  err.valueType = typeof value;
  err.value = value;
  return err;
}

/**
 * Dynamically creates a plugin-type-specific error based on plugin type
 * @param {string} message - Error message
 * @param {"reporter"|"interface"} pluginType - Plugin type. Future: expand as needed
 * @param {string} [pluginId] - Name/path of plugin, if any
 * @throws When `pluginType` is not known
 * @public
 * @returns {Error}
 */
function createInvalidLegacyPluginError(message, pluginType, pluginId) {
  switch (pluginType) {
    case 'reporter':
      return createInvalidReporterError(message, pluginId);
    case 'interface':
      return createInvalidInterfaceError(message, pluginId);
    default:
      throw new Error('unknown pluginType "' + pluginType + '"');
  }
}

/**
 * **DEPRECATED**.  Use {@link createInvalidLegacyPluginError} instead  Dynamically creates a plugin-type-specific error based on plugin type
 * @deprecated
 * @param {string} message - Error message
 * @param {"reporter"|"interface"} pluginType - Plugin type. Future: expand as needed
 * @param {string} [pluginId] - Name/path of plugin, if any
 * @throws When `pluginType` is not known
 * @public
 * @returns {Error}
 */
function createInvalidPluginError(...args) {
  deprecate('Use createInvalidLegacyPluginError() instead');
  return createInvalidLegacyPluginError(...args);
}

/**
 * Creates an error object to be thrown when a mocha object's `run` method is executed while it is already disposed.
 * @param {string} message The error message to be displayed.
 * @param {boolean} cleanReferencesAfterRun the value of `cleanReferencesAfterRun`
 * @param {Mocha} instance the mocha instance that throw this error
 */
function createMochaInstanceAlreadyDisposedError(
  message,
  cleanReferencesAfterRun,
  instance
) {
  var err = new Error(message);
  err.code = constants.INSTANCE_ALREADY_DISPOSED;
  err.cleanReferencesAfterRun = cleanReferencesAfterRun;
  err.instance = instance;
  return err;
}

/**
 * Creates an error object to be thrown when a mocha object's `run` method is called while a test run is in progress.
 * @param {string} message The error message to be displayed.
 */
function createMochaInstanceAlreadyRunningError(message, instance) {
  var err = new Error(message);
  err.code = constants.INSTANCE_ALREADY_RUNNING;
  err.instance = instance;
  return err;
}

/*
 * Creates an error object to be thrown when done() is called multiple times in a test
 *
 * @public
 * @param {Runnable} runnable - Original runnable
 * @param {Error} [originalErr] - Original error, if any
 * @returns {Error} instance detailing the error condition
 */
function createMultipleDoneError(runnable, originalErr) {
  var title;
  try {
    title = format('<%s>', runnable.fullTitle());
    if (runnable.parent.root) {
      title += ' (of root suite)';
    }
  } catch (ignored) {
    title = format('<%s> (of unknown suite)', runnable.title);
  }
  var message = format(
    'done() called multiple times in %s %s',
    runnable.type ? runnable.type : 'unknown runnable',
    title
  );
  if (runnable.file) {
    message += format(' of file %s', runnable.file);
  }
  if (originalErr) {
    message += format('; in addition, done() received error: %s', originalErr);
  }

  var err = new Error(message);
  err.code = constants.MULTIPLE_DONE;
  err.valueType = typeof originalErr;
  err.value = originalErr;
  return err;
}

/**
 * Creates an error object to be thrown when `.only()` is used with
 * `--forbid-only`.
 * @public
 * @param {Mocha} mocha - Mocha instance
 * @returns {Error} Error with code {@link constants.FORBIDDEN_EXCLUSIVITY}
 */
function createForbiddenExclusivityError(mocha) {
  var err = new Error(
    mocha.isWorker
      ? '`.only` is not supported in parallel mode'
      : '`.only` forbidden by --forbid-only'
  );
  err.code = constants.FORBIDDEN_EXCLUSIVITY;
  return err;
}

/**
 * Creates an error object to be thrown when a plugin definition is invalid
 * @param {string} msg - Error message
 * @param {PluginDefinition} [pluginDef] - Problematic plugin definition
 * @public
 * @returns {Error} Error with code {@link constants.INVALID_PLUGIN_DEFINITION}
 */
function createInvalidPluginDefinitionError(msg, pluginDef) {
  const err = new Error(msg);
  err.code = constants.INVALID_PLUGIN_DEFINITION;
  err.pluginDef = pluginDef;
  return err;
}

/**
 * Creates an error object to be thrown when a plugin implementation (user code) is invalid
 * @param {string} msg - Error message
 * @param {Object} [opts] - Plugin definition and user-supplied implementation
 * @param {PluginDefinition} [opts.pluginDef] - Plugin Definition
 * @param {*} [opts.pluginImpl] - Plugin Implementation (user-supplied)
 * @public
 * @returns {Error} Error with code {@link constants.INVALID_PLUGIN_DEFINITION}
 */
function createInvalidPluginImplementationError(
  msg,
  {pluginDef, pluginImpl} = {}
) {
  const err = new Error(msg);
  err.code = constants.INVALID_PLUGIN_IMPLEMENTATION;
  err.pluginDef = pluginDef;
  err.pluginImpl = pluginImpl;
  return err;
}

module.exports = {
  constants,
  createFatalError,
  createForbiddenExclusivityError,
  createInvalidArgumentTypeError,
  createInvalidArgumentValueError,
  createInvalidExceptionError,
  createInvalidInterfaceError,
  createInvalidPluginDefinitionError,
  createInvalidPluginImplementationError,
  createInvalidPluginError,
  createInvalidLegacyPluginError,
  createInvalidReporterError,
  createMissingArgumentError,
  createMochaInstanceAlreadyDisposedError,
  createMochaInstanceAlreadyRunningError,
  createMultipleDoneError,
  createNoFilesMatchPatternError,
  createUnsupportedError
};

1	'use strict';
2
3	var format = require('util').format;	427✔
4	const {deprecate} = require('./utils');	427✔
5
6	/**
7	* Factory functions to create throwable error objects
8	* @module Errors
9	*/
10
11	/**
12	* When Mocha throw exceptions (or otherwise errors), it attempts to assign a
13	* `code` property to the `Error` object, for easier handling. These are the
14	* potential values of `code`.
15	*/
16	var constants = {	427✔
17	/**
18	* An unrecoverable error.
19	*/
20	FATAL: 'ERR_MOCHA_FATAL',
21
22	/**
23	* The type of an argument to a function call is invalid
24	*/
25	INVALID_ARG_TYPE: 'ERR_MOCHA_INVALID_ARG_TYPE',
26
27	/**
28	* The value of an argument to a function call is invalid
29	*/
30	INVALID_ARG_VALUE: 'ERR_MOCHA_INVALID_ARG_VALUE',
31
32	/**
33	* Something was thrown, but it wasn't an `Error`
34	*/
35	INVALID_EXCEPTION: 'ERR_MOCHA_INVALID_EXCEPTION',
36
37	/**
38	* An interface (e.g., `Mocha.interfaces`) is unknown or invalid
39	*/
40	INVALID_INTERFACE: 'ERR_MOCHA_INVALID_INTERFACE',
41
42	/**
43	* A reporter (.e.g, `Mocha.reporters`) is unknown or invalid
44	*/
45	INVALID_REPORTER: 'ERR_MOCHA_INVALID_REPORTER',
46
47	/**
48	* `done()` was called twice in a `Test` or `Hook` callback
49	*/
50	MULTIPLE_DONE: 'ERR_MOCHA_MULTIPLE_DONE',
51
52	/**
53	* No files matched the pattern provided by the user
54	*/
55	NO_FILES_MATCH_PATTERN: 'ERR_MOCHA_NO_FILES_MATCH_PATTERN',
56
57	/**
58	* Known, but unsupported behavior of some kind
59	*/
60	UNSUPPORTED: 'ERR_MOCHA_UNSUPPORTED',
61
62	/**
63	* Invalid state transition occurring in `Mocha` instance
64	*/
65	INSTANCE_ALREADY_RUNNING: 'ERR_MOCHA_INSTANCE_ALREADY_RUNNING',
66
67	/**
68	* Invalid state transition occurring in `Mocha` instance
69	*/
70	INSTANCE_ALREADY_DISPOSED: 'ERR_MOCHA_INSTANCE_ALREADY_DISPOSED',
71
72	/**
73	* Use of `only()` w/ `--forbid-only` results in this error.
74	*/
75	FORBIDDEN_EXCLUSIVITY: 'ERR_MOCHA_FORBIDDEN_EXCLUSIVITY',
76
77	/**
78	* To be thrown when a user-defined plugin implementation (e.g., `mochaHooks`) is invalid
79	*/
80	INVALID_PLUGIN_IMPLEMENTATION: 'ERR_MOCHA_INVALID_PLUGIN_IMPLEMENTATION',
81
82	/**
83	* To be thrown when a builtin or third-party plugin definition (the _definition_ of `mochaHooks`) is invalid
84	*/
85	INVALID_PLUGIN_DEFINITION: 'ERR_MOCHA_INVALID_PLUGIN_DEFINITION'
86	};
87
88	/**
89	* Creates an error object to be thrown when no files to be tested could be found using specified pattern.
90	*
91	* @public
92	* @param {string} message - Error message to be displayed.
93	* @param {string} pattern - User-specified argument value.
94	* @returns {Error} instance detailing the error condition
95	*/
96	function createNoFilesMatchPatternError(message, pattern) {
97	var err = new Error(message);	12✔
98	err.code = constants.NO_FILES_MATCH_PATTERN;	12✔
99	err.pattern = pattern;	12✔
100	return err;	12✔
101	}
102
103	/**
104	* Creates an error object to be thrown when the reporter specified in the options was not found.
105	*
106	* @public
107	* @param {string} message - Error message to be displayed.
108	* @param {string} reporter - User-specified reporter value.
109	* @returns {Error} instance detailing the error condition
110	*/
111	function createInvalidReporterError(message, reporter) {
112	var err = new TypeError(message);	10✔
113	err.code = constants.INVALID_REPORTER;	10✔
114	err.reporter = reporter;	10✔
115	return err;	10✔
116	}
117
118	/**
119	* Creates an error object to be thrown when the interface specified in the options was not found.
120	*
121	* @public
122	* @param {string} message - Error message to be displayed.
123	* @param {string} ui - User-specified interface value.
124	* @returns {Error} instance detailing the error condition
125	*/
126	function createInvalidInterfaceError(message, ui) {
127	var err = new Error(message);	3✔
128	err.code = constants.INVALID_INTERFACE;	3✔
129	err.interface = ui;	3✔
130	return err;	3✔
131	}
132
133	/**
134	* Creates an error object to be thrown when a behavior, option, or parameter is unsupported.
135	*
136	* @public
137	* @param {string} message - Error message to be displayed.
138	* @returns {Error} instance detailing the error condition
139	*/
140	function createUnsupportedError(message) {
141	var err = new Error(message);	15✔
142	err.code = constants.UNSUPPORTED;	15✔
143	return err;	15✔
144	}
145
146	/**
147	* Creates an error object to be thrown when an argument is missing.
148	*
149	* @public
150	* @param {string} message - Error message to be displayed.
151	* @param {string} argument - Argument name.
152	* @param {string} expected - Expected argument datatype.
153	* @returns {Error} instance detailing the error condition
154	*/
155	function createMissingArgumentError(message, argument, expected) {
156	return createInvalidArgumentTypeError(message, argument, expected);	3✔
157	}
158
159	/**
160	* Creates an error object to be thrown when an argument did not use the supported type
161	*
162	* @public
163	* @param {string} message - Error message to be displayed.
164	* @param {string} argument - Argument name.
165	* @param {string} expected - Expected argument datatype.
166	* @returns {Error} instance detailing the error condition
167	*/
168	function createInvalidArgumentTypeError(message, argument, expected) {
169	var err = new TypeError(message);	13✔
170	err.code = constants.INVALID_ARG_TYPE;	13✔
171	err.argument = argument;	13✔
172	err.expected = expected;	13✔
173	err.actual = typeof argument;	13✔
174	return err;	13✔
175	}
176
177	/**
178	* Creates an error object to be thrown when an argument did not use the supported value
179	*
180	* @public
181	* @param {string} message - Error message to be displayed.
182	* @param {string} argument - Argument name.
183	* @param {string} value - Argument value.
184	* @param {string} [reason] - Why value is invalid.
185	* @returns {Error} instance detailing the error condition
186	*/
187	function createInvalidArgumentValueError(message, argument, value, reason) {
188	var err = new TypeError(message);	11✔
189	err.code = constants.INVALID_ARG_VALUE;	11✔
190	err.argument = argument;	11✔
191	err.value = value;	11✔
192	err.reason = typeof reason !== 'undefined' ? reason : 'is invalid';	11✔
193	return err;	11✔
194	}
195
196	/**
197	* Creates an error object to be thrown when an exception was caught, but the `Error` is falsy or undefined.
198	*
199	* @public
200	* @param {string} message - Error message to be displayed.
201	* @returns {Error} instance detailing the error condition
202	*/
203	function createInvalidExceptionError(message, value) {
204	var err = new Error(message);	9✔
205	err.code = constants.INVALID_EXCEPTION;	9✔
206	err.valueType = typeof value;	9✔
207	err.value = value;	9✔
208	return err;	9✔
209	}
210
211	/**
212	* Creates an error object to be thrown when an unrecoverable error occurs.
213	*
214	* @public
215	* @param {string} message - Error message to be displayed.
216	* @returns {Error} instance detailing the error condition
217	*/
218	function createFatalError(message, value) {
219	var err = new Error(message);	2✔
220	err.code = constants.FATAL;	2✔
221	err.valueType = typeof value;	2✔
222	err.value = value;	2✔
223	return err;	2✔
224	}
225
226	/**
227	* Dynamically creates a plugin-type-specific error based on plugin type
228	* @param {string} message - Error message
229	* @param {"reporter"\|"interface"} pluginType - Plugin type. Future: expand as needed
230	* @param {string} [pluginId] - Name/path of plugin, if any
231	* @throws When `pluginType` is not known
232	* @public
233	* @returns {Error}
234	*/
235	function createInvalidLegacyPluginError(message, pluginType, pluginId) {
236	switch (pluginType) {	6✔
237	case 'reporter':
238	return createInvalidReporterError(message, pluginId);	3✔
239	case 'interface':
240	return createInvalidInterfaceError(message, pluginId);	2✔
241	default:
242	throw new Error('unknown pluginType "' + pluginType + '"');	1✔
243	}
244	}
245
246	/**
247	* DEPRECATED. Use {@link createInvalidLegacyPluginError} instead Dynamically creates a plugin-type-specific error based on plugin type
248	* @deprecated
249	* @param {string} message - Error message
250	* @param {"reporter"\|"interface"} pluginType - Plugin type. Future: expand as needed
251	* @param {string} [pluginId] - Name/path of plugin, if any
252	* @throws When `pluginType` is not known
253	* @public
254	* @returns {Error}
255	*/
256	function createInvalidPluginError(...args) {
257	deprecate('Use createInvalidLegacyPluginError() instead');	×
258	return createInvalidLegacyPluginError(...args);	×
259	}
260
261	/**
262	* Creates an error object to be thrown when a mocha object's `run` method is executed while it is already disposed.
263	* @param {string} message The error message to be displayed.
264	* @param {boolean} cleanReferencesAfterRun the value of `cleanReferencesAfterRun`
265	* @param {Mocha} instance the mocha instance that throw this error
266	*/
267	function createMochaInstanceAlreadyDisposedError(
268	message,
269	cleanReferencesAfterRun,
270	instance
271	) {
272	var err = new Error(message);	6✔
273	err.code = constants.INSTANCE_ALREADY_DISPOSED;	6✔
274	err.cleanReferencesAfterRun = cleanReferencesAfterRun;	6✔
275	err.instance = instance;	6✔
276	return err;	6✔
277	}
278
279	/**
280	* Creates an error object to be thrown when a mocha object's `run` method is called while a test run is in progress.
281	* @param {string} message The error message to be displayed.
282	*/
283	function createMochaInstanceAlreadyRunningError(message, instance) {
284	var err = new Error(message);	3✔
285	err.code = constants.INSTANCE_ALREADY_RUNNING;	3✔
286	err.instance = instance;	3✔
287	return err;	3✔
288	}
289
290	/*
291	* Creates an error object to be thrown when done() is called multiple times in a test
292	*
293	* @public
294	* @param {Runnable} runnable - Original runnable
295	* @param {Error} [originalErr] - Original error, if any
296	* @returns {Error} instance detailing the error condition
297	*/
298	function createMultipleDoneError(runnable, originalErr) {
299	var title;
300	try {	11✔
301	title = format('<%s>', runnable.fullTitle());	11✔
302	if (runnable.parent.root) {	9✔
303	title += ' (of root suite)';	3✔
304	}
305	} catch (ignored) {
306	title = format('<%s> (of unknown suite)', runnable.title);	2✔
307	}
308	var message = format(	11✔
309	'done() called multiple times in %s %s',
310	runnable.type ? runnable.type : 'unknown runnable',	11✔
311	title
312	);
313	if (runnable.file) {	11✔
314	message += format(' of file %s', runnable.file);	9✔
315	}
316	if (originalErr) {	11✔
317	message += format('; in addition, done() received error: %s', originalErr);	3✔
318	}
319
320	var err = new Error(message);	11✔
321	err.code = constants.MULTIPLE_DONE;	11✔
322	err.valueType = typeof originalErr;	11✔
323	err.value = originalErr;	11✔
324	return err;	11✔
325	}
326
327	/**
328	* Creates an error object to be thrown when `.only()` is used with
329	* `--forbid-only`.
330	* @public
331	* @param {Mocha} mocha - Mocha instance
332	* @returns {Error} Error with code {@link constants.FORBIDDEN_EXCLUSIVITY}
333	*/
334	function createForbiddenExclusivityError(mocha) {
335	var err = new Error(	11✔
336	mocha.isWorker	11✔
337	? '`.only` is not supported in parallel mode'
338	: '`.only` forbidden by --forbid-only'
339	);
340	err.code = constants.FORBIDDEN_EXCLUSIVITY;	11✔
341	return err;	11✔
342	}
343
344	/**
345	* Creates an error object to be thrown when a plugin definition is invalid
346	* @param {string} msg - Error message
347	* @param {PluginDefinition} [pluginDef] - Problematic plugin definition
348	* @public
349	* @returns {Error} Error with code {@link constants.INVALID_PLUGIN_DEFINITION}
350	*/
351	function createInvalidPluginDefinitionError(msg, pluginDef) {
352	const err = new Error(msg);	4✔
353	err.code = constants.INVALID_PLUGIN_DEFINITION;	4✔
354	err.pluginDef = pluginDef;	4✔
355	return err;	4✔
356	}
357
358	/**
359	* Creates an error object to be thrown when a plugin implementation (user code) is invalid
360	* @param {string} msg - Error message
361	* @param {Object} [opts] - Plugin definition and user-supplied implementation
362	* @param {PluginDefinition} [opts.pluginDef] - Plugin Definition
363	* @param {*} [opts.pluginImpl] - Plugin Implementation (user-supplied)
364	* @public
365	* @returns {Error} Error with code {@link constants.INVALID_PLUGIN_DEFINITION}
366	*/
367	function createInvalidPluginImplementationError(
368	msg,
369	{pluginDef, pluginImpl} = {}	2✔
370	) {
371	const err = new Error(msg);	6✔
372	err.code = constants.INVALID_PLUGIN_IMPLEMENTATION;	6✔
373	err.pluginDef = pluginDef;	6✔
374	err.pluginImpl = pluginImpl;	6✔
375	return err;	6✔
376	}
377
378	module.exports = {	427✔
379	constants,
380	createFatalError,
381	createForbiddenExclusivityError,
382	createInvalidArgumentTypeError,
383	createInvalidArgumentValueError,
384	createInvalidExceptionError,
385	createInvalidInterfaceError,
386	createInvalidPluginDefinitionError,
387	createInvalidPluginImplementationError,
388	createInvalidPluginError,
389	createInvalidLegacyPluginError,
390	createInvalidReporterError,
391	createMissingArgumentError,
392	createMochaInstanceAlreadyDisposedError,
393	createMochaInstanceAlreadyRunningError,
394	createMultipleDoneError,
395	createNoFilesMatchPatternError,
396	createUnsupportedError
397	};

mochajs / mocha / 8029

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous