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

package/src/isolates/__tests__/skipWhen.test.ts

@@ -0,0 +1,163 @@
+import { dummyTest } from '../../../testUtils/testDummy';
+
+import { TTestSuite } from 'testUtils/TVestMock';
+import * as vest from 'vest';
+
+describe('skipWhen', () => {
+  let fn = jest.fn();
+  beforeEach(() => {
+    fn = jest.fn();
+    suite.reset();
+  });
+  it('Should run callback both when condition is true or false', () => {
+    let counter = 0;
+    const suite = vest.create(() => {
+      vest.skipWhen(counter === 1, fn);
+
+      counter++;
+    });
+    expect(fn).toHaveBeenCalledTimes(0);
+    suite();
+    expect(fn).toHaveBeenCalledTimes(1);
+    suite();
+    expect(fn).toHaveBeenCalledTimes(2);
+  });
+
+  it('Should respect both boolean and function conditions', () => {
+    const suite = vest.create(() => {
+      vest.skipWhen(false, fn);
+      vest.skipWhen(true, fn);
+      vest.skipWhen(() => false, fn);
+      vest.skipWhen(() => true, fn);
+    });
+
+    suite();
+
+    expect(fn).toHaveBeenCalledTimes(4);
+  });
+
+  it('Should pass result draft to the functional condition', () => {
+    const f = jest.fn();
+    const control = jest.fn();
+
+    vest.create(() => {
+      vest.skipWhen(draft => {
+        expect(draft.hasErrors()).toBe(false);
+        expect(draft).toMatchSnapshot();
+        control();
+        return false;
+      }, f);
+      dummyTest.failing('f1', 'msg');
+      vest.skipWhen(draft => {
+        expect(draft.hasErrors()).toBe(true);
+        expect(draft.hasErrors('f1')).toBe(true);
+        expect(draft.hasErrors('f2')).toBe(false);
+        expect(draft.hasErrors('f3')).toBe(false);
+        expect(draft).toMatchSnapshot();
+        control();
+        return false;
+      }, f);
+      dummyTest.failing('f2', 'msg');
+      vest.skipWhen(draft => {
+        expect(draft.hasErrors()).toBe(true);
+        expect(draft.hasErrors('f1')).toBe(true);
+        expect(draft.hasErrors('f2')).toBe(true);
+        expect(draft.hasErrors('f3')).toBe(false);
+        expect(draft).toMatchSnapshot();
+        control();
+        return false;
+      }, f);
+      dummyTest.failing('f3', 'msg');
+    })();
+
+    expect(control).toHaveBeenCalledTimes(3);
+  });
+
+  it('Should skip tests when the condition is truthy', () => {
+    const res = suite(true);
+    expect(res.tests.username.testCount).toBe(0);
+  });
+
+  it('Should run tests when the condition is falsy', () => {
+    const res = suite(false);
+    expect(res.tests.username.testCount).toBe(1);
+  });
+
+  it('Should correctly refill the state when field is skipped', () => {
+    const res = suite(false);
+    expect(res.tests.username.testCount).toBe(1);
+    suite(true);
+
+    expect(suite.get().tests.username.testCount).toBe(1);
+  });
+
+  describe('nested calls', () => {
+    let suite: TTestSuite;
+
+    describe('skipped in non-skipped', () => {
+      beforeEach(() => {
+        suite = vest.create(() => {
+          vest.skipWhen(false, () => {
+            vest.test('outer', () => false);
+
+            vest.skipWhen(true, () => {
+              vest.test('inner', () => false);
+            });
+          });
+        });
+        suite();
+      });
+      it('Should run `outer` and skip `inner`', () => {
+        expect(suite.get().testCount).toBe(1);
+        expect(suite.get().hasErrors('outer')).toBe(true);
+        expect(suite.get().hasErrors('inner')).toBe(false);
+      });
+    });
+
+    describe('skipped in skipped', () => {
+      beforeEach(() => {
+        suite = vest.create(() => {
+          vest.skipWhen(true, () => {
+            vest.test('outer', () => false);
+
+            vest.skipWhen(true, () => {
+              vest.test('inner', () => false);
+            });
+          });
+        });
+        suite();
+      });
+      it('Should skip both `outer` and `inner`', () => {
+        expect(suite.get().testCount).toBe(0);
+        expect(suite.get().hasErrors('outer')).toBe(false);
+        expect(suite.get().hasErrors('inner')).toBe(false);
+      });
+    });
+    describe('non-skipped in skipped', () => {
+      beforeEach(() => {
+        suite = vest.create(() => {
+          vest.skipWhen(true, () => {
+            vest.test('outer', () => false);
+
+            vest.skipWhen(false, () => {
+              vest.test('inner', () => false);
+            });
+          });
+        });
+        suite();
+      });
+      it('Should skip both', () => {
+        expect(suite.get().testCount).toBe(0);
+        expect(suite.get().hasErrors('outer')).toBe(false);
+        expect(suite.get().hasErrors('inner')).toBe(false);
+      });
+    });
+  });
+});
+
+const suite = vest.create((skipTest: boolean) => {
+  vest.skipWhen(skipTest, () => {
+    vest.test('username', () => false);
+  });
+  vest.test('control', () => false);
+});

package/src/isolates/each.ts

@@ -0,0 +1,30 @@
+import { invariant, isFunction } from 'vest-utils';
+
+import { IsolateTypes } from 'IsolateTypes';
+import { Isolate } from 'isolate';
+
+/**
+ * Iterates over an array of items, allowing to run tests individually per item.
+ *
+ * Requires setting a "key" property on each item tested.
+ *
+ * @example
+ *
+ * each(itemsArray, (item) => {
+ *  test(item.name, 'Item value must not be empty', () => {
+ *    enforce(item.value).isNotEmpty();
+ *  }, item.id)
+ * })
+ */
+export function each<T>(
+  list: T[],
+  callback: (arg: T, index: number) => void
+): void {
+  invariant(isFunction(callback), 'each callback must be a function');
+
+  Isolate.create(IsolateTypes.EACH, () => {
+    list.forEach((arg, index) => {
+      callback(arg, index);
+    });
+  });
+}

package/src/isolates/group.ts

@@ -0,0 +1,9 @@
+import { IsolateTypes } from 'IsolateTypes';
+import { SuiteContext } from 'SuiteContext';
+import { Isolate } from 'isolate';
+
+export function group(groupName: string, callback: () => void): Isolate {
+  return Isolate.create(IsolateTypes.GROUP, () => {
+    SuiteContext.run({ groupName }, callback);
+  });
+}

package/src/isolates/omitWhen.ts

@@ -0,0 +1,41 @@
+import type { CB } from 'vest-utils';
+import { optionalFunctionValue } from 'vest-utils';
+
+import { IsolateTypes } from 'IsolateTypes';
+import { SuiteContext, useOmitted } from 'SuiteContext';
+import { SuiteResult, TFieldName } from 'SuiteResultTypes';
+import { Isolate } from 'isolate';
+import { createSuiteResult } from 'suiteResult';
+
+/**
+ * Conditionally omits tests from the suite.
+ *
+ * @example
+ *
+ * omitWhen(res => res.hasErrors('username'), () => {
+ *  test('username', 'User already taken', async () => await doesUserExist(username)
+ * });
+ */
+export function omitWhen<F extends TFieldName>(
+  conditional: boolean | ((draft: SuiteResult<F>) => boolean),
+  callback: CB
+): void {
+  Isolate.create(IsolateTypes.OMIT_WHEN, () => {
+    SuiteContext.run(
+      {
+        omitted:
+          withinActiveOmitWhen() ||
+          optionalFunctionValue(
+            conditional,
+            optionalFunctionValue(createSuiteResult)
+          ),
+      },
+      callback
+    );
+  });
+}
+
+// Checks that we're currently in an active omitWhen block
+export function withinActiveOmitWhen(): boolean {
+  return useOmitted();
+}

package/src/isolates/skipWhen.ts

@@ -0,0 +1,42 @@
+import { CB, optionalFunctionValue } from 'vest-utils';
+
+import { IsolateTypes } from 'IsolateTypes';
+import { SuiteContext, useSkipped } from 'SuiteContext';
+import { SuiteResult, TFieldName } from 'SuiteResultTypes';
+import { Isolate } from 'isolate';
+import { createSuiteResult } from 'suiteResult';
+
+/**
+ * Conditionally skips running tests within the callback.
+ *
+ * @example
+ *
+ * skipWhen(res => res.hasErrors('username'), () => {
+ *  test('username', 'User already taken', async () => await doesUserExist(username)
+ * });
+ */
+export function skipWhen<F extends TFieldName>(
+  condition: boolean | ((draft: SuiteResult<F>) => boolean),
+  callback: CB
+): void {
+  Isolate.create(IsolateTypes.SKIP_WHEN, () => {
+    SuiteContext.run(
+      {
+        skipped:
+          // Checking for nested conditional. If we're in a nested skipWhen,
+          // we should skip the test if the parent conditional is true.
+          isExcludedIndividually() ||
+          // Otherwise, we should skip the test if the conditional is true.
+          optionalFunctionValue(
+            condition,
+            optionalFunctionValue(createSuiteResult)
+          ),
+      },
+      callback
+    );
+  });
+}
+
+export function isExcludedIndividually(): boolean {
+  return useSkipped();
+}

package/src/suite/__tests__/__snapshots__/create.test.ts.snap

@@ -0,0 +1,67 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`Test createSuite module Initial run Should be able to get the suite from the result of createSuite 1`] = `
+{
+  "errorCount": 0,
+  "getErrors": [Function],
+  "getErrorsByGroup": [Function],
+  "getWarnings": [Function],
+  "getWarningsByGroup": [Function],
+  "groups": {},
+  "hasErrors": [Function],
+  "hasErrorsByGroup": [Function],
+  "hasWarnings": [Function],
+  "hasWarningsByGroup": [Function],
+  "isValid": [Function],
+  "isValidByGroup": [Function],
+  "suiteName": undefined,
+  "testCount": 0,
+  "tests": {},
+  "valid": false,
+  "warnCount": 0,
+}
+`;
+
+exports[`Test createSuite module Initial run Should initialize with an empty result object 1`] = `
+{
+  "errorCount": 0,
+  "getErrors": [Function],
+  "getErrorsByGroup": [Function],
+  "getWarnings": [Function],
+  "getWarningsByGroup": [Function],
+  "groups": {},
+  "hasErrors": [Function],
+  "hasErrorsByGroup": [Function],
+  "hasWarnings": [Function],
+  "hasWarningsByGroup": [Function],
+  "isValid": [Function],
+  "isValidByGroup": [Function],
+  "suiteName": undefined,
+  "testCount": 0,
+  "tests": {},
+  "valid": false,
+  "warnCount": 0,
+}
+`;
+
+exports[`Test createSuite module Test suite Arguments allows omitting suite name 1`] = `
+{
+  "errorCount": 0,
+  "getErrors": [Function],
+  "getErrorsByGroup": [Function],
+  "getWarnings": [Function],
+  "getWarningsByGroup": [Function],
+  "groups": {},
+  "hasErrors": [Function],
+  "hasErrorsByGroup": [Function],
+  "hasWarnings": [Function],
+  "hasWarningsByGroup": [Function],
+  "isValid": [Function],
+  "isValidByGroup": [Function],
+  "suiteName": undefined,
+  "testCount": 0,
+  "tests": {},
+  "valid": false,
+  "warnCount": 0,
+}
+`;

package/src/suite/__tests__/create.test.ts

@@ -0,0 +1,109 @@
+import { faker } from '@faker-js/faker';
+import { noop } from 'lodash';
+
+import { dummyTest } from '../../../testUtils/testDummy';
+import { TestPromise } from '../../../testUtils/testPromise';
+
+import { create } from 'vest';
+
+describe('Test createSuite module', () => {
+  describe('Test suite Arguments', () => {
+    it('allows omitting suite name', () => {
+      expect(typeof create(jest.fn())).toBe('function');
+      expect(typeof create(jest.fn()).get).toBe('function');
+      expect(typeof create(jest.fn()).reset).toBe('function');
+      expect(typeof create(jest.fn()).remove).toBe('function');
+      expect(create(jest.fn()).get()).toMatchSnapshot();
+    });
+
+    it.each([faker.random.word(), null, undefined, 0, 1, true, false, NaN, ''])(
+      'Throws an error when `tests` callback is not a function',
+      value => {
+        // @ts-expect-error - testing invalid input
+        expect(() => create(value)).toThrow(
+          'vest.create: Expected callback to be a function.'
+        );
+      }
+    );
+
+    describe('When suite name is provided', () => {
+      it('Should add suite name to suite result', () => {
+        const res = create('form_name', () => {})();
+
+        expect(res.suiteName).toBe('form_name');
+      });
+    });
+  });
+
+  describe('Return value', () => {
+    it('should be a function', () => {
+      expect(typeof create(noop)).toBe('function');
+    });
+  });
+
+  describe('When returned function is invoked', () => {
+    it('Calls `tests` argument', () =>
+      TestPromise(done => {
+        const validate = create(() => {
+          done();
+        });
+        validate();
+      }));
+
+    it('Passes all arguments over to tests callback', () => {
+      const testsCallback = jest.fn();
+      const params = [
+        1,
+        2,
+        3,
+        { [faker.random.word()]: [1, 2, 3] },
+        false,
+        [faker.random.word()],
+      ];
+      const validate = create(testsCallback);
+      validate(...params);
+      expect(testsCallback).toHaveBeenCalledWith(...params);
+    });
+  });
+
+  describe('Initial run', () => {
+    const testsCb = jest.fn();
+    const genValidate = () => create(testsCb);
+
+    it('Should initialize with an empty result object', () => {
+      const validate = genValidate();
+      expect(Object.keys(validate.get().tests)).toHaveLength(0);
+      expect(Object.keys(validate.get().groups)).toHaveLength(0);
+
+      expect(validate.get().errorCount).toBe(0);
+      expect(validate.get().warnCount).toBe(0);
+      expect(validate.get().testCount).toBe(0);
+
+      expect(validate.get()).toMatchSnapshot();
+    });
+
+    it('Should be able to get the suite from the result of createSuite', () => {
+      const testsCb = jest.fn();
+      expect(create(testsCb).get()).toMatchSnapshot();
+    });
+
+    it('Should be able to reset the suite from the result of createSuite', () => {
+      const testSuite = create(() => {
+        dummyTest.failing('f1', 'm1');
+      });
+      testSuite();
+      expect(testSuite.get().hasErrors()).toBe(true);
+      expect(testSuite.get().testCount).toBe(1);
+      testSuite.reset();
+      expect(testSuite.get().hasErrors()).toBe(false);
+      expect(testSuite.get().testCount).toBe(0);
+    });
+
+    it('Should return without calling tests callback', () => {
+      const validate = create(testsCb);
+      expect(testsCb).not.toHaveBeenCalled();
+      validate();
+      expect(testsCb).toHaveBeenCalled();
+    });
+  });
+});

package/src/suite/__tests__/remove.test.ts

@@ -0,0 +1,50 @@
+import wait from 'wait';
+
+import { dummyTest } from '../../../testUtils/testDummy';
+
+import * as vest from 'vest';
+
+describe('suite.remove', () => {
+  it('Should remove field from validation result', async () => {
+    const suite = vest.create(() => {
+      dummyTest.failing('field1');
+      dummyTest.failing('field1');
+      dummyTest.failingAsync('field1', { time: 100 });
+      dummyTest.failing('field2');
+      dummyTest.passing('field2');
+      dummyTest.passing('field1');
+    });
+    suite();
+    expect(suite.get().testCount).toBe(6);
+    expect(suite.get().tests.field1.testCount).toBe(4);
+    expect(suite.get().tests.field2.testCount).toBe(2);
+    suite.remove('field1');
+    expect(suite.get().testCount).toBe(2);
+    expect(suite.get().tests.field1).toBeUndefined();
+    await wait(150);
+    expect(suite.get().testCount).toBe(2);
+    expect(suite.get().tests.field1).toBeUndefined();
+  });
+
+  it('Should clear the cache when removing a field', () => {
+    const suite = vest.create(() => {
+      dummyTest.failing('field1');
+      dummyTest.failing('field2');
+    });
+    suite();
+    const res = suite.get();
+    suite.remove('field2');
+    expect(suite.get()).not.toBe(res);
+  });
+
+  it('Should return silently when removing a field that does not exist', () => {
+    const suite = vest.create(() => {
+      dummyTest.failing('field1');
+      dummyTest.passing('field2');
+    });
+    suite();
+    const res = suite.get();
+    suite.remove('field3');
+    expect(suite.get()).isDeepCopyOf(res);
+  });
+});

package/src/suite/__tests__/resetField.test.ts

@@ -0,0 +1,74 @@
+import { TTestSuite } from 'testUtils/TVestMock';
+import { create, test } from 'vest';
+
+describe('suite.resetField', () => {
+  let suite: TTestSuite;
+
+  beforeEach(() => {
+    suite = create(() => {
+      test('field1', 'f1 error', () => false);
+      test('field2', 'f2 error', () => false);
+    });
+    suite();
+  });
+
+  it('Should reset the validity state of a field', () => {
+    expect(suite.get().hasErrors('field1')).toBe(true);
+    expect(suite.get().hasErrors('field2')).toBe(true);
+    expect(suite.get().getErrors('field1')).toEqual(['f1 error']);
+    expect(suite.get().getErrors('field2')).toEqual(['f2 error']);
+    suite.resetField('field1');
+    expect(suite.get().hasErrors('field1')).toBe(false);
+    expect(suite.get().hasErrors('field2')).toBe(true);
+    expect(suite.get().getErrors('field1')).toEqual([]);
+    expect(suite.get().getErrors('field2')).toEqual(['f2 error']);
+    suite.resetField('field2');
+    expect(suite.get().hasErrors('field1')).toBe(false);
+    expect(suite.get().hasErrors('field2')).toBe(false);
+    expect(suite.get().getErrors('field1')).toEqual([]);
+    expect(suite.get().getErrors('field2')).toEqual([]);
+  });
+
+  it('Should refresh the suite result', () => {
+    const res = suite.get();
+    expect(res).toBe(suite.get());
+    suite.resetField('field1');
+    expect(res).not.toBe(suite.get());
+  });
+
+  it('Should allow the field to keep updating (no final status)', () => {
+    suite.resetField('field1');
+    expect(suite.get().hasErrors('field1')).toBe(false);
+    expect(suite.get().hasErrors('field2')).toBe(true);
+    suite();
+    expect(suite.get().hasErrors('field1')).toBe(true);
+    expect(suite.get().hasErrors('field2')).toBe(true);
+  });
+
+  it('sanity', () => {
+    expect(suite.get().tests).toMatchInlineSnapshot(`
+      {
+        "field1": {
+          "errorCount": 1,
+          "errors": [
+            "f1 error",
+          ],
+          "testCount": 1,
+          "valid": false,
+          "warnCount": 0,
+          "warnings": [],
+        },
+        "field2": {
+          "errorCount": 1,
+          "errors": [
+            "f2 error",
+          ],
+          "testCount": 1,
+          "valid": false,
+          "warnCount": 0,
+          "warnings": [],
+        },
+      }
+    `);
+  });
+});

package/src/suite/createSuite.ts

@@ -0,0 +1,94 @@
+import { assign, CB, invariant, isFunction } from 'vest-utils';
+
+import { IsolateTypes } from 'IsolateTypes';
+import {
+  createVestState,
+  persist,
+  PersistedContext,
+  prepareEmitter,
+  useEmit,
+} from 'PersistedContext';
+import { SuiteContext } from 'SuiteContext';
+import { SuiteResult, SuiteRunResult, TFieldName } from 'SuiteResultTypes';
+import { Events } from 'VestBus';
+import { Isolate } from 'isolate';
+import { createSuiteResult } from 'suiteResult';
+import { suiteRunResult } from 'suiteRunResult';
+
+function createSuite<T extends CB, F extends TFieldName>(
+  suiteName: SuiteName,
+  suiteCallback: T
+): Suite<T, F>;
+function createSuite<T extends CB, F extends TFieldName>(
+  suiteCallback: T
+): Suite<T, F>;
+function createSuite<T extends CB, F extends TFieldName>(
+  ...args: [suiteName: SuiteName, suiteCallback: T] | [suiteCallback: T]
+): Suite<T, F> {
+  const [suiteCallback, suiteName] = args.reverse() as [T, SuiteName];
+
+  validateSuiteCallback(suiteCallback);
+
+  // Create a stateRef for the suite
+  // It holds the suite's persisted values that may remain between runs.
+  const stateRef = createVestState({ suiteName });
+
+  function suite(...args: Parameters<T>): SuiteRunResult<F> {
+    return SuiteContext.run({}, () => {
+      const emit = useEmit();
+
+      emit(Events.SUITE_RUN_STARTED);
+
+      return Isolate.create(IsolateTypes.SUITE, runSuiteCallback(...args));
+    }).output;
+  }
+
+  // Assign methods to the suite
+  // We do this within the PersistedContext so that the suite methods
+  // will be bound to the suite's stateRef and be able to access it.
+  return PersistedContext.run(stateRef, () => {
+    return assign(
+      // We're also binding the suite to the stateRef, so that the suite
+      // can access the stateRef when it's called.
+      PersistedContext.bind(stateRef, suite),
+      {
+        get: persist(createSuiteResult),
+        remove: prepareEmitter<string>(Events.REMOVE_FIELD),
+        reset: prepareEmitter(Events.RESET_SUITE),
+        resetField: prepareEmitter<string>(Events.RESET_FIELD),
+      }
+    );
+  });
+
+  function runSuiteCallback(...args: Parameters<T>): () => SuiteRunResult<F> {
+    return () => {
+      suiteCallback(...args);
+      return suiteRunResult();
+    };
+  }
+}
+
+function validateSuiteCallback<T extends CB>(
+  suiteCallback: T
+): asserts suiteCallback is T {
+  invariant(
+    isFunction(suiteCallback),
+    'vest.create: Expected callback to be a function.'
+  );
+}
+
+export type SuiteName = string | undefined;
+
+export type Suite<T extends CB, F extends TFieldName> = ((
+  ...args: Parameters<T>
+) => SuiteRunResult<F>) &
+  SuiteMethods<F>;
+
+type SuiteMethods<F extends TFieldName> = {
+  get: () => SuiteResult<F>;
+  reset: () => void;
+  remove: (fieldName: F) => void;
+  resetField: (fieldName: F) => void;
+};
+
+export { createSuite };