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

package/src/suiteResult/selectors/__tests__/__snapshots__/collectFailureMessages.test.ts.snap

@@ -0,0 +1,89 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`collectFailureMessages getErrors When no options passed should match snapshot 1`] = `
+{
+  "field_1": [
+    "field_1_failure message 2",
+    "field_1_failure message 3",
+  ],
+  "field_2": [
+    "field_2_failure message 1",
+    "field_2_failure message 3",
+  ],
+}
+`;
+
+exports[`collectFailureMessages getErrors When specific field requested Should match snapshot 1`] = `
+[
+  "field_1_failure message 2",
+  "field_1_failure message 3",
+]
+`;
+
+exports[`collectFailureMessages getErrors When specific field requested Should match snapshot 2`] = `
+[
+  "field_2_failure message 1",
+  "field_2_failure message 3",
+]
+`;
+
+exports[`collectFailureMessages getErrors When specific field requested Should match snapshot 3`] = `[]`;
+
+exports[`collectFailureMessages getErrorsByGroup Should match snapshot 1`] = `
+{
+  "field_1": [],
+  "field_2": [
+    "field_2_failure message 1",
+    "field_2_failure message 3",
+  ],
+}
+`;
+
+exports[`collectFailureMessages getErrorsByGroup with field name Should match snapshot 1`] = `[]`;
+
+exports[`collectFailureMessages getErrorsByGroup with field name Should match snapshot 2`] = `
+[
+  "field_2_failure message 1",
+  "field_2_failure message 3",
+]
+`;
+
+exports[`collectFailureMessages getErrorsByGroup with field name Should match snapshot 3`] = `[]`;
+
+exports[`collectFailureMessages getWarnings When no options passed should match snapshot 1`] = `
+{
+  "field_2": [
+    "field_2_warning message 2",
+    "field_2_warning message 3",
+  ],
+}
+`;
+
+exports[`collectFailureMessages getWarnings When specific field requested Should match snapshot 1`] = `[]`;
+
+exports[`collectFailureMessages getWarnings When specific field requested Should match snapshot 2`] = `
+[
+  "field_2_warning message 2",
+  "field_2_warning message 3",
+]
+`;
+
+exports[`collectFailureMessages getWarnings When specific field requested Should match snapshot 3`] = `[]`;
+
+exports[`collectFailureMessages getWarningsByGroup Should match snapshot 1`] = `
+{
+  "field_2": [
+    "field_2_warning message 3",
+  ],
+}
+`;
+
+exports[`collectFailureMessages getWarningsByGroup with field name Should match snapshot 1`] = `[]`;
+
+exports[`collectFailureMessages getWarningsByGroup with field name Should match snapshot 2`] = `
+[
+  "field_2_warning message 3",
+]
+`;
+
+exports[`collectFailureMessages getWarningsByGroup with field name Should match snapshot 3`] = `[]`;

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

@@ -0,0 +1,124 @@
+// TODO: Verify this test file is not needed and delete it
+import { dummyTest } from '../../../../testUtils/testDummy';
+
+import { SuiteResult } from 'SuiteResultTypes';
+import { TTestSuite } from 'testUtils/TVestMock';
+import { create, group } from 'vest';
+import * as vest from 'vest';
+
+describe('collectFailureMessages', () => {
+  let suite: TTestSuite;
+  let res: SuiteResult<string>;
+
+  test('Result has an array of matching error messages', () => {
+    const result = res.getErrors();
+    expect(result.field_1).toEqual([
+      'field_1_failure message 2',
+      'field_1_failure message 3',
+    ]);
+  });
+
+  it('Should return filtered messages by the selected group', () => {
+    const result = res.getErrorsByGroup('group_1');
+
+    expect(result).toEqual({
+      field_1: [],
+      field_2: ['field_2_failure message 1', 'field_2_failure message 3'],
+    });
+  });
+
+  it('Should return an empty object when no options and no failures', () => {
+    expect(res.getErrors('nonexistent_field')).toEqual([]);
+  });
+
+  it('Should return an object with an empty array when selected field has no errors', () => {
+    expect(res.getErrors('v')).toEqual([]);
+  });
+
+  describe('getErrors', () => {
+    describe('When no options passed', () => {
+      it('should match snapshot', () => {
+        expect(res.getErrors()).toMatchSnapshot();
+      });
+    });
+
+    describe('When specific field requested', () => {
+      it('Should match snapshot', () => {
+        expect(res.getErrors('field_1')).toMatchSnapshot();
+        expect(res.getErrors('field_2')).toMatchSnapshot();
+        expect(res.getErrors('field_3')).toMatchSnapshot();
+      });
+    });
+  });
+
+  describe('getWarnings', () => {
+    describe('When no options passed', () => {
+      it('should match snapshot', () => {
+        expect(res.getWarnings()).toMatchSnapshot();
+      });
+    });
+
+    describe('When specific field requested', () => {
+      it('Should match snapshot', () => {
+        expect(res.getWarnings('field_1')).toMatchSnapshot();
+        expect(res.getWarnings('field_2')).toMatchSnapshot();
+        expect(res.getWarnings('field_3')).toMatchSnapshot();
+      });
+    });
+  });
+
+  describe('getErrorsByGroup', () => {
+    it('Should match snapshot', () => {
+      expect(res.getErrorsByGroup('group_1')).toMatchSnapshot();
+    });
+
+    describe('with field name', () => {
+      it('Should match snapshot', () => {
+        expect(res.getErrorsByGroup('group_1', 'field_1')).toMatchSnapshot();
+        expect(res.getErrorsByGroup('group_1', 'field_2')).toMatchSnapshot();
+        expect(res.getErrorsByGroup('group_1', 'field_3')).toMatchSnapshot();
+      });
+    });
+  });
+  describe('getWarningsByGroup', () => {
+    it('Should match snapshot', () => {
+      expect(res.getWarningsByGroup('group_1')).toMatchSnapshot();
+    });
+
+    describe('with field name', () => {
+      it('Should match snapshot', () => {
+        expect(res.getWarningsByGroup('group_1', 'field_1')).toMatchSnapshot();
+        expect(res.getWarningsByGroup('group_1', 'field_2')).toMatchSnapshot();
+        expect(res.getWarningsByGroup('group_1', 'field_3')).toMatchSnapshot();
+      });
+    });
+  });
+
+  beforeEach(() => {
+    suite = create(() => {
+      dummyTest.passing('field_1', 'field_1_failure message 1');
+      dummyTest.failing('field_1', 'field_1_failure message 2');
+      dummyTest.failing('field_1', 'field_1_failure message 3');
+      group('group_1', () => {
+        vest.test('field_1', () => false);
+        vest.test('field_3', () => {});
+      });
+      dummyTest.failing('field_2', 'field_2_failure message 1', 'group_1');
+      dummyTest.passingWarning('field_2', 'field_2_warning message 1');
+      dummyTest.failingWarning('field_2', 'field_2_warning message 2');
+      dummyTest.failingWarning(
+        'field_2',
+        'field_2_warning message 3',
+        'group_1'
+      );
+      dummyTest.failing('field_2', 'field_2_failure message 3', 'group_1');
+      dummyTest.passing('v');
+
+      group('group_2', () => {
+        dummyTest.passing('x');
+      });
+    });
+    suite();
+    res = suite.get();
+  });
+});

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

@@ -0,0 +1,158 @@
+import { dummyTest } from '../../../../testUtils/testDummy';
+
+import * as vest from 'vest';
+
+describe('->getFailures', () => {
+  describe(`getErrors`, () => {
+    describe('When no tests', () => {
+      describe('When no parameters passed', () => {
+        it('Should return an empty object', () => {
+          const suite = vest.create(() => {});
+
+          expect(suite().getErrors()).toEqual({});
+          expect(suite.get().getErrors()).toEqual({});
+        });
+      });
+      describe('When requesting a fieldName', () => {
+        it('Should return an empty array', () => {
+          const suite = vest.create(() => {});
+          expect(suite().getErrors()).toEqual({});
+          expect(suite.get().getErrors('field_2')).toEqual([]);
+        });
+      });
+    });
+    describe('When no errors', () => {
+      describe('When no parameters passed', () => {
+        it('Should return an object no errors', () => {
+          const suite = vest.create(() => {
+            dummyTest.passing('f1');
+            dummyTest.passing('f2');
+          });
+          expect(suite().getErrors()).toEqual({});
+          expect(suite.get().getErrors()).toEqual({});
+        });
+      });
+      describe('When requesting a fieldName', () => {
+        it('Should return an empty array', () => {
+          const suite = vest.create(() => {
+            dummyTest.passing('field_1');
+            dummyTest.passing();
+          });
+          expect(suite().getErrors('field_1')).toEqual([]);
+          expect(suite.get().getErrors('field_1')).toEqual([]);
+        });
+      });
+    });
+
+    describe('When there are errors', () => {
+      describe('When no parameters passed', () => {
+        it('Should return an object with an array per field', () => {
+          const suite = vest.create(() => {
+            dummyTest.failing('field_1', 'msg_1');
+            dummyTest.failing('field_2', 'msg_2');
+            dummyTest.failing('field_2', 'msg_3');
+            dummyTest.passing('field_1', 'msg_4');
+            dummyTest.failingWarning('field_1', 'msg_5');
+          });
+          expect(suite().getErrors()).toEqual({
+            field_1: ['msg_1'],
+            field_2: ['msg_2', 'msg_3'],
+          });
+          expect(suite.get().getErrors()).toEqual({
+            field_1: ['msg_1'],
+            field_2: ['msg_2', 'msg_3'],
+          });
+        });
+      });
+      describe('When requesting a fieldName', () => {
+        it('Should return an empty array', () => {
+          const suite = vest.create(() => {
+            dummyTest.failing('field_1', 'msg_1');
+            dummyTest.failing('field_2', 'msg_2');
+            dummyTest.failing('field_2', 'msg_3');
+            dummyTest.passing('field_1', 'msg_4');
+            dummyTest.failingWarning('field_1', 'msg_5');
+          });
+          expect(suite().getErrors('field_1')).toEqual(['msg_1']);
+          expect(suite.get().getErrors('field_1')).toEqual(['msg_1']);
+        });
+      });
+    });
+  });
+
+  describe(`getWarnings`, () => {
+    describe('When no testObjects', () => {
+      describe('When no parameters passed', () => {
+        it('Should return an empty object', () => {
+          const suite = vest.create(() => {});
+          expect(suite().getWarnings()).toEqual({});
+          expect(suite.get().getWarnings()).toEqual({});
+        });
+      });
+      describe('When requesting a fieldName', () => {
+        it('Should return an empty array', () => {
+          const suite = vest.create(() => {});
+          expect(suite().getWarnings('field_1')).toEqual([]);
+          expect(suite.get().getWarnings('field_1')).toEqual([]);
+        });
+      });
+    });
+    describe('When no warnings', () => {
+      describe('When no parameters passed', () => {
+        it('Should return an empty object', () => {
+          const suite = vest.create(() => {
+            dummyTest.passing('x');
+            dummyTest.passing('y');
+          });
+          expect(suite().getWarnings()).toEqual({});
+          expect(suite.get().getWarnings()).toEqual({});
+        });
+      });
+      describe('When requesting a fieldName', () => {
+        it('Should return an empty array', () => {
+          const suite = vest.create(() => {
+            dummyTest.passing('field_1');
+            dummyTest.passing();
+          });
+          expect(suite().getWarnings('field_1')).toEqual([]);
+          expect(suite.get().getWarnings('field_1')).toEqual([]);
+        });
+      });
+    });
+
+    describe('When there are warnings', () => {
+      describe('When no parameters passed', () => {
+        it('Should return an object with an array per field', () => {
+          const suite = vest.create(() => {
+            dummyTest.failingWarning('field_1', 'msg_1');
+            dummyTest.failingWarning('field_2', 'msg_2');
+            dummyTest.failingWarning('field_2', 'msg_3');
+            dummyTest.passingWarning('field_1', 'msg_4');
+            dummyTest.failing('field_1', 'msg_5');
+          });
+          expect(suite().getWarnings()).toEqual({
+            field_1: ['msg_1'],
+            field_2: ['msg_2', 'msg_3'],
+          });
+          expect(suite.get().getWarnings()).toEqual({
+            field_1: ['msg_1'],
+            field_2: ['msg_2', 'msg_3'],
+          });
+        });
+      });
+      describe('When requesting a fieldName', () => {
+        it('Should return an empty array', () => {
+          const suite = vest.create(() => {
+            dummyTest.failingWarning('field_1', 'msg_1');
+            dummyTest.failingWarning('field_2', 'msg_2');
+            dummyTest.failingWarning('field_2', 'msg_3');
+            dummyTest.passingWarning('field_1', 'msg_4');
+            dummyTest.failing('field_1', 'msg_5');
+          });
+          expect(suite().getWarnings('field_1')).toEqual(['msg_1']);
+          expect(suite.get().getWarnings('field_1')).toEqual(['msg_1']);
+        });
+      });
+    });
+  });
+});

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

@@ -0,0 +1,199 @@
+import { dummyTest } from '../../../../testUtils/testDummy';
+
+import { TTestSuite } from 'testUtils/TVestMock';
+import { create, group } from 'vest';
+import * as vest from 'vest';
+
+const modes = ['SuiteRunResult', 'SuiteResult'];
+
+describe.each(modes)('produce method: %s', mode => {
+  let suite: TTestSuite;
+
+  function getRes(...args: any[]) {
+    const res = suite(...args);
+    return mode === 'SuiteRunResult' ? res : suite.get();
+  }
+
+  describe(`${mode}->getErrorsByGroup`, () => {
+    describe('When no tests', () => {
+      beforeEach(() => {
+        suite = create(() => {});
+      });
+      describe('When no fieldName passed', () => {
+        it('Should return an object with empty message arrays', () => {
+          expect(getRes().getErrorsByGroup('group_name')).toEqual({});
+        });
+      });
+      describe('When fieldName passed', () => {
+        it('Should return an empty array', () => {
+          expect(getRes().getErrorsByGroup('group_name', 'field_name')).toEqual(
+            []
+          );
+        });
+      });
+    });
+
+    describe('When no failures', () => {
+      describe('When no fieldName passed', () => {
+        it('Should return an object with empty message arrays', () => {
+          suite = create(() => {
+            dummyTest.passing('field_1', 'message', 'group_name');
+            dummyTest.passing('f2');
+          });
+          expect(getRes().getErrorsByGroup('group_name')).toEqual({});
+        });
+      });
+      describe('When fieldName passed', () => {
+        it('Should return an empty array', () => {
+          suite = create(() => {
+            dummyTest.passing('field_1', 'message', 'group_name');
+            dummyTest.passing();
+          });
+          expect(getRes().getErrorsByGroup('group_name', 'field_name')).toEqual(
+            []
+          );
+        });
+      });
+    });
+
+    describe('When there are failures', () => {
+      describe('When no fieldName passed', () => {
+        it('Should return an object containing the error messages of each group', () => {
+          suite = create(() => {
+            dummyTest.failing('field_1', 'message_1', 'group_name');
+            dummyTest.failing('field_1', 'message_2');
+            dummyTest.failing('field_2');
+            dummyTest.failing('field_2', 'message_3', 'group_name');
+            dummyTest.failing('field_2', 'message_4', 'group_name');
+            dummyTest.failing('field_2', 'message_4', 'group_name_2');
+            dummyTest.passing('field_1');
+            dummyTest.passing('field_2');
+            dummyTest.passing('field_3');
+          });
+          expect(getRes().getErrorsByGroup('group_name')).toEqual({
+            field_1: ['message_1'],
+            field_2: ['message_3', 'message_4'],
+          });
+        });
+      });
+      describe('When fieldName passed', () => {
+        it("Should return an array of the field's error messages", () => {
+          suite = create(() => {
+            group('group_name', () => {
+              vest.test('field_1', 'message_1', () => false);
+              vest.test('field_2', 'message_3', () => false);
+            });
+            vest.test('field_1', 'message_2', () => false);
+            vest.test('field_2', () => false);
+            vest.test('field_1', () => {});
+            vest.test('field_2', () => {});
+            vest.test('field_3', () => {});
+          });
+          expect(getRes().getErrorsByGroup('group_name', 'field_1')).toEqual([
+            'message_1',
+          ]);
+          expect(getRes().getErrorsByGroup('group_name', 'field_2')).toEqual([
+            'message_3',
+          ]);
+        });
+      });
+    });
+  });
+  describe(`${mode}->getWarningsByGroup`, () => {
+    describe('When no tests', () => {
+      beforeEach(() => {
+        suite = create(() => {});
+      });
+      describe('When no fieldName passed', () => {
+        it('Should return an object with empty message arrays', () => {
+          expect(getRes().getWarningsByGroup('group_name')).toEqual({});
+        });
+      });
+      describe('When fieldName passed', () => {
+        it('Should return an empty array', () => {
+          expect(
+            getRes().getWarningsByGroup('group_name', 'field_name')
+          ).toEqual([]);
+        });
+      });
+    });
+
+    describe('When no failures', () => {
+      describe('When no fieldName passed', () => {
+        it('Should return an object with no message arrays', () => {
+          suite = create(() => {
+            dummyTest.passing('field_1', 'message', 'group_name');
+            dummyTest.passing();
+          });
+          expect(getRes().getWarningsByGroup('group_name')).toEqual({});
+        });
+      });
+      describe('When fieldName passed', () => {
+        it('Should return an empty array', () => {
+          suite = create(() => {
+            dummyTest.passing('field_1', 'message', 'group_name');
+            dummyTest.passing();
+          });
+          expect(
+            getRes().getWarningsByGroup('group_name', 'field_name')
+          ).toEqual([]);
+        });
+      });
+    });
+
+    describe('When there are failures', () => {
+      describe('When no fieldName passed', () => {
+        it('Should return an object containing the warning messages of each group', () => {
+          suite = create(() => {
+            dummyTest.failingWarning('field_1', 'message_1', 'group_name');
+            dummyTest.failingWarning('field_1', 'message_2');
+            dummyTest.failingWarning('field_2');
+            dummyTest.failingWarning('field_2', 'message_3', 'group_name');
+            dummyTest.failingWarning('field_2', 'message_4', 'group_name');
+            dummyTest.failingWarning('field_2', 'message_4', 'group_name_2');
+            dummyTest.passing('field_1');
+            dummyTest.passing('field_2');
+            dummyTest.passing('field_3');
+          });
+          expect(getRes().getWarningsByGroup('group_name')).toEqual({
+            field_1: ['message_1'],
+            field_2: ['message_3', 'message_4'],
+          });
+        });
+      });
+      describe('When fieldName passed', () => {
+        it("Should return an array of the field's warning messages", () => {
+          suite = create(() => {
+            group('group_name', () => {
+              vest.test('field_1', 'message_1', () => {
+                vest.warn();
+                return false;
+              });
+              vest.test('field_2', 'message_3', () => {
+                vest.warn();
+                return false;
+              });
+            });
+            vest.test('field_1', 'message_2', () => {
+              vest.warn();
+              return false;
+            });
+            vest.test('field_2', () => {
+              vest.warn();
+              return false;
+            });
+            vest.test('field_1', () => {});
+            vest.test('field_2', () => {});
+            vest.test('field_3', () => {});
+          });
+          expect(getRes().getWarningsByGroup('group_name', 'field_1')).toEqual([
+            'message_1',
+          ]);
+          expect(getRes().getWarningsByGroup('group_name', 'field_2')).toEqual([
+            'message_3',
+          ]);
+        });
+      });
+    });
+  });
+});