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

package/src/core/isolate/reconciler/Reconciler/Reconciler.ts

@@ -0,0 +1,123 @@
+import { CB, invariant, isNullish } from 'vest-utils';
+
+import {
+  useHistoryKey,
+  useSetIsolateKey,
+  useHistoryNode,
+  useIsolate,
+  useCurrentCursor,
+  PersistedContext,
+  useRuntimeRoot,
+} from 'PersistedContext';
+import type { Isolate } from 'isolate';
+
+export class Reconciler {
+  static reconciler(
+    currentNode: Isolate,
+    historicNode: Isolate | null
+  ): Isolate {
+    if (isNullish(historicNode)) {
+      return currentNode;
+    }
+    return currentNode;
+  }
+
+  static reconcile<Callback extends CB = CB>(
+    node: Isolate,
+    callback: Callback
+  ): [Isolate, ReturnType<Callback>] {
+    const parent = useIsolate();
+
+    const historyNode = useHistoryNode();
+    let localHistoryNode = historyNode;
+
+    if (parent) {
+      // If we have a parent, we need to get the history node from the parent's children
+      // We take the history node from the cursor of the active node's children
+      localHistoryNode = historyNode?.at(useCurrentCursor()) ?? null;
+    }
+
+    const nextNode = this.reconciler(node, localHistoryNode);
+
+    invariant(nextNode);
+
+    if (Object.is(nextNode, node)) {
+      return [node, runAsNew(localHistoryNode, node, callback)];
+    }
+
+    return [nextNode, nextNode.output];
+  }
+
+  static removeAllNextNodesInIsolate() {
+    const testIsolate = useIsolate();
+    const historyNode = useHistoryNode();
+
+    if (!historyNode || !testIsolate) {
+      return;
+    }
+
+    historyNode.slice(useCurrentCursor());
+  }
+
+  static handleCollision(newNode: Isolate, prevNode: Isolate): Isolate {
+    // we should base our calculation on the key property
+    if (newNode.usesKey()) {
+      return this.handleIsolateNodeWithKey(newNode);
+    }
+
+    if (this.nodeReorderDetected(newNode, prevNode)) {
+      this.onNodeReorder(newNode, prevNode);
+    }
+
+    return prevNode ? prevNode : newNode;
+  }
+
+  static nodeReorderDetected(newNode: Isolate, prevNode: Isolate): boolean {
+    // This is a dummy return just to satisfy the linter. Overrides will supply the real implementation.
+    return !(newNode ?? prevNode);
+  }
+
+  static onNodeReorder(newNode: Isolate, prevNode: Isolate): Isolate {
+    this.removeAllNextNodesInIsolate();
+    // This is a dummy return just to satisfy the linter. Overrides will supply the real implementation.
+    return newNode ?? prevNode;
+  }
+
+  static handleIsolateNodeWithKey(node: Isolate): Isolate {
+    invariant(node.usesKey());
+
+    const prevNodeByKey = useHistoryKey(node.key);
+
+    let nextNode = node;
+
+    if (!isNullish(prevNodeByKey)) {
+      nextNode = prevNodeByKey;
+    }
+
+    useSetIsolateKey(node.key, node);
+
+    return nextNode;
+  }
+}
+
+function runAsNew<Callback extends CB = CB>(
+  localHistoryNode: Isolate | null,
+  current: Isolate,
+  callback: CB
+): ReturnType<Callback> {
+  const runtimeRoot = useRuntimeRoot();
+
+  // We're creating a new child isolate context where the local history node
+  // is the current history node, thus advancing the history cursor.
+  const output = PersistedContext.run(
+    {
+      historyNode: localHistoryNode,
+      runtimeNode: current,
+      ...(!runtimeRoot && { runtimeRoot: current }),
+    },
+    () => callback(current)
+  );
+
+  current.output = output;
+  return output;
+}

package/src/core/isolate/reconciler/cancelOverriddenPendingTest.ts

@@ -0,0 +1,15 @@
+import { IsolateTest } from 'IsolateTest';
+import { isSameProfileTest } from 'isSameProfileTest';
+
+export default function cancelOverriddenPendingTest(
+  prevRunTestObject: IsolateTest,
+  currentRunTestObject: IsolateTest
+): void {
+  if (
+    currentRunTestObject !== prevRunTestObject &&
+    isSameProfileTest(prevRunTestObject, currentRunTestObject) &&
+    prevRunTestObject.isPending()
+  ) {
+    prevRunTestObject.cancel();
+  }
+}

package/src/core/isolate/reconciler/isSameProfileTest.ts

@@ -0,0 +1,12 @@
+import { IsolateTest } from 'IsolateTest';
+
+export function isSameProfileTest(
+  testObject1: IsolateTest,
+  testObject2: IsolateTest
+): boolean {
+  return (
+    testObject1.fieldName === testObject2.fieldName &&
+    testObject1.groupName === testObject2.groupName &&
+    testObject1.key === testObject2.key
+  );
+}

package/src/core/isolate/walker.ts

@@ -0,0 +1,127 @@
+import { isNullish, optionalFunctionValue } from 'vest-utils';
+
+import type { Isolate } from 'isolate';
+
+export type VisitOnlyPredicate = (isolate: Isolate) => boolean;
+
+// eslint-disable-next-line complexity, max-statements
+export function walk(
+  startNode: Isolate,
+  callback: (isolate: Isolate, breakout: () => void) => void,
+  visitOnly?: VisitOnlyPredicate
+): void {
+  if (isNullish(startNode.children)) {
+    return;
+  }
+
+  let broke = false;
+
+  for (const isolate of startNode.children) {
+    if (broke) {
+      return;
+    }
+
+    if (isNullish(visitOnly) || optionalFunctionValue(visitOnly, isolate)) {
+      callback(isolate, breakout);
+    }
+
+    if (broke) {
+      return;
+    }
+
+    walk(
+      isolate,
+      (child, innerBreakout) => {
+        callback(child, () => {
+          innerBreakout();
+          breakout();
+        });
+      },
+      visitOnly
+    );
+  }
+
+  function breakout() {
+    broke = true;
+  }
+}
+
+export function some(
+  startNode: Isolate,
+  predicate: (node: Isolate) => boolean,
+  visitOnly?: VisitOnlyPredicate
+): boolean {
+  let hasMatch = false;
+  walk(
+    startNode,
+    (node, breakout) => {
+      if (predicate(node)) {
+        breakout();
+        hasMatch = true;
+      }
+    },
+    visitOnly
+  );
+
+  return hasMatch;
+}
+
+export function has(startNode: Isolate, match: VisitOnlyPredicate): boolean {
+  return some(startNode, () => true, match);
+}
+
+export function find(
+  startNode: Isolate,
+  predicate: (node: Isolate) => boolean,
+  visitOnly?: VisitOnlyPredicate
+): Isolate | null {
+  let found = null;
+  walk(
+    startNode,
+    (node, breakout) => {
+      if (predicate(node)) {
+        breakout();
+        found = node;
+      }
+    },
+    visitOnly
+  );
+
+  return found;
+}
+
+export function every(
+  startNode: Isolate,
+  predicate: (node: Isolate) => boolean,
+  visitOnly?: VisitOnlyPredicate
+): boolean {
+  let hasMatch = true;
+  walk(
+    startNode,
+    (node, breakout) => {
+      if (!predicate(node)) {
+        breakout();
+        hasMatch = false;
+      }
+    },
+    visitOnly
+  );
+
+  return hasMatch;
+}
+
+export function pluck(
+  startNode: Isolate,
+  predicate: (node: Isolate) => boolean,
+  visitOnly?: VisitOnlyPredicate
+): void {
+  walk(
+    startNode,
+    node => {
+      if (predicate(node) && node.parent) {
+        node.parent.removeChild(node);
+      }
+    },
+    visitOnly
+  );
+}

package/src/core/test/TestTypes.ts

@@ -0,0 +1,3 @@
+export type TestFn = () => TestResult;
+export type AsyncTest = Promise<string | void | false>;
+export type TestResult = AsyncTest | boolean | void;

package/src/core/test/__tests__/IsolateTest.test.ts

@@ -0,0 +1,152 @@
+import wait from 'wait';
+
+import { TestPromise } from '../../../../testUtils/testPromise';
+
+import { IsolateTest } from 'IsolateTest';
+import { IsolateTypes } from 'IsolateTypes';
+import * as vest from 'vest';
+
+const fieldName = 'unicycle';
+const message = 'I am Root.';
+
+describe('IsolateTest', () => {
+  let testObject: IsolateTest;
+
+  beforeEach(() => {
+    testObject = new IsolateTest(IsolateTypes.TEST, {
+      fieldName,
+      testFn: jest.fn(),
+      message,
+    });
+  });
+
+  test('TestObject constructor', () => {
+    expect(testObject).toMatchSnapshot();
+  });
+
+  it('Should have a unique id', () => {
+    Array.from(
+      { length: 100 },
+      () =>
+        new IsolateTest(IsolateTypes.TEST, {
+          fieldName,
+          testFn: jest.fn(),
+          message,
+        })
+    ).reduce((existing, { id }) => {
+      expect(existing.has(id)).toBe(false);
+      existing.add(id);
+      return existing;
+    }, new Set<string>());
+  });
+
+  describe('testObject.warn', () => {
+    it('Should mark the test as warning', () => {
+      expect(testObject.warns()).toBe(false);
+      testObject.warn();
+      expect(testObject.warns()).toBe(true);
+      expect(testObject).toMatchSnapshot();
+    });
+  });
+
+  describe('testObject.fail', () => {
+    beforeEach(() => {
+      jest.resetModules();
+
+      const { IsolateTest } = require('IsolateTest'); // eslint-disable-line @typescript-eslint/no-var-requires
+      testObject = new IsolateTest(fieldName, jest.fn(), { message });
+    });
+
+    afterEach(() => {
+      jest.resetAllMocks();
+    });
+
+    it('Should set status to failed', () => {
+      expect(testObject.isFailing()).toBe(false);
+      testObject.fail();
+      expect(testObject.isFailing()).toBe(true);
+    });
+  });
+
+  describe('testObject.valueOf', () => {
+    test('When test did not fail', () => {
+      expect(testObject.valueOf()).toBe(true);
+    });
+
+    test('When test failed', () => {
+      testObject.fail();
+      expect(testObject.valueOf()).toBe(false);
+    });
+  });
+
+  describe('testObject.cancel', () => {
+    it('Should set the testObject to cancel', () => {
+      let testObject: IsolateTest;
+      return TestPromise(done => {
+        const suite = vest.create(() => {
+          testObject = vest.test('f1', async () => {
+            await wait(100);
+          });
+          vest.test('f2', async () => {
+            await wait(100);
+          });
+          testObject.cancel();
+        });
+        suite();
+
+        expect(testObject.isCanceled()).toBe(true);
+        done();
+      });
+    });
+
+    describe('final statuses', () => {
+      let control = jest.fn();
+      beforeEach(() => {
+        control = jest.fn();
+      });
+      it('keep status unchanged when `failed`', () => {
+        vest.create(() => {
+          // async so it is not a final status
+          const testObject = vest.test('f1', async () => {
+            await wait(100);
+          });
+          testObject.fail();
+          expect(testObject.isFailing()).toBe(true);
+          testObject.skip();
+          expect(testObject.isSkipped()).toBe(false);
+          expect(testObject.isFailing()).toBe(true);
+          testObject.cancel();
+          expect(testObject.isCanceled()).toBe(false);
+          expect(testObject.isFailing()).toBe(true);
+          testObject.setPending();
+          expect(testObject.isPending()).toBe(false);
+          expect(testObject.isFailing()).toBe(true);
+          control();
+        })();
+        expect(control).toHaveBeenCalledTimes(1);
+      });
+
+      it('keep status unchanged when `canceled`', () => {
+        vest.create(() => {
+          // async so it is not a final status
+          const testObject = vest.test('f1', async () => {
+            await wait(100);
+          });
+          testObject.cancel();
+          expect(testObject.isCanceled()).toBe(true);
+          testObject.fail();
+          expect(testObject.isCanceled()).toBe(true);
+          expect(testObject.isFailing()).toBe(false);
+          testObject.skip();
+          expect(testObject.isSkipped()).toBe(false);
+          expect(testObject.isCanceled()).toBe(true);
+          testObject.setPending();
+          expect(testObject.isPending()).toBe(false);
+          expect(testObject.isCanceled()).toBe(true);
+          control();
+        })();
+        expect(control).toHaveBeenCalledTimes(1);
+      });
+    });
+  });
+});

package/src/core/test/__tests__/__snapshots__/IsolateTest.test.ts.snap

@@ -0,0 +1,39 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`IsolateTest TestObject constructor 1`] = `
+IsolateTest {
+  "children": null,
+  "fieldName": "unicycle",
+  "id": "0",
+  "key": null,
+  "keys": {},
+  "message": "I am Root.",
+  "parent": null,
+  "severity": "error",
+  "stateMachine": {
+    "getState": [Function],
+    "transition": [Function],
+  },
+  "testFn": [MockFunction],
+  "type": "TEST",
+}
+`;
+
+exports[`IsolateTest testObject.warn Should mark the test as warning 1`] = `
+IsolateTest {
+  "children": null,
+  "fieldName": "unicycle",
+  "id": "102",
+  "key": null,
+  "keys": {},
+  "message": "I am Root.",
+  "parent": null,
+  "severity": "warning",
+  "stateMachine": {
+    "getState": [Function],
+    "transition": [Function],
+  },
+  "testFn": [MockFunction],
+  "type": "TEST",
+}
+`;

package/src/core/test/__tests__/__snapshots__/memo.test.ts.snap

@@ -0,0 +1,101 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`test.memo cache hit Should produce correct initial result 1`] = `
+{
+  "done": [Function],
+  "errorCount": 1,
+  "getErrors": [Function],
+  "getErrorsByGroup": [Function],
+  "getWarnings": [Function],
+  "getWarningsByGroup": [Function],
+  "groups": {},
+  "hasErrors": [Function],
+  "hasErrorsByGroup": [Function],
+  "hasWarnings": [Function],
+  "hasWarningsByGroup": [Function],
+  "isValid": [Function],
+  "isValidByGroup": [Function],
+  "suiteName": undefined,
+  "testCount": 4,
+  "tests": {
+    "field1": {
+      "errorCount": 1,
+      "errors": [
+        "msg1",
+      ],
+      "testCount": 2,
+      "valid": false,
+      "warnCount": 0,
+      "warnings": [],
+    },
+    "field2": {
+      "errorCount": 0,
+      "errors": [],
+      "testCount": 1,
+      "valid": true,
+      "warnCount": 0,
+      "warnings": [],
+    },
+    "field3": {
+      "errorCount": 0,
+      "errors": [],
+      "testCount": 1,
+      "valid": true,
+      "warnCount": 1,
+      "warnings": [],
+    },
+  },
+  "valid": false,
+  "warnCount": 1,
+}
+`;
+
+exports[`test.memo cache hit sync Should restore previous result on re-run 1`] = `
+{
+  "done": [Function],
+  "errorCount": 1,
+  "getErrors": [Function],
+  "getErrorsByGroup": [Function],
+  "getWarnings": [Function],
+  "getWarningsByGroup": [Function],
+  "groups": {},
+  "hasErrors": [Function],
+  "hasErrorsByGroup": [Function],
+  "hasWarnings": [Function],
+  "hasWarningsByGroup": [Function],
+  "isValid": [Function],
+  "isValidByGroup": [Function],
+  "suiteName": undefined,
+  "testCount": 4,
+  "tests": {
+    "field1": {
+      "errorCount": 1,
+      "errors": [
+        "msg1",
+      ],
+      "testCount": 2,
+      "valid": false,
+      "warnCount": 0,
+      "warnings": [],
+    },
+    "field2": {
+      "errorCount": 0,
+      "errors": [],
+      "testCount": 1,
+      "valid": true,
+      "warnCount": 0,
+      "warnings": [],
+    },
+    "field3": {
+      "errorCount": 0,
+      "errors": [],
+      "testCount": 1,
+      "valid": true,
+      "warnCount": 1,
+      "warnings": [],
+    },
+  },
+  "valid": false,
+  "warnCount": 1,
+}
+`;