vest 4.3.1 → 4.3.3

package/dist/umd/vest.development.js

@@ -144,7 +144,7 @@
       else if (typeof value === 'object') {
           return lengthEquals(Object.keys(value), 0);
       }
-      return true;
+      return false;
   }
   var isNotEmpty = bindNot(isEmpty);
 
@@ -644,15 +644,10 @@
           context: function () { return ctx.useX(); },
           extend: function (customRules) {
               assign(baseRules, customRules);
+              handleNoProxy(); // TODO: REMOVE when we stop supporting ES5
           }
       };
-      if (!isProxySupported()) {
-          eachEnforceRule(function (ruleName) {
-              // Only on the first rule access - start the chain of calls
-              target[ruleName] = genEnforceLazy(ruleName);
-          });
-          return assign(enforceEager, target);
-      }
+      handleNoProxy();
       return new Proxy(assign(enforceEager, target), {
           get: function (target, key) {
               if (key in target) {
@@ -665,6 +660,15 @@
               return genEnforceLazy(key);
           }
       });
+      function handleNoProxy() {
+          if (!isProxySupported()) {
+              eachEnforceRule(function (ruleName) {
+                  // Only on the first rule access - start the chain of calls
+                  target[ruleName] = genEnforceLazy(ruleName);
+              });
+              return assign(enforceEager, target);
+          }
+      }
   }
   var enforce = genEnforce();
 
@@ -857,22 +861,37 @@
   function useTestCallbacks() {
       return useStateRef().testCallbacks();
   }
+  // OPTIONAL FIELDS
+  function useOptionalField(fieldName) {
+      var optionalFields = useOptionalFields()[0];
+      return optionalFields[fieldName];
+  }
   function useOptionalFields() {
       return useStateRef().optionalFields();
   }
+  function useSetOptionalField(fieldName, setter) {
+      var _a = useOptionalFields(), setOptionalFields = _a[1];
+      setOptionalFields(function (optionalFields) {
+          var _a;
+          return assign(optionalFields, (_a = {},
+              _a[fieldName] = optionalFunctionValue(setter, optionalFields[fieldName]),
+              _a));
+      });
+  }
+  function useOptionalFieldApplied(fieldName) {
+      var _a;
+      return (_a = useOptionalField(fieldName)) === null || _a === void 0 ? void 0 : _a[1];
+  }
+  function useOptionalFieldConfig(fieldName) {
+      var _a;
+      return (_a = useOptionalField(fieldName)) === null || _a === void 0 ? void 0 : _a[0];
+  }
   function useTestObjects() {
       return useStateRef().testObjects();
   }
   // STATE ACTIONS
   function useRefreshTestObjects() {
-      var _a = useTestObjects(), setTestObjects = _a[1];
-      setTestObjects(function (_a) {
-          var current = _a.current, prev = _a.prev;
-          return ({
-              prev: prev,
-              current: asArray(current)
-          });
-      });
+      useSetTests(function (tests) { return tests; });
   }
   function useSetTests(handler) {
       var _a = useTestObjects(), testObjects = _a[1];
@@ -886,22 +905,7 @@
   }
   // Derived state
   function useAllIncomplete() {
-      var current = useTestObjects()[0].current;
-      return flatten(transform(current, function (testObject) {
-          return testObject.isPending() ? testObject : null;
-      }));
-  }
-  function useOmittedFields() {
-      var testObjects = useTestsFlat();
-      return testObjects.reduce(function (omittedFields, testObject) {
-          if (omittedFields[testObject.fieldName]) {
-              return omittedFields;
-          }
-          if (testObject.isOmitted()) {
-              omittedFields[testObject.fieldName] = true;
-          }
-          return omittedFields;
-      }, {});
+      return useTestsFlat().filter(function (test) { return test.isPending(); });
   }
   var flatCache = createCache();
   function useTestsFlat() {
@@ -1197,9 +1201,7 @@
 
   function isolate(_a, callback) {
       var _b = _a.type, type = _b === void 0 ? IsolateTypes.DEFAULT : _b;
-      if (!isFunction(callback)) {
-          return;
-      }
+      invariant(isFunction(callback));
       var keys = {
           current: {},
           prev: {}
@@ -1229,6 +1231,11 @@
       SeverityCount["ERROR_COUNT"] = "errorCount";
       SeverityCount["WARN_COUNT"] = "warnCount";
   })(SeverityCount || (SeverityCount = {}));
+  function countKeyBySeverity(severity) {
+      return severity === Severity.ERRORS
+          ? SeverityCount.ERROR_COUNT
+          : SeverityCount.WARN_COUNT;
+  }
 
   function nonMatchingFieldName(testObject, fieldName) {
       return !!fieldName && !matchingFieldName(testObject, fieldName);
@@ -1248,10 +1255,23 @@
       return either(severity === Severity.WARNINGS, testObject.warns());
   }
 
+  /**
+   * The difference between this file and hasFailures is that hasFailures uses the static
+   * summary object, while this one uses the actual validation state
+   */
+  function hasErrorsByTestObjects(fieldName) {
+      return hasFailuresByTestObjects(Severity.ERRORS, fieldName);
+  }
+  function hasFailuresByTestObjects(severityKey, fieldName) {
+      var testObjects = useTestsFlat();
+      return testObjects.some(function (testObject) {
+          return hasFailuresByTestObject(testObject, severityKey, fieldName);
+      });
+  }
   /**
    * Determines whether a certain test profile has failures.
    */
-  function hasFailuresLogic(testObject, severityKey, fieldName) {
+  function hasFailuresByTestObject(testObject, severityKey, fieldName) {
       if (!testObject.hasFailures()) {
           return false;
       }
@@ -1264,79 +1284,54 @@
       return true;
   }
 
-  function hasErrors(fieldName) {
-      return has(Severity.ERRORS, fieldName);
-  }
-  function hasWarnings(fieldName) {
-      return has(Severity.WARNINGS, fieldName);
-  }
-  function has(severityKey, fieldName) {
-      var testObjects = useTestsFlat();
-      return testObjects.some(function (testObject) {
-          return hasFailuresLogic(testObject, severityKey, fieldName);
-      });
-  }
-
-  function isValid(fieldName) {
-      var _a, _b;
-      var summary = context.useX().summary;
-      invariant(summary);
-      return Boolean(fieldName ? (_b = (_a = summary.tests) === null || _a === void 0 ? void 0 : _a[fieldName]) === null || _b === void 0 ? void 0 : _b.valid : summary.valid);
-  }
   // eslint-disable-next-line max-statements, complexity
   function shouldAddValidProp(fieldName) {
       if (fieldIsOmitted(fieldName)) {
           return true;
       }
-      if (hasErrors(fieldName)) {
+      if (hasErrorsByTestObjects(fieldName)) {
           return false;
       }
       var testObjects = useTestsFlat();
       if (isEmpty(testObjects)) {
           return false;
       }
-      if (fieldDoesNotExist(fieldName)) {
-          return false;
-      }
       if (hasNonOptionalIncomplete(fieldName)) {
           return false;
       }
       return noMissingTests(fieldName);
   }
   function fieldIsOmitted(fieldName) {
-      var omittedFields = useOmittedFields();
       if (!fieldName) {
           return false;
       }
-      return !!omittedFields[fieldName];
+      return useOptionalFieldApplied(fieldName) === true;
   }
   function hasNonOptionalIncomplete(fieldName) {
-      var optionalFields = useOptionalFields()[0];
       return isNotEmpty(useAllIncomplete().filter(function (testObject) {
           if (nonMatchingFieldName(testObject, fieldName)) {
               return false;
           }
-          return optionalFields[testObject.fieldName] !== true;
+          return useOptionalFieldConfig(testObject.fieldName) !== true;
       }));
   }
-  function fieldDoesNotExist(fieldName) {
-      var testObjects = useTestsFlat();
-      return (!!fieldName &&
-          !testObjects.find(function (testObject) { return testObject.fieldName === fieldName; }));
-  }
   function noMissingTests(fieldName) {
       var testObjects = useTestsFlat();
-      var optionalFields = useOptionalFields()[0];
       return testObjects.every(function (testObject) {
           if (nonMatchingFieldName(testObject, fieldName)) {
               return true;
           }
-          return (optionalFields[testObject.fieldName] === true ||
+          return (useOptionalFieldConfig(testObject.fieldName) === true ||
               testObject.isTested() ||
               testObject.isOmitted());
       });
   }
 
+  function useSummary() {
+      var summary = context.useX().summary;
+      invariant(summary);
+      return summary;
+  }
   /**
    * Reads the testObjects list and gets full validation result from it.
    */
@@ -1385,13 +1380,9 @@
       }
       return summary;
   }
-  /**
-   * Appends the test to a results object
-   */
-  // eslint-disable-next-line max-statements
   function appendTestObject(summaryKey, testObject) {
       var fieldName = testObject.fieldName, message = testObject.message;
-      summaryKey[fieldName] = summaryKey[fieldName] || baseStats();
+      summaryKey[fieldName] = summaryKey[fieldName] || baseTestStats();
       var testKey = summaryKey[fieldName];
       if (testObject.isNonActionable())
           return testKey;
@@ -1404,18 +1395,13 @@
       }
       return testKey;
       function incrementFailures(severity) {
-          var countKey = getCountKey(severity);
+          var countKey = countKeyBySeverity(severity);
           testKey[countKey]++;
           if (message) {
               testKey[severity] = (testKey[severity] || []).concat(message);
           }
       }
   }
-  function getCountKey(severity) {
-      return severity === Severity.ERRORS
-          ? SeverityCount.ERROR_COUNT
-          : SeverityCount.WARN_COUNT;
-  }
   function baseStats() {
       return {
           errorCount: 0,
@@ -1423,6 +1409,12 @@
           testCount: 0
       };
   }
+  function baseTestStats() {
+      return assign(baseStats(), {
+          errors: [],
+          warnings: []
+      });
+  }
 
   // calls collectAll or getByFieldName depending on whether fieldName is provided
   function gatherFailures(testGroup, severityKey, fieldName) {
@@ -1435,10 +1427,11 @@
       return ((_a = testGroup === null || testGroup === void 0 ? void 0 : testGroup[fieldName]) === null || _a === void 0 ? void 0 : _a[severityKey]) || [];
   }
   function collectAll(testGroup, severityKey) {
-      var _a;
       var output = {};
       for (var field in testGroup) {
-          output[field] = ((_a = testGroup[field]) === null || _a === void 0 ? void 0 : _a[severityKey]) || [];
+          // We will probably never get to the fallback array
+          // leaving it just in case the implementation changes
+          output[field] = testGroup[field][severityKey] || [];
       }
       return output;
   }
@@ -1453,8 +1446,7 @@
    * @returns suite or field's errors or warnings.
    */
   function getFailures(severityKey, fieldName) {
-      var summary = context.useX().summary;
-      invariant(summary);
+      var summary = useSummary();
       return gatherFailures(summary.tests, severityKey, fieldName);
   }
 
@@ -1465,27 +1457,55 @@
       return getFailuresByGroup(groupName, Severity.WARNINGS, fieldName);
   }
   function getFailuresByGroup(groupName, severityKey, fieldName) {
-      var summary = context.useX().summary;
-      invariant(summary);
+      var summary = useSummary();
       return gatherFailures(summary.groups[groupName], severityKey, fieldName);
   }
 
+  function hasErrors(fieldName) {
+      return hasFailures(SeverityCount.ERROR_COUNT, fieldName);
+  }
+  function hasWarnings(fieldName) {
+      return hasFailures(SeverityCount.WARN_COUNT, fieldName);
+  }
+  function hasFailures(severityCount, fieldName) {
+      var _a;
+      var summary = useSummary();
+      if (fieldName) {
+          return isPositive((_a = summary.tests[fieldName]) === null || _a === void 0 ? void 0 : _a[severityCount]);
+      }
+      return isPositive(summary[severityCount]);
+  }
+
   function hasErrorsByGroup(groupName, fieldName) {
-      return hasByGroup(Severity.ERRORS, groupName, fieldName);
+      return hasFailuresByGroup(Severity.ERRORS, groupName, fieldName);
   }
   function hasWarningsByGroup(groupName, fieldName) {
-      return hasByGroup(Severity.WARNINGS, groupName, fieldName);
+      return hasFailuresByGroup(Severity.WARNINGS, groupName, fieldName);
   }
-  /**
-   * Checks whether there are failures in a given group.
-   */
-  function hasByGroup(severityKey, group, fieldName) {
-      var testObjects = useTestsFlat();
-      return testObjects.some(function (testObject) {
-          return group === testObject.groupName
-              ? hasFailuresLogic(testObject, severityKey, fieldName)
-              : false;
-      });
+  // eslint-disable-next-line max-statements
+  function hasFailuresByGroup(severityKey, groupName, fieldName) {
+      var _a, _b;
+      var summary = useSummary();
+      var severityCount = countKeyBySeverity(severityKey);
+      var group = summary.groups[groupName];
+      if (!group) {
+          return false;
+      }
+      if (fieldName) {
+          return isPositive((_a = group[fieldName]) === null || _a === void 0 ? void 0 : _a[severityCount]);
+      }
+      for (var field in group) {
+          if (isPositive((_b = group[field]) === null || _b === void 0 ? void 0 : _b[severityCount])) {
+              return true;
+          }
+      }
+      return false;
+  }
+
+  function isValid(fieldName) {
+      var _a;
+      var summary = useSummary();
+      return fieldName ? Boolean((_a = summary.tests[fieldName]) === null || _a === void 0 ? void 0 : _a.valid) : summary.valid;
   }
 
   var cache$1 = createCache(1);
@@ -1495,7 +1515,7 @@
       return cache$1([testObjects], context.bind(ctxRef, function () {
           var summary = genTestsSummary();
           var suiteName = useSuiteName();
-          var ref = assign({ summary: summary }, ctxRef);
+          var ref = { summary: summary };
           return assign(summary, {
               getErrors: context.bind(ref, getErrors),
               getErrorsByGroup: context.bind(ref, getErrorsByGroup),
@@ -1608,7 +1628,7 @@
       }
   }
 
-  function omitOptionalTests() {
+  function omitOptionalFields() {
       var optionalFields = useOptionalFields()[0];
       if (isEmpty(optionalFields)) {
           return;
@@ -1629,10 +1649,11 @@
       function verifyAndOmit(testObject) {
           if (shouldOmit[testObject.fieldName]) {
               testObject.omit();
+              useSetOptionalField(testObject.fieldName, function (current) { return [current[0], true]; });
           }
       }
       function runOptionalConfig(testObject) {
-          var optionalConfig = optionalFields[testObject.fieldName];
+          var optionalConfig = useOptionalFieldConfig(testObject.fieldName);
           if (isFunction(optionalConfig)) {
               shouldOmit[testObject.fieldName] = optionalConfig();
               verifyAndOmit(testObject);
@@ -1692,7 +1713,7 @@
       // Async operations may still be running.
       bus.on(Events.SUITE_CALLBACK_DONE_RUNNING, function () {
           // Remove tests that are optional and need to be omitted
-          omitOptionalTests();
+          omitOptionalFields();
       });
       // Called when all the tests, including async, are done running
       bus.on(Events.ALL_RUNNING_TESTS_FINISHED, function () {
@@ -1888,7 +1909,7 @@
               return keyTests[fieldName] === false;
           }
       }
-      if (isMissingFromIncludedGroup(groupName)) {
+      if (isTopLevelWhenThereIsAnIncludedGroup(groupName)) {
           return true;
       }
       // if field is only'ed
@@ -1897,39 +1918,13 @@
       // If there is _ANY_ `only`ed test (and we already know this one isn't) return true
       if (hasIncludedTests(keyTests)) {
           // Check if inclusion rules for this field (`include` hook)
+          // TODO: Check if this may need to be moved outside of the condition.
+          // What if there are no included tests? This shouldn't run then?
           return !optionalFunctionValue(inclusion[fieldName]);
       }
       // We're done here. This field is not excluded
       return false;
   }
-  // eslint-disable-next-line max-statements
-  function isMissingFromIncludedGroup(groupName) {
-      var context$1 = context.useX();
-      var exclusion = context$1.exclusion;
-      if (!hasIncludedGroups()) {
-          return false;
-      }
-      if (!groupName) {
-          return true;
-      }
-      if (groupName in exclusion.groups) {
-          if (exclusion.groups[groupName]) {
-              return false;
-          }
-          return true;
-      }
-      return true;
-  }
-  function hasIncludedGroups() {
-      var context$1 = context.useX();
-      var exclusion = context$1.exclusion;
-      for (var group in exclusion.groups) {
-          if (exclusion.groups[group]) {
-              return true;
-          }
-      }
-      return false;
-  }
   /**
    * Checks whether a given group is excluded from running.
    */
@@ -1944,13 +1939,8 @@
           return keyGroups[groupName] === false;
       }
       // Group is not present
-      for (var group in keyGroups) {
-          // If any other group is only'ed
-          if (keyGroups[group] === true) {
-              return true;
-          }
-      }
-      return false;
+      // Return whether other groups are included
+      return hasIncludedGroups();
   }
   /**
    * Adds fields to a specified exclusion group.
@@ -1979,6 +1969,24 @@
       }
       return false;
   }
+  // are we not in a group and there is an included group?
+  function isTopLevelWhenThereIsAnIncludedGroup(groupName) {
+      if (!hasIncludedGroups()) {
+          return false;
+      }
+      // Return whether there's an included group, and we're not inside a group
+      return !groupName;
+  }
+  function hasIncludedGroups() {
+      var context$1 = context.useX();
+      var exclusion = context$1.exclusion;
+      for (var group in exclusion.groups) {
+          if (exclusion.groups[group]) {
+              return true;
+          }
+      }
+      return false;
+  }
 
   /**
    * Runs tests within a group so that they can be controlled or queried separately.
@@ -2004,16 +2012,18 @@
   function include(fieldName) {
       var context$1 = context.useX();
       var inclusion = context$1.inclusion, exclusion = context$1.exclusion;
-      if (!fieldName) {
-          return { when: when };
-      }
+      invariant(isStringValue(fieldName));
       inclusion[fieldName] = defaultTo(exclusion.tests[fieldName], true);
       return { when: when };
       function when(condition) {
           var context$1 = context.useX();
           var inclusion = context$1.inclusion, exclusion = context$1.exclusion;
+          // This callback will run as part of the "isExcluded" series of checks
           inclusion[fieldName] = function () {
               if (hasOwnProperty(exclusion.tests, fieldName)) {
+                  // I suspect this code is technically unreachable because
+                  // if there are any skip/only rules applied to the current
+                  // field, the "isExcluded" function will have already bailed
                   return defaultTo(exclusion.tests[fieldName], true);
               }
               if (isStringValue(condition)) {
@@ -2047,7 +2057,7 @@
       setMode(Modes.EAGER);
   }
   function shouldSkipBasedOnMode(testObject) {
-      if (isEager() && hasErrors(testObject.fieldName))
+      if (isEager() && hasErrorsByTestObjects(testObject.fieldName))
           return true;
       return false;
   }
@@ -2096,22 +2106,21 @@
    * });
    */
   function optional(optionals) {
-      var _a = useOptionalFields(), setOptionalFields = _a[1];
-      setOptionalFields(function (state) {
-          if (!isArray(optionals) && !isStringValue(optionals)) {
-              var optionalFunctions = optionals;
-              for (var field in optionalFunctions) {
-                  var predicate = optionalFunctions[field];
-                  state[field] = predicate;
-              }
-          }
-          else {
-              asArray(optionals).forEach(function (optionalField) {
-                  state[optionalField] = true;
-              });
+      // When the optional is given as a string or a list of strings
+      // we just add them to the list of optional fields.
+      if (isArray(optionals) || isStringValue(optionals)) {
+          asArray(optionals).forEach(function (optionalField) {
+              useSetOptionalField(optionalField, [true, false]);
+          });
+      }
+      else {
+          // if it's an object, we iterate over the keys and add them to the list
+          var optionalFunctions = optionals;
+          for (var field in optionalFunctions) {
+              var predicate = optionalFunctions[field];
+              useSetOptionalField(field, [predicate, false]);
           }
-          return state;
-      });
+      }
   }
 
   function isPromise(value) {
@@ -2159,6 +2168,8 @@
           asyncTest.then(done, fail);
       }
       catch (e) {
+          // We will probably never get here, unless the consumer uses a buggy custom Promise
+          // implementation that behaves differently than the native one, or if they for some
           fail();
       }
   }
@@ -2167,22 +2178,7 @@
    * Runs sync tests - or extracts promise.
    */
   function runSyncTest(testObject) {
-      return context.run({ currentTest: testObject }, function () {
-          var result;
-          try {
-              result = testObject.testFn();
-          }
-          catch (e) {
-              if (shouldUseErrorAsMessage(testObject.message, e)) {
-                  testObject.message = e;
-              }
-              result = false;
-          }
-          if (result === false) {
-              testObject.fail();
-          }
-          return result;
-      });
+      return context.run({ currentTest: testObject }, function () { return testObject.run(); });
   }
 
   /**
@@ -2401,7 +2397,7 @@
       ctx.currentTest.warn();
   }
 
-  var VERSION = "4.3.1";
+  var VERSION = "4.3.3";
 
   exports.VERSION = VERSION;
   exports.context = context;