vest 4.1.0 → 4.2.0

package/dist/umd/vest.development.js

@@ -509,7 +509,7 @@
           return ruleReturn(result);
       }
       else {
-          return ruleReturn(result.pass, optionalFunctionValue.apply(void 0, __spreadArray([result.message, ruleName, value], args)));
+          return ruleReturn(result.pass, optionalFunctionValue.apply(void 0, __spreadArray([result.message, ruleName, value], args, false)));
       }
   }
   function validateResult(result) {
@@ -543,12 +543,12 @@
               for (var _i = 0; _i < arguments.length; _i++) {
                   args[_i] = arguments[_i];
               }
-              var transformedResult = transformResult.apply(void 0, __spreadArray([ctx.run({ value: value }, function () { return rule.apply(void 0, __spreadArray([value], args)); }),
+              var transformedResult = transformResult.apply(void 0, __spreadArray([ctx.run({ value: value }, function () { return rule.apply(void 0, __spreadArray([value], args, false)); }),
                   ruleName,
-                  value], args));
+                  value], args, false));
               if (!transformedResult.pass) {
                   if (isEmpty(transformedResult.message)) {
-                      throwError("enforce/" + ruleName + " failed with " + JSON.stringify(value));
+                      throwError("enforce/".concat(ruleName, " failed with ").concat(JSON.stringify(value)));
                   }
                   else {
                       // Explicitly throw a string so that vest.test can pick it up as the validation error message
@@ -590,7 +590,7 @@
               }
               var rule = getRule(ruleName);
               registeredRules.push(function (value) {
-                  return transformResult.apply(void 0, __spreadArray([rule.apply(void 0, __spreadArray([value], args)), ruleName, value], args));
+                  return transformResult.apply(void 0, __spreadArray([rule.apply(void 0, __spreadArray([value], args, false)), ruleName, value], args, false));
               });
               var proxy = {
                   run: function (value) {
@@ -690,7 +690,7 @@
    * @returns a unique numeric id.
    */
   var genId = (function (n) { return function () {
-      return "" + n++;
+      return "".concat(n++);
   }; })(0);
 
   // eslint-disable-next-line max-lines-per-function
@@ -829,6 +829,12 @@
       };
   }
 
+  var Modes;
+  (function (Modes) {
+      Modes[Modes["ALL"] = 0] = "ALL";
+      Modes[Modes["EAGER"] = 1] = "EAGER";
+  })(Modes || (Modes = {}));
+
   var context = createContext(function (ctxRef, parentContext) {
       return parentContext
           ? null
@@ -845,13 +851,14 @@
                       prev: {}
                   }
               },
+              mode: [Modes.ALL],
               testCursor: createCursor()
           }, ctxRef);
   });
 
-  // This is sort of a map/filter in one function.
-  // Normally, behaves like a nested-array map
-  // Returning `null` will drop the element from the array
+  // This is kind of a map/filter in one function.
+  // Normally, behaves like a nested-array map,
+  // but returning `null` will drop the element from the array
   function transform(array, cb) {
       var res = [];
       for (var _i = 0, array_1 = array; _i < array_1.length; _i++) {
@@ -918,23 +925,22 @@
       };
       // invalidate an item in the cache by its dependencies
       cache.invalidate = function (deps) {
-          var index = cacheStorage.findIndex(function (_a) {
-              var cachedDeps = _a[0];
-              return lengthEquals(deps, cachedDeps.length) &&
-                  deps.every(function (dep, i) { return dep === cachedDeps[i]; });
-          });
+          var index = findIndex(deps);
           if (index > -1)
               cacheStorage.splice(index, 1);
       };
       // Retrieves an item from the cache.
       cache.get = function (deps) {
-          return cacheStorage[cacheStorage.findIndex(function (_a) {
+          return cacheStorage[findIndex(deps)] || null;
+      };
+      return cache;
+      function findIndex(deps) {
+          return cacheStorage.findIndex(function (_a) {
               var cachedDeps = _a[0];
               return lengthEquals(deps, cachedDeps.length) &&
                   deps.every(function (dep, i) { return dep === cachedDeps[i]; });
-          })] || null;
-      };
-      return cache;
+          });
+      }
   }
 
   // STATE REF
@@ -1112,31 +1118,34 @@
           return this.isSkipped() || this.isOmitted() || this.isCanceled();
       };
       VestTest.prototype.isPending = function () {
-          return this.status === STATUS_PENDING;
+          return this.statusEquals(STATUS_PENDING);
       };
       VestTest.prototype.isTested = function () {
           return this.hasFailures() || this.isPassing();
       };
       VestTest.prototype.isOmitted = function () {
-          return this.status === STATUS_OMITTED;
+          return this.statusEquals(STATUS_OMITTED);
       };
       VestTest.prototype.isUntested = function () {
-          return this.status === STATUS_UNTESTED;
+          return this.statusEquals(STATUS_UNTESTED);
       };
       VestTest.prototype.isFailing = function () {
-          return this.status === STATUS_FAILED;
+          return this.statusEquals(STATUS_FAILED);
       };
       VestTest.prototype.isCanceled = function () {
-          return this.status === STATUS_CANCELED;
+          return this.statusEquals(STATUS_CANCELED);
       };
       VestTest.prototype.isSkipped = function () {
-          return this.status === STATUS_SKIPPED;
+          return this.statusEquals(STATUS_SKIPPED);
       };
       VestTest.prototype.isPassing = function () {
-          return this.status === STATUS_PASSING;
+          return this.statusEquals(STATUS_PASSING);
       };
       VestTest.prototype.isWarning = function () {
-          return this.status === STATUS_WARNING;
+          return this.statusEquals(STATUS_WARNING);
+      };
+      VestTest.prototype.statusEquals = function (status) {
+          return this.status === status;
       };
       return VestTest;
   }());
@@ -1194,7 +1203,7 @@
           current[key] = testObject;
       }
       else {
-          throwErrorDeferred("Encountered the same test key \"" + key + "\" twice. This may lead to tests overriding each other's results, or to tests being unexpectedly omitted.");
+          throwErrorDeferred("Encountered the same test key \"".concat(key, "\" twice. This may lead to tests overriding each other's results, or to tests being unexpectedly omitted."));
       }
   }
 
@@ -1245,18 +1254,21 @@
       return isNotEmpty(allIncomplete);
   }
 
+  var Severity;
+  (function (Severity) {
+      Severity["WARNINGS"] = "warnings";
+      Severity["ERRORS"] = "errors";
+  })(Severity || (Severity = {}));
+
   /**
    * Reads the testObjects list and gets full validation result from it.
    */
   function genTestsSummary() {
       var testObjects = useTestsFlat();
-      var summary = {
-          errorCount: 0,
+      var summary = assign(baseStats(), {
           groups: {},
-          testCount: 0,
-          tests: {},
-          warnCount: 0
-      };
+          tests: {}
+      });
       appendSummary(testObjects);
       return countFailures(summary);
       function appendSummary(testObjects) {
@@ -1284,30 +1296,34 @@
   // eslint-disable-next-line max-statements
   function genTestObject(summaryKey, testObject) {
       var fieldName = testObject.fieldName, message = testObject.message;
-      summaryKey[fieldName] = summaryKey[fieldName] || {
-          errorCount: 0,
-          warnCount: 0,
-          testCount: 0
-      };
+      summaryKey[fieldName] = summaryKey[fieldName] || baseStats();
       var testKey = summaryKey[fieldName];
       if (testObject.isNonActionable())
           return testKey;
       summaryKey[fieldName].testCount++;
       // Adds to severity group
-      function addTo(countKey, group) {
+      function addTo(severity) {
+          var countKey = severity === Severity.ERRORS ? 'errorCount' : 'warnCount';
           testKey[countKey]++;
           if (message) {
-              testKey[group] = (testKey[group] || []).concat(message);
+              testKey[severity] = (testKey[severity] || []).concat(message);
           }
       }
       if (testObject.isFailing()) {
-          addTo('errorCount', 'errors');
+          addTo(Severity.ERRORS);
       }
       else if (testObject.isWarning()) {
-          addTo('warnCount', 'warnings');
+          addTo(Severity.WARNINGS);
       }
       return testKey;
   }
+  function baseStats() {
+      return {
+          errorCount: 0,
+          warnCount: 0,
+          testCount: 0
+      };
+  }
 
   function either(a, b) {
       return !!a !== !!b;
@@ -1317,7 +1333,7 @@
    * Checks that a given test object matches the currently specified severity level
    */
   function nonMatchingSeverityProfile(severity, testObject) {
-      return either(severity === 'warnings', testObject.warns());
+      return either(severity === Severity.WARNINGS, testObject.warns());
   }
 
   function collectFailureMessages(severity, testObjects, options) {
@@ -1359,10 +1375,10 @@
   }
 
   function getErrors(fieldName) {
-      return getFailures('errors', fieldName);
+      return getFailures(Severity.ERRORS, fieldName);
   }
   function getWarnings(fieldName) {
-      return getFailures('warnings', fieldName);
+      return getFailures(Severity.WARNINGS, fieldName);
   }
   /**
    * @returns suite or field's errors or warnings.
@@ -1376,11 +1392,11 @@
   }
 
   function getErrorsByGroup(groupName, fieldName) {
-      var errors = getByGroup('errors', groupName, fieldName);
+      var errors = getByGroup(Severity.ERRORS, groupName, fieldName);
       return getFailuresArrayOrObject(errors, fieldName);
   }
   function getWarningsByGroup(groupName, fieldName) {
-      var warnings = getByGroup('warnings', groupName, fieldName);
+      var warnings = getByGroup(Severity.WARNINGS, groupName, fieldName);
       return getFailuresArrayOrObject(warnings, fieldName);
   }
   /**
@@ -1388,7 +1404,7 @@
    */
   function getByGroup(severityKey, group, fieldName) {
       if (!group) {
-          throwError("get" + severityKey[0].toUpperCase() + severityKey.slice(1) + "ByGroup requires a group name. Received `" + group + "` instead.");
+          throwError("get".concat(severityKey[0].toUpperCase()).concat(severityKey.slice(1), "ByGroup requires a group name. Received `").concat(group, "` instead."));
       }
       var testObjects = useTestsFlat();
       return collectFailureMessages(severityKey, testObjects, {
@@ -1414,10 +1430,10 @@
   }
 
   function hasErrors(fieldName) {
-      return has('errors', fieldName);
+      return has(Severity.ERRORS, fieldName);
   }
   function hasWarnings(fieldName) {
-      return has('warnings', fieldName);
+      return has(Severity.WARNINGS, fieldName);
   }
   function has(severityKey, fieldName) {
       var testObjects = useTestsFlat();
@@ -1427,10 +1443,10 @@
   }
 
   function hasErrorsByGroup(groupName, fieldName) {
-      return hasByGroup('errors', groupName, fieldName);
+      return hasByGroup(Severity.ERRORS, groupName, fieldName);
   }
   function hasWarningsByGroup(groupName, fieldName) {
-      return hasByGroup('warnings', groupName, fieldName);
+      return hasByGroup(Severity.WARNINGS, groupName, fieldName);
   }
   /**
    * Checks whether there are failures in a given group.
@@ -1583,18 +1599,12 @@
       var listeners = {};
       return {
           emit: function (event, data) {
-              if (!listeners[event]) {
-                  return;
-              }
-              listeners[event].forEach(function (listener) {
-                  listener(data);
+              (listeners[event] || []).forEach(function (handler) {
+                  handler(data);
               });
           },
           on: function (event, handler) {
-              if (!listeners[event]) {
-                  listeners[event] = [];
-              }
-              listeners[event].push(handler);
+              listeners[event] = (listeners[event] || []).concat(handler);
               return {
                   off: function () {
                       listeners[event] = listeners[event].filter(function (h) { return h !== handler; });
@@ -1662,9 +1672,7 @@
    */
   function runDoneCallbacks() {
       var doneCallbacks = useTestCallbacks()[0].doneCallbacks;
-      if (!hasRemainingTests()) {
-          callEach(doneCallbacks);
-      }
+      callEach(doneCallbacks);
   }
 
   // eslint-disable-next-line max-lines-per-function
@@ -1678,14 +1686,21 @@
           }
           testObject.done();
           runFieldCallbacks(testObject.fieldName);
-          runDoneCallbacks();
+          if (!hasRemainingTests()) {
+              // When no more tests are running, emit the done event
+              bus.emit(Events.ALL_RUNNING_TESTS_FINISHED);
+          }
       });
       // Report that the suite completed its synchronous test run.
       // Async operations may still be running.
-      bus.on(Events.SUITE_COMPLETED, function () {
+      bus.on(Events.SUITE_CALLBACK_DONE_RUNNING, function () {
           // Remove tests that are optional and need to be omitted
           omitOptionalTests();
       });
+      // Called when all the tests, including async, are done running
+      bus.on(Events.ALL_RUNNING_TESTS_FINISHED, function () {
+          runDoneCallbacks();
+      });
       // Removes a certain field from the state.
       bus.on(Events.REMOVE_FIELD, function (fieldName) {
           useEachTestObject(function (testObject) {
@@ -1715,9 +1730,10 @@
   var Events;
   (function (Events) {
       Events["TEST_COMPLETED"] = "test_completed";
+      Events["ALL_RUNNING_TESTS_FINISHED"] = "all_running_tests_finished";
       Events["REMOVE_FIELD"] = "remove_field";
       Events["RESET_FIELD"] = "reset_field";
-      Events["SUITE_COMPLETED"] = "suite_completed";
+      Events["SUITE_CALLBACK_DONE_RUNNING"] = "suite_callback_done_running";
   })(Events || (Events = {}));
 
   // eslint-disable-next-line max-lines-per-function
@@ -1754,7 +1770,7 @@
           });
           // Report the suite is done registering tests
           // Async tests may still be running
-          bus.emit(Events.SUITE_COMPLETED);
+          bus.emit(Events.SUITE_CALLBACK_DONE_RUNNING);
           // Return the result
           return produceFullResult();
       }), {
@@ -1785,7 +1801,7 @@
    */
   function each(list, callback) {
       if (!isFunction(callback)) {
-          throwError('callback must be a function');
+          throwError('each callback must be a function');
       }
       isolate({ type: IsolateTypes.EACH }, function () {
           list.forEach(function (arg, index) {
@@ -1799,6 +1815,31 @@
    */
   var ERROR_HOOK_CALLED_OUTSIDE = 'hook called outside of a running suite.';
 
+  /**
+   * Conditionally skips running tests within the callback.
+   *
+   * @example
+   *
+   * skipWhen(res => res.hasErrors('username'), () => {
+   *  test('username', 'User already taken', async () => await doesUserExist(username)
+   * });
+   */
+  function skipWhen(conditional, callback) {
+      isolate({ type: IsolateTypes.SKIP_WHEN }, function () {
+          context.run({
+              skipped: 
+              // Checking for nested conditional. If we're in a nested skipWhen,
+              // we should skip the test if the parent conditional is true.
+              isExcludedIndividually() ||
+                  // Otherwise, we should skip the test if the conditional is true.
+                  optionalFunctionValue(conditional, optionalFunctionValue(produceDraft))
+          }, function () { return callback(); });
+      });
+  }
+  function isExcludedIndividually() {
+      return !!context.useX().skipped;
+  }
+
   /**
    * Adds a field or a list of fields into the inclusion list
    *
@@ -1825,9 +1866,6 @@
   skip.group = function (item) {
       return addTo(1 /* SKIP */, 'groups', item);
   };
-  function isExcludedIndividually() {
-      return !!context.useX().skipped;
-  }
   //Checks whether a certain test profile excluded by any of the exclusion groups.
   // eslint-disable-next-line complexity, max-statements, max-lines-per-function
   function isExcluded(testObject) {
@@ -1973,7 +2011,7 @@
       });
   }
   function throwGroupError(error) {
-      throwError("Wrong arguments passed to group. Group " + error + ".");
+      throwError("Wrong arguments passed to group. Group ".concat(error, "."));
   }
 
   function include(fieldName) {
@@ -1999,6 +2037,45 @@
       }
   }
 
+  /**
+   * Sets the suite to "eager" (fail fast) mode.
+   * Eager mode will skip running subsequent tests of a failing fields.
+   *
+   * @example
+   *  // in the following example, the second test of username will not run
+   *  // if the first test of username failed.
+   * const suite = create((data) => {
+   *  eager();
+   *
+   *  test('username', 'username is required', () => {
+   *   enforce(data.username).isNotBlank();
+   *  });
+   *
+   *  test('username', 'username is too short', () => {
+   *   enforce(data.username).longerThan(2);
+   *  });
+   * });
+   */
+  function eager() {
+      setMode(Modes.EAGER);
+  }
+  function shouldSkipBasedOnMode(testObject) {
+      if (isEager() && hasErrors(testObject.fieldName))
+          return true;
+      return false;
+  }
+  function isEager() {
+      return isMode(Modes.EAGER);
+  }
+  function isMode(mode) {
+      var currentMode = context.useX().mode;
+      return currentMode[0] === mode;
+  }
+  function setMode(nextMode) {
+      var mode = context.useX().mode;
+      mode[0] = nextMode;
+  }
+
   /**
    * Conditionally omits tests from the suite.
    *
@@ -2011,7 +2088,8 @@
   function omitWhen(conditional, callback) {
       isolate({ type: IsolateTypes.OMIT_WHEN }, function () {
           context.run({
-              omitted: optionalFunctionValue(conditional, optionalFunctionValue(produceDraft))
+              omitted: isOmitted() ||
+                  optionalFunctionValue(conditional, optionalFunctionValue(produceDraft))
           }, function () { return callback(); });
       });
   }
@@ -2049,23 +2127,6 @@
       });
   }
 
-  /**
-   * Conditionally skips running tests within the callback.
-   *
-   * @example
-   *
-   * skipWhen(res => res.hasErrors('username'), () => {
-   *  test('username', 'User already taken', async () => await doesUserExist(username)
-   * });
-   */
-  function skipWhen(conditional, callback) {
-      isolate({ type: IsolateTypes.SKIP_WHEN }, function () {
-          context.run({
-              skipped: optionalFunctionValue(conditional, optionalFunctionValue(produceDraft))
-          }, function () { return callback(); });
-      });
-  }
-
   function isPromise(value) {
       return value && isFunction(value.then);
   }
@@ -2159,7 +2220,7 @@
           }
       }
       catch (e) {
-          throwError("Your test function " + testObject.fieldName + " returned a value. Only \"false\" or Promise returns are supported.");
+          throwError("Unexpected error encountered during test registration.\n      Test Object: ".concat(testObject, ".\n      Error: ").concat(e, "."));
       }
   }
 
@@ -2230,7 +2291,7 @@
       if (shouldAllowReorder()) {
           return;
       }
-      throwErrorDeferred("Vest Critical Error: Tests called in different order than previous run.\n    expected: " + prevTest.fieldName + "\n    received: " + newTestObject.fieldName + "\n    This can happen on one of two reasons:\n    1. You're using if/else statements to conditionally select tests. Instead, use \"skipWhen\".\n    2. You are iterating over a list of tests, and their order changed. Use \"each\" and a custom key prop so that Vest retains their state.");
+      throwErrorDeferred("Vest Critical Error: Tests called in different order than previous run.\n    expected: ".concat(prevTest.fieldName, "\n    received: ").concat(newTestObject.fieldName, "\n    This can happen on one of two reasons:\n    1. You're using if/else statements to conditionally select tests. Instead, use \"skipWhen\".\n    2. You are iterating over a list of tests, and their order changed. Use \"each\" and a custom key prop so that Vest retains their state."));
   }
   function handleKeyTest(key, newTestObject) {
       var prevTestByKey = usePrevTestByKey(key);
@@ -2245,6 +2306,11 @@
   // eslint-disable-next-line max-statements
   function registerPrevRunTest(testObject) {
       var prevRunTest = useTestAtCursor(testObject);
+      if (shouldSkipBasedOnMode(testObject)) {
+          moveForward();
+          testObject.skip();
+          return testObject;
+      }
       if (isOmitted()) {
           prevRunTest.omit();
           moveForward();
@@ -2309,7 +2375,7 @@
       for (var _i = 1; _i < arguments.length; _i++) {
           args[_i - 1] = arguments[_i];
       }
-      var _a = (isFunction(args[1]) ? args : __spreadArray([undefined], args)), message = _a[0], testFn = _a[1], key = _a[2];
+      var _a = (isFunction(args[1]) ? args : __spreadArray([undefined], args, true)), message = _a[0], testFn = _a[1], key = _a[2];
       if (isNotString(fieldName)) {
           throwIncompatibleParamsError('fieldName', 'string');
       }
@@ -2337,7 +2403,7 @@
       memo: bindTestMemo(testBase)
   });
   function throwIncompatibleParamsError(name, expected) {
-      throwError("Incompatible params passed to test function. " + name + " must be a " + expected);
+      throwError("Incompatible params passed to test function. ".concat(name, " must be a ").concat(expected));
   }
 
   var ERROR_OUTSIDE_OF_TEST = "warn hook called outside of a test callback. It won't have an effect."
@@ -2353,12 +2419,13 @@
       ctx.currentTest.warn();
   }
 
-  var VERSION = "4.0.3";
+  var VERSION = "4.2.0";
 
   exports.VERSION = VERSION;
   exports.context = context;
   exports.create = create;
   exports.each = each;
+  exports.eager = eager;
   exports.enforce = enforce;
   exports.group = group;
   exports.include = include;