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

package/src/hooks/__tests__/eager.test.ts

@@ -0,0 +1,130 @@
+import { dummyTest } from '../../../testUtils/testDummy';
+
+import { TTestSuite } from 'testUtils/TVestMock';
+import { create, eager, only, group } from 'vest';
+
+describe('mode: eager', () => {
+  let suite: TTestSuite;
+
+  describe('When tests fail', () => {
+    beforeEach(() => {
+      suite = create(include => {
+        only(include);
+
+        eager();
+        dummyTest.failing('field_1', 'first-of-field_1');
+        dummyTest.failing('field_1', 'second-of-field_1'); // Should not run
+        dummyTest.failing('field_2', 'first-of-field_2');
+        dummyTest.failing('field_2', 'second-of-field_2'); // Should not run
+        dummyTest.failing('field_3', 'first-of-field_3');
+        dummyTest.failing('field_3', 'second-of-field_3'); // Should not run
+      });
+    });
+
+    it('Should fail fast for every failing field', () => {
+      expect(suite.get().testCount).toBe(0); // sanity
+      suite();
+      expect(suite.get().testCount).toBe(3);
+      expect(suite.get().errorCount).toBe(3);
+      expect(suite.get().getErrors('field_1')).toEqual(['first-of-field_1']);
+      expect(suite.get().getErrors('field_2')).toEqual(['first-of-field_2']);
+      expect(suite.get().getErrors('field_3')).toEqual(['first-of-field_3']);
+    });
+
+    describe('When test is `only`ed', () => {
+      it('Should fail fast for failing field', () => {
+        suite('field_1');
+        expect(suite.get().testCount).toBe(1);
+        expect(suite.get().errorCount).toBe(1);
+        expect(suite.get().getErrors('field_1')).toEqual(['first-of-field_1']);
+      });
+    });
+
+    describe('When test is in a group', () => {
+      beforeEach(() => {
+        suite = create(() => {
+          eager();
+          group('group_1', () => {
+            dummyTest.failing('field_1', 'first-of-field_1');
+          });
+          dummyTest.failing('field_1', 'second-of-field_1');
+        });
+      });
+      it('Should fail fast for failing field', () => {
+        suite();
+        expect(suite.get().testCount).toBe(1);
+        expect(suite.get().errorCount).toBe(1);
+        expect(suite.get().getErrors('field_1')).toEqual(['first-of-field_1']);
+      });
+    });
+  });
+
+  describe('When tests pass', () => {
+    beforeEach(() => {
+      suite = create(() => {
+        eager();
+        dummyTest.passing('field_1', 'first-of-field_1');
+        dummyTest.failing('field_1', 'second-of-field_1');
+        dummyTest.passing('field_2', 'first-of-field_2');
+        dummyTest.failing('field_2', 'second-of-field_2');
+        dummyTest.passing('field_3', 'first-of-field_3');
+        dummyTest.failing('field_3', 'second-of-field_3');
+      });
+    });
+
+    it('Should fail fast for every failing field', () => {
+      expect(suite.get().testCount).toBe(0); // sanity
+      suite();
+      expect(suite.get().testCount).toBe(6);
+      expect(suite.get().errorCount).toBe(3);
+      expect(suite.get().getErrors('field_1')).toEqual(['second-of-field_1']);
+      expect(suite.get().getErrors('field_2')).toEqual(['second-of-field_2']);
+      expect(suite.get().getErrors('field_3')).toEqual(['second-of-field_3']);
+    });
+  });
+
+  describe('sanity', () => {
+    beforeEach(() => {
+      suite = create(() => {
+        dummyTest.failing('field_1', 'first-of-field_1');
+        dummyTest.failing('field_1', 'second-of-field_1');
+        dummyTest.failing('field_2', 'first-of-field_2');
+        dummyTest.failing('field_2', 'second-of-field_2');
+        dummyTest.failing('field_3', 'first-of-field_3');
+        dummyTest.failing('field_3', 'second-of-field_3');
+      });
+    });
+
+    it('Should run all tests', () => {
+      expect(suite.get().testCount).toBe(0); // sanity
+      suite();
+      expect(suite.get().testCount).toBe(6);
+      expect(suite.get().errorCount).toBe(6);
+    });
+  });
+
+  describe('When test used to fail and it now passes', () => {
+    let run = 0;
+    beforeEach(() => {
+      suite = create(() => {
+        dummyTest.passing('field_1');
+
+        if (run === 0) {
+          dummyTest.failing('field_1', 'second-of-field_1');
+        } else {
+          dummyTest.passing('field_1');
+        }
+        run++;
+      });
+    });
+
+    it('Should treat test as passing', () => {
+      suite();
+      expect(suite.get().hasErrors()).toBe(true);
+      expect(suite.get().getErrors('field_1')).toEqual(['second-of-field_1']);
+      suite();
+      expect(suite.get().hasErrors()).toBe(false);
+      expect(suite.get().getErrors('field_1')).toEqual([]);
+    });
+  });
+});

package/src/hooks/__tests__/exclusive.test.ts

@@ -0,0 +1,578 @@
+import { faker } from '@faker-js/faker';
+
+import { dummyTest } from '../../../testUtils/testDummy';
+
+import { ErrorStrings } from 'ErrorStrings';
+import { IsolateTest } from 'IsolateTest';
+import { IsolateTypes } from 'IsolateTypes';
+import { SuiteContext, TExclusion, useExclusion } from 'SuiteContext';
+import { isExcluded, isGroupExcluded, skip, only } from 'exclusive';
+import { group } from 'group';
+import { TTestSuite } from 'testUtils/TVestMock';
+import * as vest from 'vest';
+
+let res: boolean, res1: boolean;
+
+describe('exclusive hooks', () => {
+  let test1: vest.IsolateTest, test2: vest.IsolateTest, test3: vest.IsolateTest;
+
+  beforeEach(() => {
+    test1 = new IsolateTest(IsolateTypes.TEST, {
+      fieldName: faker.lorem.word(),
+      testFn: jest.fn(),
+    });
+    test2 = new IsolateTest(IsolateTypes.TEST, {
+      fieldName: faker.lorem.slug(),
+      testFn: jest.fn(),
+    });
+    test3 = new IsolateTest(IsolateTypes.TEST, {
+      fieldName: faker.random.word(),
+      testFn: jest.fn(),
+    });
+  });
+
+  test('isExcluded should respect group exclusion', () => {
+    let testObject: vest.IsolateTest;
+    let testObject1: vest.IsolateTest;
+
+    const validate = vest.create(() => {
+      vest.skip.group('group_1');
+
+      testObject = dummyTest.failing();
+
+      group('group_1', () => {
+        testObject1 = dummyTest.failing();
+      });
+
+      res = isExcluded(testObject);
+      res1 = isExcluded(testObject1);
+    });
+
+    validate();
+
+    expect(res).toBe(false);
+    expect(res1).toBe(true);
+  });
+
+  describe('`only` hook', () => {
+    describe('string input', () => {
+      test('isExcluded returns false for included field', () => {
+        vest.create(() => {
+          vest.only(test1.fieldName);
+          res = isExcluded(test1);
+        })();
+        expect(res).toBe(false);
+      });
+
+      test('isGroupExcluded returns false for included groups', () => {
+        vest.create(() => {
+          vest.only('group_name');
+
+          group('group_name', () => {
+            res = isGroupExcluded('group_name');
+          });
+        })();
+        expect(res).toBe(false);
+      });
+
+      test('isExcluded returns true for non included field', () => {
+        vest.create(() => {
+          vest.only(test1.fieldName);
+          res1 = isExcluded(test1);
+          res = isExcluded(test2);
+        })();
+        expect(res1).toBe(false);
+        expect(res).toBe(true);
+      });
+
+      test('isGroupExcluded returns true for non included group', () => {
+        vest.create(() => {
+          vest.only.group('group_1');
+
+          group('group_1', jest.fn());
+          group('group_2', jest.fn());
+
+          res1 = isGroupExcluded('group_1');
+          res = isGroupExcluded('group_2');
+        })();
+
+        expect(res1).toBe(false);
+        expect(res).toBe(true);
+      });
+    });
+
+    describe('array input', () => {
+      test('isExcluded returns false for included field', () => {
+        vest.create(() => {
+          vest.only([test1.fieldName, test2.fieldName]);
+          res = isExcluded(test1);
+          res1 = isExcluded(test2);
+        })();
+        expect(res).toBe(false);
+        expect(res1).toBe(false);
+      });
+
+      test('isGroupExcluded returns false for included groups', () => {
+        const results: boolean[] = [];
+        vest.create(() => {
+          vest.only.group(['group_1', 'group_2']);
+
+          group('group_1', jest.fn());
+          group('group_2', jest.fn());
+          group('group_3', jest.fn());
+
+          results.push(
+            isGroupExcluded('group_1'),
+            isGroupExcluded('group_2'),
+            isGroupExcluded('group_3')
+          );
+        })();
+        expect(results).toEqual([false, false, true]);
+      });
+
+      test('isExcluded returns true for non included field', () => {
+        const results: boolean[] = [];
+        const results1: boolean[] = [];
+        vest.create(() => {
+          results.push(isExcluded(test1), isExcluded(test2), isExcluded(test3));
+          vest.only([test1.fieldName, test2.fieldName]);
+          results1.push(
+            isExcluded(test1),
+            isExcluded(test2),
+            isExcluded(test3)
+          );
+        })();
+        expect(results).toEqual([false, false, false]);
+        expect(results1).toEqual([false, false, true]);
+      });
+
+      test('isGroupExcluded returns true for non included groups', () => {
+        const results: boolean[] = [];
+        vest.create(() => {
+          vest.only.group(['group_1', 'group_2']);
+
+          group('group_3', jest.fn());
+          results.push(
+            isGroupExcluded('group_1'),
+            isGroupExcluded('group_2'),
+            isGroupExcluded('group_3')
+          );
+        })();
+        expect(results).toEqual([false, false, true]);
+      });
+    });
+  });
+
+  describe('`skip` hook', () => {
+    describe('string input', () => {
+      test('isExcluded returns true for excluded field', () => {
+        vest.create(() => {
+          vest.skip(test1.fieldName);
+          res = isExcluded(test1);
+        })();
+        expect(res).toBe(true);
+      });
+
+      test('isGroupExcluded returns true for excluded groups', () => {
+        vest.create(() => {
+          vest.skip.group('group_1');
+          res = isGroupExcluded('group_1');
+          res1 = isGroupExcluded('group_2');
+        })();
+
+        expect(res).toBe(true);
+        expect(res1).toBe(false);
+      });
+
+      test('isExcluded returns false for non excluded field', () => {
+        vest.create(() => {
+          vest.skip(test1.fieldName);
+          res = isExcluded(vest.test(test2.fieldName, jest.fn()));
+        })();
+        expect(res).toBe(false);
+      });
+    });
+
+    test('isGroupExcluded returns false for tests in non excluded groups', () => {
+      vest.create(() => {
+        vest.skip('group_1');
+        res = isExcluded(vest.test('field_1', jest.fn()));
+      })();
+      expect(res).toBe(false);
+    });
+
+    describe('array input', () => {
+      test('isExcluded returns true for excluded field', () => {
+        vest.create(() => {
+          vest.skip([test1.fieldName, test2.fieldName]);
+
+          res = isExcluded(test1);
+          res1 = isExcluded(test2);
+        })();
+        expect(res).toBe(true);
+        expect(res1).toBe(true);
+      });
+
+      test('isGroupExcluded returns true for excluded groups', () => {
+        const results: boolean[] = [];
+        vest.create(() => {
+          vest.skip.group(['group_1', 'group_2']);
+          results.push(isGroupExcluded('group_1'), isGroupExcluded('group_2'));
+        })();
+        expect(results).toEqual([true, true]);
+      });
+
+      test('isExcluded returns false for non included field', () => {
+        vest.create(() => {
+          vest.skip([test1.fieldName, test2.fieldName]);
+          res = isExcluded(test3);
+        })();
+        expect(res).toBe(false);
+      });
+
+      test('isGroupExcluded returns false for non excluded groups', () => {
+        vest.create(() => {
+          vest.skip(['group_1', 'group_2']);
+          res = isGroupExcluded('group_3');
+        })();
+        expect(res).toBe(false);
+      });
+    });
+
+    describe('Field is in a non included group', () => {
+      let suite: TTestSuite;
+
+      beforeEach(() => {
+        suite = vest.create(() => {
+          vest.only.group('group_1');
+
+          vest.group('group_1', () => {
+            vest.test('field_1', jest.fn());
+          });
+          vest.group('group_2', () => {
+            vest.test('field_2', jest.fn());
+          });
+        });
+        suite();
+      });
+
+      it('Should exclude test', () => {
+        expect(suite.get().tests.field_2.testCount).toBe(0);
+      });
+    });
+  });
+
+  describe('Error handling', () => {
+    describe('When called outside of a suite', () => {
+      it('Should throw an error', () => {
+        expect(() => only(faker.random.word())).toThrow(
+          ErrorStrings.HOOK_CALLED_OUTSIDE
+        );
+        expect(() => skip(faker.random.word())).toThrow(
+          ErrorStrings.HOOK_CALLED_OUTSIDE
+        );
+      });
+    });
+  });
+});
+
+describe('isExcluded', () => {
+  let exclusion: Partial<TExclusion>;
+
+  const runIsExcluded = (
+    exclusion: Partial<TExclusion>,
+    testObject: IsolateTest
+  ) =>
+    SuiteContext.run({}, () => {
+      Object.assign(useExclusion(), exclusion);
+      const res = isExcluded(testObject);
+
+      return res;
+    });
+
+  const genTest = (fieldName: string, groupName?: string) =>
+    new IsolateTest(IsolateTypes.TEST, {
+      fieldName,
+      testFn: jest.fn(),
+      groupName,
+    });
+  describe('skip', () => {
+    beforeEach(() => {
+      exclusion = { tests: { field_1: false, field_2: false } };
+    });
+    it('returns true for skipped field', () => {
+      expect(runIsExcluded(exclusion, genTest('field_1'))).toBe(true);
+      expect(runIsExcluded(exclusion, genTest('field_2', 'group_1'))).toBe(
+        true
+      );
+    });
+    it('returns false for non skipped field', () => {
+      expect(runIsExcluded(exclusion, genTest('field_3'))).toBe(false);
+      expect(runIsExcluded(exclusion, genTest('field_4', 'group_1'))).toBe(
+        false
+      );
+    });
+  });
+  describe('only', () => {
+    beforeEach(() => {
+      exclusion = { tests: { field_1: true, field_2: true } };
+    });
+    it('returns false for included field', () => {
+      expect(runIsExcluded(exclusion, genTest('field_1'))).toBe(false);
+      expect(runIsExcluded(exclusion, genTest('field_2', 'group_1'))).toBe(
+        false
+      );
+    });
+    it('returns true for non included field', () => {
+      expect(runIsExcluded(exclusion, genTest('field_3'))).toBe(true);
+      expect(runIsExcluded(exclusion, genTest('field_4', 'group_1'))).toBe(
+        true
+      );
+    });
+  });
+  describe('only+skip', () => {
+    beforeEach(() => {
+      exclusion = {
+        tests: { field_1: true, field_2: true, field_3: false, field_4: false },
+      };
+    });
+    it('returns false for included tests', () => {
+      expect(runIsExcluded(exclusion, genTest('field_1'))).toBe(false);
+      expect(runIsExcluded(exclusion, genTest('field_2', 'group_1'))).toBe(
+        false
+      );
+    });
+    it('returns true excluded tests', () => {
+      expect(runIsExcluded(exclusion, genTest('field_3'))).toBe(true);
+      expect(runIsExcluded(exclusion, genTest('field_4', 'group_1'))).toBe(
+        true
+      );
+    });
+    it('returns true for non included field', () => {
+      expect(runIsExcluded(exclusion, genTest('field_5'))).toBe(true);
+      expect(runIsExcluded(exclusion, genTest('field_6', 'group_1'))).toBe(
+        true
+      );
+    });
+  });
+  describe('skip.group', () => {
+    beforeEach(() => {
+      exclusion = {
+        groups: {
+          group_1: false,
+          group_2: false,
+        },
+      };
+    });
+
+    it('Returns true for tests in skipped group', () => {
+      expect(runIsExcluded(exclusion, genTest('field_1', 'group_1'))).toBe(
+        true
+      );
+      expect(runIsExcluded(exclusion, genTest('field_2', 'group_2'))).toBe(
+        true
+      );
+    });
+    it('Returns false for tests in non skipped groups', () => {
+      expect(runIsExcluded(exclusion, genTest('field_3', 'group_3'))).toBe(
+        false
+      );
+      expect(runIsExcluded(exclusion, genTest('field_4', 'group_4'))).toBe(
+        false
+      );
+    });
+    it('Returns false for tests outside of any group', () => {
+      expect(runIsExcluded(exclusion, genTest('field_3'))).toBe(false);
+      expect(runIsExcluded(exclusion, genTest('field_4'))).toBe(false);
+    });
+  });
+  describe('only.group', () => {
+    beforeEach(() => {
+      exclusion = {
+        groups: {
+          group_1: true,
+          group_2: true,
+        },
+      };
+    });
+
+    it('returns false for tests in included groups', () => {
+      expect(runIsExcluded(exclusion, genTest('field_1', 'group_1'))).toBe(
+        false
+      );
+      expect(runIsExcluded(exclusion, genTest('field_1', 'group_2'))).toBe(
+        false
+      );
+    });
+
+    it('returns true for groups in non included groups', () => {
+      expect(runIsExcluded(exclusion, genTest('field_1', 'group_3'))).toBe(
+        true
+      );
+      expect(runIsExcluded(exclusion, genTest('field_2', 'group_4'))).toBe(
+        true
+      );
+    });
+
+    it('returns true for tests outside of any group', () => {
+      expect(runIsExcluded(exclusion, genTest('field_1'))).toBe(true);
+      expect(runIsExcluded(exclusion, genTest('field_2'))).toBe(true);
+    });
+  });
+
+  describe('only.group + only', () => {
+    beforeEach(() => {
+      exclusion = {
+        groups: {
+          group_1: true,
+          group_2: true,
+        },
+        tests: { field_1: true, field_2: true },
+      };
+    });
+
+    it('returns true for included tests outside of the group', () => {
+      expect(runIsExcluded(exclusion, genTest('field_1'))).toBe(true);
+      expect(runIsExcluded(exclusion, genTest('field_2'))).toBe(true);
+    });
+
+    it('returns false for included tests in included groups', () => {
+      expect(runIsExcluded(exclusion, genTest('field_1', 'group_1'))).toBe(
+        false
+      );
+      expect(runIsExcluded(exclusion, genTest('field_2', 'group_2'))).toBe(
+        false
+      );
+    });
+
+    it('returns true for included test in non included group', () => {
+      expect(runIsExcluded(exclusion, genTest('field_1', 'group_3'))).toBe(
+        true
+      );
+      expect(runIsExcluded(exclusion, genTest('field_2', 'group_4'))).toBe(
+        true
+      );
+    });
+
+    it('returns true for non included test in included group', () => {
+      expect(runIsExcluded(exclusion, genTest('field_3', 'group_1'))).toBe(
+        true
+      );
+      expect(runIsExcluded(exclusion, genTest('field_4', 'group_2'))).toBe(
+        true
+      );
+    });
+
+    it('returns true for non included tests', () => {
+      expect(runIsExcluded(exclusion, genTest('field_3'))).toBe(true);
+      expect(runIsExcluded(exclusion, genTest('field_4'))).toBe(true);
+    });
+  });
+
+  describe('skip.group + only', () => {
+    beforeEach(() => {
+      exclusion = {
+        groups: {
+          group_1: false,
+          group_2: false,
+        },
+        tests: { field_1: true, field_2: true },
+      };
+    });
+
+    it('returns true for included tests in excluded groups', () => {
+      expect(runIsExcluded(exclusion, genTest('field_1', 'group_1'))).toBe(
+        true
+      );
+      expect(runIsExcluded(exclusion, genTest('field_2', 'group_1'))).toBe(
+        true
+      );
+      expect(runIsExcluded(exclusion, genTest('field_3', 'group_1'))).toBe(
+        true
+      );
+      expect(runIsExcluded(exclusion, genTest('field_1', 'group_2'))).toBe(
+        true
+      );
+      expect(runIsExcluded(exclusion, genTest('field_2', 'group_2'))).toBe(
+        true
+      );
+      expect(runIsExcluded(exclusion, genTest('field_3', 'group_2'))).toBe(
+        true
+      );
+    });
+
+    it('returns false for included tests in non excluded groups', () => {
+      expect(runIsExcluded(exclusion, genTest('field_1', 'group_3'))).toBe(
+        false
+      );
+      expect(runIsExcluded(exclusion, genTest('field_2', 'group_3'))).toBe(
+        false
+      );
+      expect(runIsExcluded(exclusion, genTest('field_1', 'group_4'))).toBe(
+        false
+      );
+      expect(runIsExcluded(exclusion, genTest('field_2', 'group_4'))).toBe(
+        false
+      );
+    });
+
+    it('returns true for non included tests', () => {
+      expect(runIsExcluded(exclusion, genTest('field_3'))).toBe(true);
+      expect(runIsExcluded(exclusion, genTest('field_4'))).toBe(true);
+    });
+
+    it('returns false for included tests outside of the group', () => {
+      expect(runIsExcluded(exclusion, genTest('field_1'))).toBe(false);
+      expect(runIsExcluded(exclusion, genTest('field_2'))).toBe(false);
+    });
+  });
+
+  describe('only.group + skip', () => {
+    beforeEach(() => {
+      exclusion = {
+        groups: {
+          group_1: true,
+          group_2: true,
+        },
+        tests: { field_1: false, field_2: false },
+      };
+    });
+
+    it('returns true for excluded tests', () => {
+      expect(runIsExcluded(exclusion, genTest('field_1'))).toBe(true);
+      expect(runIsExcluded(exclusion, genTest('field_2'))).toBe(true);
+    });
+    it('returns true for excluded test in included group', () => {
+      expect(runIsExcluded(exclusion, genTest('field_1', 'group_1'))).toBe(
+        true
+      );
+      expect(runIsExcluded(exclusion, genTest('field_2', 'group_2'))).toBe(
+        true
+      );
+    });
+    it('returns true for excluded test in non included group', () => {
+      expect(runIsExcluded(exclusion, genTest('field_1', 'group_3'))).toBe(
+        true
+      );
+      expect(runIsExcluded(exclusion, genTest('field_2', 'group_4'))).toBe(
+        true
+      );
+    });
+    it('returns false for non excluded test in included group', () => {
+      expect(runIsExcluded(exclusion, genTest('field_3', 'group_1'))).toBe(
+        false
+      );
+      expect(runIsExcluded(exclusion, genTest('field_4', 'group_2'))).toBe(
+        false
+      );
+    });
+    it('returns true for non excluded test in non included group', () => {
+      expect(runIsExcluded(exclusion, genTest('field_3', 'group_3'))).toBe(
+        true
+      );
+      expect(runIsExcluded(exclusion, genTest('field_4', 'group_4'))).toBe(
+        true
+      );
+    });
+  });
+});