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

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

@@ -0,0 +1,431 @@
+import * as vest from 'vest';
+
+describe('include', () => {
+  let cb1 = jest.fn(),
+    cb2 = jest.fn();
+
+  beforeEach(() => {
+    cb1 = jest.fn(() => false);
+    cb2 = jest.fn(() => false);
+  });
+
+  describe('When not passing a string fieldName', () => {
+    it('Should throw an error', () => {
+      // @ts-ignore
+      expect(() => vest.include({})).toThrow();
+      // @ts-ignore
+      expect(() => vest.include(undefined)).toThrow();
+    });
+  });
+
+  describe('There is an `onlyd` field', () => {
+    describe('`include` is run as-is without modifiers', () => {
+      it('Should run the included test along with the onlyd test', () => {
+        const suite = vest.create(() => {
+          vest.only('field_1');
+          vest.include('field_2');
+
+          vest.test('field_1', () => false);
+          vest.test('field_2', () => false);
+        });
+
+        const res = suite();
+        expect(res.hasErrors('field_1')).toBe(true);
+        expect(res.tests.field_1.testCount).toBe(1);
+        expect(res.hasErrors('field_2')).toBe(true);
+        expect(res.tests.field_2.testCount).toBe(1);
+        expect(res).toMatchSnapshot();
+      });
+    });
+
+    describe('include().when()', () => {
+      describe('`when` param is a string', () => {
+        describe('`when` param is a name of an onlyd field', () => {
+          it('Should run included field along with the onlyd field', () => {
+            const suite = vest.create(() => {
+              vest.only('field_1');
+              vest.include('field_2').when('field_1');
+
+              vest.test('field_1', () => false);
+              vest.test('field_2', () => false);
+              vest.test('field_3', () => false);
+            });
+
+            const res = suite();
+            expect(res.hasErrors('field_1')).toBe(true);
+            expect(res.tests.field_1.testCount).toBe(1);
+            expect(res.hasErrors('field_2')).toBe(true);
+            expect(res.tests.field_2.testCount).toBe(1);
+            expect(res.hasErrors('field_3')).toBe(false);
+            expect(res.tests.field_3.testCount).toBe(0);
+            expect(res).toMatchSnapshot();
+          });
+        });
+        describe('`when` param is a name of a non-included field', () => {
+          it('Should avoid running the included field', () => {
+            const suite = vest.create(() => {
+              vest.only('field_1');
+              vest.include('field_2').when('field_3');
+
+              vest.test('field_1', () => false);
+              vest.test('field_2', () => false);
+              vest.test('field_3', () => false);
+            });
+
+            const res = suite();
+            expect(res.hasErrors('field_1')).toBe(true);
+            expect(res.tests.field_1.testCount).toBe(1);
+            expect(res.hasErrors('field_2')).toBe(false);
+            expect(res.tests.field_2.testCount).toBe(0);
+            expect(res.hasErrors('field_3')).toBe(false);
+            expect(res.tests.field_3.testCount).toBe(0);
+            expect(res).toMatchSnapshot();
+          });
+        });
+        describe('`when` param is a name of a skipped field', () => {
+          it('Should avoid running the included field', () => {
+            const suite = vest.create(() => {
+              vest.only('field_1');
+              vest.skip('field_3');
+              vest.include('field_2').when('field_3');
+
+              vest.test('field_1', () => false);
+              vest.test('field_2', () => false);
+              vest.test('field_3', () => false);
+            });
+
+            const res = suite();
+            expect(res.hasErrors('field_1')).toBe(true);
+            expect(res.tests.field_1.testCount).toBe(1);
+            expect(res.hasErrors('field_2')).toBe(false);
+            expect(res.tests.field_2.testCount).toBe(0);
+            expect(res.hasErrors('field_3')).toBe(false);
+            expect(res.tests.field_3.testCount).toBe(0);
+            expect(res).toMatchSnapshot();
+          });
+        });
+      });
+      describe('`when` param is a boolean', () => {
+        describe('when `true`', () => {
+          it('Should run included field', () => {
+            const suite = vest.create(() => {
+              vest.only('field_1');
+              vest.include('field_2').when(true);
+
+              vest.test('field_1', () => false);
+              vest.test('field_2', () => false);
+              vest.test('field_3', () => false);
+            });
+
+            const res = suite();
+            expect(res.hasErrors('field_1')).toBe(true);
+            expect(res.tests.field_1.testCount).toBe(1);
+            expect(res.hasErrors('field_2')).toBe(true);
+            expect(res.tests.field_2.testCount).toBe(1);
+            expect(res.hasErrors('field_3')).toBe(false);
+            expect(res.tests.field_3.testCount).toBe(0);
+            expect(res).toMatchSnapshot();
+          });
+        });
+        describe('when `false`', () => {
+          it('Should skip run included field', () => {
+            const suite = vest.create(() => {
+              vest.only('field_1');
+              vest.include('field_2').when(false);
+
+              vest.test('field_1', () => false);
+              vest.test('field_2', () => false);
+              vest.test('field_3', () => false);
+            });
+
+            const res = suite();
+            expect(res.hasErrors('field_1')).toBe(true);
+            expect(res.tests.field_1.testCount).toBe(1);
+            expect(res.hasErrors('field_2')).toBe(false);
+            expect(res.tests.field_2.testCount).toBe(0);
+            expect(res.hasErrors('field_3')).toBe(false);
+            expect(res.tests.field_3.testCount).toBe(0);
+            expect(res).toMatchSnapshot();
+          });
+        });
+      });
+      describe('`when` param is a function', () => {
+        describe('when returning `true`', () => {
+          it('Should run included field', () => {
+            const suite = vest.create(() => {
+              vest.only('field_1');
+              vest.include('field_2').when(() => true);
+
+              vest.test('field_1', () => false);
+              vest.test('field_2', () => false);
+              vest.test('field_3', () => false);
+            });
+
+            const res = suite();
+            expect(res.hasErrors('field_1')).toBe(true);
+            expect(res.tests.field_1.testCount).toBe(1);
+            expect(res.hasErrors('field_2')).toBe(true);
+            expect(res.tests.field_2.testCount).toBe(1);
+            expect(res.hasErrors('field_3')).toBe(false);
+            expect(res.tests.field_3.testCount).toBe(0);
+            expect(res).toMatchSnapshot();
+          });
+        });
+        describe('when  returning`false`', () => {
+          it('Should skip run included field', () => {
+            const suite = vest.create(() => {
+              vest.only('field_1');
+              vest.include('field_2').when(() => false);
+
+              vest.test('field_1', () => false);
+              vest.test('field_2', () => false);
+              vest.test('field_3', () => false);
+            });
+
+            const res = suite();
+            expect(res.hasErrors('field_1')).toBe(true);
+            expect(res.tests.field_1.testCount).toBe(1);
+            expect(res.hasErrors('field_2')).toBe(false);
+            expect(res.tests.field_2.testCount).toBe(0);
+            expect(res.hasErrors('field_3')).toBe(false);
+            expect(res.tests.field_3.testCount).toBe(0);
+            expect(res).toMatchSnapshot();
+          });
+        });
+
+        describe('Callback evaluation', () => {
+          it('Should run the callback for each matching test', () => {
+            const cb = jest.fn(() => true);
+            const suite = vest.create(() => {
+              vest.only('field_1');
+              vest.include('field_2').when(cb);
+
+              vest.test('field_1', () => false);
+              expect(cb).toHaveBeenCalledTimes(0);
+              vest.test('field_2', () => false);
+              expect(cb).toHaveBeenCalledTimes(1);
+              vest.test('field_3', () => false);
+              expect(cb).toHaveBeenCalledTimes(1);
+              vest.test('field_2', () => false);
+              expect(cb).toHaveBeenCalledTimes(2);
+            });
+
+            suite();
+            expect(cb).toHaveBeenCalledTimes(2);
+          });
+          it('Should evaluate per test run', () => {
+            const cb1 = jest.fn(() => false);
+            const cb2 = jest.fn(() => false);
+            const cb3 = jest.fn(() => false);
+            const cb4 = jest.fn(() => false);
+
+            const suite = vest.create(() => {
+              let shouldRun = false;
+              vest.only('x');
+              vest.include('field_1').when(() => shouldRun);
+
+              vest.test('field_1', cb1);
+              shouldRun = true;
+              vest.test('field_1', cb2);
+              shouldRun = false;
+              vest.test('field_1', cb3);
+              shouldRun = true;
+              vest.test('field_1', cb4);
+            });
+
+            const res = suite();
+            expect(cb1).toHaveBeenCalledTimes(0);
+            expect(cb2).toHaveBeenCalledTimes(1);
+            expect(cb3).toHaveBeenCalledTimes(0);
+            expect(cb4).toHaveBeenCalledTimes(1);
+            expect(res.hasErrors('field_1')).toBe(true);
+            expect(res.tests.field_1.testCount).toBe(2);
+            expect(res).toMatchSnapshot();
+          });
+        });
+      });
+    });
+  });
+
+  describe('Field is excluded via `skip`', () => {
+    it('Should disregard `include` and avoid running the test', () => {
+      const suite = vest.create(() => {
+        vest.skip('field_1');
+        vest.include('field_1');
+
+        vest.test('field_1', () => false);
+        vest.test('field_2', () => false);
+      });
+
+      const res = suite();
+      expect(res.hasErrors('field_1')).toBe(false);
+      expect(res.tests.field_1.testCount).toBe(0);
+      expect(res.hasErrors('field_2')).toBe(true);
+      expect(res.tests.field_2.testCount).toBe(1);
+      expect(res).toMatchSnapshot();
+    });
+    it('Should disregard `include.when` and avoid running the test', () => {
+      const suite = vest.create(() => {
+        vest.skip('field_1');
+        vest.include('field_1').when(true);
+
+        vest.test('field_1', () => false);
+        vest.test('field_2', () => false);
+      });
+
+      const res = suite();
+      expect(res.hasErrors('field_1')).toBe(false);
+      expect(res.tests.field_1.testCount).toBe(0);
+      expect(res.hasErrors('field_2')).toBe(true);
+      expect(res.tests.field_2.testCount).toBe(1);
+      expect(res).toMatchSnapshot();
+    });
+  });
+
+  describe('Field is included via `only`', () => {
+    it('Should disregard `when` condition and test the field anyway', () => {
+      const suite = vest.create(() => {
+        vest.only('field_1');
+        vest.include('field_1').when(false);
+
+        vest.test('field_1', () => false);
+      });
+
+      const res = suite();
+      expect(res.hasErrors('field_1')).toBe(true);
+      expect(res.tests.field_1.testCount).toBe(1);
+    });
+  });
+  describe('Test is excluded by being out of an included group', () => {
+    it('Should disregard `include` and avoid running the test', () => {
+      const suite = vest.create(() => {
+        vest.only.group('g1');
+        vest.include('field_1');
+        vest.group('g1', () => {});
+
+        vest.test('field_1', () => false);
+        vest.group('g2', () => {
+          vest.test('field_1', () => false);
+        });
+      });
+
+      const res = suite();
+      expect(res.hasErrors('field_1')).toBe(false);
+      expect(res.tests.field_1.testCount).toBe(0);
+      expect(res).toMatchSnapshot();
+    });
+  });
+  describe('Test is excluded via `skip.group`', () => {
+    it('Should disregard `include` and avoid running the test', () => {
+      const suite = vest.create(() => {
+        vest.skip.group('g1');
+        vest.include('field_1');
+
+        vest.group('g1', () => {
+          vest.test('field_1', cb1);
+          vest.test('field_2', () => false);
+        });
+        vest.test('field_1', cb2);
+      });
+
+      const res = suite();
+      expect(res.hasErrors('field_1')).toBe(true);
+      expect(res.tests.field_1.testCount).toBe(1);
+      expect(cb1).toHaveBeenCalledTimes(0);
+      expect(cb2).toHaveBeenCalledTimes(1);
+      expect(res.hasErrors('field_2')).toBe(false);
+      expect(res.tests.field_2.testCount).toBe(0);
+      expect(res).toMatchSnapshot();
+    });
+    it('Should disregard `include.when` and avoid running the test', () => {
+      const suite = vest.create(() => {
+        vest.skip.group('g1');
+        vest.include('field_1').when(true);
+
+        vest.group('g1', () => {
+          vest.test('field_1', cb1);
+          vest.test('field_2', () => false);
+        });
+        vest.test('field_1', cb2);
+      });
+
+      const res = suite();
+      expect(res.hasErrors('field_1')).toBe(true);
+      expect(res.tests.field_1.testCount).toBe(1);
+      expect(cb1).toHaveBeenCalledTimes(0);
+      expect(cb2).toHaveBeenCalledTimes(1);
+      expect(res.hasErrors('field_2')).toBe(false);
+      expect(res.tests.field_2.testCount).toBe(0);
+      expect(res).toMatchSnapshot();
+    });
+  });
+  describe('Test is excluded via `skipWhen`', () => {
+    it('Should disregard `include` and avoid running the matching tests', () => {
+      const suite = vest.create(() => {
+        vest.include('field_1');
+
+        vest.skipWhen(true, () => {
+          vest.test('field_1', cb1);
+        });
+        vest.test('field_1', cb2);
+      });
+
+      const res = suite();
+      expect(res.hasErrors('field_1')).toBe(true);
+      expect(res.tests.field_1.testCount).toBe(1);
+      expect(cb1).not.toHaveBeenCalled();
+      expect(cb2).toHaveBeenCalled();
+      expect(res).toMatchSnapshot();
+    });
+    it('Should disregard `include.when` and avoid running the matching tests', () => {
+      const suite = vest.create(() => {
+        vest.include('field_1').when(true);
+
+        vest.skipWhen(true, () => {
+          vest.test('field_1', cb1);
+        });
+        vest.test('field_1', cb2);
+      });
+
+      const res = suite();
+      expect(res.hasErrors('field_1')).toBe(true);
+      expect(res.tests.field_1.testCount).toBe(1);
+      expect(cb1).not.toHaveBeenCalled();
+      expect(cb2).toHaveBeenCalled();
+      expect(res).toMatchSnapshot();
+    });
+  });
+  describe('When no `skip` or `only`', () => {
+    test('include has no effect', () => {
+      const suite = vest.create(() => {
+        vest.include('field_1');
+
+        vest.test('field_1', () => false);
+        vest.test('field_2', () => false);
+      });
+      const res = suite();
+
+      expect(res.hasErrors('field_1')).toBe(true);
+      expect(res.tests.field_1.testCount).toBe(1);
+      expect(res.hasErrors('field_2')).toBe(true);
+      expect(res.tests.field_2.testCount).toBe(1);
+      expect(res).toMatchSnapshot();
+    });
+
+    test('include().when has no effect', () => {
+      const suite = vest.create(() => {
+        vest.include('field_1').when(false);
+
+        vest.test('field_1', () => false);
+        vest.test('field_2', () => false);
+      });
+      const res = suite();
+
+      expect(res.hasErrors('field_1')).toBe(true);
+      expect(res.tests.field_1.testCount).toBe(1);
+      expect(res.hasErrors('field_2')).toBe(true);
+      expect(res.tests.field_2.testCount).toBe(1);
+      expect(res).toMatchSnapshot();
+    });
+  });
+});

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

@@ -0,0 +1,83 @@
+import { optional, create, test } from 'vest';
+
+describe('optional hook', () => {
+  describe('Functional Optional Interface', () => {
+    it('Should omit test failures based on optional functions', () => {
+      const suite = create(() => {
+        optional({
+          f1: () => true,
+          f2: () => true,
+        });
+
+        test('f1', () => false);
+        test('f2', () => false);
+      });
+
+      const res = suite();
+
+      expect(res.hasErrors('f1')).toBe(false);
+      expect(res.hasErrors('f2')).toBe(false);
+      expect(res.isValid('f1')).toBe(true);
+      expect(res.isValid('f2')).toBe(true);
+      expect(res.isValid()).toBe(true);
+    });
+
+    describe('example: "any of" test', () => {
+      it('Should allow specifying custom optional based on other tests in the suite', () => {
+        const suite = create(() => {
+          optional({
+            f1: () => !suite.get().hasErrors('f2'),
+            f2: () => !suite.get().hasErrors('f1'),
+          });
+
+          test('f1', () => false);
+          test('f2', () => true);
+        });
+
+        const res = suite();
+
+        expect(res.hasErrors('f1')).toBe(false);
+        expect(res.hasErrors('f2')).toBe(false);
+        expect(res.isValid('f1')).toBe(true);
+        expect(res.isValid('f2')).toBe(true);
+        expect(res.isValid()).toBe(true);
+      });
+    });
+  });
+
+  describe('boolean optional field indicator', () => {
+    describe('When true', () => {
+      it('Should omit field as optional', () => {
+        const suite = create(() => {
+          optional({
+            field_1: true,
+          });
+          test('field_1', () => false);
+        });
+
+        const res = suite();
+
+        expect(res.hasErrors('field_1')).toBe(false);
+        expect(res.isValid('field_1')).toBe(true);
+        expect(res.isValid()).toBe(true);
+      });
+    });
+
+    describe('When false', () => {
+      it('Should fail the field normally', () => {
+        const suite = create(() => {
+          optional({
+            field_1: false,
+          });
+          test('field_1', () => false);
+        });
+
+        const res = suite();
+
+        expect(res.hasErrors('field_1')).toBe(true);
+        expect(res.isValid('field_1')).toBe(false);
+        expect(res.isValid()).toBe(false);
+      });
+    });
+  });
+});

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

@@ -0,0 +1,42 @@
+import { faker } from '@faker-js/faker';
+
+import { ErrorStrings } from 'ErrorStrings';
+import * as vest from 'vest';
+
+const { create, test, warn } = vest;
+
+function asVestTest(t: unknown): vest.IsolateTest {
+  return t as vest.IsolateTest;
+}
+
+describe('warn hook', () => {
+  describe('When currentTest exists', () => {
+    it('Should set warns to true', () => {
+      let t;
+      create(() => {
+        t = test(faker.lorem.word(), faker.lorem.sentence(), () => {
+          warn();
+        });
+      })();
+
+      expect(asVestTest(t).warns()).toBe(true);
+    });
+  });
+
+  describe('Error handling', () => {
+    it('Should throw error when currentTest is not present', () => {
+      const done = jest.fn();
+      create(() => {
+        expect(warn).toThrow(
+          "warn hook called outside of a test callback. It won't have an effect."
+        );
+        done();
+      })();
+      expect(done).toHaveBeenCalled();
+    });
+
+    it('Should throw error when no suite present', () => {
+      expect(warn).toThrow(ErrorStrings.HOOK_CALLED_OUTSIDE);
+    });
+  });
+});