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

package/dist/umd/vest.development.js

@@ -230,8 +230,16 @@
         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
@@ -242,14 +250,6 @@
     }
     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);
     }
@@ -602,7 +602,7 @@
 
     function isProxySupported() {
         try {
-            return typeof Proxy === 'function';
+            return isFunction(Proxy);
         }
         catch (_a) {
             return false;
@@ -623,7 +623,7 @@
             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) {
@@ -657,9 +657,9 @@
                 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));
@@ -689,7 +689,7 @@
                 }
                 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) {
@@ -796,10 +796,6 @@
     }
     var enforce = genEnforce();
 
-    function asArray(possibleArg) {
-        return [].concat(possibleArg);
-    }
-
     /**
      * @returns a unique numeric id.
      */
@@ -836,15 +832,16 @@
             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],
@@ -870,18 +867,74 @@
         }
     }
 
+    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
         };
     }
 
@@ -889,6 +942,8 @@
         return parentContext
             ? null
             : assign({}, {
+                isolate: { type: IsolateTypes.DEFAULT },
+                testCursor: createCursor(),
                 exclusion: {
                     tests: {},
                     groups: {}
@@ -896,11 +951,49 @@
             }, 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;
     }
 
     /**
@@ -959,89 +1052,101 @@
     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();
@@ -1060,7 +1165,7 @@
      * 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: {},
@@ -1180,7 +1285,7 @@
      * @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
         });
@@ -1202,7 +1307,7 @@
         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
@@ -1233,7 +1338,7 @@
         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);
         });
@@ -1249,7 +1354,7 @@
      * 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)
@@ -1265,7 +1370,7 @@
         if (result.hasErrors(fieldName)) {
             return false;
         }
-        var testObjects = useTestObjects()[0];
+        var testObjects = useTestsFlat();
         if (isEmpty(testObjects)) {
             return false;
         }
@@ -1297,7 +1402,7 @@
         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)) {
@@ -1311,7 +1416,7 @@
 
     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(), {
@@ -1332,7 +1437,7 @@
 
     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(), {
@@ -1415,6 +1520,44 @@
         };
     }
 
+    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(); });
     }
@@ -1425,8 +1568,7 @@
     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]);
             }
         }
@@ -1443,6 +1585,8 @@
 
     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;
@@ -1451,6 +1595,22 @@
             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() {
@@ -1463,42 +1623,48 @@
     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;
     }
@@ -1512,16 +1678,20 @@
      * 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) {
@@ -1593,7 +1763,8 @@
             if (!isStringValue(itemName)) {
                 return;
             }
-            context.exclusion[itemType][itemName] = exclusionGroup === 'only';
+            context.exclusion[itemType][itemName] =
+                exclusionGroup === 0 /* ONLY */;
         });
     }
     /**
@@ -1608,6 +1779,12 @@
         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."
         ;
     /**
@@ -1621,10 +1798,6 @@
         ctx$1.currentTest.warn();
     }
 
-    function skipWhen(conditional, callback) {
-        ctx.run({ skipped: optionalFunctionValue(conditional) }, function () { return callback(); });
-    }
-
     /**
      * Runs a group callback.
      */
@@ -1636,7 +1809,9 @@
             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 + ".");
@@ -1661,29 +1836,6 @@
         });
     }
 
-    /**
-     * 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);
@@ -1745,11 +1897,17 @@
             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);
@@ -1873,7 +2031,7 @@
      * 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.
@@ -1887,36 +2045,89 @@
                 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;
     }
@@ -1935,7 +2146,7 @@
          * 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) {
@@ -1944,9 +2155,12 @@
                     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;
@@ -1964,7 +2178,7 @@
                 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);
@@ -2001,7 +2215,7 @@
         memo: bindTestMemo(testBase)
     });
 
-    var VERSION = "4.0.0-dev-cc5cf5";
+    var VERSION = "4.0.0-dev-31f012";
 
     exports.VERSION = VERSION;
     exports.create = create;