vest 5.1.4 → 5.2.0

package/dist/cjs/vest.development.js

@@ -201,25 +201,68 @@ function useLoadSuite(rootNode) {
     useExpireSuiteResultCache();
 }
 
-var TestStatus;
-(function (TestStatus) {
-    TestStatus["UNTESTED"] = "UNTESTED";
-    TestStatus["SKIPPED"] = "SKIPPED";
-    TestStatus["FAILED"] = "FAILED";
-    TestStatus["WARNING"] = "WARNING";
-    TestStatus["PASSING"] = "PASSING";
-    TestStatus["PENDING"] = "PENDING";
-    TestStatus["CANCELED"] = "CANCELED";
-    TestStatus["OMITTED"] = "OMITTED";
-})(TestStatus || (TestStatus = {}));
-var TestAction;
-(function (TestAction) {
-    TestAction["RESET"] = "RESET";
-})(TestAction || (TestAction = {}));
-function createTestStateMachine() {
-    return vestUtils.StateMachine(machine);
-}
-/* eslint-disable sort-keys */
+const CommonStates = {
+    PENDING: 'PENDING',
+};
+const State = {
+    [CommonStates.PENDING]: CommonStates.PENDING,
+    INITIAL: 'INITIAL',
+    DONE: 'DONE',
+};
+const machine$1 = {
+    initial: State.INITIAL,
+    states: {
+        [State.DONE]: {},
+        [State.INITIAL]: {
+            [State.PENDING]: State.PENDING,
+            [State.DONE]: State.DONE,
+        },
+        [State.PENDING]: {
+            [State.DONE]: State.DONE,
+        },
+    },
+};
+function transition(from, to) {
+    return CommonStateMachine.staticTransition(from !== null && from !== void 0 ? from : State.INITIAL, to);
+}
+function setDone(isolate) {
+    isolate.status = transition(isolate.status, State.DONE);
+}
+function setPending(isolate) {
+    isolate.status = transition(isolate.status, State.PENDING);
+}
+const CommonStateMachine = vestUtils.StateMachine(machine$1);
+
+var ErrorStrings;
+(function (ErrorStrings) {
+    ErrorStrings["HOOK_CALLED_OUTSIDE"] = "hook called outside of a running suite.";
+    ErrorStrings["EXPECTED_VEST_TEST"] = "Expected value to be an instance of IsolateTest";
+    ErrorStrings["FIELD_NAME_REQUIRED"] = "Field name must be passed";
+    ErrorStrings["SUITE_MUST_BE_INITIALIZED_WITH_FUNCTION"] = "Suite must be initialized with a function";
+    ErrorStrings["PROMISIFY_REQUIRE_FUNCTION"] = "Vest.Promisify must be called with a function";
+    ErrorStrings["PARSER_EXPECT_RESULT_OBJECT"] = "Vest parser: expected argument at position 0 to be Vest's result object.";
+    ErrorStrings["WARN_MUST_BE_CALLED_FROM_TEST"] = "Warn must be called from within the body of a test function";
+    ErrorStrings["EACH_CALLBACK_MUST_BE_A_FUNCTION"] = "Each must be called with a function";
+    ErrorStrings["INVALID_PARAM_PASSED_TO_FUNCTION"] = "Incompatible params passed to {fn_name} function. \"{param}\" must be of type {expected}";
+    ErrorStrings["TESTS_CALLED_IN_DIFFERENT_ORDER"] = "Vest Critical Error: Tests called in different order than previous run.\n    expected: {fieldName}\n    received: {prevName}\n    This can happen on one of two reasons:\n    1. You're using if/else statements to conditionally select tests. Instead, use \"skipWhen\".\n    2. You are iterating over a list of tests, and their order changed. Use \"each\" and a custom key prop so that Vest retains their state.";
+    ErrorStrings["UNEXPECTED_TEST_REGISTRATION_ERROR"] = "Unexpected error encountered during test registration.\n      Please report this issue to Vest's Github repository.\n      Test Object: {testObject}.\n      Error: {error}.";
+    ErrorStrings["UNEXPECTED_TEST_RUN_ERROR"] = "Unexpected error encountered during test run. Please report this issue to Vest's Github repository.\n      Test Object: {testObject}.";
+    ErrorStrings["INCLUDE_SELF"] = "Trying to call include.when on the same field.";
+})(ErrorStrings || (ErrorStrings = {}));
+
+const TestStatus = {
+    [CommonStates.PENDING]: CommonStates.PENDING,
+    CANCELED: 'CANCELED',
+    FAILED: 'FAILED',
+    OMITTED: 'OMITTED',
+    PASSING: 'PASSING',
+    SKIPPED: 'SKIPPED',
+    UNTESTED: 'UNTESTED',
+    WARNING: 'WARNING',
+};
+const TestAction = {
+    RESET: 'RESET',
+};
 const machine = {
     initial: TestStatus.UNTESTED,
     states: {
@@ -253,7 +296,7 @@ const machine = {
         [TestStatus.OMITTED]: {},
     },
 };
-/* eslint-enable sort-keys */
+const IsolateTestStateMachine = vestUtils.StateMachine(machine);
 
 var Severity;
 (function (Severity) {
@@ -276,13 +319,22 @@ var TestSeverity;
     TestSeverity["Warning"] = "warning";
 })(TestSeverity || (TestSeverity = {}));
 
-const TestStateMachine = createTestStateMachine();
 class VestTest {
     // Read
     static getData(test) {
         vestUtils.invariant(test.data);
         return test.data;
     }
+    static is(isolate) {
+        return vestjsRuntime.IsolateSelectors.isIsolateType(isolate, VestIsolateType.Test);
+    }
+    static isX(isolate) {
+        vestUtils.invariant(VestTest.is(isolate), ErrorStrings.EXPECTED_VEST_TEST);
+    }
+    static cast(isolate) {
+        VestTest.isX(isolate);
+        return isolate;
+    }
     static warns(test) {
         return VestTest.getData(test).severity === TestSeverity.Warning;
     }
@@ -332,7 +384,7 @@ class VestTest {
         return vestUtils.isPromise(VestTest.getData(test).asyncTest);
     }
     static statusEquals(test, status) {
-        return VestTest.getData(test).status === status;
+        return test.status === status;
     }
     // Mutate
     static setPending(test) {
@@ -365,7 +417,7 @@ class VestTest {
     }
     static cancel(test) {
         VestTest.setStatus(test, TestStatus.CANCELED);
-        VestTest.getData(test).abortController.abort(TestStatus.CANCELED);
+        vestjsRuntime.IsolateMutator.abort(test, TestStatus.CANCELED);
     }
     static omit(test) {
         VestTest.setStatus(test, TestStatus.OMITTED);
@@ -374,80 +426,80 @@ class VestTest {
         VestTest.setStatus(test, TestAction.RESET);
     }
     static setStatus(test, status, payload) {
-        VestTest.setData(test, current => (Object.assign(Object.assign({}, current), { status: TestStateMachine.staticTransition(current.status, status, payload) })));
+        test.status = IsolateTestStateMachine.staticTransition(test.status, status, payload);
     }
 }
 
-function isIsolateTest(isolate) {
-    return vestjsRuntime.IsolateSelectors.isIsolateType(isolate, VestIsolateType.Test);
-}
-function isIsolateTestX(isolate) {
-    vestUtils.invariant(isIsolateTest(isolate));
-}
-function castIsolateTest(isolate) {
-    isIsolateTestX(isolate);
-    return isolate;
-}
-
 function nonMatchingFieldName(WithFieldName, fieldName) {
     return !!fieldName && !matchingFieldName(WithFieldName, fieldName);
 }
 function matchingFieldName(WithFieldName, fieldName) {
     return !!(fieldName && WithFieldName.fieldName === fieldName);
 }
+function matchesOrHasNoFieldName(WithFieldName, fieldName) {
+    if (fieldName) {
+        return matchingFieldName(WithFieldName, fieldName);
+    }
+    return true;
+}
+
+class SuiteWalker {
+    static hasPending(predicate) {
+        const root = SuiteWalker.defaultRoot();
+        if (!root) {
+            return false;
+        }
+        return vestjsRuntime.Walker.some(root, vestUtils.Predicates.all(isPendingStatus, predicate !== null && predicate !== void 0 ? predicate : true));
+    }
+    // Checks whether there are pending isolates in the tree.
+    // If a fieldname is provided, will only check tests with a matching fieldname.
+    static hasRemainingWithTestNameMatching(fieldName) {
+        return SuiteWalker.hasPending(vestUtils.Predicates.any(vestUtils.isNullish(fieldName), vestUtils.Predicates.all(VestTest.is, (testObject) => {
+            return matchesOrHasNoFieldName(VestTest.getData(testObject), fieldName);
+        })));
+    }
+}
+SuiteWalker.defaultRoot = vestjsRuntime.VestRuntime.useAvailableRoot;
+function isPendingStatus(isolate) {
+    return isolate.status === CommonStates.PENDING;
+}
 
 class TestWalker {
     static hasNoTests(root = TestWalker.defaultRoot()) {
         if (!root)
             return true;
-        return !vestjsRuntime.Walker.has(root, isIsolateTest);
-    }
-    static someIncompleteTests(predicate, root = TestWalker.defaultRoot()) {
-        if (!root)
-            return false;
-        return vestjsRuntime.Walker.some(root, isolate => {
-            isIsolateTestX(isolate);
-            return VestTest.isPending(isolate) && predicate(isolate);
-        }, isIsolateTest);
+        return !vestjsRuntime.Walker.has(root, VestTest.is);
     }
     static someTests(predicate, root = TestWalker.defaultRoot()) {
         if (!root)
             return false;
         return vestjsRuntime.Walker.some(root, isolate => {
-            isIsolateTestX(isolate);
+            VestTest.isX(isolate);
             return predicate(isolate);
-        }, isIsolateTest);
+        }, VestTest.is);
     }
     static everyTest(predicate, root = TestWalker.defaultRoot()) {
         if (!root)
             return false;
         return vestjsRuntime.Walker.every(root, isolate => {
-            isIsolateTestX(isolate);
+            VestTest.isX(isolate);
             return predicate(isolate);
-        }, isIsolateTest);
+        }, VestTest.is);
     }
     static walkTests(callback, root = TestWalker.defaultRoot()) {
         if (!root)
             return;
         vestjsRuntime.Walker.walk(root, (isolate, breakout) => {
-            callback(castIsolateTest(isolate), breakout);
-        }, isIsolateTest);
-    }
-    static hasRemainingTests(fieldName) {
-        return TestWalker.someIncompleteTests(testObject => {
-            if (fieldName) {
-                return matchingFieldName(VestTest.getData(testObject), fieldName);
-            }
-            return true;
-        });
+            callback(VestTest.cast(isolate), breakout);
+        }, VestTest.is);
     }
     static pluckTests(predicate, root = TestWalker.defaultRoot()) {
         if (!root)
             return;
         vestjsRuntime.Walker.pluck(root, isolate => {
-            isIsolateTestX(isolate);
+            VestTest.isX(isolate);
             return predicate(isolate);
-        }, isIsolateTest);
+        }, VestTest.is);
     }
     static resetField(fieldName) {
         TestWalker.walkTests(testObject => {
@@ -521,7 +573,7 @@ function useOmitOptionalFields() {
 function useRunFieldCallbacks(fieldName) {
     const [fieldCallbacks] = useFieldCallbacks();
     if (fieldName &&
-        !TestWalker.hasRemainingTests(fieldName) &&
+        !SuiteWalker.hasRemainingWithTestNameMatching(fieldName) &&
         vestUtils.isArray(fieldCallbacks[fieldName])) {
         vestUtils.callEach(fieldCallbacks[fieldName]);
     }
@@ -545,14 +597,26 @@ function useInitVestBus() {
         }
         const { fieldName } = VestTest.getData(testObject);
         useRunFieldCallbacks(fieldName);
-        if (!TestWalker.hasRemainingTests()) {
-            // When no more tests are running, emit the done event
-            VestBus.emit(Events.ALL_RUNNING_TESTS_FINISHED);
-        }
     });
     on(Events.TEST_RUN_STARTED, () => {
         /* Let's just invalidate the suite cache for now */
     });
+    on(vestjsRuntime.RuntimeEvents.ISOLATE_PENDING, (isolate) => {
+        if (VestTest.is(isolate)) {
+            VestTest.setPending(isolate);
+        }
+        setPending(isolate);
+    });
+    on(vestjsRuntime.RuntimeEvents.ISOLATE_DONE, (isolate) => {
+        if (VestTest.is(isolate)) {
+            VestBus.emit(Events.TEST_COMPLETED, isolate);
+        }
+        setDone(isolate);
+        if (!SuiteWalker.hasPending()) {
+            // When no more tests are running, emit the done event
+            VestBus.emit(Events.ALL_RUNNING_TESTS_FINISHED);
+        }
+    });
     on(Events.DONE_TEST_OMISSION_PASS, () => {
         /* We NEED to refresh the cache here. Don't ask */
     });
@@ -600,23 +664,6 @@ function useInitVestBus() {
     }
 }
 
-var ErrorStrings;
-(function (ErrorStrings) {
-    ErrorStrings["HOOK_CALLED_OUTSIDE"] = "hook called outside of a running suite.";
-    ErrorStrings["EXPECTED_VEST_TEST"] = "Expected value to be an instance of IsolateTest";
-    ErrorStrings["FIELD_NAME_REQUIRED"] = "Field name must be passed";
-    ErrorStrings["SUITE_MUST_BE_INITIALIZED_WITH_FUNCTION"] = "Suite must be initialized with a function";
-    ErrorStrings["PROMISIFY_REQUIRE_FUNCTION"] = "Vest.Promisify must be called with a function";
-    ErrorStrings["PARSER_EXPECT_RESULT_OBJECT"] = "Vest parser: expected argument at position 0 to be Vest's result object.";
-    ErrorStrings["WARN_MUST_BE_CALLED_FROM_TEST"] = "Warn must be called from within the body of a test function";
-    ErrorStrings["EACH_CALLBACK_MUST_BE_A_FUNCTION"] = "Each must be called with a function";
-    ErrorStrings["INVALID_PARAM_PASSED_TO_FUNCTION"] = "Incompatible params passed to {fn_name} function. \"{param}\" must be of type {expected}";
-    ErrorStrings["TESTS_CALLED_IN_DIFFERENT_ORDER"] = "Vest Critical Error: Tests called in different order than previous run.\n    expected: {fieldName}\n    received: {prevName}\n    This can happen on one of two reasons:\n    1. You're using if/else statements to conditionally select tests. Instead, use \"skipWhen\".\n    2. You are iterating over a list of tests, and their order changed. Use \"each\" and a custom key prop so that Vest retains their state.";
-    ErrorStrings["UNEXPECTED_TEST_REGISTRATION_ERROR"] = "Unexpected error encountered during test registration.\n      Please report this issue to Vest's Github repository.\n      Test Object: {testObject}.\n      Error: {error}.";
-    ErrorStrings["UNEXPECTED_TEST_RUN_ERROR"] = "Unexpected error encountered during test run. Please report this issue to Vest's Github repository.\n      Test Object: {testObject}.";
-    ErrorStrings["INCLUDE_SELF"] = "Trying to call include.when on the same field.";
-})(ErrorStrings || (ErrorStrings = {}));
-
 class IsolateReconciler {
     static match(_currentNode, _historyNode) {
         return false;
@@ -969,24 +1016,11 @@ function useShouldAddValidPropertyInGroup(groupName, fieldName) {
 }
 // Does the given field have any pending tests that are not optional?
 function useHasNonOptionalIncomplete(fieldName) {
-    return TestWalker.someIncompleteTests(testObject => {
-        if (nonMatchingFieldName(VestTest.getData(testObject), fieldName)) {
-            return false;
-        }
-        return !useIsOptionalFieldApplied(fieldName);
-    });
+    return SuiteWalker.hasPending(vestUtils.Predicates.all(VestTest.is, (testObject) => !nonMatchingFieldName(VestTest.getData(testObject), fieldName), () => !useIsOptionalFieldApplied(fieldName)));
 }
 // Do the given group/field have any pending tests that are not optional?
 function useHasNonOptionalIncompleteByGroup(groupName, fieldName) {
-    return TestWalker.someIncompleteTests(testObject => {
-        if (nonMatchingGroupName(testObject, groupName)) {
-            return false;
-        }
-        if (nonMatchingFieldName(VestTest.getData(testObject), fieldName)) {
-            return false;
-        }
-        return !useIsOptionalFieldApplied(fieldName);
-    });
+    return SuiteWalker.hasPending(vestUtils.Predicates.all(VestTest.is, (testObject) => !nonMatchingGroupName(testObject, groupName), (testObject) => !nonMatchingFieldName(VestTest.getData(testObject), fieldName), () => !useIsOptionalFieldApplied(fieldName)));
 }
 // Did all of the tests for the provided field run/omit?
 // This makes sure that the fields are not skipped or pending.
@@ -1333,7 +1367,7 @@ function useForceSkipIfInSkipWhen(testNode) {
 
 class IsolateTestReconciler extends IsolateReconciler {
     static match(currentNode, historyNode) {
-        return isIsolateTest(currentNode) && isIsolateTest(historyNode);
+        return VestTest.is(currentNode) && VestTest.is(historyNode);
     }
     static reconcile(currentNode, historyNode) {
         const reconcilerOutput = usePickNode(historyNode, currentNode);
@@ -1347,13 +1381,13 @@ function usePickNode(historyNode, currentNode) {
 }
 function handleCollision(newNode, prevNode) {
     if (vestjsRuntime.IsolateInspector.usesKey(newNode)) {
-        return castIsolateTest(vestjsRuntime.Reconciler.handleIsolateNodeWithKey(newNode));
+        return VestTest.cast(vestjsRuntime.Reconciler.handleIsolateNodeWithKey(newNode));
     }
     if (vestjsRuntime.Reconciler.dropNextNodesOnReorder(nodeReorderDetected, newNode, prevNode)) {
         throwTestOrderError(newNode, prevNode);
         return newNode;
     }
-    if (!isIsolateTest(prevNode)) {
+    if (!VestTest.is(prevNode)) {
         // I believe we cannot actually reach this point.
         // Because it should already be handled by nodeReorderDetected.
         /* istanbul ignore next */
@@ -1371,12 +1405,12 @@ function handleCollision(newNode, prevNode) {
     return prevNode;
 }
 function cancelOverriddenPendingTestOnTestReRun(nextNode, currentNode, prevTestObject) {
-    if (nextNode === currentNode && isIsolateTest(currentNode)) {
+    if (nextNode === currentNode && VestTest.is(currentNode)) {
         cancelOverriddenPendingTest(prevTestObject, currentNode);
     }
 }
 function nodeReorderDetected(newNode, prevNode) {
-    return isIsolateTest(prevNode) && !isSameProfileTest(prevNode, newNode);
+    return VestTest.is(prevNode) && !isSameProfileTest(prevNode, newNode);
 }
 function throwTestOrderError(newNode, prevNode) {
     if (vestjsRuntime.IsolateInspector.canReorder(newNode)) {
@@ -1384,7 +1418,7 @@ function throwTestOrderError(newNode, prevNode) {
     }
     vestUtils.deferThrow(vestUtils.text(ErrorStrings.TESTS_CALLED_IN_DIFFERENT_ORDER, {
         fieldName: VestTest.getData(newNode).fieldName,
-        prevName: isIsolateTest(prevNode)
+        prevName: VestTest.is(prevNode)
             ? VestTest.getData(prevNode).fieldName
             : undefined,
     }));
@@ -1457,8 +1491,7 @@ function IsolateTest(callback, input, key) {
 function IsolateTestBase() {
     return {
         severity: TestSeverity.Error,
-        status: TestStatus.UNTESTED,
-        abortController: new AbortController(),
+        status: IsolateTestStateMachine.initial(),
     };
 }
 
@@ -1485,9 +1518,9 @@ function useAttemptRunTest(testObject) {
 function runSyncTest(testObject) {
     return SuiteContext.run({ currentTest: testObject }, () => {
         let result;
-        const { message, testFn, abortController } = VestTest.getData(testObject);
+        const { message, testFn } = VestTest.getData(testObject);
         try {
-            result = testFn({ signal: abortController.signal });
+            result = testFn({ signal: testObject.abortController.signal });
         }
         catch (error) {
             if (shouldUseErrorAsMessage(message, error)) {
@@ -1505,7 +1538,6 @@ function runSyncTest(testObject) {
  * runs test, if async - adds to pending array
  */
 function useRunTest(testObject) {
-    const VestBus = vestjsRuntime.Bus.useBus();
     // Run test callback.
     // If a promise is returned, set as async and
     // Move to pending list.
@@ -1515,11 +1547,9 @@ function useRunTest(testObject) {
         // in case object is an enforce chain
         if (vestUtils.isPromise(result)) {
             VestTest.getData(testObject).asyncTest = result;
-            useRunAsyncTest(testObject);
-        }
-        else {
-            onTestCompleted(VestBus, testObject);
+            return useRunAsyncTest(testObject);
         }
+        onTestCompleted(testObject);
     }
     catch (e) {
         // Probably unreachable. If we get here, it means that
@@ -1538,10 +1568,9 @@ function useRunAsyncTest(testObject) {
     const { asyncTest, message } = VestTest.getData(testObject);
     if (!vestUtils.isPromise(asyncTest))
         return;
-    VestTest.setPending(testObject);
-    const VestBus = vestjsRuntime.Bus.useBus();
+    // VestTest.setPending(testObject);
     const done = vestjsRuntime.VestRuntime.persist(() => {
-        onTestCompleted(VestBus, testObject);
+        onTestCompleted(testObject);
     });
     const fail = vestjsRuntime.VestRuntime.persist((rejectionMessage) => {
         if (VestTest.isCanceled(testObject)) {
@@ -1553,13 +1582,12 @@ function useRunAsyncTest(testObject) {
         VestTest.fail(testObject);
         done();
     });
-    asyncTest.then(done, fail);
+    return asyncTest.then(done, fail);
 }
-function onTestCompleted(VestBus, testObject) {
+function onTestCompleted(testObject) {
     // Attempts passing if the test is not already failed.
     // or is not canceled/omitted.
     VestTest.pass(testObject);
-    VestBus.emit(Events.TEST_COMPLETED, testObject);
 }
 
 // @vx-allow use-use
@@ -1676,7 +1704,7 @@ function done(...args) {
         return output;
     }
     const useDoneCallback = () => callback(useCreateSuiteResult());
-    if (!TestWalker.hasRemainingTests(fieldName)) {
+    if (!SuiteWalker.hasRemainingWithTestNameMatching(fieldName)) {
         useDoneCallback();
         return output;
     }