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

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

@@ -0,0 +1,362 @@
+import { faker } from '@faker-js/faker';
+import _ from 'lodash';
+import { enforce } from 'n4s';
+
+import partition from '../../../testUtils/partition';
+import { dummyTest } from '../../../testUtils/testDummy';
+
+import { IsolateTest } from 'IsolateTest';
+import { group } from 'group';
+import { matchingGroupName } from 'matchingGroupName';
+import { TTestSuite } from 'testUtils/TVestMock';
+import * as vest from 'vest';
+
+let groupName = 'group_name_1';
+const groupName2 = 'group_name_2';
+
+const topLevelTestObjects: Record<string, IsolateTest> = {};
+const groupTestObjects: Record<string, IsolateTest> = {};
+
+describe('group: exclusion', () => {
+  const validation = () =>
+    vest.create(
+      ({
+        only,
+        skip,
+        skipGroup,
+        onlyGroup,
+      }: {
+        only?: string;
+        skip?: string;
+        skipGroup?: string;
+        onlyGroup?: string;
+      } = {}) => {
+        vest.only(only);
+        vest.skip(skip);
+        vest.only.group(onlyGroup);
+        vest.skip.group(skipGroup);
+
+        topLevelTestObjects['field_1'] = dummyTest.failing('field_1');
+        topLevelTestObjects['field_1'] = dummyTest.failing('field_1');
+        topLevelTestObjects['field_2'] = dummyTest.passing('field_2');
+        topLevelTestObjects['field_3'] = dummyTest.failingWarning('field_3');
+        topLevelTestObjects['field_4'] = dummyTest.passingWarning('field_4');
+        topLevelTestObjects['field_5'] = dummyTest.failing('field_5');
+
+        group(groupName, () => {
+          groupTestObjects['field_1'] = dummyTest.failing('field_1');
+          groupTestObjects['field_2'] = dummyTest.passing('field_2');
+          groupTestObjects['field_3'] = dummyTest.failingWarning('field_3');
+          groupTestObjects['field_4'] = dummyTest.passingWarning('field_4');
+          groupTestObjects['field_6'] = dummyTest.failing('field_6');
+        });
+
+        group(groupName2, () => {
+          groupTestObjects['field_6'] = dummyTest.failing('field_6');
+          groupTestObjects['field_7'] = dummyTest.failing('field_7');
+          groupTestObjects['field_8'] = dummyTest.passing('field_8');
+        });
+      }
+    );
+  let res: vest.SuiteRunResult<string>;
+  let suite: TTestSuite;
+
+  beforeEach(() => {
+    groupName = faker.random.word();
+    suite = validation();
+  });
+
+  describe('When skipped', () => {
+    beforeEach(() => {
+      res = suite({ skipGroup: groupName });
+    });
+
+    it('produce result object with the group', () => {
+      expect(res.groups[groupName]).toMatchInlineSnapshot(`
+        {
+          "field_1": {
+            "errorCount": 0,
+            "errors": [],
+            "testCount": 0,
+            "valid": false,
+            "warnCount": 0,
+            "warnings": [],
+          },
+          "field_2": {
+            "errorCount": 0,
+            "errors": [],
+            "testCount": 0,
+            "valid": false,
+            "warnCount": 0,
+            "warnings": [],
+          },
+          "field_3": {
+            "errorCount": 0,
+            "errors": [],
+            "testCount": 0,
+            "valid": false,
+            "warnCount": 0,
+            "warnings": [],
+          },
+          "field_4": {
+            "errorCount": 0,
+            "errors": [],
+            "testCount": 0,
+            "valid": false,
+            "warnCount": 0,
+            "warnings": [],
+          },
+          "field_6": {
+            "errorCount": 0,
+            "errors": [],
+            "testCount": 0,
+            "valid": false,
+            "warnCount": 0,
+            "warnings": [],
+          },
+        }
+      `);
+    });
+
+    it('Should skip tests within group', () => {
+      Object.values(groupTestObjects)
+        .filter(testObject => {
+          return matchingGroupName(testObject, groupName);
+        })
+        .forEach(testObject => {
+          expect(testObject.testFn).not.toHaveBeenCalled();
+        });
+    });
+
+    it('Should run all tests outside of the group', () => {
+      Object.values(topLevelTestObjects).forEach(testObject => {
+        expect(testObject.testFn).toHaveBeenCalled();
+      });
+
+      const [withGroup, withoutGroup] = partition(
+        Object.values(groupTestObjects),
+        testObject => matchingGroupName(testObject, groupName)
+      );
+      withGroup.forEach(testObject => {
+        expect(testObject.testFn).not.toHaveBeenCalled();
+      });
+      withoutGroup.forEach(testObject => {
+        expect(testObject.testFn).toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe('When `only`ed', () => {
+    beforeEach(() => {
+      res = suite({ onlyGroup: groupName });
+    });
+    it('produce result object with group', () => {
+      expect(res.groups).toHaveProperty(groupName);
+    });
+
+    it('produce correct result object', () => {
+      expect(res.testCount).toBe(5);
+      expect(res.errorCount).toBe(2);
+      expect(res.warnCount).toBe(1);
+      expect(res.tests['field_1'].errorCount).toBe(1);
+      expect(res.tests['field_1'].warnCount).toBe(0);
+      expect(res.tests['field_2'].errorCount).toBe(0);
+      expect(res.tests['field_2'].warnCount).toBe(0);
+      expect(res.tests['field_3'].errorCount).toBe(0);
+      expect(res.tests['field_3'].warnCount).toBe(1);
+      expect(res.tests['field_4'].errorCount).toBe(0);
+      expect(res.tests['field_4'].warnCount).toBe(0);
+      expect(res.tests['field_5'].errorCount).toBe(0);
+      expect(res.tests['field_5'].warnCount).toBe(0);
+      expect(res.tests['field_6'].errorCount).toBe(1);
+      expect(res.tests['field_6'].warnCount).toBe(0);
+    });
+
+    it('Should run tests within group', () => {
+      const [withGroup, withoutGroup] = partition(
+        Object.values(groupTestObjects),
+        testObject => {
+          return matchingGroupName(testObject, groupName);
+        }
+      );
+
+      withGroup.forEach(testObject => {
+        expect(testObject.testFn).toHaveBeenCalled();
+      });
+
+      withoutGroup.forEach(testObject => {
+        expect(testObject.testFn).not.toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe('When skipped field inside `only`ed group', () => {
+    beforeEach(() => {
+      res = suite({ skip: 'field_1', onlyGroup: groupName });
+    });
+    it('produce result object with group', () => {
+      expect(res.groups).toHaveProperty(groupName);
+    });
+
+    it('Should run all tests within group but skipped test', () => {
+      Object.values(groupTestObjects)
+        // all but skipped test
+        .filter(({ fieldName }) => fieldName !== 'field_1')
+        .filter(testObject => testObject.groupName === groupName)
+        .forEach(testObject => {
+          expect(testObject.testFn).toHaveBeenCalled();
+        });
+
+      Object.values(groupTestObjects)
+        // only skipped test
+        .filter(({ fieldName }) => fieldName === 'field_1')
+        .forEach(testObject => {
+          expect(testObject.testFn).not.toHaveBeenCalled();
+        });
+    });
+    it('Should skip all tests outside of the group', () => {
+      Object.values(topLevelTestObjects).forEach(testObject => {
+        expect(testObject.testFn).not.toHaveBeenCalled();
+      });
+    });
+  });
+});
+
+describe('group: base case', () => {
+  let inGroup: IsolateTest, outsideGroup: IsolateTest;
+  const validation = () =>
+    vest.create(() => {
+      dummyTest.failing('field_1');
+      dummyTest.failing('field_1');
+      dummyTest.passing('field_2');
+      dummyTest.failingWarning('field_3');
+      dummyTest.passingWarning('field_4');
+      dummyTest.failing('field_5');
+
+      group(groupName, () => {
+        dummyTest.failing('field_1');
+        dummyTest.passing('field_2');
+        dummyTest.failingWarning('field_3');
+        dummyTest.passingWarning('field_4');
+        inGroup = dummyTest.failing('field_6');
+      });
+
+      outsideGroup = dummyTest.failing('last');
+    });
+  let res: vest.SuiteRunResult<string>;
+  beforeEach(() => {
+    groupName = faker.random.word();
+    const suite = validation();
+    res = suite();
+  });
+
+  it('Should contain all tests in tests object', () => {
+    expect(res.tests).toHaveProperty('field_1');
+    expect(res.tests).toHaveProperty('field_2');
+    expect(res.tests).toHaveProperty('field_3');
+    expect(res.tests).toHaveProperty('field_4');
+    expect(res.tests).toHaveProperty('field_5');
+    expect(res.tests).toHaveProperty('field_6');
+  });
+
+  it('Should contain only group test in group object', () => {
+    expect(res.groups[groupName]).toHaveProperty('field_1');
+    expect(res.groups[groupName]).toHaveProperty('field_2');
+    expect(res.groups[groupName]).toHaveProperty('field_3');
+    expect(res.groups[groupName]).toHaveProperty('field_4');
+    expect(res.groups[groupName]).not.toHaveProperty('field_5');
+    expect(res.groups[groupName]).toHaveProperty('field_6');
+  });
+
+  it('Should have all group errors inside test object', () => {
+    expect(res.tests['field_1'].errors).toEqual(
+      expect.arrayContaining(res.groups[groupName]['field_1'].errors)
+    );
+
+    // This one is equal because it has no errors and no warnings - so both represent the base object
+    // The test count is different, though
+    expect(_.omit(res.tests['field_2'], 'testCount')).toMatchObject(
+      _.omit(res.groups[groupName]['field_2'], 'testCount')
+    );
+
+    expect(res.tests['field_3'].warnings).toEqual(
+      expect.arrayContaining(res.groups[groupName]['field_3'].warnings)
+    );
+
+    // This one is equal since it has no tests outside the group
+    expect(res.tests['field_6']).toEqual(res.groups[groupName]['field_6']);
+  });
+
+  test('Group object is a subset of test object (negating previous test)', () => {
+    expect(res.groups[groupName]['field_1'].errors).not.toEqual(
+      expect.arrayContaining(res.tests['field_1'].errors)
+    );
+
+    enforce(res.groups[groupName]['field_1'].errorCount).lte(
+      res.tests['field_1'].errorCount
+    );
+
+    expect(res.groups[groupName]['field_3'].warnings).not.toEqual(
+      expect.arrayContaining(res.tests['field_3'].warnings)
+    );
+    enforce(res.groups[groupName]['field_3'].warnCount).lte(
+      res.tests['field_3'].warnCount
+    );
+  });
+
+  describe('Test object creation', () => {
+    it('when in group, should create test with matching group property', () => {
+      expect(inGroup.groupName).toBe(groupName);
+    });
+
+    it('after exiting group, should create est without group property', () => {
+      expect(outsideGroup).not.toHaveProperty('groupName');
+    });
+  });
+
+  test('Group validity', () => {
+    const suite = vest.create(() => {
+      vest.group('group_1', () => {
+        vest.test('field_1', () => {});
+        vest.test('field_2', () => {});
+        vest.test('field_2', () => false);
+      });
+      vest.group('group_2', () => {
+        vest.test('field_1', () => false);
+        vest.test('field_2', () => {});
+      });
+      vest.group('group_3', () => {
+        vest.test('field_1', () => false);
+        vest.test('field_2', () => false);
+      });
+      vest.group('group_4', () => {
+        vest.test('field_1', () => {});
+        vest.test('field_2', () => {});
+      });
+    });
+
+    const res = suite();
+
+    expect(res.groups.group_1.field_1.valid).toBe(true);
+    expect(res.groups.group_1.field_2.valid).toBe(false);
+    expect(res.groups.group_2.field_1.valid).toBe(false);
+    expect(res.groups.group_2.field_2.valid).toBe(true);
+    expect(res.groups.group_3.field_1.valid).toBe(false);
+    expect(res.groups.group_3.field_2.valid).toBe(false);
+    expect(res.groups.group_4.field_1.valid).toBe(true);
+    expect(res.groups.group_4.field_2.valid).toBe(true);
+    expect(res.isValidByGroup('group_1')).toBe(false);
+    expect(res.isValidByGroup('group_1', 'field_1')).toBe(true);
+    expect(res.isValidByGroup('group_1', 'field_2')).toBe(false);
+    expect(res.isValidByGroup('group_2')).toBe(false);
+    expect(res.isValidByGroup('group_2', 'field_1')).toBe(false);
+    expect(res.isValidByGroup('group_2', 'field_2')).toBe(true);
+    expect(res.isValidByGroup('group_3')).toBe(false);
+    expect(res.isValidByGroup('group_3', 'field_1')).toBe(false);
+    expect(res.isValidByGroup('group_3', 'field_2')).toBe(false);
+    expect(res.isValidByGroup('group_4')).toBe(true);
+    expect(res.isValidByGroup('group_4', 'field_1')).toBe(true);
+    expect(res.isValidByGroup('group_4', 'field_2')).toBe(true);
+    expect(res).toMatchSnapshot();
+  });
+});

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

@@ -0,0 +1,246 @@
+import { TTestSuite } from 'testUtils/TVestMock';
+import * as vest from 'vest';
+import { omitWhen, only } from 'vest';
+
+describe('omitWhen', () => {
+  let suite: TTestSuite;
+  let cb1 = jest.fn(),
+    cb2 = jest.fn(),
+    cb3 = jest.fn(),
+    cb4 = jest.fn(),
+    cb5 = jest.fn(),
+    allFieldsPass: boolean | undefined;
+
+  beforeEach(() => {
+    cb1 = jest.fn();
+    cb2 = jest.fn(() => (allFieldsPass ? undefined : false));
+    cb3 = jest.fn(() => (allFieldsPass ? undefined : false));
+    cb4 = jest.fn(() => (allFieldsPass ? undefined : false));
+    cb5 = jest.fn();
+
+    suite = vest.create((omitConditional, currentField) => {
+      only(currentField);
+      vest.test('field_1', cb1);
+      vest.test('field_2', cb2);
+
+      omitWhen(omitConditional, () => {
+        vest.test('field_1', cb3);
+        vest.test('field_3', cb4);
+        vest.test('field_4', cb5);
+      });
+    });
+  });
+
+  afterEach(() => {
+    allFieldsPass = undefined;
+  });
+
+  describe('When conditional is falsy', () => {
+    describe.each([
+      ['boolean conditional', false],
+      ['function conditional', () => false],
+    ])('%s', (_, omitConditional) => {
+      it('Should run tests normally', () => {
+        suite(omitConditional, 'field_1');
+        expect(cb1).toHaveBeenCalledTimes(1);
+        expect(cb2).not.toHaveBeenCalled();
+        expect(cb3).toHaveBeenCalledTimes(1);
+        expect(cb4).not.toHaveBeenCalled();
+        expect(cb5).not.toHaveBeenCalled();
+        expect(suite.get().hasErrors('field_1')).toBe(true);
+        expect(suite.get().tests.field_1.testCount).toBe(2);
+        expect(suite.get().tests.field_1.errorCount).toBe(1);
+        expect(suite.get().hasErrors('field_2')).toBe(false);
+        expect(suite.get().hasErrors('field_3')).toBe(false);
+        expect(suite.get().hasErrors('field_4')).toBe(false);
+        expect(suite.get().tests).toMatchSnapshot();
+        suite(omitConditional, 'field_4');
+        expect(cb1).toHaveBeenCalledTimes(1);
+        expect(cb2).not.toHaveBeenCalled();
+        expect(cb3).toHaveBeenCalledTimes(1);
+        expect(cb4).not.toHaveBeenCalled();
+        expect(cb5).toHaveBeenCalledTimes(1);
+        expect(suite.get().hasErrors('field_1')).toBe(true);
+        expect(suite.get().tests.field_1.testCount).toBe(2);
+        expect(suite.get().tests.field_1.errorCount).toBe(1);
+        expect(suite.get().hasErrors('field_2')).toBe(false);
+        expect(suite.get().hasErrors('field_3')).toBe(false);
+        expect(suite.get().hasErrors('field_4')).toBe(false);
+        expect(suite.get().tests.field_4.testCount).toBe(1);
+        expect(suite.get().tests.field_4.errorCount).toBe(0);
+        expect(suite.get().tests).toMatchSnapshot();
+      });
+
+      it('Should have all tests within the omit block referenced in the result', () => {
+        suite(omitConditional, 'field_1');
+        expect(suite.get().tests.field_1).toBeDefined();
+        expect(suite.get().tests.field_3).toBeDefined();
+        expect(suite.get().tests.field_4).toBeDefined();
+        expect(suite.get().tests).toMatchSnapshot();
+      });
+
+      it('Should retain normal `isValid` functionality', () => {
+        expect(suite.get().isValid()).toBe(false);
+        suite(omitConditional, 'field_1');
+        expect(suite.get().isValid()).toBe(false);
+        allFieldsPass = true;
+        suite(omitConditional);
+        expect(suite.get().isValid()).toBe(true);
+      });
+    });
+  });
+
+  describe('When conditional is truthy', () => {
+    describe.each([
+      ['boolean conditional', true],
+      ['function conditional', () => true],
+    ])('%s', (_, omitConditional) => {
+      it('Should avoid running the omitted tests', () => {
+        suite(omitConditional, 'field_1');
+        expect(suite.get().tests.field_1.testCount).toBe(1);
+        suite(omitConditional, 'field_2');
+        expect(suite.get().tests.field_2.testCount).toBe(1);
+        suite(omitConditional, 'field_3');
+        expect(suite.get().tests.field_3.testCount).toBe(0);
+        suite(omitConditional, 'field_4');
+        expect(suite.get().tests.field_4.testCount).toBe(0);
+        expect(cb1).toHaveBeenCalledTimes(1);
+        expect(cb2).toHaveBeenCalledTimes(1);
+        expect(cb3).toHaveBeenCalledTimes(0);
+        expect(cb4).toHaveBeenCalledTimes(0);
+        expect(cb5).toHaveBeenCalledTimes(0);
+        suite(omitConditional);
+        expect(cb1).toHaveBeenCalledTimes(2);
+        expect(cb2).toHaveBeenCalledTimes(2);
+        expect(cb3).toHaveBeenCalledTimes(0);
+        expect(cb4).toHaveBeenCalledTimes(0);
+        expect(cb5).toHaveBeenCalledTimes(0);
+        expect(suite.get()).toMatchSnapshot();
+      });
+
+      it('Should consider the suite as valid even without the omitted tests', () => {
+        expect(suite.get().isValid()).toBe(false);
+        suite(omitConditional, 'field_1');
+        expect(suite.get().isValid()).toBe(false);
+        suite(omitConditional, 'field_2');
+        expect(suite.get().isValid()).toBe(false);
+        allFieldsPass = true;
+        suite(omitConditional, 'field_2');
+        expect(suite.get().tests.field_1.testCount).toBe(1);
+        expect(suite.get().tests.field_2.testCount).toBe(1);
+        expect(suite.get().tests.field_3.testCount).toBe(0);
+        expect(suite.get().tests.field_4.testCount).toBe(0);
+
+        expect(suite.get().isValid()).toBe(true);
+      });
+
+      it('Should skip and not run omitted fields when no filter provided', () => {
+        suite(omitConditional);
+        expect(suite.get().tests.field_1.testCount).toBe(1);
+        expect(suite.get().tests.field_2.testCount).toBe(1);
+        expect(suite.get().tests.field_3.testCount).toBe(0);
+        expect(suite.get().tests.field_4.testCount).toBe(0);
+        expect(suite.get()).toMatchSnapshot();
+      });
+    });
+  });
+
+  describe('When the conditional changes between runs', () => {
+    it('Should omit previously run fields if changes to `true`', () => {
+      suite(false, 'field_1');
+      expect(suite.get().tests.field_1.testCount).toBe(2);
+      expect(cb1).toHaveBeenCalledTimes(1);
+      expect(cb3).toHaveBeenCalledTimes(1);
+      suite(true, 'field_1');
+      expect(suite.get().tests.field_1.testCount).toBe(1);
+      expect(cb1).toHaveBeenCalledTimes(2);
+      expect(cb3).toHaveBeenCalledTimes(1);
+    });
+
+    it('Should run fields that were previously omitted when changing to `false`', () => {
+      suite(true, 'field_3');
+      expect(suite.get().tests.field_3.testCount).toBe(0);
+      expect(cb4).toHaveBeenCalledTimes(0);
+      suite(false, 'field_3');
+      expect(suite.get().tests.field_3.testCount).toBe(1);
+      expect(cb4).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('nested calls', () => {
+    let suite: TTestSuite;
+
+    describe('omitted in non-omitted', () => {
+      beforeEach(() => {
+        suite = vest.create(() => {
+          vest.omitWhen(false, () => {
+            vest.test('outer', () => false);
+
+            vest.omitWhen(true, () => {
+              vest.test('inner', () => false);
+            });
+          });
+        });
+        suite();
+      });
+      it('Should run `outer` and omit `inner`', () => {
+        expect(suite.get().testCount).toBe(1);
+        expect(suite.get().hasErrors('outer')).toBe(true);
+        expect(suite.get().hasErrors('inner')).toBe(false);
+      });
+    });
+
+    describe('omitted in omitted', () => {
+      beforeEach(() => {
+        suite = vest.create(() => {
+          vest.omitWhen(true, () => {
+            vest.test('outer', () => false);
+
+            vest.omitWhen(true, () => {
+              vest.test('inner', () => false);
+            });
+          });
+        });
+        suite();
+      });
+      it('Should omit 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-omitted in omitted', () => {
+      beforeEach(() => {
+        suite = vest.create(() => {
+          vest.omitWhen(true, () => {
+            vest.test('outer', () => false);
+
+            vest.omitWhen(false, () => {
+              vest.test('inner', () => false);
+            });
+          });
+        });
+        suite();
+      });
+      it('Should omit both', () => {
+        expect(suite.get().testCount).toBe(0);
+        expect(suite.get().hasErrors('outer')).toBe(false);
+        expect(suite.get().hasErrors('inner')).toBe(false);
+      });
+    });
+  });
+
+  describe('When some tests of the same field are inside omitWhen and some not', () => {
+    it('Should mark the field as invalid when failing', () => {
+      const res = vest.create(() => {
+        vest.test('f1', () => false);
+
+        vest.omitWhen(true, () => {
+          vest.test('f1', () => false);
+        });
+      })();
+      expect(res.isValid()).toBe(false);
+      expect(res.isValid('f1')).toBe(false);
+    });
+  });
+});