vest 4.4.3-dev-c786f7 → 4.6.0

package/dist/es/vest.development.js

@@ -1,5 +1,5 @@
 export { enforce } from 'n4s';
-import { isUndefined, isStringValue, assign, cache as cache$2, optionalFunctionValue, nestedArray, asArray, genId, isFunction, isNullish, deferThrow, invariant, bindNot, either, isEmpty, isNotEmpty, isPositive, hasOwnProperty, isArray, callEach, bus, defaultTo, isPromise, isNull } from 'vest-utils';
+import { isUndefined, isStringValue, assign, cache as cache$2, nestedArray, asArray, seq, optionalFunctionValue, isFunction, isNullish, deferThrow, invariant, bindNot, either, isArray, isEmpty, isNotEmpty, isPositive, numberEquals, hasOwnProperty, callEach, bus, defaultTo, isPromise, isNull } from 'vest-utils';
 import { createContext } from 'context';
 
 function shouldUseErrorAsMessage(message, error) {
@@ -61,7 +61,7 @@ function generateIsolate(type, path) {
 var context = createContext(function (ctxRef, parentContext) {
     return parentContext
         ? null
-        : assign({}, {
+        : assign({
             exclusion: {
                 tests: {},
                 groups: {}
@@ -88,29 +88,22 @@ 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) {
+    setOptionalFields(function (prev) {
         var _a;
-        return assign(optionalFields, (_a = {},
-            _a[fieldName] = optionalFunctionValue(setter, optionalFields[fieldName]),
+        return assign(prev, (_a = {},
+            _a[fieldName] = assign({}, prev[fieldName], setter(prev[fieldName])),
             _a));
     });
 }
-function useOptionalFieldApplied(fieldName) {
-    var _a;
-    return (_a = useOptionalField(fieldName)) === null || _a === void 0 ? void 0 : _a[1];
-}
-function useOptionalFieldConfig(fieldName) {
+function useOptionalField(fieldName) {
     var _a;
-    return (_a = useOptionalField(fieldName)) === null || _a === void 0 ? void 0 : _a[0];
+    var optionalFields = useOptionalFields()[0];
+    return (_a = optionalFields[fieldName]) !== null && _a !== void 0 ? _a : {};
 }
 function useTestObjects() {
     return useStateRef().testObjects();
@@ -152,7 +145,7 @@ var VestTest = /** @class */ (function () {
     function VestTest(fieldName, testFn, _a) {
         var _b = _a === void 0 ? {} : _a, message = _b.message, groupName = _b.groupName, key = _b.key;
         this.key = null;
-        this.id = genId();
+        this.id = seq();
         this.severity = TestSeverity.Error;
         this.status = STATUS_UNTESTED;
         this.fieldName = fieldName;
@@ -240,18 +233,9 @@ var VestTest = /** @class */ (function () {
     VestTest.prototype.valueOf = function () {
         return !this.isFailing();
     };
-    VestTest.prototype.hasFailures = function () {
-        return this.isFailing() || this.isWarning();
-    };
-    VestTest.prototype.isNonActionable = function () {
-        return this.isSkipped() || this.isOmitted() || this.isCanceled();
-    };
     VestTest.prototype.isPending = function () {
         return this.statusEquals(STATUS_PENDING);
     };
-    VestTest.prototype.isTested = function () {
-        return this.hasFailures() || this.isPassing();
-    };
     VestTest.prototype.isOmitted = function () {
         return this.statusEquals(STATUS_OMITTED);
     };
@@ -273,6 +257,20 @@ var VestTest = /** @class */ (function () {
     VestTest.prototype.isWarning = function () {
         return this.statusEquals(STATUS_WARNING);
     };
+    VestTest.prototype.hasFailures = function () {
+        return this.isFailing() || this.isWarning();
+    };
+    VestTest.prototype.isNonActionable = function () {
+        return this.isSkipped() || this.isOmitted() || this.isCanceled();
+    };
+    VestTest.prototype.isTested = function () {
+        return this.hasFailures() || this.isPassing();
+    };
+    VestTest.prototype.awaitsResolution = function () {
+        // Is the test in a state where it can still be run, or complete running
+        // and its final status is indeterminate?
+        return this.isSkipped() || this.isUntested() || this.isPending();
+    };
     VestTest.prototype.statusEquals = function (status) {
         return this.status === status;
     };
@@ -512,26 +510,85 @@ function hasFailuresByTestObject(testObject, severityKey, fieldName) {
     return true;
 }
 
+/**
+ * Marks a field as optional, either just by name, or by a given condition.
+ *
+ * @example
+ *
+ * optional('field_name');
+ *
+ * optional({
+ *  username: () => allowUsernameEmpty,
+ * });
+ */
+function optional(optionals) {
+    // There are two types of optional field declarations:
+    // 1. Delayed: A string, which is the name of the field to be optional.
+    // We will only determine whether to omit the test after the suite is done running
+    //
+    // 2. Immediate: Either a boolean or a function, which is used to determine
+    // if the field should be optional.
+    // Delayed case (field name)
+    if (isArray(optionals) || isStringValue(optionals)) {
+        asArray(optionals).forEach(function (optionalField) {
+            useSetOptionalField(optionalField, function () { return ({
+                type: OptionalFieldTypes.Delayed,
+                applied: false,
+                rule: null
+            }); });
+        });
+    }
+    else {
+        var _loop_1 = function (field) {
+            var value = optionals[field];
+            useSetOptionalField(field, function () { return ({
+                type: OptionalFieldTypes.Immediate,
+                rule: value,
+                applied: optionalFunctionValue(value)
+            }); });
+        };
+        // Immediately case (function or boolean)
+        for (var field in optionals) {
+            _loop_1(field);
+        }
+    }
+}
+function optionalFiedIsApplied(fieldName) {
+    if (!fieldName) {
+        return false;
+    }
+    return useOptionalField(fieldName).applied;
+}
+var OptionalFieldTypes;
+(function (OptionalFieldTypes) {
+    OptionalFieldTypes[OptionalFieldTypes["Immediate"] = 0] = "Immediate";
+    OptionalFieldTypes[OptionalFieldTypes["Delayed"] = 1] = "Delayed";
+})(OptionalFieldTypes || (OptionalFieldTypes = {}));
+
 // eslint-disable-next-line max-statements, complexity
 function shouldAddValidProperty(fieldName) {
-    if (fieldIsOmitted(fieldName)) {
+    // Is the field optional, and the optional condition is applied
+    if (optionalFiedIsApplied(fieldName)) {
         return true;
     }
-    if (hasErrorsByTestObjects(fieldName)) {
-        return false;
-    }
     var testObjects = useTestsFlat();
+    // Are there no tests?
     if (isEmpty(testObjects)) {
         return false;
     }
+    // Does the field have any tests with errors?
+    if (hasErrorsByTestObjects(fieldName)) {
+        return false;
+    }
     // Does the given field have any pending tests that are not optional?
     if (hasNonOptionalIncomplete(fieldName)) {
         return false;
     }
+    // Does the field have no missing tests?
     return noMissingTests(fieldName);
 }
 function shouldAddValidPropertyInGroup(groupName, fieldName) {
-    if (fieldIsOmitted(fieldName)) {
+    if (optionalFiedIsApplied(fieldName)) {
         return true;
     }
     if (hasGroupFailuresByTestObjects(Severity.ERRORS, groupName, fieldName)) {
@@ -543,16 +600,10 @@ function shouldAddValidPropertyInGroup(groupName, fieldName) {
     }
     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) {
-        return isOptionalFieldIncomplete(testObject, fieldName);
+        return isTestObjectOptional(testObject, fieldName);
     }));
 }
 // Do the given group/field have any pending tests that are not optional?
@@ -561,47 +612,58 @@ function hasNonOptionalIncompleteByGroup(groupName, fieldName) {
         if (nonMatchingGroupName(testObject, groupName)) {
             return false;
         }
-        return isOptionalFieldIncomplete(testObject, fieldName);
+        return isTestObjectOptional(testObject, fieldName);
     }));
 }
-function isOptionalFieldIncomplete(testObject, fieldName) {
+function isTestObjectOptional(testObject, fieldName) {
     if (nonMatchingFieldName(testObject, fieldName)) {
         return false;
     }
-    return useOptionalFieldConfig(testObject.fieldName) !== true;
+    return optionalFiedIsApplied(fieldName);
 }
+// Did all of the tests for the provided field run/omit?
+// This makes sure that the fields are not skipped or pending.
 function noMissingTests(fieldName) {
     var testObjects = useTestsFlat();
     return testObjects.every(function (testObject) {
-        if (nonMatchingFieldName(testObject, fieldName)) {
-            return true;
-        }
-        return missingTestsLogic(testObject, fieldName);
+        return noMissingTestsLogic(testObject, fieldName);
     });
 }
+// Does the group have no missing tests?
 function noMissingTestsByGroup(groupName, fieldName) {
     var testObjects = useTestsFlat();
     return testObjects.every(function (testObject) {
         if (nonMatchingGroupName(testObject, groupName)) {
             return true;
         }
-        return missingTestsLogic(testObject, fieldName);
+        return noMissingTestsLogic(testObject, fieldName);
     });
 }
-function missingTestsLogic(testObject, fieldName) {
+// Does the object qualify as either tested or omitted (but not skipped!)
+function noMissingTestsLogic(testObject, fieldName) {
     if (nonMatchingFieldName(testObject, fieldName)) {
         return true;
     }
-    return (useOptionalFieldConfig(testObject.fieldName) === true ||
+    /**
+     * The reason we're checking for the optional field here and not in "omitOptionalFields"
+     * is because that unlike the bool/function check we do there, here it only depends on
+     * whether the field was tested alredy or not.
+     *
+     * We qualify the test as not missing only if it was already run, if it is omitted,
+     * or if it is marked as optional, even if the optional check did not apply yet -
+     * but the test did not reach its final state.
+     */
+    return (optionalTestAwaitsResolution(testObject) ||
         testObject.isTested() ||
         testObject.isOmitted());
 }
-
-function useSummary() {
-    var summary = context.useX().summary;
-    invariant(summary);
-    return summary;
+function optionalTestAwaitsResolution(testObject) {
+    // Does the test belong to an optional field,
+    // and the test itself is still in an indeterminate state?
+    return (useOptionalField(testObject.fieldName).type ===
+        OptionalFieldTypes.Delayed && testObject.awaitsResolution());
 }
+
 /**
  * Reads the testObjects list and gets full validation result from it.
  */
@@ -713,57 +775,85 @@ function collectAll(testGroup, severityKey) {
     return output;
 }
 
-function getErrors(fieldName) {
-    return getFailures(Severity.ERRORS, fieldName);
-}
-function getWarnings(fieldName) {
-    return getFailures(Severity.WARNINGS, fieldName);
+// eslint-disable-next-line max-lines-per-function, max-statements
+function suiteSelectors(summary) {
+    var selectors = {
+        getErrors: getErrors,
+        getErrorsByGroup: getErrorsByGroup,
+        getWarnings: getWarnings,
+        getWarningsByGroup: getWarningsByGroup,
+        hasErrors: hasErrors,
+        hasErrorsByGroup: hasErrorsByGroup,
+        hasWarnings: hasWarnings,
+        hasWarningsByGroup: hasWarningsByGroup,
+        isValid: isValid,
+        isValidByGroup: isValidByGroup
+    };
+    return selectors;
+    // Booleans
+    function isValid(fieldName) {
+        var _a;
+        return fieldName ? Boolean((_a = summary.tests[fieldName]) === null || _a === void 0 ? void 0 : _a.valid) : summary.valid;
+    }
+    function isValidByGroup(groupName, fieldName) {
+        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 hasWarnings(fieldName) {
+        return hasFailures(summary, SeverityCount.WARN_COUNT, fieldName);
+    }
+    function hasErrors(fieldName) {
+        return hasFailures(summary, SeverityCount.ERROR_COUNT, fieldName);
+    }
+    function hasWarningsByGroup(groupName, fieldName) {
+        return hasFailuresByGroup(summary, SeverityCount.WARN_COUNT, groupName, fieldName);
+    }
+    function hasErrorsByGroup(groupName, fieldName) {
+        return hasFailuresByGroup(summary, SeverityCount.ERROR_COUNT, groupName, fieldName);
+    }
+    function getWarnings(fieldName) {
+        return getFailures(summary, Severity.WARNINGS, fieldName);
+    }
+    function getErrors(fieldName) {
+        return getFailures(summary, Severity.ERRORS, fieldName);
+    }
+    function getErrorsByGroup(groupName, fieldName) {
+        return getFailuresByGroup(summary, Severity.ERRORS, groupName, fieldName);
+    }
+    function getWarningsByGroup(groupName, fieldName) {
+        return getFailuresByGroup(summary, Severity.WARNINGS, groupName, fieldName);
+    }
 }
-/**
- * @returns suite or field's errors or warnings.
- */
-function getFailures(severityKey, fieldName) {
-    var summary = useSummary();
+// Gathers all failures of a given severity
+// With a fieldName, it will only gather failures for that field
+function getFailures(summary, severityKey, fieldName) {
     return gatherFailures(summary.tests, severityKey, fieldName);
 }
-
-function getErrorsByGroup(groupName, fieldName) {
-    return getFailuresByGroup(groupName, Severity.ERRORS, fieldName);
-}
-function getWarningsByGroup(groupName, fieldName) {
-    return getFailuresByGroup(groupName, Severity.WARNINGS, fieldName);
-}
-function getFailuresByGroup(groupName, severityKey, fieldName) {
-    var summary = useSummary();
+// Gathers all failures of a given severity within a group
+// With a fieldName, it will only gather failures for that field
+function getFailuresByGroup(summary, severityKey, groupName, fieldName) {
     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) {
+// Checks if a field is valid within a container object - can be within a group or top level
+function isFieldValid(testContainer, 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 hasFailuresByGroup(Severity.ERRORS, groupName, fieldName);
-}
-function hasWarningsByGroup(groupName, fieldName) {
-    return hasFailuresByGroup(Severity.WARNINGS, groupName, fieldName);
+    return !!((_a = testContainer[fieldName]) === null || _a === void 0 ? void 0 : _a.valid);
 }
-// eslint-disable-next-line max-statements
-function hasFailuresByGroup(severityKey, groupName, fieldName) {
+// Checks if a there are any failures of a given severity within a group
+// If a fieldName is provided, it will only check for failures within that field
+function hasFailuresByGroup(summary, severityCount, groupName, fieldName) {
     var _a, _b;
-    var summary = useSummary();
-    var severityCount = countKeyBySeverity(severityKey);
     var group = summary.groups[groupName];
     if (!group) {
         return false;
@@ -778,32 +868,14 @@ function hasFailuresByGroup(severityKey, groupName, fieldName) {
     }
     return false;
 }
-
-function isValid(fieldName) {
-    var summary = useSummary();
-    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) {
+// Checks if there are any failures of a given severity
+// If a fieldName is provided, it will only check for failures within that field
+function hasFailures(summary, countKey, fieldName) {
     var _a;
-    return !!((_a = testContainer[fieldName]) === null || _a === void 0 ? void 0 : _a.valid);
+    var failureCount = fieldName
+        ? (_a = summary.tests[fieldName]) === null || _a === void 0 ? void 0 : _a[countKey]
+        : summary[countKey] || 0;
+    return isPositive(failureCount);
 }
 
 var cache$1 = cache$2(1);
@@ -813,18 +885,7 @@ function produceSuiteResult() {
     return cache$1([testObjects], context.bind(ctxRef, function () {
         var summary = genTestsSummary();
         var suiteName = useSuiteName();
-        var ref = { summary: summary };
-        return assign(summary, {
-            getErrors: context.bind(ref, getErrors),
-            getErrorsByGroup: context.bind(ref, getErrorsByGroup),
-            getWarnings: context.bind(ref, getWarnings),
-            getWarningsByGroup: context.bind(ref, getWarningsByGroup),
-            hasErrors: context.bind(ref, hasErrors),
-            hasErrorsByGroup: context.bind(ref, hasErrorsByGroup),
-            hasWarnings: context.bind(ref, hasWarnings),
-            hasWarningsByGroup: context.bind(ref, hasWarningsByGroup),
-            isValid: context.bind(ref, isValid),
-            isValidByGroup: context.bind(ref, isValidByGroup),
+        return assign(summary, suiteSelectors(summary), {
             suiteName: suiteName
         });
     }));
@@ -843,7 +904,7 @@ function hasRemainingTests(fieldName) {
             return matchingFieldName(testObject, fieldName);
         });
     }
-    return isNotEmpty(allIncomplete);
+    return true;
 }
 
 var cache = cache$2(20);
@@ -860,10 +921,10 @@ function produceFullResult() {
  * DONE is here and not in its own module to prevent circular dependency issues.
  */
 function shouldSkipDoneRegistration(callback, fieldName, output) {
+    var _a;
     // If we do not have any test runs for the current field
     return !!(!isFunction(callback) ||
-        (fieldName &&
-            (!output.tests[fieldName] || isEmpty(output.tests[fieldName].testCount))));
+        (fieldName && numberEquals((_a = output.tests[fieldName]) === null || _a === void 0 ? void 0 : _a.testCount, 0)));
 }
 function shouldRunDoneCallback(fieldName) {
     // is suite finished || field name exists, and test is finished;
@@ -905,34 +966,48 @@ function deferDoneCallback(doneCallback, fieldName) {
     });
 }
 
+/**
+ * This module gets triggered once the suite is done running its sync tests.
+ *
+ * It goes over all the tests in the state, and checks if they need to be omitted.
+ */
 function omitOptionalFields() {
     var optionalFields = useOptionalFields()[0];
+    // If there are no optional fields, we don't need to do anything
     if (isEmpty(optionalFields)) {
         return;
     }
+    // Create an object to store the fields that need to be omitted
     var shouldOmit = {};
-    useSetTests(function (tests) {
-        return nestedArray.transform(tests, function (testObject) {
-            var fieldName = testObject.fieldName;
-            if (hasOwnProperty(shouldOmit, fieldName)) {
-                verifyAndOmit(testObject);
-            }
-            else {
-                runOptionalConfig(testObject);
-            }
-            return testObject;
-        });
+    // iterate over each of the tests in the state
+    useTestsFlat().forEach(function (testObject) {
+        // If we already added the current field (not this test specifically)
+        // no need for further checks, go and omit the test
+        if (hasOwnProperty(shouldOmit, testObject.fieldName)) {
+            verifyAndOmit(testObject);
+        }
+        else {
+            // check if the field has an optional function
+            // if so, run it and verify/omit the test
+            runOptionalConfig(testObject);
+        }
     });
+    // refresh the tests in the state so that the omitted fields are applied
+    useRefreshTestObjects();
     function verifyAndOmit(testObject) {
         if (shouldOmit[testObject.fieldName]) {
             testObject.omit();
-            useSetOptionalField(testObject.fieldName, function (current) { return [current[0], true]; });
+            useSetOptionalField(testObject.fieldName, function () { return ({
+                applied: true
+            }); });
         }
     }
     function runOptionalConfig(testObject) {
-        var optionalConfig = useOptionalFieldConfig(testObject.fieldName);
-        if (isFunction(optionalConfig)) {
-            shouldOmit[testObject.fieldName] = optionalConfig();
+        // Ge the optional configuration for the given field
+        var optionalConfig = useOptionalField(testObject.fieldName);
+        // If the optional was set to a function or a boolean, run it and verify/omit the test
+        if (optionalConfig.type === OptionalFieldTypes.Immediate) {
+            shouldOmit[testObject.fieldName] = optionalFunctionValue(optionalConfig.rule);
             verifyAndOmit(testObject);
         }
     }
@@ -1038,7 +1113,7 @@ function create() {
     // State initialization
     var state = createState();
     // State reference - this holds the actual state values
-    var stateRef = createStateRef(state, { suiteId: genId(), suiteName: suiteName });
+    var stateRef = createStateRef(state, { suiteId: seq(), suiteName: suiteName });
     // Create base context reference. All hooks will derive their data from this
     var ctxRef = { stateRef: stateRef, bus: bus };
     var suite = assign(
@@ -1152,7 +1227,7 @@ skip.group = function (item) {
     return addTo(1 /* ExclusionGroup.SKIP */, 'groups', item);
 };
 //Checks whether a certain test profile excluded by any of the exclusion groups.
-// eslint-disable-next-line complexity, max-statements, max-lines-per-function
+// eslint-disable-next-line complexity, max-statements
 function isExcluded(testObject) {
     var fieldName = testObject.fieldName, groupName = testObject.groupName;
     if (isExcludedIndividually())
@@ -1356,44 +1431,16 @@ function setMode(nextMode) {
 function omitWhen(conditional, callback) {
     isolate({ type: IsolateTypes.OMIT_WHEN }, function () {
         context.run({
-            omitted: isOmitted() ||
+            omitted: inActiveOmitWhen() ||
                 optionalFunctionValue(conditional, optionalFunctionValue(produceSuiteResult))
         }, function () { return callback(); });
     });
 }
-function isOmitted() {
+// Checks that we're currently in an active omitWhen block
+function inActiveOmitWhen() {
     return !!context.useX().omitted;
 }
 
-/**
- * Marks a field as optional, either just by name, or by a given condition.
- *
- * @example
- *
- * optional('field_name');
- *
- * optional({
- *  username: () => allowUsernameEmpty,
- * });
- */
-function optional(optionals) {
-    // 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]);
-        }
-    }
-}
-
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
 
@@ -1419,8 +1466,6 @@ function __spreadArray(to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 }
 
-bindNot(isStringValue);
-
 function isSameProfileTest(testObject1, testObject2) {
     return (testObject1.fieldName === testObject2.fieldName &&
         testObject1.groupName === testObject2.groupName);
@@ -1583,7 +1628,7 @@ function registerPrevRunTest(testObject) {
         return testObject;
     }
     var prevRunTest = useTestAtCursor(testObject);
-    if (isOmitted()) {
+    if (inActiveOmitWhen() || optionalFiedIsApplied(testObject.fieldName)) {
         prevRunTest.omit();
         cursor.next();
         return prevRunTest;
@@ -1614,7 +1659,6 @@ function registerTestObjectByTier(testObject) {
 }
 
 /* eslint-disable jest/valid-title */
-// eslint-disable-next-line max-lines-per-function
 function bindTestMemo(test) {
     var cache = cache$2(10); // arbitrary cache size
     // eslint-disable-next-line max-statements
@@ -1685,6 +1729,6 @@ function warn() {
     ctx.currentTest.warn();
 }
 
-var VERSION = "4.4.3-dev-c786f7";
+var VERSION = "4.6.0";
 
-export { VERSION, context, create, each, eager, group, include, omitWhen, only, optional, skip, skipWhen, test, warn };
+export { VERSION, context, create, each, eager, group, include, omitWhen, only, optional, skip, skipWhen, suiteSelectors, test, warn };