vest 4.0.0-dev-cc5cf5 → 4.0.0-dev-31f012

package/dist/es/vest.development.js

@@ -224,8 +224,16 @@ function greaterThanOrEquals(value, gte) {
     return isNumeric(value) && isNumeric(gte) && Number(value) >= Number(gte);
 }
 
+// The module is named "isArrayValue" since it
+// is conflicting with a nested npm dependency.
+// We may need to revisit this in the future.
+function isArray(value) {
+    return Boolean(Array.isArray(value));
+}
+var isNotArray = bindNot(isArray);
+
 function inside(value, arg1) {
-    if (Array.isArray(arg1)) {
+    if (isArray(arg1)) {
         return arg1.indexOf(value) !== -1;
     }
     // both value and arg1 are strings
@@ -236,14 +244,6 @@ function inside(value, arg1) {
 }
 var notInside = bindNot(inside);
 
-// The module is named "isArrayValue" since it
-// is conflicting with a nested npm dependency.
-// We may need to revisit this in the future.
-function isArray(value) {
-    return Boolean(Array.isArray(value));
-}
-var isNotArray = bindNot(isArray);
-
 function lessThanOrEquals(value, lte) {
     return isNumeric(value) && isNumeric(lte) && Number(value) <= Number(lte);
 }
@@ -596,7 +596,7 @@ function eachEnforceRule(action) {
 
 function isProxySupported() {
     try {
-        return typeof Proxy === 'function';
+        return isFunction(Proxy);
     }
     catch (_a) {
         return false;
@@ -617,7 +617,7 @@ function transformResult(result, ruleName, value) {
         return ruleReturn(result);
     }
     else {
-        return ruleReturn(result.pass, optionalFunctionValue.apply(void 0, __spreadArray([result.message, ruleName, value], args, false)));
+        return ruleReturn(result.pass, optionalFunctionValue.apply(void 0, __spreadArray([result.message, ruleName, value], args)));
     }
 }
 function validateResult(result) {
@@ -651,9 +651,9 @@ function enforceEager(value) {
             for (var _i = 0; _i < arguments.length; _i++) {
                 args[_i] = arguments[_i];
             }
-            var transformedResult = transformResult.apply(void 0, __spreadArray([ctx$1.run({ value: value }, function () { return rule.apply(void 0, __spreadArray([value], args, false)); }),
+            var transformedResult = transformResult.apply(void 0, __spreadArray([ctx$1.run({ value: value }, function () { return rule.apply(void 0, __spreadArray([value], args)); }),
                 ruleName,
-                value], args, false));
+                value], args));
             if (!transformedResult.pass) {
                 if (isEmpty(transformedResult.message)) {
                     throwError("enforce/" + ruleName + " failed with " + JSON.stringify(value));
@@ -683,7 +683,7 @@ function genEnforceLazy(key) {
             }
             var rule = getRule(ruleName);
             registeredRules.push(function (value) {
-                return transformResult.apply(void 0, __spreadArray([rule.apply(void 0, __spreadArray([value], args, false)), ruleName, value], args, false));
+                return transformResult.apply(void 0, __spreadArray([rule.apply(void 0, __spreadArray([value], args)), ruleName, value], args));
             });
             var proxy = {
                 run: function (value) {
@@ -790,10 +790,6 @@ function genEnforce() {
 }
 var enforce = genEnforce();
 
-function asArray(possibleArg) {
-    return [].concat(possibleArg);
-}
-
 /**
  * @returns a unique numeric id.
  */
@@ -830,15 +826,16 @@ function createState(onStateChange) {
         return initKey(key, initialState);
     }
     function reset() {
+        var prev = current();
         state.references = [];
         registrations.forEach(function (_a, index) {
             var initialValue = _a[0];
-            return initKey(index, initialValue);
+            return initKey(index, initialValue, prev[index]);
         });
     }
-    function initKey(key, initialState) {
+    function initKey(key, initialState, prevState) {
         current().push();
-        set(key, optionalFunctionValue(initialState));
+        set(key, optionalFunctionValue(initialState, prevState));
         return function useStateKey() {
             return [
                 current()[key],
@@ -864,18 +861,74 @@ function createState(onStateChange) {
     }
 }
 
+var IsolateTypes;
+(function (IsolateTypes) {
+    IsolateTypes[IsolateTypes["DEFAULT"] = 0] = "DEFAULT";
+    IsolateTypes[IsolateTypes["SUITE"] = 1] = "SUITE";
+    IsolateTypes[IsolateTypes["EACH"] = 2] = "EACH";
+    IsolateTypes[IsolateTypes["SKIP_WHEN"] = 3] = "SKIP_WHEN";
+    IsolateTypes[IsolateTypes["GROUP"] = 4] = "GROUP";
+})(IsolateTypes || (IsolateTypes = {}));
+
 function createStateRef(state, _a) {
     var suiteId = _a.suiteId;
     return {
         optionalFields: state.registerStateKey(function () { return ({}); }),
-        prevTestObjects: state.registerStateKey(function () { return []; }),
-        suiteId: state.registerStateKey(function () { return suiteId; }),
+        suiteId: state.registerStateKey(suiteId),
         testCallbacks: state.registerStateKey(function () { return ({
             fieldCallbacks: {},
             doneCallbacks: []
         }); }),
-        testObjects: state.registerStateKey(function () { return []; }),
-        testObjectsCursor: state.registerStateKey(function () { return 0; })
+        testObjects: state.registerStateKey(function (prev) {
+            return {
+                prev: (prev ? prev.current : []),
+                current: []
+            };
+        })
+    };
+}
+
+function asArray(possibleArg) {
+    return [].concat(possibleArg);
+}
+
+function last(values) {
+    var valuesArray = asArray(values);
+    var _a = valuesArray, l = _a.length, _b = l - 1, lastValue = _a[_b];
+    return lastValue;
+}
+
+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
     };
 }
 
@@ -883,6 +936,8 @@ var ctx = createContext(function (ctxRef, parentContext) {
     return parentContext
         ? null
         : assign({}, {
+            isolate: { type: IsolateTypes.DEFAULT },
+            testCursor: createCursor(),
             exclusion: {
                 tests: {},
                 groups: {}
@@ -890,11 +945,49 @@ var ctx = createContext(function (ctxRef, parentContext) {
         }, ctxRef);
 });
 
-function nonMatchingFieldName(testObject, fieldName) {
-    return !!fieldName && !matchingFieldName(testObject, fieldName);
+// 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
+function transform(array, cb) {
+    var res = [];
+    for (var _i = 0, array_1 = array; _i < array_1.length; _i++) {
+        var v = array_1[_i];
+        if (isArray(v)) {
+            res.push(transform(v, cb));
+        }
+        else {
+            var output = cb(v);
+            if (isNotNull(output)) {
+                res.push(output);
+            }
+        }
+    }
+    return res;
 }
-function matchingFieldName(testObject, fieldName) {
-    return !!(fieldName && testObject.fieldName === fieldName);
+function valueAtPath(array, path) {
+    return getCurrent(array, path)[last(path)];
+}
+function setValueAtPath(array, path, value) {
+    var current = getCurrent(array, path);
+    current[last(path)] = value;
+    return array;
+}
+function flatten(values) {
+    return asArray(values).reduce(function (acc, value) {
+        if (isArray(value)) {
+            return acc.concat(flatten(value));
+        }
+        return asArray(acc).concat(value);
+    }, []);
+}
+function getCurrent(array, path) {
+    var current = array;
+    for (var _i = 0, _a = path.slice(0, -1); _i < _a.length; _i++) {
+        var p = _a[_i];
+        current[p] = defaultTo(current[p], []);
+        current = current[p];
+    }
+    return current;
 }
 
 /**
@@ -953,89 +1046,101 @@ function useOptionalFields() {
 function useTestObjects() {
     return useStateRef().testObjects();
 }
-function usePrevTestObjects() {
-    return useStateRef().prevTestObjects();
-}
-function useCursorAt() {
-    return useStateRef().testObjectsCursor();
-}
-function useSetNextCursorAt() {
-    var _a = useCursorAt(), setCursorAt = _a[1];
-    setCursorAt(function (cursorAt) { return cursorAt + 1; });
-}
 // STATE ACTIONS
 function useRefreshTestObjects() {
     var _a = useTestObjects(), setTestObjects = _a[1];
-    setTestObjects(function (testObjects) { return testObjects.slice(0); });
+    setTestObjects(function (_a) {
+        var current = _a.current, prev = _a.prev;
+        return ({
+            prev: prev,
+            current: asArray(current)
+        });
+    });
 }
-function useSetTestAtCursor(testObject) {
-    var cursorAt = useCursorAt()[0];
-    var _a = useTestObjects(), testObjects = _a[0], setTestObjects = _a[1];
-    if (testObject === testObjects[cursorAt]) {
-        return;
-    }
-    setTestObjects(function (testObjects) {
-        var newTestsOrder = testObjects.slice(0);
-        newTestsOrder[cursorAt] = testObject;
-        return newTestsOrder;
+function useSetTests(handler) {
+    var _a = useTestObjects(), testObjects = _a[1];
+    testObjects(function (_a) {
+        var current = _a.current, prev = _a.prev;
+        return ({
+            prev: prev,
+            current: asArray(handler(current))
+        });
     });
 }
-// DERIVED VALUES
-var omittedFieldsCache = createCache();
+// Derived state
+function useAllIncomplete() {
+    var current = useTestObjects()[0].current;
+    return flatten(transform(current, function (testObject) {
+        return testObject.isPending() ? testObject : null;
+    }));
+}
 function useOmittedFields() {
-    var testObjects = useTestObjects()[0];
-    return omittedFieldsCache([testObjects], function () {
-        return testObjects.reduce(function (omittedFields, testObject) {
-            if (omittedFields[testObject.fieldName]) {
-                return omittedFields;
-            }
-            if (testObject.isOmitted()) {
-                omittedFields[testObject.fieldName] = true;
-            }
+    var testObjects = useTestsFlat();
+    return testObjects.reduce(function (omittedFields, testObject) {
+        if (omittedFields[testObject.fieldName]) {
             return omittedFields;
-        }, {});
-    });
+        }
+        if (testObject.isOmitted()) {
+            omittedFields[testObject.fieldName] = true;
+        }
+        return omittedFields;
+    }, {});
 }
-var incompleteCache = createCache();
-function useAllIncomplete() {
-    var testObjects = useTestObjects()[0];
-    return incompleteCache([testObjects], function () {
-        return testObjects.filter(function (testObject) { return testObject.isPending(); });
-    });
+var flatCache = createCache();
+function useTestsFlat() {
+    var current = useTestObjects()[0].current;
+    return flatCache([current], function () { return flatten(current); });
 }
 
-function omitOptionalTests() {
-    var _a = useTestObjects(), setTestObjects = _a[1];
-    var optionalFields = useOptionalFields()[0];
-    if (isEmpty(optionalFields)) {
+function usePath() {
+    var context = ctx.useX();
+    return context.testCursor.getCursor();
+}
+function useCursorAt() {
+    var context = ctx.useX();
+    return context.testCursor.cursorAt();
+}
+function moveForward() {
+    var context = ctx.useX();
+    return context.testCursor.next();
+}
+function addLevel() {
+    var context = ctx.useX();
+    context.testCursor.addLevel();
+}
+function removeLevel() {
+    var context = ctx.useX();
+    context.testCursor.removeLevel();
+}
+
+function isolate(_a, callback) {
+    var _b = _a.type, type = _b === void 0 ? IsolateTypes.DEFAULT : _b;
+    if (!isFunction(callback)) {
         return;
     }
-    var shouldOmit = {};
-    setTestObjects(function (testObjects) {
-        return testObjects.map(function (testObject) {
-            var fieldName = testObject.fieldName;
-            if (shouldOmit.hasOwnProperty(fieldName)) {
-                omit(testObject);
-            }
-            else {
-                var optionalConfig = optionalFields[fieldName];
-                if (isFunction(optionalConfig)) {
-                    shouldOmit[fieldName] = optionalConfig();
-                    omit(testObject);
-                }
-            }
-            return testObject;
-        });
+    var path = usePath();
+    return ctx.run({ isolate: { type: type } }, function () {
+        addLevel();
+        useSetTests(function (tests) { return setValueAtPath(tests, path, []); });
+        var res = callback();
+        removeLevel();
+        moveForward();
+        return res;
     });
-    function omit(testObject) {
-        if (shouldOmit[testObject.fieldName]) {
-            testObject.omit();
-        }
-    }
+}
+function shouldAllowReorder() {
+    return ctx.useX().isolate.type === IsolateTypes.EACH;
+}
+
+function nonMatchingFieldName(testObject, fieldName) {
+    return !!fieldName && !matchingFieldName(testObject, fieldName);
+}
+function matchingFieldName(testObject, fieldName) {
+    return !!(fieldName && testObject.fieldName === fieldName);
 }
 
 /**
- * Checks if a given tests, or the suite as a whole still have remaining tests.
+ * Checks if a given field, or the suite as a whole still have remaining tests.
  */
 function hasRemainingTests(fieldName) {
     var allIncomplete = useAllIncomplete();
@@ -1054,7 +1159,7 @@ function hasRemainingTests(fieldName) {
  * Reads the testObjects list and gets full validation result from it.
  */
 function genTestsSummary() {
-    var testObjects = useTestObjects()[0];
+    var testObjects = useTestsFlat();
     var summary = {
         errorCount: 0,
         groups: {},
@@ -1174,7 +1279,7 @@ function getWarnings(fieldName) {
  * @returns suite or field's errors or warnings.
  */
 function getFailures(severityKey, fieldName) {
-    var testObjects = useTestObjects()[0];
+    var testObjects = useTestsFlat();
     var failureMessages = collectFailureMessages(severityKey, testObjects, {
         fieldName: fieldName
     });
@@ -1196,7 +1301,7 @@ function getByGroup(severityKey, group, fieldName) {
     if (!group) {
         throwError("get" + severityKey[0].toUpperCase() + severityKey.slice(1) + "ByGroup requires a group name. Received `" + group + "` instead.");
     }
-    var testObjects = useTestObjects()[0];
+    var testObjects = useTestsFlat();
     var failureMessages = collectFailureMessages(severityKey, testObjects, {
         group: group,
         fieldName: fieldName
@@ -1227,7 +1332,7 @@ function hasWarnings(fieldName) {
     return has('warnings', fieldName);
 }
 function has(severityKey, fieldName) {
-    var testObjects = useTestObjects()[0];
+    var testObjects = useTestsFlat();
     return testObjects.some(function (testObject) {
         return hasFailuresLogic(testObject, severityKey, fieldName);
     });
@@ -1243,7 +1348,7 @@ function hasWarningsByGroup(groupName, fieldName) {
  * Checks whether there are failures in a given group.
  */
 function hasByGroup(severityKey, group, fieldName) {
-    var testObjects = useTestObjects()[0];
+    var testObjects = useTestsFlat();
     return testObjects.some(function (testObject) {
         return group === testObject.groupName
             ? hasFailuresLogic(testObject, severityKey, fieldName)
@@ -1259,7 +1364,7 @@ function isValid(result, fieldName) {
     if (result.hasErrors(fieldName)) {
         return false;
     }
-    var testObjects = useTestObjects()[0];
+    var testObjects = useTestsFlat();
     if (isEmpty(testObjects)) {
         return false;
     }
@@ -1291,7 +1396,7 @@ function fieldDoesNotExist(result, fieldName) {
     return !!fieldName && isEmpty(result.tests[fieldName]);
 }
 function noMissingTests(fieldName) {
-    var testObjects = useTestObjects()[0];
+    var testObjects = useTestsFlat();
     var optionalFields = useOptionalFields()[0];
     return testObjects.every(function (testObject) {
         if (nonMatchingFieldName(testObject, fieldName)) {
@@ -1305,7 +1410,7 @@ function noMissingTests(fieldName) {
 
 var cache$1 = createCache(20);
 function produceDraft() {
-    var testObjects = useTestObjects()[0];
+    var testObjects = useTestsFlat();
     var ctxRef = { stateRef: useStateRef() };
     return cache$1([testObjects], ctx.bind(ctxRef, function () {
         return assign(genTestsSummary(), {
@@ -1326,7 +1431,7 @@ function produceDraft() {
 
 var cache = createCache(20);
 function produceFullResult() {
-    var testObjects = useTestObjects()[0];
+    var testObjects = useTestsFlat();
     var ctxRef = { stateRef: useStateRef() };
     return cache([testObjects], ctx.bind(ctxRef, function () {
         return assign({}, produceDraft(), {
@@ -1409,6 +1514,44 @@ function createBus() {
     };
 }
 
+function omitOptionalTests() {
+    var optionalFields = useOptionalFields()[0];
+    if (isEmpty(optionalFields)) {
+        return;
+    }
+    var shouldOmit = {};
+    useSetTests(function (tests) {
+        return transform(tests, function (testObject) {
+            var fieldName = testObject.fieldName;
+            if (shouldOmit.hasOwnProperty(fieldName)) {
+                omit(testObject);
+            }
+            else {
+                var optionalConfig = optionalFields[fieldName];
+                if (isFunction(optionalConfig)) {
+                    shouldOmit[fieldName] = optionalConfig();
+                    omit(testObject);
+                }
+            }
+            return testObject;
+        });
+    });
+    function omit(testObject) {
+        if (shouldOmit[testObject.fieldName]) {
+            testObject.omit();
+        }
+    }
+}
+
+/**
+ * Removes test object from suite state
+ */
+function removeTestFromState (testObject) {
+    useSetTests(function (tests) {
+        return transform(tests, function (test) { return (testObject !== test ? test : null); });
+    });
+}
+
 function callEach(arr) {
     return arr.forEach(function (fn) { return fn(); });
 }
@@ -1419,8 +1562,7 @@ function callEach(arr) {
 function runFieldCallbacks(fieldName) {
     var fieldCallbacks = useTestCallbacks()[0].fieldCallbacks;
     if (fieldName) {
-        if (!hasRemainingTests(fieldName) &&
-            Array.isArray(fieldCallbacks[fieldName])) {
+        if (!hasRemainingTests(fieldName) && isArray(fieldCallbacks[fieldName])) {
             callEach(fieldCallbacks[fieldName]);
         }
     }
@@ -1437,6 +1579,8 @@ function runDoneCallbacks() {
 
 function initBus() {
     var bus = createBus();
+    // Report a the completion of a test. There may be other tests with the same
+    // name that are still running, or not yet started.
     bus.on(Events.TEST_COMPLETED, function (testObject) {
         if (testObject.isCanceled()) {
             return;
@@ -1445,6 +1589,22 @@ function initBus() {
         runFieldCallbacks(testObject.fieldName);
         runDoneCallbacks();
     });
+    // Report that the suite completed its synchronous test run.
+    // Async operations may still be running.
+    bus.on(Events.SUITE_COMPLETED, function () {
+        // Remove tests that are optional and need to be omitted
+        omitOptionalTests();
+    });
+    // Removes a certain field from the state.
+    bus.on(Events.REMOVE_FIELD, function (fieldName) {
+        var testObjects = useTestsFlat();
+        testObjects.forEach(function (testObject) {
+            if (matchingFieldName(testObject, fieldName)) {
+                testObject.cancel();
+                removeTestFromState(testObject);
+            }
+        });
+    });
     return bus;
 }
 function useBus() {
@@ -1457,42 +1617,48 @@ function useBus() {
 var Events;
 (function (Events) {
     Events["TEST_COMPLETED"] = "test_completed";
+    Events["REMOVE_FIELD"] = "remove_field";
+    Events["SUITE_COMPLETED"] = "suite_completed";
 })(Events || (Events = {}));
 
 // eslint-disable-next-line max-lines-per-function
 function create(suiteCallback) {
     if (!isFunction(suiteCallback)) {
-        throwError('Suite initialization error. Expected `tests` to be a function.');
+        throwError('vest.create: Expected callback to be a function.');
     }
+    // Event bus initialization
     var bus = initBus();
+    // State initialization
     var state = createState();
+    // State reference - this holds the actual state values
     var stateRef = createStateRef(state, { suiteId: genId() });
-    var suite = assign(ctx.bind({ stateRef: stateRef, bus: bus }, function () {
+    // Create base context reference. All hooks will derive their data from this
+    var ctxRef = { stateRef: stateRef, bus: bus };
+    var suite = assign(
+    // Bind the suite body to the context
+    ctx.bind(ctxRef, function () {
         var args = [];
         for (var _i = 0; _i < arguments.length; _i++) {
             args[_i] = arguments[_i];
         }
-        var prevTestObjects = useTestObjects()[0];
-        var _a = usePrevTestObjects(), setPrevTestObjects = _a[1];
+        // Reset the state. Migrates current test objects to `prev` array.
         state.reset();
-        setPrevTestObjects(function () { return prevTestObjects; });
-        // Run the consumer's callback
-        suiteCallback.apply(void 0, args);
-        omitOptionalTests();
-        var res = produceFullResult();
-        return res;
+        // Create a top level isolate
+        isolate({ type: IsolateTypes.SUITE }, function () {
+            // Run the consumer's callback
+            suiteCallback.apply(void 0, args);
+        });
+        // Report the suite is done registering tests
+        // Async tests may still be running
+        bus.emit(Events.SUITE_COMPLETED);
+        // Return the result
+        return produceFullResult();
     }), {
-        get: ctx.bind({ stateRef: stateRef }, produceDraft),
-        remove: ctx.bind({ stateRef: stateRef }, function (name) {
-            var testObjects = useTestObjects()[0];
-            // We're mutating the array in `cancel`, so we have to first copy it.
-            asArray(testObjects).forEach(function (testObject) {
-                if (matchingFieldName(testObject, name)) {
-                    testObject.cancel();
-                }
-            });
-        }),
-        reset: state.reset
+        get: ctx.bind(ctxRef, produceDraft),
+        reset: state.reset,
+        remove: ctx.bind(ctxRef, function (fieldName) {
+            bus.emit(Events.REMOVE_FIELD, fieldName);
+        })
     });
     return suite;
 }
@@ -1506,16 +1672,20 @@ var ERROR_HOOK_CALLED_OUTSIDE = 'hook called outside of a running suite.';
  * Adds a field or multiple fields to inclusion group.
  */
 function only(item) {
-    return addTo('only', 'tests', item);
+    return addTo(0 /* ONLY */, 'tests', item);
 }
-only.group = function (item) { return addTo('only', 'groups', item); };
+only.group = function (item) {
+    return addTo(0 /* ONLY */, 'groups', item);
+};
 /**
  * Adds a field or multiple fields to exclusion group.
  */
 function skip(item) {
-    return addTo('skip', 'tests', item);
+    return addTo(1 /* SKIP */, 'tests', item);
 }
-skip.group = function (item) { return addTo('skip', 'groups', item); };
+skip.group = function (item) {
+    return addTo(1 /* SKIP */, 'groups', item);
+};
 //Checks whether a certain test profile excluded by any of the exclusion groups.
 // eslint-disable-next-line complexity, max-statements
 function isExcluded(testObject) {
@@ -1587,7 +1757,8 @@ function addTo(exclusionGroup, itemType, item) {
         if (!isStringValue(itemName)) {
             return;
         }
-        context.exclusion[itemType][itemName] = exclusionGroup === 'only';
+        context.exclusion[itemType][itemName] =
+            exclusionGroup === 0 /* ONLY */;
     });
 }
 /**
@@ -1602,6 +1773,12 @@ function hasIncludedTests(keyTests) {
     return false;
 }
 
+function skipWhen(conditional, callback) {
+    isolate({ type: IsolateTypes.SKIP_WHEN }, function () {
+        ctx.run({ skipped: optionalFunctionValue(conditional) }, function () { return callback(); });
+    });
+}
+
 var ERROR_OUTSIDE_OF_TEST = "warn hook called outside of a test callback. It won't have an effect."
     ;
 /**
@@ -1615,10 +1792,6 @@ function warn() {
     ctx$1.currentTest.warn();
 }
 
-function skipWhen(conditional, callback) {
-    ctx.run({ skipped: optionalFunctionValue(conditional) }, function () { return callback(); });
-}
-
 /**
  * Runs a group callback.
  */
@@ -1630,7 +1803,9 @@ function group(groupName, tests) {
         throwGroupError('callback must be a function');
     }
     // Running with the context applied
-    ctx.run({ groupName: groupName }, tests);
+    isolate({ type: IsolateTypes.GROUP }, function () {
+        ctx.run({ groupName: groupName }, tests);
+    });
 }
 function throwGroupError(error) {
     throwError("Wrong arguments passed to group. Group " + error + ".");
@@ -1655,29 +1830,6 @@ function optional(optionals) {
     });
 }
 
-/**
- * Removes first found element from array
- * WARNING: Mutates array
- */
-function removeElementFromArray(array, element) {
-    var index = array.indexOf(element);
-    if (index !== -1) {
-        array.splice(index, 1);
-    }
-    return array;
-}
-
-/**
- * Removes test object from suite state
- */
-function removeTestFromState (testObject) {
-    var _a = useTestObjects(), setTestObjects = _a[1];
-    setTestObjects(function (testObjects) {
-        // using asArray to clear the cache.
-        return asArray(removeElementFromArray(testObjects, testObject));
-    });
-}
-
 function shouldUseErrorAsMessage(message, error) {
     // kind of cheating with this safe guard, but it does the job
     return isUndefined(message) && isStringValue(error);
@@ -1739,11 +1891,17 @@ var VestTest = /** @class */ (function () {
         return this.hasFailures() || this.isCanceled() || this.isPassing();
     };
     VestTest.prototype.skip = function () {
+        if (this.isPending()) {
+            // Without this condition, the test will be marked as skipped even if it is pending.
+            // This means that it will not be counted in "allIncomplete" and its done callbacks
+            // will not be called, or will be called prematurely.
+            return;
+        }
         this.setStatus(STATUS_SKIPPED);
     };
     VestTest.prototype.cancel = function () {
         this.setStatus(STATUS_CANCELED);
-        removeTestFromState(this);
+        useRefreshTestObjects();
     };
     VestTest.prototype.omit = function () {
         this.setStatus(STATUS_OMITTED);
@@ -1867,7 +2025,7 @@ function runSyncTest(testObject) {
  * Registers test, if async - adds to pending array
  */
 function registerTest(testObject) {
-    var emit = useBus().emit;
+    var bus = useBus();
     // Run test callback.
     // If a promise is returned, set as async and
     // Move to pending list.
@@ -1881,36 +2039,89 @@ function registerTest(testObject) {
             runAsyncTest(testObject);
         }
         else {
-            emit(Events.TEST_COMPLETED, testObject);
+            bus.emit(Events.TEST_COMPLETED, testObject);
         }
     }
-    catch (_a) {
-        throwError("Your test function " + testObject.fieldName + " returned " + JSON.stringify(result) + ". Only \"false\" or a Promise are supported. Return values may cause unexpected behavior.");
+    catch (e) {
+        throwError("Your test function " + testObject.fieldName + " returned a value. Only \"false\" or Promise returns are supported.");
     }
 }
 
-function useTestAtCursor(initialValue) {
-    var cursorAt = useCursorAt()[0];
-    var prevTestObjects = usePrevTestObjects()[0];
-    if (isNotEmpty(prevTestObjects[cursorAt]) &&
-        !isSameProfileTest(prevTestObjects[cursorAt], initialValue)) {
-        throwErrorDeferred("Vest Critical Error: Tests called in different order than previous run.\n    The test at cursor " + cursorAt + " was not the same profile as the previous test.\n    expected: " + JSON.stringify(prevTestObjects[cursorAt]) + "\n    actual: " + JSON.stringify(initialValue) + "\n    This usually happens when you conditionally call your tests using if/else.\n    This might lead to unexpected behavior in your test results.\n    Replacing if/else with skipWhen solves these issues.");
+/**
+ * This module serves as the "collision detection" mechanism for Vest.
+ * It is used to ensure that tests are not called in a different order than
+ * they were called in the previous run.
+ * If they are, it will throw a deferred error unless explicitly allowed.
+ *
+ * For now it seems pretty safe, and it covers most common use cases, but it can
+ * be improved in the future both in terms of performance and scenarios it covers.
+ */
+// eslint-disable-next-line max-statements, max-lines-per-function
+function useTestAtCursor(newTestObject) {
+    var _a = useTestObjects(), testObjects = _a[0], setTestObjects = _a[1];
+    var prevTests = testObjects.prev;
+    if (isEmpty(prevTests)) {
+        useSetTestAtCursor(newTestObject);
+        return newTestObject;
+    }
+    var prevTest = useGetTestAtCursor(prevTests);
+    if (shouldPurgePrevTest(prevTest, newTestObject)) {
+        throwTestOrderError(prevTest, newTestObject);
+        // Here we handle just the omission of tests in the middle of the test suite.
+        // We need to also handle a case in which tests are added in between other tests.
+        // At the moment all we can do is just splice the tests out of the array when this happens.
+        // A viable solution would be to use something like React's key prop to identify tests regardless
+        // of their position in the suite. https://reactjs.org/docs/lists-and-keys.html#keys
+        var current = getCurrent(prevTests, usePath());
+        var cursorAt = useCursorAt();
+        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
+        // to prevent future headaches if we ever do need to rely on prev-state immutability.
+        setTestObjects(function (_a) {
+            var current = _a.current;
+            return ({
+                prev: prevTests,
+                current: current
+            });
+        });
+        // Need to see if this has any effect at all.
+        prevTest = null;
     }
-    var nextTest = defaultTo(prevTestObjects[cursorAt], initialValue);
+    var nextTest = defaultTo(prevTest, newTestObject);
     useSetTestAtCursor(nextTest);
     return nextTest;
 }
+function useSetTestAtCursor(testObject) {
+    var cursorPath = usePath();
+    useSetTests(function (tests) {
+        return setValueAtPath(tests, cursorPath, testObject);
+    });
+}
+function useGetTestAtCursor(tests) {
+    var cursorPath = usePath();
+    return valueAtPath(tests, cursorPath);
+}
+function shouldPurgePrevTest(prevTest, newTest) {
+    return isNotEmpty(prevTest) && !isSameProfileTest(prevTest, newTest);
+}
+function throwTestOrderError(prevTest, newTestObject) {
+    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 happens when you conditionally call your tests using if/else.\n    This might lead to incorrect validation results.\n    Replacing if/else with skipWhen solves these issues.");
+}
 
 function registerPrevRunTest(testObject) {
     var prevRunTest = useTestAtCursor(testObject);
     if (isExcluded(testObject)) {
         testObject.skip();
-        useSetNextCursorAt();
+        moveForward();
         return prevRunTest;
     }
     cancelOverriddenPendingTest(prevRunTest, testObject);
     useSetTestAtCursor(testObject);
-    useSetNextCursorAt();
+    moveForward();
     registerTestObjectByTier(testObject);
     return testObject;
 }
@@ -1929,7 +2140,7 @@ function bindTestEach(test) {
      * Run multiple tests using a parameter table
      */
     function each(table) {
-        if (!Array.isArray(table)) {
+        if (!isArray(table)) {
             throwError('test.each: Expected table to be an array.');
         }
         function eachReturn(fieldName) {
@@ -1938,9 +2149,12 @@ function bindTestEach(test) {
                 args[_i - 1] = arguments[_i];
             }
             var _a = args.reverse(), testFn = _a[0], message = _a[1];
-            return table.map(function (item) {
-                item = asArray(item);
-                return test(optionalFunctionValue.apply(void 0, __spreadArray([fieldName], item, false)), optionalFunctionValue.apply(void 0, __spreadArray([message], item, false)), function () { return testFn.apply(void 0, item); });
+            return isolate({ type: IsolateTypes.EACH }, function () {
+                return table.map(function (item) {
+                    item = asArray(item);
+                    return test(optionalFunctionValue.apply(void 0, __spreadArray([fieldName], item)), optionalFunctionValue.apply(void 0, __spreadArray([message], item)), function () { return testFn.apply(void 0, item); } // eslint-disable-line max-nested-callbacks
+                    );
+                });
             });
         }
         return eachReturn;
@@ -1958,7 +2172,7 @@ function bindTestMemo(test) {
             args[_i - 1] = arguments[_i];
         }
         var suiteId = useSuiteId()[0];
-        var cursorAt = useCursorAt()[0];
+        var cursorAt = useCursorAt();
         var _a = args.reverse(), deps = _a[0], testFn = _a[1], msg = _a[2];
         // Implicit dependency for more specificity
         var dependencies = [suiteId, fieldName, cursorAt].concat(deps);
@@ -1995,6 +2209,6 @@ var test = assign(testBase, {
     memo: bindTestMemo(testBase)
 });
 
-var VERSION = "4.0.0-dev-cc5cf5";
+var VERSION = "4.0.0-dev-31f012";
 
 export { VERSION, create, enforce, group, only, optional, skip, skipWhen, test, warn };