mocha-compat 3.6.4 → 10.8.2

package/lib/suite.js

@@ -2,14 +2,24 @@
 
 /**
  * Module dependencies.
+ * @private
  */
+const {EventEmitter} = require('events');
+const Hook = require('./hook');
+var {
+  assignNewMochaID,
+  clamp,
+  constants: utilsConstants,
+  defineConstants,
+  getMochaID,
+  inherits,
+  isString
+} = require('./utils');
+const debug = require('debug')('mocha:suite');
+const milliseconds = require('ms');
+const errors = require('./errors');
 
-var EventEmitter = require('events').EventEmitter;
-var Hook = require('./hook');
-var utils = require('./utils');
-var inherits = utils.inherits;
-var debug = require('debug')('mocha:suite');
-var milliseconds = require('./ms');
+const {MOCHA_ID_PROP_NAME} = utilsConstants;
 
 /**
  * Expose `Suite`.
@@ -18,16 +28,14 @@ var milliseconds = require('./ms');
 exports = module.exports = 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.
+ * Create a new `Suite` with the given `title` and parent `Suite`.
  *
- * @api public
- * @param {Suite} parent
- * @param {string} title
+ * @public
+ * @param {Suite} parent - Parent suite (required!)
+ * @param {string} title - Title
  * @return {Suite}
  */
-exports.create = function (parent, title) {
+Suite.create = function (parent, title) {
   var suite = new Suite(title, parent.ctx);
   suite.parent = parent;
   title = suite.fullTitle();
@@ -36,36 +44,53 @@ exports.create = function (parent, title) {
 };
 
 /**
- * Initialize a new `Suite` with the given `title` and `ctx`.
+ * Constructs a new `Suite` instance with the given `title`, `ctx`, and `isRoot`.
  *
- * @api private
- * @param {string} title
- * @param {Context} parentContext
+ * @public
+ * @class
+ * @extends EventEmitter
+ * @see {@link https://nodejs.org/api/events.html#events_class_eventemitter|EventEmitter}
+ * @param {string} title - Suite title.
+ * @param {Context} parentContext - Parent context instance.
+ * @param {boolean} [isRoot=false] - Whether this is the root suite.
  */
-function Suite (title, parentContext) {
-  if (!utils.isString(title)) {
-    throw new Error('Suite `title` should be a "string" but "' + typeof title + '" was given instead.');
+function Suite(title, parentContext, isRoot) {
+  if (!isString(title)) {
+    throw errors.createInvalidArgumentTypeError(
+      'Suite argument "title" must be a string. Received type "' +
+        typeof title +
+        '"',
+      'title',
+      'string'
+    );
   }
   this.title = title;
-  function Context () {}
+  function Context() {}
   Context.prototype = parentContext;
   this.ctx = new Context();
   this.suites = [];
   this.tests = [];
+  this.root = isRoot === true;
   this.pending = false;
+  this._retries = -1;
   this._beforeEach = [];
   this._beforeAll = [];
   this._afterEach = [];
   this._afterAll = [];
-  this.root = !title;
   this._timeout = 2000;
-  this._enableTimeouts = true;
   this._slow = 75;
   this._bail = false;
-  this._retries = -1;
   this._onlyTests = [];
   this._onlySuites = [];
-  this.delayed = false;
+  assignNewMochaID(this);
+
+  Object.defineProperty(this, 'id', {
+    get() {
+      return getMochaID(this);
+    }
+  });
+
+  this.reset();
 }
 
 /**
@@ -73,28 +98,45 @@ function Suite (title, parentContext) {
  */
 inherits(Suite, EventEmitter);
 
+/**
+ * Resets the state initially or for a next run.
+ */
+Suite.prototype.reset = function () {
+  this.delayed = false;
+  function doReset(thingToReset) {
+    thingToReset.reset();
+  }
+  this.suites.forEach(doReset);
+  this.tests.forEach(doReset);
+  this._beforeEach.forEach(doReset);
+  this._afterEach.forEach(doReset);
+  this._beforeAll.forEach(doReset);
+  this._afterAll.forEach(doReset);
+};
+
 /**
  * Return a clone of this `Suite`.
  *
- * @api private
+ * @private
  * @return {Suite}
  */
 Suite.prototype.clone = function () {
   var suite = new Suite(this.title);
   debug('clone');
   suite.ctx = this.ctx;
+  suite.root = this.root;
   suite.timeout(this.timeout());
   suite.retries(this.retries());
-  suite.enableTimeouts(this.enableTimeouts());
   suite.slow(this.slow());
   suite.bail(this.bail());
   return suite;
 };
 
 /**
- * Set timeout `ms` or short-hand such as "2s".
+ * Set or get timeout `ms` or short-hand such as "2s".
  *
- * @api private
+ * @private
+ * @todo Do not attempt to set value if `ms` is undefined
  * @param {number|string} ms
  * @return {Suite|number} for chaining
  */
@@ -102,21 +144,24 @@ Suite.prototype.timeout = function (ms) {
   if (!arguments.length) {
     return this._timeout;
   }
-  if (ms.toString() === '0') {
-    this._enableTimeouts = false;
-  }
   if (typeof ms === 'string') {
     ms = milliseconds(ms);
   }
+
+  // Clamp to range
+  var INT_MAX = Math.pow(2, 31) - 1;
+  var range = [0, INT_MAX];
+  ms = clamp(ms, range);
+
   debug('timeout %d', ms);
   this._timeout = parseInt(ms, 10);
   return this;
 };
 
 /**
- * Set number of times to retry a failed test.
+ * Set or get number of times to retry a failed test.
  *
- * @api private
+ * @private
  * @param {number|string} n
  * @return {Suite|number} for chaining
  */
@@ -130,25 +175,9 @@ Suite.prototype.retries = function (n) {
 };
 
 /**
-  * Set timeout to `enabled`.
-  *
-  * @api private
-  * @param {boolean} enabled
-  * @return {Suite|boolean} self or enabled
-  */
-Suite.prototype.enableTimeouts = function (enabled) {
-  if (!arguments.length) {
-    return this._enableTimeouts;
-  }
-  debug('enableTimeouts %s', enabled);
-  this._enableTimeouts = enabled;
-  return this;
-};
-
-/**
- * Set slow `ms` or short-hand such as "2s".
+ * Set or get slow `ms` or short-hand such as "2s".
  *
- * @api private
+ * @private
  * @param {number|string} ms
  * @return {Suite|number} for chaining
  */
@@ -165,9 +194,9 @@ Suite.prototype.slow = function (ms) {
 };
 
 /**
- * Sets whether to bail after first error.
+ * Set or get whether to bail after first error.
  *
- * @api private
+ * @private
  * @param {boolean} bail
  * @return {Suite|number} for chaining
  */
@@ -183,16 +212,34 @@ Suite.prototype.bail = function (bail) {
 /**
  * Check if this suite or its parent suite is marked as pending.
  *
- * @api private
+ * @private
  */
 Suite.prototype.isPending = function () {
   return this.pending || (this.parent && this.parent.isPending());
 };
 
+/**
+ * Generic hook-creator.
+ * @private
+ * @param {string} title - Title of hook
+ * @param {Function} fn - Hook callback
+ * @returns {Hook} A new hook
+ */
+Suite.prototype._createHook = function (title, fn) {
+  var hook = new Hook(title, fn);
+  hook.parent = this;
+  hook.timeout(this.timeout());
+  hook.retries(this.retries());
+  hook.slow(this.slow());
+  hook.ctx = this.ctx;
+  hook.file = this.file;
+  return hook;
+};
+
 /**
  * Run `fn(test[, done])` before running tests.
  *
- * @api private
+ * @private
  * @param {string} title
  * @param {Function} fn
  * @return {Suite} for chaining
@@ -207,22 +254,16 @@ Suite.prototype.beforeAll = function (title, fn) {
   }
   title = '"before all" hook' + (title ? ': ' + title : '');
 
-  var hook = new Hook(title, fn);
-  hook.parent = this;
-  hook.timeout(this.timeout());
-  hook.retries(this.retries());
-  hook.enableTimeouts(this.enableTimeouts());
-  hook.slow(this.slow());
-  hook.ctx = this.ctx;
+  var hook = this._createHook(title, fn);
   this._beforeAll.push(hook);
-  this.emit('beforeAll', hook);
+  this.emit(constants.EVENT_SUITE_ADD_HOOK_BEFORE_ALL, hook);
   return this;
 };
 
 /**
  * Run `fn(test[, done])` after running tests.
  *
- * @api private
+ * @private
  * @param {string} title
  * @param {Function} fn
  * @return {Suite} for chaining
@@ -237,22 +278,16 @@ Suite.prototype.afterAll = function (title, fn) {
   }
   title = '"after all" hook' + (title ? ': ' + title : '');
 
-  var hook = new Hook(title, fn);
-  hook.parent = this;
-  hook.timeout(this.timeout());
-  hook.retries(this.retries());
-  hook.enableTimeouts(this.enableTimeouts());
-  hook.slow(this.slow());
-  hook.ctx = this.ctx;
+  var hook = this._createHook(title, fn);
   this._afterAll.push(hook);
-  this.emit('afterAll', hook);
+  this.emit(constants.EVENT_SUITE_ADD_HOOK_AFTER_ALL, hook);
   return this;
 };
 
 /**
  * Run `fn(test[, done])` before each test case.
  *
- * @api private
+ * @private
  * @param {string} title
  * @param {Function} fn
  * @return {Suite} for chaining
@@ -267,22 +302,16 @@ Suite.prototype.beforeEach = function (title, fn) {
   }
   title = '"before each" hook' + (title ? ': ' + title : '');
 
-  var hook = new Hook(title, fn);
-  hook.parent = this;
-  hook.timeout(this.timeout());
-  hook.retries(this.retries());
-  hook.enableTimeouts(this.enableTimeouts());
-  hook.slow(this.slow());
-  hook.ctx = this.ctx;
+  var hook = this._createHook(title, fn);
   this._beforeEach.push(hook);
-  this.emit('beforeEach', hook);
+  this.emit(constants.EVENT_SUITE_ADD_HOOK_BEFORE_EACH, hook);
   return this;
 };
 
 /**
  * Run `fn(test[, done])` after each test case.
  *
- * @api private
+ * @private
  * @param {string} title
  * @param {Function} fn
  * @return {Suite} for chaining
@@ -297,41 +326,35 @@ Suite.prototype.afterEach = function (title, fn) {
   }
   title = '"after each" hook' + (title ? ': ' + title : '');
 
-  var hook = new Hook(title, fn);
-  hook.parent = this;
-  hook.timeout(this.timeout());
-  hook.retries(this.retries());
-  hook.enableTimeouts(this.enableTimeouts());
-  hook.slow(this.slow());
-  hook.ctx = this.ctx;
+  var hook = this._createHook(title, fn);
   this._afterEach.push(hook);
-  this.emit('afterEach', hook);
+  this.emit(constants.EVENT_SUITE_ADD_HOOK_AFTER_EACH, hook);
   return this;
 };
 
 /**
  * Add a test `suite`.
  *
- * @api private
+ * @private
  * @param {Suite} suite
  * @return {Suite} for chaining
  */
 Suite.prototype.addSuite = function (suite) {
   suite.parent = this;
+  suite.root = false;
   suite.timeout(this.timeout());
   suite.retries(this.retries());
-  suite.enableTimeouts(this.enableTimeouts());
   suite.slow(this.slow());
   suite.bail(this.bail());
   this.suites.push(suite);
-  this.emit('suite', suite);
+  this.emit(constants.EVENT_SUITE_ADD_SUITE, suite);
   return this;
 };
 
 /**
  * Add a `test` to this suite.
  *
- * @api private
+ * @private
  * @param {Test} test
  * @return {Suite} for chaining
  */
@@ -339,11 +362,10 @@ Suite.prototype.addTest = function (test) {
   test.parent = this;
   test.timeout(this.timeout());
   test.retries(this.retries());
-  test.enableTimeouts(this.enableTimeouts());
   test.slow(this.slow());
   test.ctx = this.ctx;
   this.tests.push(test);
-  this.emit('test', test);
+  this.emit(constants.EVENT_SUITE_ADD_TEST, test);
   return this;
 };
 
@@ -351,42 +373,59 @@ Suite.prototype.addTest = function (test) {
  * Return the full title generated by recursively concatenating the parent's
  * full title.
  *
- * @api public
+ * @memberof Suite
+ * @public
  * @return {string}
  */
 Suite.prototype.fullTitle = function () {
+  return this.titlePath().join(' ');
+};
+
+/**
+ * Return the title path generated by recursively concatenating the parent's
+ * title path.
+ *
+ * @memberof Suite
+ * @public
+ * @return {string[]}
+ */
+Suite.prototype.titlePath = function () {
+  var result = [];
   if (this.parent) {
-    var full = this.parent.fullTitle();
-    if (full) {
-      return full + ' ' + this.title;
-    }
+    result = result.concat(this.parent.titlePath());
   }
-  return this.title;
+  if (!this.root) {
+    result.push(this.title);
+  }
+  return result;
 };
 
 /**
  * Return the total number of tests.
  *
- * @api public
+ * @memberof Suite
+ * @public
  * @return {number}
  */
 Suite.prototype.total = function () {
-  return utils.reduce(this.suites, function (sum, suite) {
-    return sum + suite.total();
-  }, 0) + this.tests.length;
+  return (
+    this.suites.reduce(function (sum, suite) {
+      return sum + suite.total();
+    }, 0) + this.tests.length
+  );
 };
 
 /**
  * Iterates through each suite recursively to find all tests. Applies a
  * function in the format `fn(test)`.
  *
- * @api private
+ * @private
  * @param {Function} fn
  * @return {Suite}
  */
 Suite.prototype.eachTest = function (fn) {
-  utils.forEach(this.tests, fn);
-  utils.forEach(this.suites, function (suite) {
+  this.tests.forEach(fn);
+  this.suites.forEach(function (suite) {
     suite.eachTest(fn);
   });
   return this;
@@ -394,9 +433,234 @@ Suite.prototype.eachTest = function (fn) {
 
 /**
  * This will run the root suite if we happen to be running in delayed mode.
+ * @private
  */
-Suite.prototype.run = function run () {
+Suite.prototype.run = function run() {
   if (this.root) {
-    this.emit('run');
+    this.emit(constants.EVENT_ROOT_SUITE_RUN);
+  }
+};
+
+/**
+ * Determines whether a suite has an `only` test or suite as a descendant.
+ *
+ * @private
+ * @returns {Boolean}
+ */
+Suite.prototype.hasOnly = function hasOnly() {
+  return (
+    this._onlyTests.length > 0 ||
+    this._onlySuites.length > 0 ||
+    this.suites.some(function (suite) {
+      return suite.hasOnly();
+    })
+  );
+};
+
+/**
+ * Filter suites based on `isOnly` logic.
+ *
+ * @private
+ * @returns {Boolean}
+ */
+Suite.prototype.filterOnly = function filterOnly() {
+  if (this._onlyTests.length) {
+    // If the suite contains `only` tests, run those and ignore any nested suites.
+    this.tests = this._onlyTests;
+    this.suites = [];
+  } else {
+    // Otherwise, do not run any of the tests in this suite.
+    this.tests = [];
+    this._onlySuites.forEach(function (onlySuite) {
+      // If there are other `only` tests/suites nested in the current `only` suite, then filter that `only` suite.
+      // Otherwise, all of the tests on this `only` suite should be run, so don't filter it.
+      if (onlySuite.hasOnly()) {
+        onlySuite.filterOnly();
+      }
+    });
+    // Run the `only` suites, as well as any other suites that have `only` tests/suites as descendants.
+    var onlySuites = this._onlySuites;
+    this.suites = this.suites.filter(function (childSuite) {
+      return onlySuites.indexOf(childSuite) !== -1 || childSuite.filterOnly();
+    });
+  }
+  // Keep the suite only if there is something to run
+  return this.tests.length > 0 || this.suites.length > 0;
+};
+
+/**
+ * Adds a suite to the list of subsuites marked `only`.
+ *
+ * @private
+ * @param {Suite} suite
+ */
+Suite.prototype.appendOnlySuite = function (suite) {
+  this._onlySuites.push(suite);
+};
+
+/**
+ * Marks a suite to be `only`.
+ *
+ * @private
+ */
+Suite.prototype.markOnly = function () {
+  this.parent && this.parent.appendOnlySuite(this);
+};
+
+/**
+ * Adds a test to the list of tests marked `only`.
+ *
+ * @private
+ * @param {Test} test
+ */
+Suite.prototype.appendOnlyTest = function (test) {
+  this._onlyTests.push(test);
+};
+
+/**
+ * Returns the array of hooks by hook name; see `HOOK_TYPE_*` constants.
+ * @private
+ */
+Suite.prototype.getHooks = function getHooks(name) {
+  return this['_' + name];
+};
+
+/**
+ * cleans all references from this suite and all child suites.
+ */
+Suite.prototype.dispose = function () {
+  this.suites.forEach(function (suite) {
+    suite.dispose();
+  });
+  this.cleanReferences();
+};
+
+/**
+ * Cleans up the references to all the deferred functions
+ * (before/after/beforeEach/afterEach) and tests of a Suite.
+ * These must be deleted otherwise a memory leak can happen,
+ * as those functions may reference variables from closures,
+ * thus those variables can never be garbage collected as long
+ * as the deferred functions exist.
+ *
+ * @private
+ */
+Suite.prototype.cleanReferences = function cleanReferences() {
+  function cleanArrReferences(arr) {
+    for (var i = 0; i < arr.length; i++) {
+      delete arr[i].fn;
+    }
+  }
+
+  if (Array.isArray(this._beforeAll)) {
+    cleanArrReferences(this._beforeAll);
+  }
+
+  if (Array.isArray(this._beforeEach)) {
+    cleanArrReferences(this._beforeEach);
+  }
+
+  if (Array.isArray(this._afterAll)) {
+    cleanArrReferences(this._afterAll);
+  }
+
+  if (Array.isArray(this._afterEach)) {
+    cleanArrReferences(this._afterEach);
+  }
+
+  for (var i = 0; i < this.tests.length; i++) {
+    delete this.tests[i].fn;
   }
 };
+
+/**
+ * Returns an object suitable for IPC.
+ * Functions are represented by keys beginning with `$$`.
+ * @private
+ * @returns {Object}
+ */
+Suite.prototype.serialize = function serialize() {
+  return {
+    _bail: this._bail,
+    $$fullTitle: this.fullTitle(),
+    $$isPending: Boolean(this.isPending()),
+    root: this.root,
+    title: this.title,
+    [MOCHA_ID_PROP_NAME]: this.id,
+    parent: this.parent ? {[MOCHA_ID_PROP_NAME]: this.parent.id} : null
+  };
+};
+
+var constants = defineConstants(
+  /**
+   * {@link Suite}-related constants.
+   * @public
+   * @memberof Suite
+   * @alias constants
+   * @readonly
+   * @static
+   * @enum {string}
+   */
+  {
+    /**
+     * Event emitted after a test file has been loaded. Not emitted in browser.
+     */
+    EVENT_FILE_POST_REQUIRE: 'post-require',
+    /**
+     * Event emitted before a test file has been loaded. In browser, this is emitted once an interface has been selected.
+     */
+    EVENT_FILE_PRE_REQUIRE: 'pre-require',
+    /**
+     * Event emitted immediately after a test file has been loaded. Not emitted in browser.
+     */
+    EVENT_FILE_REQUIRE: 'require',
+    /**
+     * Event emitted when `global.run()` is called (use with `delay` option).
+     */
+    EVENT_ROOT_SUITE_RUN: 'run',
+
+    /**
+     * Namespace for collection of a `Suite`'s "after all" hooks.
+     */
+    HOOK_TYPE_AFTER_ALL: 'afterAll',
+    /**
+     * Namespace for collection of a `Suite`'s "after each" hooks.
+     */
+    HOOK_TYPE_AFTER_EACH: 'afterEach',
+    /**
+     * Namespace for collection of a `Suite`'s "before all" hooks.
+     */
+    HOOK_TYPE_BEFORE_ALL: 'beforeAll',
+    /**
+     * Namespace for collection of a `Suite`'s "before each" hooks.
+     */
+    HOOK_TYPE_BEFORE_EACH: 'beforeEach',
+
+    /**
+     * Emitted after a child `Suite` has been added to a `Suite`.
+     */
+    EVENT_SUITE_ADD_SUITE: 'suite',
+    /**
+     * Emitted after an "after all" `Hook` has been added to a `Suite`.
+     */
+    EVENT_SUITE_ADD_HOOK_AFTER_ALL: 'afterAll',
+    /**
+     * Emitted after an "after each" `Hook` has been added to a `Suite`.
+     */
+    EVENT_SUITE_ADD_HOOK_AFTER_EACH: 'afterEach',
+    /**
+     * Emitted after an "before all" `Hook` has been added to a `Suite`.
+     */
+    EVENT_SUITE_ADD_HOOK_BEFORE_ALL: 'beforeAll',
+    /**
+     * Emitted after an "before each" `Hook` has been added to a `Suite`.
+     */
+    EVENT_SUITE_ADD_HOOK_BEFORE_EACH: 'beforeEach',
+    /**
+     * Emitted after a `Test` has been added to a `Suite`.
+     */
+    EVENT_SUITE_ADD_TEST: 'test'
+  }
+);
+
+Suite.constants = constants;