vest 5.1.4 → 5.2.0

package/dist/umd/vest.development.js

@@ -200,25 +200,68 @@
       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: {
@@ -252,7 +295,7 @@
           [TestStatus.OMITTED]: {},
       },
   };
-  /* eslint-enable sort-keys */
+  const IsolateTestStateMachine = vestUtils.StateMachine(machine);
 
   var Severity;
   (function (Severity) {
@@ -275,13 +318,22 @@
       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;
       }
@@ -331,7 +383,7 @@
           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) {
@@ -364,7 +416,7 @@
       }
       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);
@@ -373,80 +425,80 @@
           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 => {
@@ -520,7 +572,7 @@
   function useRunFieldCallbacks(fieldName) {
       const [fieldCallbacks] = useFieldCallbacks();
       if (fieldName &&
-          !TestWalker.hasRemainingTests(fieldName) &&
+          !SuiteWalker.hasRemainingWithTestNameMatching(fieldName) &&
           vestUtils.isArray(fieldCallbacks[fieldName])) {
           vestUtils.callEach(fieldCallbacks[fieldName]);
       }
@@ -544,14 +596,26 @@
           }
           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 */
       });
@@ -599,23 +663,6 @@
       }
   }
 
-  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;
@@ -968,24 +1015,11 @@
   }
   // 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.
@@ -1332,7 +1366,7 @@
 
   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);
@@ -1346,13 +1380,13 @@
   }
   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 */
@@ -1370,12 +1404,12 @@
       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)) {
@@ -1383,7 +1417,7 @@
       }
       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,
       }));
@@ -1456,8 +1490,7 @@
   function IsolateTestBase() {
       return {
           severity: TestSeverity.Error,
-          status: TestStatus.UNTESTED,
-          abortController: new AbortController(),
+          status: IsolateTestStateMachine.initial(),
       };
   }
 
@@ -1484,9 +1517,9 @@
   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)) {
@@ -1504,7 +1537,6 @@
    * 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.
@@ -1514,11 +1546,9 @@
           // 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
@@ -1537,10 +1567,9 @@
       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)) {
@@ -1552,13 +1581,12 @@
           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
@@ -1675,7 +1703,7 @@
           return output;
       }
       const useDoneCallback = () => callback(useCreateSuiteResult());
-      if (!TestWalker.hasRemainingTests(fieldName)) {
+      if (!SuiteWalker.hasRemainingWithTestNameMatching(fieldName)) {
           useDoneCallback();
           return output;
       }