vest 5.0.0-dev-781e21 → 5.0.2-dev-d315d9

package/src/core/isolate/IsolateTest/IsolateTest.ts

@@ -0,0 +1,213 @@
+import { CB, invariant, isPromise, seq } from 'vest-utils';
+
+import { IsolateTestReconciler } from 'IsolateTestReconciler';
+import {
+  TestAction,
+  TestStatus,
+  createTestStateMachine,
+} from 'IsolateTestStateMachine';
+import { IsolateTypes } from 'IsolateTypes';
+import { TFieldName } from 'SuiteResultTypes';
+import { TestFn, AsyncTest, TestResult } from 'TestTypes';
+import { Isolate, IsolateKey } from 'isolate';
+import { shouldUseErrorAsMessage } from 'shouldUseErrorMessage';
+
+export type IsolateTestInput = {
+  message?: string;
+  groupName?: string;
+  fieldName: TFieldName;
+  testFn: TestFn;
+  key?: IsolateKey;
+};
+
+export class IsolateTest extends Isolate<IsolateTypes.TEST> {
+  children = null;
+  fieldName: TFieldName;
+  testFn: TestFn;
+  groupName?: string;
+  message?: string;
+  asyncTest?: AsyncTest;
+  id = seq();
+  severity = TestSeverity.Error;
+  private stateMachine = createTestStateMachine();
+
+  static reconciler = IsolateTestReconciler;
+
+  constructor(
+    type: IsolateTypes.TEST,
+    { fieldName, testFn, message, groupName, key = null }: IsolateTestInput
+  ) {
+    super(type);
+
+    this.fieldName = fieldName;
+    this.testFn = testFn;
+
+    if (groupName) {
+      this.groupName = groupName;
+    }
+
+    if (message) {
+      this.message = message;
+    }
+
+    this.setKey(key);
+  }
+
+  static factory<Callback extends CB = CB>(
+    callback: Callback,
+    data: IsolateTestInput
+  ): IsolateTest {
+    return super.create(IsolateTypes.TEST, callback, data) as IsolateTest;
+  }
+
+  get status(): TestStatus {
+    return this.stateMachine.getState();
+  }
+
+  setStatus(status: TestStatus, payload?: any): void {
+    this.stateMachine.transition(status, payload);
+  }
+
+  run(): TestResult {
+    let result: TestResult;
+    try {
+      result = this.testFn();
+    } catch (error) {
+      if (shouldUseErrorAsMessage(this.message, error)) {
+        this.message = error;
+      }
+      result = false;
+    }
+
+    if (result === false) {
+      this.fail();
+    }
+
+    return result;
+  }
+
+  // Selectors
+
+  warns(): boolean {
+    return this.severity === TestSeverity.Warning;
+  }
+
+  isPending(): boolean {
+    return this.statusEquals(TestStatus.PENDING);
+  }
+
+  isOmitted(): boolean {
+    return this.statusEquals(TestStatus.OMITTED);
+  }
+
+  isUntested(): boolean {
+    return this.statusEquals(TestStatus.UNTESTED);
+  }
+
+  isFailing(): boolean {
+    return this.statusEquals(TestStatus.FAILED);
+  }
+
+  isCanceled(): boolean {
+    return this.statusEquals(TestStatus.CANCELED);
+  }
+
+  isSkipped(): boolean {
+    return this.statusEquals(TestStatus.SKIPPED);
+  }
+
+  isPassing(): boolean {
+    return this.statusEquals(TestStatus.PASSING);
+  }
+
+  isWarning(): boolean {
+    return this.statusEquals(TestStatus.WARNING);
+  }
+
+  hasFailures(): boolean {
+    return this.isFailing() || this.isWarning();
+  }
+
+  isNonActionable(): boolean {
+    return this.isSkipped() || this.isOmitted() || this.isCanceled();
+  }
+
+  isTested(): boolean {
+    return this.hasFailures() || this.isPassing();
+  }
+
+  awaitsResolution(): boolean {
+    // Is the test in a state where it can still be run, or complete running
+    // and its final status is indeterminate?
+    return this.isSkipped() || this.isUntested() || this.isPending();
+  }
+
+  statusEquals(status: TestStatus): boolean {
+    return this.status === status;
+  }
+
+  // State modifiers
+
+  setPending() {
+    this.setStatus(TestStatus.PENDING);
+  }
+
+  fail(): void {
+    this.setStatus(this.warns() ? TestStatus.WARNING : TestStatus.FAILED);
+  }
+
+  pass(): void {
+    this.setStatus(TestStatus.PASSING);
+  }
+
+  warn(): void {
+    this.severity = TestSeverity.Warning;
+  }
+
+  skip(force?: boolean): void {
+    // Without this force flag, 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.
+    // What this mostly say is that when we have a pending test for one field, and we then
+    // start typing in a different field - the pending test will be canceled, which
+    // is usually an unwanted behavior.
+    // The only scenario in which we DO want to cancel the async test regardless
+    // is when we specifically skip a test with `skipWhen`, which is handled by the
+    // "force" boolean flag.
+    // I am not a fan of this flag, but it gets the job done.
+    this.setStatus(TestStatus.SKIPPED, force);
+  }
+
+  cancel(): void {
+    this.setStatus(TestStatus.CANCELED);
+  }
+
+  reset(): void {
+    this.stateMachine.transition(TestAction.RESET);
+  }
+
+  omit(): void {
+    this.setStatus(TestStatus.OMITTED);
+  }
+
+  valueOf(): boolean {
+    return !this.isFailing();
+  }
+
+  isAsyncTest(): boolean {
+    return isPromise(this.asyncTest);
+  }
+
+  static is(value: any): value is IsolateTest {
+    return value instanceof IsolateTest;
+  }
+
+  static isX(value: any): asserts value is IsolateTest {
+    invariant(this.is(value));
+  }
+}
+
+enum TestSeverity {
+  Error = 'error',
+  Warning = 'warning',
+}

package/src/core/isolate/IsolateTest/IsolateTestReconciler.ts

@@ -0,0 +1,156 @@
+import { isOptionalFiedApplied } from 'optional';
+import { deferThrow, isNullish, invariant } from 'vest-utils';
+
+import { IsolateTest } from 'IsolateTest';
+import { IsolateTypes } from 'IsolateTypes';
+import { Reconciler } from 'Reconciler';
+import cancelOverriddenPendingTest from 'cancelOverriddenPendingTest';
+import { isExcluded } from 'exclusive';
+import { isIsolateType } from 'isIsolate';
+import { isSameProfileTest } from 'isSameProfileTest';
+import { Isolate } from 'isolate';
+import { shouldSkipBasedOnMode } from 'mode';
+import { withinActiveOmitWhen } from 'omitWhen';
+import { isExcludedIndividually } from 'skipWhen';
+
+export class IsolateTestReconciler extends Reconciler {
+  static reconciler(
+    currentNode: Isolate,
+    historyNode: Isolate | null
+  ): Isolate {
+    // Start by verifying params
+    if (!IsolateTest.is(currentNode)) {
+      return currentNode;
+    }
+
+    if (isNullish(historyNode)) {
+      return this.handleNoHistoryNode(currentNode);
+    }
+
+    if (!IsolateTest.is(historyNode)) {
+      return currentNode;
+    }
+
+    const reconcilerOutput = this.pickNode(historyNode, currentNode);
+
+    cancelOverriddenPendingTestOnTestReRun(
+      reconcilerOutput,
+      currentNode,
+      historyNode
+    );
+
+    return reconcilerOutput;
+  }
+
+  static nodeReorderDetected(
+    newNode: IsolateTest,
+    prevNode?: Isolate
+  ): boolean {
+    return !!IsolateTest.is(prevNode) && !isSameProfileTest(prevNode, newNode);
+  }
+
+  static handleCollision(
+    newNode: IsolateTest,
+    prevNode?: Isolate
+  ): IsolateTest {
+    if (newNode.usesKey()) {
+      return this.handleIsolateNodeWithKey(newNode) as IsolateTest;
+    }
+
+    if (this.nodeReorderDetected(newNode, prevNode)) {
+      return this.onNodeReorder(newNode, prevNode);
+    }
+
+    return (prevNode ? prevNode : newNode) as IsolateTest;
+  }
+
+  static onNodeReorder(newNode: IsolateTest, prevNode?: Isolate): IsolateTest {
+    throwTestOrderError(newNode, prevNode);
+    this.removeAllNextNodesInIsolate();
+    return newNode;
+  }
+
+  static pickNode(historyNode: IsolateTest, currentNode: IsolateTest): Isolate {
+    const collisionResult = this.handleCollision(currentNode, historyNode);
+
+    if (shouldSkipBasedOnMode(currentNode)) {
+      return skipTestAndReturn(currentNode);
+    }
+
+    if (shouldOmit(currentNode)) {
+      return omitTestAndReturn(currentNode);
+    }
+
+    if (isExcluded(currentNode)) {
+      return forceSkipIfInSkipWhen(collisionResult);
+    }
+
+    return currentNode;
+  }
+
+  static handleNoHistoryNode(testNode: IsolateTest): IsolateTest {
+    if (testNode.usesKey()) {
+      return this.handleIsolateNodeWithKey(testNode) as IsolateTest;
+    }
+
+    return testNode;
+  }
+}
+
+function cancelOverriddenPendingTestOnTestReRun(
+  nextNode: Isolate,
+  currentNode: Isolate,
+  prevTestObject: IsolateTest
+) {
+  if (nextNode === currentNode && IsolateTest.is(currentNode)) {
+    cancelOverriddenPendingTest(prevTestObject, currentNode);
+  }
+}
+
+function shouldOmit(testObject: IsolateTest): boolean {
+  return withinActiveOmitWhen() || isOptionalFiedApplied(testObject.fieldName);
+}
+
+function skipTestAndReturn(testNode: IsolateTest): IsolateTest {
+  testNode.skip();
+  return testNode;
+}
+
+function omitTestAndReturn(testNode: IsolateTest): IsolateTest {
+  testNode.omit();
+  return testNode;
+}
+
+function forceSkipIfInSkipWhen(testNode: IsolateTest): IsolateTest {
+  // We're forcing skipping the pending test
+  // if we're directly within a skipWhen block
+  // This mostly means that we're probably giving
+  // up on this async test intentionally.
+  testNode.skip(isExcludedIndividually());
+  return testNode;
+}
+
+function throwTestOrderError(
+  newNode: IsolateTest,
+  prevNode: Isolate | undefined
+): void {
+  if (shouldAllowReorder(newNode)) {
+    return;
+  }
+
+  deferThrow(`Vest Critical Error: Tests called in different order than previous run.
+    expected: ${newNode.fieldName}
+    received: ${IsolateTest.is(prevNode) ? prevNode.fieldName : undefined}
+    This can happen on one of two reasons:
+    1. You're using if/else statements to conditionally select tests. Instead, use "skipWhen".
+    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.`);
+}
+
+/**
+ * @returns {boolean} Whether or not the current isolate allows tests to be reordered
+ */
+function shouldAllowReorder(newNode: IsolateTest): boolean {
+  const parent = newNode.parent;
+  invariant(parent);
+  return isIsolateType(parent, IsolateTypes.EACH);
+}

package/src/core/isolate/IsolateTest/IsolateTestStateMachine.ts

@@ -0,0 +1,69 @@
+import { StateMachine, TStateMachine } from 'SimpleStateMachine';
+
+export enum TestStatus {
+  UNTESTED = 'UNTESTED',
+  SKIPPED = 'SKIPPED',
+  FAILED = 'FAILED',
+  WARNING = 'WARNING',
+  PASSING = 'PASSING',
+  PENDING = 'PENDING',
+  CANCELED = 'CANCELED',
+  OMITTED = 'OMITTED',
+}
+
+export enum TestAction {
+  RESET = 'RESET',
+}
+
+type TAction = TestAction | TestStatus;
+
+export function createTestStateMachine() {
+  return StateMachine<TestStatus, TAction>(machine);
+}
+
+/* eslint-disable sort-keys */
+const machine: TStateMachine<TestStatus, TAction> = {
+  initial: TestStatus.UNTESTED,
+  states: {
+    [TestStatus.UNTESTED]: {
+      [TestStatus.CANCELED]: TestStatus.CANCELED,
+      [TestStatus.FAILED]: TestStatus.FAILED,
+      [TestStatus.OMITTED]: TestStatus.OMITTED,
+      [TestStatus.PASSING]: TestStatus.PASSING,
+      [TestStatus.PENDING]: TestStatus.PENDING,
+      [TestStatus.SKIPPED]: TestStatus.SKIPPED,
+      [TestStatus.WARNING]: TestStatus.WARNING,
+    },
+    [TestStatus.SKIPPED]: {
+      [TestAction.RESET]: TestStatus.UNTESTED,
+    },
+    [TestStatus.FAILED]: {
+      [TestAction.RESET]: TestStatus.UNTESTED,
+    },
+    [TestStatus.WARNING]: {
+      [TestAction.RESET]: TestStatus.UNTESTED,
+    },
+    [TestStatus.PASSING]: {
+      [TestAction.RESET]: TestStatus.UNTESTED,
+    },
+    [TestStatus.PENDING]: {
+      [TestAction.RESET]: TestStatus.UNTESTED,
+      [TestStatus.CANCELED]: TestStatus.CANCELED,
+      [TestStatus.FAILED]: TestStatus.FAILED,
+      [TestStatus.OMITTED]: TestStatus.OMITTED,
+      [TestStatus.PASSING]: TestStatus.PASSING,
+      [TestStatus.SKIPPED]: [
+        TestStatus.SKIPPED,
+        (force?: boolean) => force === true,
+      ],
+      [TestStatus.WARNING]: TestStatus.WARNING,
+    },
+    [TestStatus.CANCELED]: {
+      [TestAction.RESET]: TestStatus.UNTESTED,
+    },
+    [TestStatus.OMITTED]: {
+      [TestAction.RESET]: TestStatus.UNTESTED,
+    },
+  },
+};
+/* eslint-enable sort-keys */

package/src/core/isolate/IsolateTest/SimpleStateMachine.ts

@@ -0,0 +1,43 @@
+export type TStateMachine<S extends string, A extends string> = {
+  initial: S;
+  states: {
+    [key in S]: {
+      [key in A]?: S | [S, (payload?: any) => boolean];
+    };
+  };
+};
+
+export function StateMachine<S extends string, A extends string>(
+  machine: TStateMachine<S, A>
+): { getState: () => S; transition: (action: A, payload?: any) => void } {
+  let state = machine.initial;
+
+  const api = { getState, transition };
+
+  return api;
+
+  function getState(): S {
+    return state;
+  }
+
+  function transition(action: A, payload?: any): void {
+    const transitionTo = machine.states[state][action];
+
+    let target = transitionTo;
+
+    if (Array.isArray(target)) {
+      const [, conditional] = target;
+      if (!conditional(payload)) {
+        return;
+      }
+
+      target = target[0];
+    }
+
+    if (!target || target === state) {
+      return;
+    }
+
+    state = target as S;
+  }
+}

package/src/core/isolate/IsolateTest/TestWalker.ts

@@ -0,0 +1,77 @@
+import { IsolateTest } from 'IsolateTest';
+import { TFieldName } from 'SuiteResultTypes';
+import { SuiteWalker } from 'SuiteWalker';
+import matchingFieldName from 'matchingFieldName';
+
+export class TestWalker {
+  static hasNoTests(): boolean {
+    return !SuiteWalker.has(IsolateTest.is);
+  }
+
+  static someIncompleteTests(
+    predicate: (test: IsolateTest) => boolean
+  ): boolean {
+    return SuiteWalker.some(isolate => {
+      IsolateTest.isX(isolate);
+
+      return isolate.isPending() && predicate(isolate);
+    }, IsolateTest.is);
+  }
+
+  static someTests(predicate: (test: IsolateTest) => boolean): boolean {
+    return SuiteWalker.some(isolate => {
+      IsolateTest.isX(isolate);
+
+      return predicate(isolate);
+    }, IsolateTest.is);
+  }
+
+  static everyTest(predicate: (test: IsolateTest) => boolean): boolean {
+    return SuiteWalker.every(isolate => {
+      IsolateTest.isX(isolate);
+
+      return predicate(isolate);
+    }, IsolateTest.is);
+  }
+
+  static walkTests(
+    callback: (test: IsolateTest, breakout: () => void) => void
+  ): void {
+    SuiteWalker.walk((isolate, breakout) => {
+      IsolateTest.isX(isolate);
+
+      callback(isolate, breakout);
+    }, IsolateTest.is);
+  }
+
+  static hasRemainingTests(fieldName?: TFieldName): boolean {
+    return TestWalker.someIncompleteTests(testObject => {
+      if (fieldName) {
+        return matchingFieldName(testObject, fieldName);
+      }
+      return true;
+    });
+  }
+
+  static pluckTests(predicate: (test: IsolateTest) => boolean): void {
+    SuiteWalker.pluck(isolate => {
+      IsolateTest.isX(isolate);
+
+      return predicate(isolate);
+    }, IsolateTest.is);
+  }
+
+  static resetField(fieldName: TFieldName): void {
+    TestWalker.walkTests(testObject => {
+      if (matchingFieldName(testObject, fieldName)) {
+        testObject.reset();
+      }
+    });
+  }
+
+  static removeTestByFieldName(fieldName: TFieldName): void {
+    TestWalker.pluckTests(testObject => {
+      return matchingFieldName(testObject, fieldName);
+    });
+  }
+}

package/src/core/isolate/IsolateTypes.ts

@@ -0,0 +1,10 @@
+export enum IsolateTypes {
+  DEFAULT = 'DEFAULT',
+  TEST = 'TEST',
+  SUITE = 'SUITE',
+  EACH = 'EACH',
+  GROUP = 'GROUP',
+  SKIP_WHEN = 'SKIP_WHEN',
+  OMIT_WHEN = 'OMIT_WHEN',
+  TEST_MEMO = 'TEST_MEMO',
+}

package/src/core/isolate/isIsolate.ts

@@ -0,0 +1,6 @@
+import { IsolateTypes } from 'IsolateTypes';
+import { Isolate } from 'isolate';
+
+export function isIsolateType(isolate: Isolate, type: IsolateTypes): boolean {
+  return isolate.type === type;
+}

package/src/core/isolate/isolate.ts

@@ -0,0 +1,110 @@
+import { CB, invariant, isNotNullish, isNullish } from 'vest-utils';
+
+import { IsolateTypes } from 'IsolateTypes';
+import {
+  useSetNextIsolateChild,
+  useSetHistory,
+  useIsolate,
+} from 'PersistedContext';
+import { Reconciler } from 'Reconciler';
+
+export type IsolateKey = null | string;
+
+export class Isolate<T extends IsolateTypes = IsolateTypes, _D = any> {
+  children: Isolate[] | null = [];
+  keys: Record<string, Isolate> = {};
+  parent: Isolate | null = null;
+  output?: any;
+  key: IsolateKey = null;
+  static reconciler = Reconciler;
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  constructor(public type: T, _data?: _D) {}
+
+  setParent(parent: Isolate | null): this {
+    this.parent = parent;
+    return this;
+  }
+
+  saveOutput(output: any): this {
+    this.output = output;
+    return this;
+  }
+
+  setKey(key: string | null): this {
+    this.key = key;
+    return this;
+  }
+
+  usesKey(): boolean {
+    return isNotNullish(this.key);
+  }
+
+  addChild(child: Isolate): void {
+    invariant(this.children);
+
+    this.children.push(child);
+  }
+
+  removeChild(node: Isolate): void {
+    this.children = this.children?.filter(child => child !== node) ?? null;
+  }
+
+  slice(at: number): void {
+    if (isNullish(this.children)) {
+      return;
+    }
+
+    this.children.length = at;
+  }
+
+  at(at: number): Isolate | null {
+    return this.children?.[at] ?? null;
+  }
+
+  cursor(): number {
+    return this.children?.length ?? 0;
+  }
+
+  static create<Callback extends CB = CB>(
+    type: IsolateTypes,
+    callback: Callback,
+    data?: any
+  ): Isolate {
+    return this.createImplementation(type, callback, data);
+  }
+
+  private static createImplementation<Callback extends CB = CB>(
+    type: IsolateTypes,
+    callback: Callback,
+    data?: any
+  ): Isolate {
+    const parent = useIsolate();
+
+    const newCreatedNode = new this(type, data).setParent(parent);
+
+    const [nextIsolateChild, output] = this.reconciler.reconcile(
+      newCreatedNode,
+      callback
+    );
+
+    nextIsolateChild.saveOutput(output);
+
+    this.setNode(nextIsolateChild);
+
+    return nextIsolateChild;
+  }
+
+  static setNode(node: Isolate): void {
+    const parent = useIsolate();
+    if (parent) {
+      useSetNextIsolateChild(node);
+    } else {
+      useSetHistory(node);
+    }
+  }
+
+  static is(node: any): boolean {
+    return node instanceof Isolate;
+  }
+}