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

package/src/suiteResult/selectors/__tests__/hasFailures.test.ts

@@ -0,0 +1,141 @@
+import { faker } from '@faker-js/faker';
+
+import { dummyTest } from '../../../../testUtils/testDummy';
+
+import * as vest from 'vest';
+
+describe('produce method: hasFailures', () => {
+  const fieldName = faker.random.word();
+
+  describe(`hasErrors`, () => {
+    describe('When no test objects', () => {
+      it('should return false', () => {
+        const suite = vest.create(() => {});
+        const res = suite();
+        expect(res.hasErrors(fieldName)).toBe(false);
+        expect(suite.get().hasErrors(fieldName)).toBe(false);
+        expect(res.hasErrors()).toBe(false);
+        expect(suite.get().hasErrors()).toBe(false);
+      });
+    });
+
+    describe('When no failing test objects', () => {
+      it('should return false', () => {
+        const suite = vest.create(() => {
+          dummyTest.passing(fieldName);
+          dummyTest.passing('field_1');
+          dummyTest.passing('field_2');
+        });
+        const res = suite();
+        expect(res.hasErrors(fieldName)).toBe(false);
+        expect(suite.get().hasErrors(fieldName)).toBe(false);
+        expect(res.hasErrors()).toBe(false);
+        expect(suite.get().hasErrors()).toBe(false);
+      });
+    });
+
+    describe('When failed fields are warning', () => {
+      it('should return false', () => {
+        const suite = vest.create(() => {
+          dummyTest.failingWarning();
+          dummyTest.passing(fieldName);
+        });
+        const res = suite();
+        expect(res.hasErrors(fieldName)).toBe(false);
+        expect(suite.get().hasErrors(fieldName)).toBe(false);
+        expect(res.hasErrors()).toBe(false);
+        expect(suite.get().hasErrors()).toBe(false);
+      });
+    });
+
+    describe('When field has an error', () => {
+      it('Should return true when some of the tests of the field are erroring', () => {
+        const suite = vest.create(() => {
+          dummyTest.passing();
+          dummyTest.failing(fieldName);
+        });
+        const res = suite();
+        expect(res.hasErrors(fieldName)).toBe(true);
+        expect(suite.get().hasErrors(fieldName)).toBe(true);
+        expect(res.hasErrors()).toBe(true);
+        expect(suite.get().hasErrors()).toBe(true);
+      });
+
+      it('should return true', () => {
+        const suite = vest.create(() => {
+          dummyTest.failing(fieldName);
+        });
+        const res = suite();
+        expect(res.hasErrors(fieldName)).toBe(true);
+        expect(suite.get().hasErrors(fieldName)).toBe(true);
+        expect(res.hasErrors()).toBe(true);
+        expect(suite.get().hasErrors()).toBe(true);
+      });
+    });
+  });
+
+  describe(`hasWarnings`, () => {
+    describe('When no test objects', () => {
+      it('should return false', () => {
+        const suite = vest.create(() => {});
+        const res = suite();
+        expect(res.hasWarnings(fieldName)).toBe(false);
+        expect(suite.get().hasWarnings(fieldName)).toBe(false);
+        expect(res.hasWarnings()).toBe(false);
+        expect(suite.get().hasWarnings()).toBe(false);
+      });
+    });
+
+    describe('When no failing test objects', () => {
+      it('should return false', () => {
+        const suite = vest.create(() => {
+          dummyTest.passingWarning(fieldName);
+          dummyTest.passing('field_1');
+        });
+        const res = suite();
+        expect(res.hasWarnings(fieldName)).toBe(false);
+        expect(suite.get().hasWarnings(fieldName)).toBe(false);
+        expect(res.hasWarnings()).toBe(false);
+        expect(suite.get().hasWarnings()).toBe(false);
+      });
+    });
+
+    describe('When failed fields is not warning', () => {
+      it('should return false', () => {
+        const suite = vest.create(() => {
+          dummyTest.failing(fieldName);
+        });
+        const res = suite();
+        expect(res.hasWarnings(fieldName)).toBe(false);
+        expect(suite.get().hasWarnings(fieldName)).toBe(false);
+        expect(res.hasWarnings()).toBe(false);
+        expect(suite.get().hasWarnings()).toBe(false);
+      });
+    });
+
+    describe('When field is warning', () => {
+      it('Should return true when some of the tests of the field are warning', () => {
+        const suite = vest.create(() => {
+          dummyTest.passingWarning();
+          dummyTest.failingWarning(fieldName);
+        });
+        const res = suite();
+        expect(res.hasWarnings(fieldName)).toBe(true);
+        expect(suite.get().hasWarnings(fieldName)).toBe(true);
+        expect(res.hasWarnings()).toBe(true);
+        expect(suite.get().hasWarnings()).toBe(true);
+      });
+
+      it('should return false', () => {
+        const suite = vest.create(() => {
+          dummyTest.failingWarning(fieldName);
+        });
+        const res = suite();
+        expect(res.hasWarnings(fieldName)).toBe(true);
+        expect(suite.get().hasWarnings(fieldName)).toBe(true);
+        expect(res.hasWarnings()).toBe(true);
+        expect(suite.get().hasWarnings()).toBe(true);
+      });
+    });
+  });
+});

package/src/suiteResult/selectors/__tests__/hasFailuresByGroup.test.ts

@@ -0,0 +1,185 @@
+import { faker } from '@faker-js/faker';
+
+import { dummyTest } from '../../../../testUtils/testDummy';
+
+import * as vest from 'vest';
+
+const fieldName = faker.random.word();
+const groupName = faker.lorem.word();
+
+let suite: vest.Suite<(...args: any[]) => void, string>;
+describe('hasErrorsByGroup', () => {
+  describe('When no tests', () => {
+    it('Should return false', () => {
+      suite = vest.create(() => undefined);
+
+      expect(suite().hasErrorsByGroup(groupName)).toBe(false);
+    });
+  });
+
+  describe('When no failing tests', () => {
+    it('Should return false', () => {
+      suite = vest.create(() => {
+        dummyTest.passing();
+      });
+      expect(suite().hasErrorsByGroup(groupName)).toBe(false);
+    });
+  });
+
+  describe('When there are failing tests without a group', () => {
+    it('Should return false', () => {
+      suite = vest.create(() => {
+        dummyTest.failing();
+      });
+      expect(suite().hasErrorsByGroup(groupName)).toBe(false);
+    });
+  });
+
+  describe('When failing tests are from a different group', () => {
+    it('Should return false', () => {
+      suite = vest.create(() => {
+        vest.group('another_group', () => {
+          dummyTest.failing('field_1', 'msg');
+        });
+      });
+
+      expect(suite().hasErrorsByGroup(groupName)).toBe(false);
+    });
+  });
+
+  describe('When failing tests are from the same group but warning', () => {
+    it('Should return false', () => {
+      suite = vest.create(() => {
+        vest.group(groupName, () => {
+          dummyTest.failingWarning('field_1', 'msg');
+        });
+      });
+      expect(suite().hasErrorsByGroup(groupName)).toBe(false);
+    });
+  });
+
+  describe('When failing tests are from the same group', () => {
+    it('Should return true', () => {
+      suite = vest.create(() => {
+        vest.group(groupName, () => {
+          dummyTest.failing('field_1', 'msg');
+        });
+      });
+      expect(suite().hasErrorsByGroup(groupName)).toBe(true);
+    });
+  });
+
+  describe('When fieldName is provided', () => {
+    describe('When not matching', () => {
+      it('Should return false', () => {
+        suite = vest.create(() => {
+          vest.group(groupName, () => {
+            dummyTest.failing('field_1', 'msg');
+          });
+        });
+        expect(suite().hasErrorsByGroup(groupName, 'non_matcing_field')).toBe(
+          false
+        );
+      });
+    });
+
+    describe('When matching', () => {
+      it('Should return true', () => {
+        suite = vest.create(() => {
+          vest.group(groupName, () => {
+            dummyTest.failing(fieldName, 'msg');
+          });
+        });
+        expect(suite().hasErrorsByGroup(groupName, fieldName)).toBe(true);
+      });
+    });
+  });
+});
+
+describe('hasWarningsByGroup', () => {
+  describe('When no tests', () => {
+    it('Should return false', () => {
+      suite = vest.create(() => undefined);
+      expect(suite().hasWarningsByGroup(groupName)).toBe(false);
+    });
+  });
+
+  describe('When no failing tests', () => {
+    it('Should return false', () => {
+      suite = vest.create(() => {
+        vest.group(groupName, () => {
+          dummyTest.passingWarning(fieldName, 'msg');
+        });
+      });
+      expect(suite().hasWarningsByGroup(groupName)).toBe(false);
+    });
+  });
+
+  describe('When there are failing tests without a group', () => {
+    it('Should return false', () => {
+      suite = vest.create(() => {
+        dummyTest.failingWarning();
+      });
+      expect(suite().hasWarningsByGroup(groupName)).toBe(false);
+    });
+  });
+
+  describe('When failing tests are from a different group', () => {
+    it('Should return false', () => {
+      suite = vest.create(() => {
+        vest.group('another_group', () => {
+          dummyTest.failingWarning('field_1', 'msg');
+        });
+      });
+      expect(suite().hasWarningsByGroup(groupName)).toBe(false);
+    });
+  });
+
+  describe('When failing tests are from the same group but erroring', () => {
+    it('Should return false', () => {
+      suite = vest.create(() => {
+        vest.group(groupName, () => {
+          dummyTest.failing('field_1', 'msg');
+        });
+      });
+      expect(suite().hasWarningsByGroup(groupName)).toBe(false);
+    });
+  });
+
+  describe('When failing tests are from the same group', () => {
+    it('Should return true', () => {
+      suite = vest.create(() => {
+        vest.group(groupName, () => {
+          dummyTest.failingWarning(fieldName, 'msg');
+        });
+      });
+      expect(suite().hasWarningsByGroup(groupName)).toBe(true);
+    });
+  });
+
+  describe('When fieldName is provided', () => {
+    describe('When not matching', () => {
+      it('Should return false', () => {
+        suite = vest.create(() => {
+          vest.group(groupName, () => {
+            dummyTest.failingWarning(fieldName, 'msg');
+          });
+        });
+        expect(suite().hasWarningsByGroup(groupName, 'non_matcing_field')).toBe(
+          false
+        );
+      });
+    });
+
+    describe('When matching', () => {
+      it('Should return true', () => {
+        suite = vest.create(() => {
+          vest.group(groupName, () => {
+            dummyTest.failingWarning(fieldName, 'msg');
+          });
+        });
+        expect(suite().hasWarningsByGroup(groupName, fieldName)).toBe(true);
+      });
+    });
+  });
+});

package/src/suiteResult/selectors/__tests__/hasFailuresByTestObject.test.ts

@@ -0,0 +1,88 @@
+import { faker } from '@faker-js/faker';
+
+import { IsolateTest } from 'IsolateTest';
+import { IsolateTypes } from 'IsolateTypes';
+import { Severity } from 'Severity';
+import { hasFailuresByTestObject } from 'hasFailuresByTestObjects';
+
+const fieldName: string = faker.random.word();
+
+describe('hasFailuresByTestObject', () => {
+  let testObject: IsolateTest;
+
+  beforeEach(() => {
+    const fieldName: string = faker.random.word();
+    testObject = new IsolateTest(IsolateTypes.TEST, {
+      fieldName,
+      testFn: jest.fn(),
+    });
+  });
+
+  describe('When test did not fail', () => {
+    it('Should return false', () => {
+      expect(hasFailuresByTestObject(testObject, Severity.ERRORS)).toBe(false);
+      expect(hasFailuresByTestObject(testObject, Severity.WARNINGS)).toBe(
+        false
+      );
+      expect(
+        hasFailuresByTestObject(testObject, Severity.ERRORS, fieldName)
+      ).toBe(false);
+    });
+  });
+
+  describe('When the test did fail', () => {
+    beforeEach(() => {
+      testObject.fail();
+    });
+    describe('When field name is not provided', () => {
+      describe('When non matching severity profile', () => {
+        it('should return false', () => {
+          expect(hasFailuresByTestObject(testObject, Severity.WARNINGS)).toBe(
+            false
+          );
+          testObject.warn();
+          expect(hasFailuresByTestObject(testObject, Severity.ERRORS)).toBe(
+            false
+          );
+        });
+      });
+
+      describe('When matching severity profile', () => {
+        it('Should return true', () => {
+          expect(hasFailuresByTestObject(testObject, Severity.ERRORS)).toBe(
+            true
+          );
+          testObject.warn();
+          expect(hasFailuresByTestObject(testObject, Severity.WARNINGS)).toBe(
+            true
+          );
+        });
+      });
+    });
+    describe('When field name is provided', () => {
+      describe('When field name matches', () => {
+        it('should return false', () => {
+          expect(
+            hasFailuresByTestObject(testObject, Severity.ERRORS, 'non_matching')
+          ).toBe(false);
+        });
+      });
+
+      describe('When field name matches', () => {
+        it('Should continue with normal flow', () => {
+          expect(hasFailuresByTestObject(testObject, Severity.WARNINGS)).toBe(
+            false
+          );
+          testObject.warn();
+          expect(hasFailuresByTestObject(testObject, Severity.ERRORS)).toBe(
+            false
+          );
+          testObject.fail();
+          expect(hasFailuresByTestObject(testObject, Severity.WARNINGS)).toBe(
+            true
+          );
+        });
+      });
+    });
+  });
+});