vest 4.3.3 → 4.4.0

package/dist/es/vest.development.js

@@ -176,40 +176,6 @@ function getCurrent(array, path) {
     return current;
 }
 
-function createCursor() {
-    var storage = {
-        cursor: []
-    };
-    function addLevel() {
-        storage.cursor.push(0);
-    }
-    function removeLevel() {
-        storage.cursor.pop();
-    }
-    function cursorAt() {
-        return last(storage.cursor);
-    }
-    function getCursor() {
-        return asArray(storage.cursor);
-    }
-    function next() {
-        storage.cursor[storage.cursor.length - 1]++;
-        return last(storage.cursor);
-    }
-    function reset() {
-        storage.cursor = [0];
-    }
-    reset();
-    return {
-        addLevel: addLevel,
-        cursorAt: cursorAt,
-        getCursor: getCursor,
-        next: next,
-        removeLevel: removeLevel,
-        reset: reset
-    };
-}
-
 var IsolateTypes;
 (function (IsolateTypes) {
     IsolateTypes[IsolateTypes["DEFAULT"] = 0] = "DEFAULT";
@@ -226,6 +192,133 @@ var Modes;
     Modes[Modes["EAGER"] = 1] = "EAGER";
 })(Modes || (Modes = {}));
 
+function invariant(condition, 
+// eslint-disable-next-line @typescript-eslint/ban-types
+message) {
+    if (condition) {
+        return;
+    }
+    // If message is a string object (rather than string literal)
+    // Throw the value directly as a string
+    // Alternatively, throw an error with the message
+    throw message instanceof String
+        ? message.valueOf()
+        : new Error(message ? optionalFunctionValue(message) : message);
+}
+
+function createIsolateCursor() {
+    var cursor = {
+        value: 0
+    };
+    return {
+        current: current,
+        next: next
+    };
+    /**
+     * @returns {number} The current value of the cursor
+     */
+    function current() {
+        return cursor.value;
+    }
+    /**
+     * Moves the isolate cursor forward by 1
+     */
+    function next() {
+        cursor.value++;
+    }
+}
+
+function isNullish(value) {
+    return isNull(value) || isUndefined(value);
+}
+
+function deferThrow(message) {
+    setTimeout(function () {
+        throw new Error(message);
+    }, 0);
+}
+
+function usePrevKeys() {
+    var prev = useTestObjects()[0].prev;
+    return asArray(getCurrent(prev, useCurrentPath())).reduce(function (prevKeys, testObject) {
+        if (!(testObject instanceof VestTest)) {
+            return prevKeys;
+        }
+        if (isNullish(testObject.key)) {
+            return prevKeys;
+        }
+        prevKeys[testObject.key] = testObject;
+        return prevKeys;
+    }, {});
+}
+function usePrevTestByKey(key) {
+    var prev = context.useX().isolate.keys.prev;
+    return prev[key];
+}
+function useRetainTestKey(key, testObject) {
+    var context$1 = context.useX();
+    var current = context$1.isolate.keys.current;
+    if (isNullish(current[key])) {
+        current[key] = testObject;
+    }
+    else {
+        deferThrow("Encountered the same test key \"".concat(key, "\" twice. This may lead to tests overriding each other's results, or to tests being unexpectedly omitted."));
+    }
+}
+
+function isolate(_a, callback) {
+    var _b = _a.type, type = _b === void 0 ? IsolateTypes.DEFAULT : _b;
+    invariant(isFunction(callback));
+    // Generate a new Isolate layer, with its own cursor
+    var isolate = generateIsolate(type, useCurrentPath());
+    var output = context.run({ isolate: isolate }, function () {
+        isolate.keys.prev = usePrevKeys();
+        useSetTests(function (tests) { return setValueAtPath(tests, isolate.path, []); });
+        var res = callback();
+        return res;
+    });
+    // Move the parent cursor forward once we're done
+    useCursor().next();
+    return output;
+}
+/**
+ * @returns {Isolate} The current isolate layer
+ */
+function useIsolate() {
+    return context.useX().isolate;
+}
+/**
+ * @returns {boolean} Whether or not the current isolate allows tests to be reordered
+ */
+function shouldAllowReorder() {
+    return context.useX().isolate.type === IsolateTypes.EACH;
+}
+/**
+ * @returns {number[]} The current cursor path of the isolate tree
+ */
+function useCurrentPath() {
+    var isolate = useIsolate();
+    return isolate.path.concat(isolate.cursor.current());
+}
+/**
+ * @returns {IsolateCursor} The cursor object for the current isolate
+ */
+function useCursor() {
+    return useIsolate().cursor;
+}
+function generateIsolate(type, path) {
+    if (path === void 0) { path = []; }
+    return {
+        cursor: createIsolateCursor(),
+        keys: {
+            current: {},
+            prev: {}
+        },
+        path: path,
+        type: type
+    };
+}
+
 var context = createContext(function (ctxRef, parentContext) {
     return parentContext
         ? null
@@ -235,15 +328,8 @@ var context = createContext(function (ctxRef, parentContext) {
                 groups: {}
             },
             inclusion: {},
-            isolate: {
-                type: IsolateTypes.DEFAULT,
-                keys: {
-                    current: {},
-                    prev: {}
-                }
-            },
-            mode: [Modes.ALL],
-            testCursor: createCursor()
+            isolate: generateIsolate(IsolateTypes.DEFAULT),
+            mode: [Modes.ALL]
         }, ctxRef);
 });
 
@@ -462,20 +548,6 @@ var STATUS_PENDING = 'PENDING';
 var STATUS_CANCELED = 'CANCELED';
 var STATUS_OMITTED = 'OMITTED';
 
-function invariant(condition, 
-// eslint-disable-next-line @typescript-eslint/ban-types
-message) {
-    if (condition) {
-        return;
-    }
-    // If message is a string object (rather than string literal)
-    // Throw the value directly as a string
-    // Alternatively, throw an error with the message
-    throw message instanceof String
-        ? message.valueOf()
-        : new Error(message ? optionalFunctionValue(message) : message);
-}
-
 // eslint-disable-next-line max-lines-per-function
 function createState(onStateChange) {
     var state = {
@@ -559,87 +631,6 @@ function createStateRef(state, _a) {
     };
 }
 
-function isNullish(value) {
-    return isNull(value) || isUndefined(value);
-}
-
-function deferThrow(message) {
-    setTimeout(function () {
-        throw new Error(message);
-    }, 0);
-}
-
-function usePath() {
-    var context$1 = context.useX();
-    return context$1.testCursor.getCursor();
-}
-function useCursorAt() {
-    var context$1 = context.useX();
-    return context$1.testCursor.cursorAt();
-}
-function moveForward() {
-    var context$1 = context.useX();
-    return context$1.testCursor.next();
-}
-function addLevel() {
-    var context$1 = context.useX();
-    context$1.testCursor.addLevel();
-}
-function removeLevel() {
-    var context$1 = context.useX();
-    context$1.testCursor.removeLevel();
-}
-
-function usePrevKeys() {
-    var prev = useTestObjects()[0].prev;
-    return asArray(getCurrent(prev, usePath())).reduce(function (prevKeys, testObject) {
-        if (!(testObject instanceof VestTest)) {
-            return prevKeys;
-        }
-        if (isNullish(testObject.key)) {
-            return prevKeys;
-        }
-        prevKeys[testObject.key] = testObject;
-        return prevKeys;
-    }, {});
-}
-function usePrevTestByKey(key) {
-    var prev = context.useX().isolate.keys.prev;
-    return prev[key];
-}
-function useRetainTestKey(key, testObject) {
-    var context$1 = context.useX();
-    var current = context$1.isolate.keys.current;
-    if (isNullish(current[key])) {
-        current[key] = testObject;
-    }
-    else {
-        deferThrow("Encountered the same test key \"".concat(key, "\" twice. This may lead to tests overriding each other's results, or to tests being unexpectedly omitted."));
-    }
-}
-
-function isolate(_a, callback) {
-    var _b = _a.type, type = _b === void 0 ? IsolateTypes.DEFAULT : _b;
-    invariant(isFunction(callback));
-    var keys = {
-        current: {},
-        prev: {}
-    };
-    var path = usePath();
-    return context.run({ isolate: { type: type, keys: keys } }, function () {
-        addLevel();
-        keys.prev = usePrevKeys();
-        useSetTests(function (tests) { return setValueAtPath(tests, path, []); });
-        var res = callback();
-        removeLevel();
-        moveForward();
-        return res;
-    });
-}
-function shouldAllowReorder() {
-    return context.useX().isolate.type === IsolateTypes.EACH;
-}
-
 var Severity;
 (function (Severity) {
     Severity["WARNINGS"] = "warnings";
@@ -691,6 +682,11 @@ function matchingFieldName(testObject, fieldName) {
     return !!(fieldName && testObject.fieldName === fieldName);
 }
 
+var nonMatchingGroupName = bindNot(matchingGroupName);
+function matchingGroupName(testObject, groupName) {
+    return testObject.groupName === groupName;
+}
+
 function either(a, b) {
     return !!a !== !!b;
 }
@@ -715,6 +711,15 @@ function hasFailuresByTestObjects(severityKey, fieldName) {
         return hasFailuresByTestObject(testObject, severityKey, fieldName);
     });
 }
+function hasGroupFailuresByTestObjects(severityKey, groupName, fieldName) {
+    var testObjects = useTestsFlat();
+    return testObjects.some(function (testObject) {
+        if (nonMatchingGroupName(testObject, groupName)) {
+            return false;
+        }
+        return hasFailuresByTestObject(testObject, severityKey, fieldName);
+    });
+}
 /**
  * Determines whether a certain test profile has failures.
  */
@@ -732,7 +737,7 @@ function hasFailuresByTestObject(testObject, severityKey, fieldName) {
 }
 
 // eslint-disable-next-line max-statements, complexity
-function shouldAddValidProp(fieldName) {
+function shouldAddValidProperty(fieldName) {
     if (fieldIsOmitted(fieldName)) {
         return true;
     }
@@ -743,36 +748,78 @@ function shouldAddValidProp(fieldName) {
     if (isEmpty(testObjects)) {
         return false;
     }
+    // Does the given field have any pending tests that are not optional?
     if (hasNonOptionalIncomplete(fieldName)) {
         return false;
     }
     return noMissingTests(fieldName);
 }
+function shouldAddValidPropertyInGroup(groupName, fieldName) {
+    if (fieldIsOmitted(fieldName)) {
+        return true;
+    }
+    if (hasGroupFailuresByTestObjects(Severity.ERRORS, groupName, fieldName)) {
+        return false;
+    }
+    // Do the given group/field have any pending tests that are not optional?
+    if (hasNonOptionalIncompleteByGroup(groupName, fieldName)) {
+        return false;
+    }
+    return noMissingTestsByGroup(groupName, fieldName);
+}
 function fieldIsOmitted(fieldName) {
     if (!fieldName) {
         return false;
     }
     return useOptionalFieldApplied(fieldName) === true;
 }
+// Does the given field have any pending tests that are not optional?
 function hasNonOptionalIncomplete(fieldName) {
     return isNotEmpty(useAllIncomplete().filter(function (testObject) {
-        if (nonMatchingFieldName(testObject, fieldName)) {
+        return isOptionalFieldIncomplete(testObject, fieldName);
+    }));
+}
+// Do the given group/field have any pending tests that are not optional?
+function hasNonOptionalIncompleteByGroup(groupName, fieldName) {
+    return isNotEmpty(useAllIncomplete().filter(function (testObject) {
+        if (nonMatchingGroupName(testObject, groupName)) {
             return false;
         }
-        return useOptionalFieldConfig(testObject.fieldName) !== true;
+        return isOptionalFieldIncomplete(testObject, fieldName);
     }));
 }
+function isOptionalFieldIncomplete(testObject, fieldName) {
+    if (nonMatchingFieldName(testObject, fieldName)) {
+        return false;
+    }
+    return useOptionalFieldConfig(testObject.fieldName) !== true;
+}
 function noMissingTests(fieldName) {
     var testObjects = useTestsFlat();
     return testObjects.every(function (testObject) {
         if (nonMatchingFieldName(testObject, fieldName)) {
             return true;
         }
-        return (useOptionalFieldConfig(testObject.fieldName) === true ||
-            testObject.isTested() ||
-            testObject.isOmitted());
+        return missingTestsLogic(testObject, fieldName);
+    });
+}
+function noMissingTestsByGroup(groupName, fieldName) {
+    var testObjects = useTestsFlat();
+    return testObjects.every(function (testObject) {
+        if (nonMatchingGroupName(testObject, groupName)) {
+            return true;
+        }
+        return missingTestsLogic(testObject, fieldName);
     });
 }
+function missingTestsLogic(testObject, fieldName) {
+    if (nonMatchingFieldName(testObject, fieldName)) {
+        return true;
+    }
+    return (useOptionalFieldConfig(testObject.fieldName) === true ||
+        testObject.isTested() ||
+        testObject.isOmitted());
+}
 
 function useSummary() {
     var summary = context.useX().summary;
@@ -794,7 +841,7 @@ function genTestsSummary() {
         appendToGroup(summary.groups, testObject);
         return summary;
     }, summary);
-    summary.valid = shouldAddValidProp();
+    summary.valid = shouldAddValidProperty();
     return countFailures(summary);
 }
 function appendToTest(tests, testObject) {
@@ -803,7 +850,7 @@ function appendToTest(tests, testObject) {
     tests[testObject.fieldName].valid =
         tests[testObject.fieldName].valid === false
             ? false
-            : shouldAddValidProp(testObject.fieldName);
+            : shouldAddValidProperty(testObject.fieldName);
 }
 /**
  * Appends to a group object if within a group
@@ -815,6 +862,10 @@ function appendToGroup(groups, testObject) {
     }
     groups[groupName] = groups[groupName] || {};
     groups[groupName][testObject.fieldName] = appendTestObject(groups[groupName], testObject);
+    groups[groupName][testObject.fieldName].valid =
+        groups[groupName][testObject.fieldName].valid === false
+            ? false
+            : shouldAddValidPropertyInGroup(groupName, testObject.fieldName);
 }
 /**
  * Counts the failed tests and adds global counters
@@ -863,6 +914,10 @@ function baseTestStats() {
     });
 }
 
+function isPositive(value) {
+    return greaterThan(value, 0);
+}
+
 // calls collectAll or getByFieldName depending on whether fieldName is provided
 function gatherFailures(testGroup, severityKey, fieldName) {
     return fieldName
@@ -875,10 +930,13 @@ function getByFieldName(testGroup, severityKey, fieldName) {
 }
 function collectAll(testGroup, severityKey) {
     var output = {};
+    var countKey = countKeyBySeverity(severityKey);
     for (var field in testGroup) {
-        // We will probably never get to the fallback array
-        // leaving it just in case the implementation changes
-        output[field] = testGroup[field][severityKey] || [];
+        if (isPositive(testGroup[field][countKey])) {
+            // We will probably never get to the fallback array
+            // leaving it just in case the implementation changes
+            output[field] = testGroup[field][severityKey] || [];
+        }
     }
     return output;
 }
@@ -908,10 +966,6 @@ function getFailuresByGroup(groupName, severityKey, fieldName) {
     return gatherFailures(summary.groups[groupName], severityKey, fieldName);
 }
 
-function isPositive(value) {
-    return greaterThan(value, 0);
-}
-
 function hasErrors(fieldName) {
     return hasFailures(SeverityCount.ERROR_COUNT, fieldName);
 }
@@ -954,9 +1008,30 @@ function hasFailuresByGroup(severityKey, groupName, fieldName) {
 }
 
 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;
+    return fieldName
+        ? Boolean(isFieldValid(summary.tests, fieldName))
+        : summary.valid;
+}
+function isValidByGroup(groupName, fieldName) {
+    var summary = useSummary();
+    var group = summary.groups[groupName];
+    if (!group) {
+        return false;
+    }
+    if (fieldName) {
+        return isFieldValid(group, fieldName);
+    }
+    for (var fieldName_1 in group) {
+        if (!isFieldValid(group, fieldName_1)) {
+            return false;
+        }
+    }
+    return true;
+}
+function isFieldValid(testContainer, fieldName) {
+    var _a;
+    return !!((_a = testContainer[fieldName]) === null || _a === void 0 ? void 0 : _a.valid);
 }
 
 var cache$1 = createCache(1);
@@ -977,6 +1052,7 @@ function produceSuiteResult() {
             hasWarnings: context.bind(ref, hasWarnings),
             hasWarningsByGroup: context.bind(ref, hasWarningsByGroup),
             isValid: context.bind(ref, isValid),
+            isValidByGroup: context.bind(ref, isValidByGroup),
             suiteName: suiteName
         });
     }));
@@ -1574,7 +1650,7 @@ function optional(optionals) {
     }
 }
 
-/*! *****************************************************************************
+/******************************************************************************
 Copyright (c) Microsoft Corporation.
 
 Permission to use, copy, modify, and/or distribute this software for any
@@ -1719,8 +1795,8 @@ function useTestAtCursor(newTestObject) {
 function removeAllNextTestsInIsolate() {
     var _a = useTestObjects(), testObjects = _a[0], setTestObjects = _a[1];
     var prevTests = testObjects.prev;
-    var current = getCurrent(prevTests, usePath());
-    var cursorAt = useCursorAt();
+    var current = getCurrent(prevTests, useCurrentPath());
+    var cursorAt = useCursor().current();
     current.splice(cursorAt);
     // We actually don't mind mutating the state directly (as can be seen above). There is no harm in it
     // since we're only touching the "prev" state. The reason we still use the setter function is
@@ -1734,13 +1810,13 @@ function removeAllNextTestsInIsolate() {
     });
 }
 function useSetTestAtCursor(testObject) {
-    var cursorPath = usePath();
+    var cursorPath = useCurrentPath();
     useSetTests(function (tests) {
         return setValueAtPath(tests, cursorPath, testObject);
     });
 }
 function useGetTestAtCursor(tests) {
-    var cursorPath = usePath();
+    var cursorPath = useCurrentPath();
     return valueAtPath(tests, cursorPath);
 }
 function testReorderDetected(prevTest, newTest) {
@@ -1764,16 +1840,17 @@ function handleKeyTest(key, newTestObject) {
 
 // eslint-disable-next-line max-statements
 function registerPrevRunTest(testObject) {
+    var cursor = useCursor();
     if (shouldSkipBasedOnMode(testObject)) {
         testObject.skip();
         useTestAtCursor(testObject);
-        moveForward();
+        cursor.next();
         return testObject;
     }
     var prevRunTest = useTestAtCursor(testObject);
     if (isOmitted()) {
         prevRunTest.omit();
-        moveForward();
+        cursor.next();
         return prevRunTest;
     }
     if (isExcluded(testObject)) {
@@ -1782,13 +1859,13 @@ function registerPrevRunTest(testObject) {
         // This mostly means that we're probably giving
         // up on this async test intentionally.
         prevRunTest.skip(isExcludedIndividually());
-        moveForward();
+        cursor.next();
         return prevRunTest;
     }
     cancelOverriddenPendingTest(prevRunTest, testObject);
     useSetTestAtCursor(testObject);
-    moveForward();
     registerTestObjectByTier(testObject);
+    cursor.next();
     return testObject;
 }
 function registerTestObjectByTier(testObject) {
@@ -1811,7 +1888,7 @@ function bindTestMemo(test) {
         for (var _i = 1; _i < arguments.length; _i++) {
             args[_i - 1] = arguments[_i];
         }
-        var cursorAt = useCursorAt();
+        var cursorAt = useCursor().current();
         var _a = args.reverse(), deps = _a[0], testFn = _a[1], msg = _a[2];
         // Implicit dependency for more specificity
         var dependencies = [useSuiteId(), fieldName, cursorAt].concat(deps);
@@ -1873,6 +1950,6 @@ function warn() {
     ctx.currentTest.warn();
 }
 
-var VERSION = "4.3.3";
+var VERSION = "4.4.0";
 
 export { VERSION, context, create, each, eager, group, include, omitWhen, only, optional, skip, skipWhen, test, warn };