vest 4.3.1 → 4.3.3

package/dist/es/vest.development.js

@@ -35,6 +35,8 @@ function asArray(possibleArg) {
     return [].concat(possibleArg);
 }
 
+var assign = Object.assign;
+
 function isNumeric(value) {
     var str = String(value);
     var num = Number(value);
@@ -174,8 +176,6 @@ function getCurrent(array, path) {
     return current;
 }
 
-var assign = Object.assign;
-
 function createCursor() {
     var storage = {
         cursor: []
@@ -262,22 +262,37 @@ function useSuiteName() {
 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];
@@ -291,22 +306,7 @@ function useSetTests(handler) {
 }
 // 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() {
@@ -620,9 +620,7 @@ function useRetainTestKey(key, testObject) {
 
 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: {}
@@ -652,6 +650,11 @@ var SeverityCount;
     SeverityCount["ERROR_COUNT"] = "errorCount";
     SeverityCount["WARN_COUNT"] = "warnCount";
 })(SeverityCount || (SeverityCount = {}));
+function countKeyBySeverity(severity) {
+    return severity === Severity.ERRORS
+        ? SeverityCount.ERROR_COUNT
+        : SeverityCount.WARN_COUNT;
+}
 
 /**
  * A safe hasOwnProperty access
@@ -677,7 +680,7 @@ function isEmpty(value) {
     else if (typeof value === 'object') {
         return lengthEquals(Object.keys(value), 0);
     }
-    return true;
+    return false;
 }
 var isNotEmpty = bindNot(isEmpty);
 
@@ -699,10 +702,23 @@ function nonMatchingSeverityProfile(severity, testObject) {
     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;
     }
@@ -715,79 +731,54 @@ function hasFailuresLogic(testObject, severityKey, fieldName) {
     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.
  */
@@ -836,13 +827,9 @@ function countFailures(summary) {
     }
     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;
@@ -855,18 +842,13 @@ function appendTestObject(summaryKey, testObject) {
     }
     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,
@@ -874,6 +856,12 @@ function baseStats() {
         testCount: 0
     };
 }
+function baseTestStats() {
+    return assign(baseStats(), {
+        errors: [],
+        warnings: []
+    });
+}
 
 // calls collectAll or getByFieldName depending on whether fieldName is provided
 function gatherFailures(testGroup, severityKey, fieldName) {
@@ -886,10 +874,11 @@ function getByFieldName(testGroup, severityKey, fieldName) {
     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;
 }
@@ -904,8 +893,7 @@ function getWarnings(fieldName) {
  * @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);
 }
 
@@ -916,27 +904,59 @@ function getWarningsByGroup(groupName, fieldName) {
     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 isPositive(value) {
+    return greaterThan(value, 0);
+}
+
+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);
@@ -946,7 +966,7 @@ function produceSuiteResult() {
     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),
@@ -1059,7 +1079,7 @@ function createBus() {
     }
 }
 
-function omitOptionalTests() {
+function omitOptionalFields() {
     var optionalFields = useOptionalFields()[0];
     if (isEmpty(optionalFields)) {
         return;
@@ -1080,10 +1100,11 @@ function omitOptionalTests() {
     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);
@@ -1143,7 +1164,7 @@ function initBus() {
     // 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 () {
@@ -1339,7 +1360,7 @@ function isExcluded(testObject) {
             return keyTests[fieldName] === false;
         }
     }
-    if (isMissingFromIncludedGroup(groupName)) {
+    if (isTopLevelWhenThereIsAnIncludedGroup(groupName)) {
         return true;
     }
     // if field is only'ed
@@ -1348,39 +1369,13 @@ function isExcluded(testObject) {
     // 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.
  */
@@ -1395,13 +1390,8 @@ function isGroupExcluded(groupName) {
         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.
@@ -1430,6 +1420,24 @@ function hasIncludedTests(keyTests) {
     }
     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.
@@ -1455,16 +1463,18 @@ function groupErrorMsg(error) {
 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)) {
@@ -1498,7 +1508,7 @@ function eager() {
     setMode(Modes.EAGER);
 }
 function shouldSkipBasedOnMode(testObject) {
-    if (isEager() && hasErrors(testObject.fieldName))
+    if (isEager() && hasErrorsByTestObjects(testObject.fieldName))
         return true;
     return false;
 }
@@ -1547,22 +1557,21 @@ function isOmitted() {
  * });
  */
 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;
-    });
+    }
 }
 
 /*! *****************************************************************************
@@ -1635,6 +1644,8 @@ function runAsyncTest(testObject) {
         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();
     }
 }
@@ -1643,22 +1654,7 @@ function runAsyncTest(testObject) {
  * 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(); });
 }
 
 /**
@@ -1877,6 +1873,6 @@ function warn() {
     ctx.currentTest.warn();
 }
 
-var VERSION = "4.3.1";
+var VERSION = "4.3.3";
 
 export { VERSION, context, create, each, eager, group, include, omitWhen, only, optional, skip, skipWhen, test, warn };