@webex/test-helper-mocha 2.59.2 → 2.59.3-next.1

package/.eslintrc.js

@@ -1,6 +1,6 @@
-const config = {
-  root: true,
-  extends: ['@webex/eslint-config-legacy'],
-};
-
-module.exports = config;
+const config = {
+  root: true,
+  extends: ['@webex/eslint-config-legacy'],
+};
+
+module.exports = config;

package/README.md

@@ -1,31 +1,31 @@
-# @webex/test-helper-mocha
-
-[![standard-readme compliant](https://img.shields.io/badge/readme%20style-standard-brightgreen.svg?style=flat-square)](https://github.com/RichardLitt/standard-readme)
-
->
-
-- [Install](#install)
-- [Usage](#usage)
-- [Contribute](#contribute)
-- [Maintainers](#maintainers)
-- [License](#license)
-
-## Install
-
-```bash
-npm install --save @webex/test-helper-mocha
-```
-
-## Usage
-
-## Maintainers
-
-This package is maintained by [Cisco Webex for Developers](https://developer.webex.com/).
-
-## Contribute
-
-Pull requests welcome. Please see [CONTRIBUTING.md](https://github.com/webex/webex-js-sdk/blob/master/CONTRIBUTING.md) for more details.
-
-## License
-
-© 2016-2020 Cisco and/or its affiliates. All Rights Reserved.
+# @webex/test-helper-mocha
+
+[![standard-readme compliant](https://img.shields.io/badge/readme%20style-standard-brightgreen.svg?style=flat-square)](https://github.com/RichardLitt/standard-readme)
+
+>
+
+- [Install](#install)
+- [Usage](#usage)
+- [Contribute](#contribute)
+- [Maintainers](#maintainers)
+- [License](#license)
+
+## Install
+
+```bash
+npm install --save @webex/test-helper-mocha
+```
+
+## Usage
+
+## Maintainers
+
+This package is maintained by [Cisco Webex for Developers](https://developer.webex.com/).
+
+## Contribute
+
+Pull requests welcome. Please see [CONTRIBUTING.md](https://github.com/webex/webex-js-sdk/blob/master/CONTRIBUTING.md) for more details.
+
+## License
+
+© 2016-2020 Cisco and/or its affiliates. All Rights Reserved.

package/babel.config.js

@@ -1,3 +1,3 @@
-const babelConfigLegacy = require('@webex/babel-config-legacy');
-
-module.exports = babelConfigLegacy;
+const babelConfigLegacy = require('@webex/babel-config-legacy');
+
+module.exports = babelConfigLegacy;

package/dist/index.js

@@ -3,83 +3,83 @@
 var _interopRequireDefault = require("@babel/runtime-corejs2/helpers/interopRequireDefault");
 var _promise = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/promise"));
 var _isNan = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/number/is-nan"));
-/*!
- * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
  */
 
 var bowser = require('bowser');
 
-/**
- * Indicates if we're running in node
- * @returns {boolean}
- * @private
+/**
+ * Indicates if we're running in node
+ * @returns {boolean}
+ * @private
  */
 function inNode() {
   return typeof window === 'undefined';
 }
 
-/**
- * Indicates if we're running in a web browser
- * @returns {boolean}
- * @private
+/**
+ * Indicates if we're running in a web browser
+ * @returns {boolean}
+ * @private
  */
 function inBrowser() {
   return !inNode();
 }
 
-/**
- * Indicates if we are running in the named browser
- * @param {string} name name of the browser
- * @returns {boolean}
+/**
+ * Indicates if we are running in the named browser
+ * @param {string} name name of the browser
+ * @returns {boolean}
  */
 function inSpecificBrowser(name) {
   return window && bowser.getParser(window.navigator.userAgent).isBrowser(name);
 }
 
-/**
- * Indicates if we're running in firefox
- * @returns {boolean}
- * @private
+/**
+ * Indicates if we're running in firefox
+ * @returns {boolean}
+ * @private
  */
 function inFirefox() {
   return inSpecificBrowser('firefox');
 }
 
-/**
- * Indicates if we're running in safari
- * @returns {boolean}
- * @private
+/**
+ * Indicates if we're running in safari
+ * @returns {boolean}
+ * @private
  */
 function inSafari() {
   return inSpecificBrowser('safari');
 }
 
-/**
- * Indicates if we're running on Jenkins
- * @returns {boolean}
- * @private
+/**
+ * Indicates if we're running on Jenkins
+ * @returns {boolean}
+ * @private
  */
 function inJenkins() {
   return process.env.JENKINS;
 }
 
-/**
- * noop
- * @returns {undefined}
- * @private
+/**
+ * noop
+ * @returns {undefined}
+ * @private
  */
 function noop() {
   // intentionally empty
 }
 module.exports = {
-  /**
-   * Wrap the desired mochaMethod with `flaky` to indicate it's a flaky test
-   * and exclude it from the test suite.
-   * example:
-   * `flaky(it)('sometimes passes and sometimes failes')`
-   * @param {Function} mochaMethod `it` or `describe`
-   * @param {string} envVar process.env.SKIP_FLAKY_TESTS
-   * @returns {Function} mochaMethod or mochaMethod.skip
+  /**
+   * Wrap the desired mochaMethod with `flaky` to indicate it's a flaky test
+   * and exclude it from the test suite.
+   * example:
+   * `flaky(it)('sometimes passes and sometimes failes')`
+   * @param {Function} mochaMethod `it` or `describe`
+   * @param {string} envVar process.env.SKIP_FLAKY_TESTS
+   * @returns {Function} mochaMethod or mochaMethod.skip
    */
   flaky: function flaky(mochaMethod, envVar) {
     // If mochaMethod doesn't have a skip method,
@@ -90,13 +90,13 @@ module.exports = {
     var shouldSkip = envVar && envVar !== 'false' && !!envVar;
     return shouldSkip ? mochaMethod.skip : mochaMethod;
   },
-  /**
-   * A lot of failures get produced by EventEmitters, which makes them difficult to
-   * detect in tests (they just look like timeouts). This is a test helper that
-   * captures that error and turns it into a rejected promise
-   * @param {EventEmitter} emitter
-   * @param {Function} fn
-   * @returns {Promise}
+  /**
+   * A lot of failures get produced by EventEmitters, which makes them difficult to
+   * detect in tests (they just look like timeouts). This is a test helper that
+   * captures that error and turns it into a rejected promise
+   * @param {EventEmitter} emitter
+   * @param {Function} fn
+   * @returns {Promise}
    */
   handleErrorEvent: function handleErrorEvent(emitter, fn) {
     var r;
@@ -115,10 +115,10 @@ module.exports = {
     };
     return handler;
 
-    /**
-     * unbinder
-     * @private
-     * @returns {undefined}
+    /**
+     * unbinder
+     * @private
+     * @returns {undefined}
      */
     function unbind() {
       try {
@@ -130,13 +130,13 @@ module.exports = {
   },
   inBrowser: inBrowser,
   inNode: inNode,
-  /**
-   * Wrap the desired mochaMethod with `skipInBrowser` to prevent the
-   * corresponding test or group of tests from running in a web browser
-   * example:
-   * `skipInBrowser(it)('does a thing that only works in node')`
-   * @param {Function} mochaMethod `it` or `describe`
-   * @returns {Function} mochaMethod or mochaMethod.skip
+  /**
+   * Wrap the desired mochaMethod with `skipInBrowser` to prevent the
+   * corresponding test or group of tests from running in a web browser
+   * example:
+   * `skipInBrowser(it)('does a thing that only works in node')`
+   * @param {Function} mochaMethod `it` or `describe`
+   * @returns {Function} mochaMethod or mochaMethod.skip
    */
   skipInBrowser: function skipInBrowser(mochaMethod) {
     // If mochaMethod doesn't have a skip method, assume that mochaMethod is
@@ -146,13 +146,13 @@ module.exports = {
     }
     return inBrowser() ? mochaMethod.skip : mochaMethod;
   },
-  /**
-   * Wrap the desired mochaMethod with `skipInNode` to prevent the
-   * corresponding test or group of tests from running in node.
-   * example:
-   * `skipInNode(it)('does a thing that only works in a web browser')`
-   * @param {Function} mochaMethod `it` or `describe`
-   * @returns {Function} mochaMethod or mochaMethod.skip
+  /**
+   * Wrap the desired mochaMethod with `skipInNode` to prevent the
+   * corresponding test or group of tests from running in node.
+   * example:
+   * `skipInNode(it)('does a thing that only works in a web browser')`
+   * @param {Function} mochaMethod `it` or `describe`
+   * @returns {Function} mochaMethod or mochaMethod.skip
    */
   skipInNode: function skipInNode(mochaMethod) {
     // If mochaMethod doesn't have a skip method, assume that mochaMethod is
@@ -162,13 +162,13 @@ module.exports = {
     }
     return inNode() ? mochaMethod.skip : mochaMethod;
   },
-  /**
-   * Wrap the desired mochaMethod with `skipInFirefox` to prevent the
-   * corresponding test or group of tests from running in Firefox.
-   * example:
-   * `skipInFirefox(it)('does a thing that does not work in Firefox')`
-   * @param {Function} mochaMethod `it` or `describe`
-   * @returns {Function} mochaMethod or mochaMethod.skip
+  /**
+   * Wrap the desired mochaMethod with `skipInFirefox` to prevent the
+   * corresponding test or group of tests from running in Firefox.
+   * example:
+   * `skipInFirefox(it)('does a thing that does not work in Firefox')`
+   * @param {Function} mochaMethod `it` or `describe`
+   * @returns {Function} mochaMethod or mochaMethod.skip
    */
   skipInFirefox: function skipInFirefox(mochaMethod) {
     // If mochaMethod doesn't have a skip method, assume that mochaMethod is
@@ -178,13 +178,13 @@ module.exports = {
     }
     return inFirefox() ? mochaMethod.skip : mochaMethod;
   },
-  /**
-   * Wrap the desired mochaMethod with `skipInSafari` to prevent the
-   * corresponding test or group of tests from running in Safari.
-   * example:
-   * `skipInSafari(it)('does a thing that does not work in Safari')`
-   * @param {Function} mochaMethod `it` or `describe`
-   * @returns {Function} mochaMethod or mochaMethod.skip
+  /**
+   * Wrap the desired mochaMethod with `skipInSafari` to prevent the
+   * corresponding test or group of tests from running in Safari.
+   * example:
+   * `skipInSafari(it)('does a thing that does not work in Safari')`
+   * @param {Function} mochaMethod `it` or `describe`
+   * @returns {Function} mochaMethod or mochaMethod.skip
    */
   skipInSafari: function skipInSafari(mochaMethod) {
     // If mochaMethod doesn't have a skip method, assume that mochaMethod is
@@ -194,51 +194,51 @@ module.exports = {
     }
     return inSafari() ? mochaMethod.skip : mochaMethod;
   },
-  /**
-   * Similar to skipInNode in that it prevents the test from running, but goes a
-   * step further to hide it from the list of skipped tests. Should be used when
-   * the test will never be valid in NodeJS
-   * @param {Function} mochaMethod
-   * @returns {Function}
+  /**
+   * Similar to skipInNode in that it prevents the test from running, but goes a
+   * step further to hide it from the list of skipped tests. Should be used when
+   * the test will never be valid in NodeJS
+   * @param {Function} mochaMethod
+   * @returns {Function}
    */
   browserOnly: function browserOnly(mochaMethod) {
     return inBrowser() ? mochaMethod : noop;
   },
-  /**
-   * Similar to skipInBrowser in that it prevents the test from running, but
-   * goes a step further to hide it from the list of skipped tests. Should be
-   * used when the test will never be valid in a Browser
-   * @param {Function} mochaMethod
-   * @returns {Function}
+  /**
+   * Similar to skipInBrowser in that it prevents the test from running, but
+   * goes a step further to hide it from the list of skipped tests. Should be
+   * used when the test will never be valid in a Browser
+   * @param {Function} mochaMethod
+   * @returns {Function}
    */
   nodeOnly: function nodeOnly(mochaMethod) {
     return inNode() ? mochaMethod : noop;
   },
-  /**
-   * Similar to skipInBrowser in that it prevents the test from running, but
-   * goes a step further to hide it from the list of skipped tests. Should be
-   * used when the test should be run on Jenkins only
-   * @param {*} mochaMethod
-   * @returns {Functions}
+  /**
+   * Similar to skipInBrowser in that it prevents the test from running, but
+   * goes a step further to hide it from the list of skipped tests. Should be
+   * used when the test should be run on Jenkins only
+   * @param {*} mochaMethod
+   * @returns {Functions}
    */
   jenkinsOnly: function jenkinsOnly(mochaMethod) {
     return inJenkins() ? mochaMethod : noop;
   },
-  /**
-   * @param {number} max
-   * @param {string} event
-   * @param {EventEmitter} emitter
-   * @param {function} activityChecker // callback to check if activity matches
-   * @param {string} msg
-   * @returns {Promise<mixed>} Resolves with the activity
+  /**
+   * @param {number} max
+   * @param {string} event
+   * @param {EventEmitter} emitter
+   * @param {function} activityChecker // callback to check if activity matches
+   * @param {string} msg
+   * @returns {Promise<mixed>} Resolves with the activity
    */
   expectActivity: function expectActivity(max, event, emitter, activityChecker, msg) {
     var timer;
 
-    /**
-     * helper
-     * @private
-     * @returns {undefined}
+    /**
+     * helper
+     * @private
+     * @returns {undefined}
      */
     function unbind() {
       try {
@@ -265,15 +265,15 @@ module.exports = {
       throw reason;
     });
   },
-  /**
-   * Returns a promise that resolves after timeout or rejects
-   * when count has been exceeded. Will also reject if count
-   * hasn't been met after timeout
-   * @param {number} max amount of time to wait for events in ms
-   * @param {number} count number of events to expect in timeframe
-   * @param {string} event
-   * @param {EventEmitter} emitter
-   * @returns {Promise}
+  /**
+   * Returns a promise that resolves after timeout or rejects
+   * when count has been exceeded. Will also reject if count
+   * hasn't been met after timeout
+   * @param {number} max amount of time to wait for events in ms
+   * @param {number} count number of events to expect in timeframe
+   * @param {string} event
+   * @param {EventEmitter} emitter
+   * @returns {Promise}
    */
   expectExactlyNEvents: function expectExactlyNEvents(max, count, event, emitter) {
     var lastResult;
@@ -290,11 +290,11 @@ module.exports = {
     }), new _promise.default(function (resolve, reject) {
       emitter.on(event, fn);
 
-      /**
-       * helper
-       * @private
-       * @param {object} result
-       * @returns {undefined}
+      /**
+       * helper
+       * @private
+       * @param {object} result
+       * @returns {undefined}
        */
       function fn(result) {
         lastResult = result;
@@ -307,14 +307,14 @@ module.exports = {
       }
     })]);
   },
-  /**
-   * Returns a promise that resolves when event is fired count times or rejects
-   * when max expires
-   * @param {number} max
-   * @param {number} count
-   * @param {string} event
-   * @param {EventEmitter} emitter
-   * @returns {Promise}
+  /**
+   * Returns a promise that resolves when event is fired count times or rejects
+   * when max expires
+   * @param {number} max
+   * @param {number} count
+   * @param {string} event
+   * @param {EventEmitter} emitter
+   * @returns {Promise}
    */
   expectNEvents: function expectNEvents(max, count, event, emitter) {
     var timer;
@@ -326,10 +326,10 @@ module.exports = {
     }), new _promise.default(function (resolve) {
       emitter.on(event, fn);
 
-      /**
-       * helper
-       * @private
-       * @returns {undefined}
+      /**
+       * helper
+       * @private
+       * @returns {undefined}
        */
       function fn() {
         currentCount += 1;
@@ -341,12 +341,12 @@ module.exports = {
       }
     })]);
   },
-  /**
-   * @param {number} max
-   * @param {string} event
-   * @param {EventEmitter} emitter
-   * @param {string} msg
-   * @returns {Promise<mixed>} Resolves with the results of the event
+  /**
+   * @param {number} max
+   * @param {string} event
+   * @param {EventEmitter} emitter
+   * @param {string} msg
+   * @returns {Promise<mixed>} Resolves with the results of the event
    */
   expectEvent: function expectEvent(max, event, emitter, msg) {
     var timer;
@@ -361,20 +361,20 @@ module.exports = {
       });
     })]);
   },
-  /**
-   * Only run the specified test in firefox
-   * @param {Function} mochaMethod
-   * @returns {Function}
+  /**
+   * Only run the specified test in firefox
+   * @param {Function} mochaMethod
+   * @returns {Function}
    */
   firefoxOnly: function firefoxOnly(mochaMethod) {
     return inFirefox() ? mochaMethod : noop;
   },
-  /**
-   * Waits max ms or until emitter fires event, then resolves
-   * @param {number} max
-   * @param {string} event
-   * @param {EventEmitter} emitter
-   * @returns {Promise<mixed>}
+  /**
+   * Waits max ms or until emitter fires event, then resolves
+   * @param {number} max
+   * @param {string} event
+   * @param {EventEmitter} emitter
+   * @returns {Promise<mixed>}
    */
   maxWaitForEvent: function maxWaitForEvent(max, event, emitter) {
     return _promise.default.race([new _promise.default(function (resolve) {
@@ -383,12 +383,12 @@ module.exports = {
       emitter.once(event, resolve);
     })]);
   },
-  /**
-   * Waits timeout ms or until the promise resolves. Rejects if the timeout is
-   * hit, otherwise resolves
-   * @param {number} timeout
-   * @param {Promise} promise
-   * @returns {Promise<mixed>}
+  /**
+   * Waits timeout ms or until the promise resolves. Rejects if the timeout is
+   * hit, otherwise resolves
+   * @param {number} timeout
+   * @param {Promise} promise
+   * @returns {Promise<mixed>}
    */
   maxWaitForPromise: function maxWaitForPromise(timeout, promise) {
     return _promise.default.race([promise, new _promise.default(function (resolve, reject) {
@@ -397,12 +397,12 @@ module.exports = {
       }, timeout);
     })]);
   },
-  /**
-   * Do not execute the specified mochaMethod until we pass the specified date
-   * @param {Date|string} until
-   * @param {string} explanation - Doesn't do anything, but forces you to defend
-   * your decision to snooze a test
-   * @returns {Function}
+  /**
+   * Do not execute the specified mochaMethod until we pass the specified date
+   * @param {Date|string} until
+   * @param {string} explanation - Doesn't do anything, but forces you to defend
+   * your decision to snooze a test
+   * @returns {Function}
    */
   snoozeUntil: function snoozeUntil(until, explanation) {
     var now = new Date();