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

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

@@ -0,0 +1,480 @@
+import wait from 'wait';
+
+import { TestPromise } from '../../../../testUtils/testPromise';
+
+import { TTestSuite } from 'testUtils/TVestMock';
+import {
+  test,
+  optional,
+  create,
+  skipWhen,
+  warn,
+  skip,
+  only,
+  group,
+} from 'vest';
+
+const GROUP_NAME = 'group_1';
+
+describe('isValidByGroup', () => {
+  describe('Before any test ran', () => {
+    it('Should return false', () => {
+      const suite = create(() => {
+        group(GROUP_NAME, () => {
+          test('field_1', () => {});
+        });
+      });
+
+      expect(suite.get().isValidByGroup(GROUP_NAME)).toBe(false);
+    });
+  });
+
+  describe('When there are errors in the group', () => {
+    let suite: TTestSuite;
+
+    beforeEach(() => {
+      suite = create((fieldToSkip: string) => {
+        skip(fieldToSkip);
+        optional('field_1');
+
+        group(GROUP_NAME, () => {
+          test('field_1', () => false);
+          test('field_2', () => false);
+          test('sanity', () => true);
+        });
+      });
+    });
+
+    it('Should return false when an optional test has errors', () => {
+      expect(suite('field_2').isValidByGroup(GROUP_NAME)).toBe(false);
+      expect(suite('field_2').isValidByGroup(GROUP_NAME, 'field_1')).toBe(
+        false
+      );
+    });
+    it('Should return false when a required test has errors', () => {
+      expect(suite('field_1').isValidByGroup(GROUP_NAME)).toBe(false);
+      expect(suite('field_1').isValidByGroup(GROUP_NAME, 'field_2')).toBe(
+        false
+      );
+    });
+
+    it('Should return false when the queried field is not optional and has errors', () => {
+      expect(suite('field_2').isValidByGroup(GROUP_NAME, 'field_2')).toBe(
+        false
+      );
+    });
+
+    it('Should return true when the queried field is optional and has errors', () => {
+      expect(suite('field_1').isValidByGroup(GROUP_NAME, 'field_1')).toBe(true);
+    });
+  });
+
+  describe('When there are warnings in the group', () => {
+    let suite: TTestSuite;
+
+    beforeEach(() => {
+      suite = create(() => {
+        group(GROUP_NAME, () => {
+          test('field_1', () => {
+            warn();
+            return false;
+          });
+        });
+      });
+    });
+    it('Should return true when a required test has warnings', () => {
+      expect(suite().isValidByGroup(GROUP_NAME)).toBe(true);
+      expect(suite().isValidByGroup(GROUP_NAME, 'field_1')).toBe(true);
+    });
+
+    describe('When some of the tests for the required field are warnings', () => {
+      beforeEach(() => {
+        suite = create(() => {
+          test('field_1', () => {
+            warn();
+            return false;
+          });
+          test('field_1', () => true);
+        });
+      });
+      it('Should return true when a required test has warnings', () => {
+        expect(suite().isValid()).toBe(true);
+      });
+    });
+
+    describe('when a warning test in a required field is skipped', () => {
+      beforeEach(() => {
+        suite = create(() => {
+          test('field_1', () => true);
+
+          skipWhen(true, () => {
+            test('field_1', () => {
+              warn();
+              return false;
+            });
+          });
+        });
+      });
+      it('Should return false even when the skipped field is warning', () => {
+        expect(suite().isValid()).toBe(false);
+      });
+    });
+  });
+
+  describe('When a non optional field is skipped', () => {
+    let suite: TTestSuite;
+
+    beforeEach(() => {
+      suite = create(fieldToSkip => {
+        skip(fieldToSkip);
+        group(GROUP_NAME, () => {
+          test('field_1', () => {
+            return false;
+          });
+          test('field_2', () => {
+            return true;
+          });
+          test('field_3', () => {
+            return true;
+          });
+        });
+      });
+    });
+    it('Should return false', () => {
+      expect(suite('field_1').isValidByGroup(GROUP_NAME)).toBe(false);
+    });
+    it('Should return false', () => {
+      expect(suite(['field_2', 'field_3']).isValidByGroup(GROUP_NAME)).toBe(
+        false
+      );
+    });
+  });
+
+  describe('When the suite has an async optional test', () => {
+    let suite: TTestSuite;
+
+    beforeEach(() => {
+      suite = create(() => {
+        optional('field_1');
+
+        group(GROUP_NAME, () => {
+          test('field_1', async () => {
+            await wait(300);
+          });
+        });
+      });
+    });
+
+    describe('When test is pending', () => {
+      it('Should return true', () => {
+        suite();
+        expect(suite.get().isValidByGroup(GROUP_NAME)).toBe(true);
+        expect(suite.get().isValidByGroup(GROUP_NAME, 'field_1')).toBe(true);
+      });
+    });
+    describe('When test is passing', () => {
+      it('Should return true', async () => {
+        suite();
+        await wait(300);
+        expect(suite.get().isValidByGroup(GROUP_NAME)).toBe(true);
+        expect(suite.get().isValidByGroup(GROUP_NAME, 'field_1')).toBe(true);
+      });
+    });
+  });
+
+  describe('When the suite has warning async tests', () => {
+    let suite: TTestSuite;
+
+    beforeEach(() => {
+      suite = create(() => {
+        group(GROUP_NAME, () => {
+          test('field_1', async () => {
+            warn();
+            await wait(300);
+          });
+
+          test('field_1', () => {
+            return true;
+          });
+        });
+      });
+    });
+
+    it('Should return false as long as the test is pending', async () => {
+      suite();
+      expect(suite.get().isValidByGroup(GROUP_NAME)).toBe(false);
+      await wait(300);
+      expect(suite.get().isValidByGroup(GROUP_NAME)).toBe(true);
+    });
+
+    it('Should return false as long as the test is pending when querying a specific field', async () => {
+      suite();
+      expect(suite.get().isValidByGroup(GROUP_NAME, 'field_1')).toBe(false);
+      await wait(300);
+      expect(suite.get().isValidByGroup(GROUP_NAME, 'field_1')).toBe(true);
+    });
+  });
+
+  describe('When the suite has async non-optional tests', () => {
+    let suite: TTestSuite;
+
+    beforeEach(() => {
+      suite = create(currentField => {
+        only(currentField);
+        optional('field_2');
+        group(GROUP_NAME, () => {
+          test('field_1', async () => {
+            await wait(300);
+          });
+          test('field_2', () => {
+            return true;
+          });
+        });
+      });
+    });
+
+    describe('When test is pending', () => {
+      it('Should return `false` for a required field', () => {
+        const result = suite();
+
+        expect(result.isValidByGroup(GROUP_NAME)).toBe(false);
+        expect(result.isValidByGroup(GROUP_NAME, 'field_1')).toBe(false);
+      });
+    });
+
+    describe('When async test is passing', () => {
+      it('Should return `true`', () => {
+        return TestPromise(done => {
+          suite().done(result => {
+            expect(result.isValidByGroup(GROUP_NAME)).toBe(true);
+            expect(result.isValidByGroup(GROUP_NAME, 'field_1')).toBe(true);
+            expect(result.isValidByGroup(GROUP_NAME, 'field_2')).toBe(true);
+            done();
+          });
+        });
+      });
+    });
+
+    describe('When test is lagging', () => {
+      it('Should return `false`', () => {
+        suite();
+        const result = suite('field_2');
+
+        expect(result.isValidByGroup(GROUP_NAME)).toBe(false);
+      });
+    });
+  });
+
+  describe('When a all required fields are passing', () => {
+    let suite: TTestSuite;
+
+    beforeEach(() => {
+      suite = create(() => {
+        group(GROUP_NAME, () => {
+          test('field_1', () => {
+            return true;
+          });
+          test('field_1', () => {
+            return true;
+          });
+          test('field_2', () => {
+            return true;
+          });
+          test('field_3', () => {
+            return true;
+          });
+        });
+      });
+    });
+    it('Should return true', () => {
+      expect(suite().isValidByGroup(GROUP_NAME)).toBe(true);
+      expect(suite().isValidByGroup(GROUP_NAME, 'field_1')).toBe(true);
+      expect(suite().isValidByGroup(GROUP_NAME, 'field_2')).toBe(true);
+      expect(suite().isValidByGroup(GROUP_NAME, 'field_3')).toBe(true);
+    });
+  });
+
+  describe('When a required field has some passing tests', () => {
+    it('Should return false', () => {
+      expect(
+        create(() => {
+          group(GROUP_NAME, () => {
+            test('field_1', () => true);
+            skipWhen(true, () => {
+              test('field_1', () => {
+                return true;
+              });
+            });
+          });
+        })().isValidByGroup(GROUP_NAME)
+      ).toBe(false);
+    });
+  });
+
+  describe('When field name is specified', () => {
+    it('Should return false when field did not run yet', () => {
+      expect(
+        create(() => {
+          skip('field_1');
+          group(GROUP_NAME, () => {
+            test('field_1', () => true);
+          });
+        })().isValidByGroup(GROUP_NAME, 'field_1')
+      ).toBe(false);
+    });
+
+    it('Should return false when testing for a field that does not exist', () => {
+      expect(
+        create(() => {
+          group(GROUP_NAME, () => {
+            test('field_1', () => {});
+          });
+        })().isValidByGroup(GROUP_NAME, 'field 2')
+      ).toBe(false);
+    });
+
+    it("Should return false when some of the field's tests ran", () => {
+      expect(
+        create(() => {
+          group(GROUP_NAME, () => {
+            test('field_1', () => {
+              return true;
+            });
+            skipWhen(true, () => {
+              test('field_1', () => {
+                return true;
+              });
+            });
+          });
+        })().isValidByGroup(GROUP_NAME, 'field_1')
+      ).toBe(false);
+    });
+
+    it('Should return false when the field has errors', () => {
+      expect(
+        create(() => {
+          group(GROUP_NAME, () => {
+            test('field_1', () => false);
+          });
+        })().isValidByGroup(GROUP_NAME, 'field_1')
+      ).toBe(false);
+    });
+
+    it('Should return true when all the tests are passing', () => {
+      expect(
+        create(() => {
+          group(GROUP_NAME, () => {
+            test('field_1', () => {});
+          });
+        })().isValidByGroup(GROUP_NAME, 'field_1')
+      ).toBe(true);
+    });
+
+    it('Should return true when the field only has warnings', () => {
+      expect(
+        create(() => {
+          group(GROUP_NAME, () => {
+            test('field_1', () => {
+              warn();
+              return false;
+            });
+          });
+        })().isValidByGroup(GROUP_NAME, 'field_1')
+      ).toBe(true);
+    });
+
+    it('Should return true if field is optional and did not run', () => {
+      expect(
+        create(() => {
+          optional('field_1');
+          skipWhen(true, () => {
+            group(GROUP_NAME, () => {
+              test('field_1', () => false);
+            });
+          });
+        })().isValidByGroup(GROUP_NAME, 'field_1')
+      ).toBe(true);
+    });
+  });
+
+  describe('When querying a non existing field', () => {
+    it('Should return false', () => {
+      expect(
+        create(() => {
+          group(GROUP_NAME, () => {
+            test('field_1', () => true);
+          });
+        })().isValidByGroup(GROUP_NAME, 'field_2')
+      ).toBe(false);
+    });
+  });
+
+  describe('When querying a non existing group', () => {
+    const suite = create(() => {
+      group(GROUP_NAME, () => {
+        test('field_1', () => true);
+      });
+    });
+    it('Should return false', () => {
+      expect(suite().isValidByGroup('does-not-exist')).toBe(false);
+      expect(suite().isValidByGroup('does-not-exist', 'field_1')).toBe(false);
+    });
+  });
+
+  describe('When queried field is omitted', () => {
+    it('Should return true', () => {
+      expect(
+        create(() => {
+          optional({
+            field_1: () => true,
+          });
+          group(GROUP_NAME, () => {
+            test('field_1', () => false);
+          });
+        })().isValidByGroup(GROUP_NAME)
+      ).toBe(true);
+    });
+  });
+
+  describe('When querying a field that is in a different group', () => {
+    const suite = create(() => {
+      group('group_1', () => {
+        test('field_1', () => {});
+      });
+      group('group_2', () => {
+        test('field_2', () => {});
+      });
+    });
+
+    it('Should return false', () => {
+      expect(suite().isValidByGroup('group_1', 'field_2')).toBe(false);
+      expect(suite().isValidByGroup('group_2', 'field_1')).toBe(false);
+    });
+  });
+
+  describe('When querying a field that is outside of a group', () => {
+    const suite = create(() => {
+      test('field_1', () => {});
+      group('group_1', () => {
+        test('field_2', () => {});
+      });
+    });
+
+    it('Should return false', () => {
+      expect(suite().isValidByGroup('group_1', 'field_1')).toBe(false);
+    });
+  });
+
+  describe('When the field exists both inside and outside of the group', () => {
+    const suite = create(() => {
+      test('field_1', () => false);
+      group('group_1', () => {
+        test('field_1', () => {});
+      });
+    });
+
+    it('Should return the result of what is inside the group', () => {
+      expect(suite().isValidByGroup('group_1', 'field_1')).toBe(true);
+    });
+  });
+});

package/src/suiteResult/selectors/collectFailures.ts

@@ -0,0 +1,43 @@
+import { isPositive } from 'vest-utils';
+
+import { countKeyBySeverity, Severity } from 'Severity';
+import { FailureMessages, TestsContainer, TFieldName } from 'SuiteResultTypes';
+
+// calls collectAll or getByFieldName depending on whether fieldName is provided
+
+export function gatherFailures(
+  testGroup: TestsContainer<TFieldName>,
+  severityKey: Severity,
+  fieldName?: TFieldName
+): string[] | FailureMessages {
+  return fieldName
+    ? getByFieldName(testGroup, severityKey, fieldName)
+    : collectAll(testGroup, severityKey);
+}
+
+function getByFieldName(
+  testGroup: TestsContainer<TFieldName>,
+  severityKey: Severity,
+  fieldName: TFieldName
+): string[] {
+  return testGroup?.[fieldName]?.[severityKey] || [];
+}
+
+function collectAll(
+  testGroup: TestsContainer<TFieldName>,
+  severityKey: Severity
+): FailureMessages {
+  const output: FailureMessages = {};
+
+  const countKey = countKeyBySeverity(severityKey);
+
+  for (const field in testGroup) {
+    if (isPositive(testGroup[field][countKey])) {
+      // We will probably never get to the fallback array
+      // leaving it just in case the implementation changes
+      output[field] = testGroup[field][severityKey] || [];
+    }
+  }
+
+  return output;
+}

package/src/suiteResult/selectors/hasFailuresByTestObjects.ts

@@ -0,0 +1,62 @@
+import { IsolateTest } from 'IsolateTest';
+import { Severity } from 'Severity';
+import { TFieldName } from 'SuiteResultTypes';
+import { TestWalker } from 'TestWalker';
+import { nonMatchingFieldName } from 'matchingFieldName';
+import { nonMatchingGroupName } from 'matchingGroupName';
+import { nonMatchingSeverityProfile } from 'nonMatchingSeverityProfile';
+
+/**
+ * The difference between this file and hasFailures is that hasFailures uses the static
+ * summary object, while this one uses the actual validation state
+ */
+
+export function hasErrorsByTestObjects(fieldName?: TFieldName): boolean {
+  return hasFailuresByTestObjects(Severity.ERRORS, fieldName);
+}
+
+export function hasFailuresByTestObjects(
+  severityKey: Severity,
+  fieldName?: TFieldName
+): boolean {
+  return TestWalker.someTests(testObject => {
+    return hasFailuresByTestObject(testObject, severityKey, fieldName);
+  });
+}
+
+export function hasGroupFailuresByTestObjects(
+  severityKey: Severity,
+  groupName: string,
+  fieldName?: TFieldName
+): boolean {
+  return TestWalker.someTests(testObject => {
+    if (nonMatchingGroupName(testObject, groupName)) {
+      return false;
+    }
+
+    return hasFailuresByTestObject(testObject, severityKey, fieldName);
+  });
+}
+
+/**
+ * Determines whether a certain test profile has failures.
+ */
+export function hasFailuresByTestObject(
+  testObject: IsolateTest,
+  severityKey: Severity,
+  fieldName?: TFieldName
+): boolean {
+  if (!testObject.hasFailures()) {
+    return false;
+  }
+
+  if (nonMatchingFieldName(testObject, fieldName)) {
+    return false;
+  }
+
+  if (nonMatchingSeverityProfile(severityKey, testObject)) {
+    return false;
+  }
+
+  return true;
+}

package/src/suiteResult/selectors/produceSuiteSummary.ts

@@ -0,0 +1,135 @@
+import { assign } from 'vest-utils';
+
+import { IsolateTest } from 'IsolateTest';
+import { countKeyBySeverity, Severity } from 'Severity';
+import {
+  Group,
+  Groups,
+  SingleTestSummary,
+  SuiteSummary,
+  TFieldName,
+  Tests,
+  TestsContainer,
+} from 'SuiteResultTypes';
+import { TestWalker } from 'TestWalker';
+import {
+  shouldAddValidProperty,
+  shouldAddValidPropertyInGroup,
+} from 'shouldAddValidProperty';
+
+export function produceSuiteSummary<F extends TFieldName>(): SuiteSummary<F> {
+  const summary: SuiteSummary<F> = assign(baseStats(), {
+    groups: {},
+    tests: {},
+    valid: false,
+  }) as SuiteSummary<F>;
+
+  TestWalker.walkTests(testObject => {
+    appendToTest(summary.tests, testObject);
+    appendToGroup(summary.groups, testObject);
+  });
+
+  summary.valid = shouldAddValidProperty();
+
+  return countFailures(summary);
+}
+
+function appendToTest(tests: Tests<TFieldName>, testObject: IsolateTest) {
+  tests[testObject.fieldName] = appendTestObject(tests, testObject);
+  // If `valid` is false to begin with, keep it that way. Otherwise, assess.
+  tests[testObject.fieldName].valid =
+    tests[testObject.fieldName].valid === false
+      ? false
+      : shouldAddValidProperty(testObject.fieldName);
+}
+
+/**
+ * Appends to a group object if within a group
+ */
+function appendToGroup(groups: Groups, testObject: IsolateTest) {
+  const { groupName } = testObject;
+
+  if (!groupName) {
+    return;
+  }
+
+  groups[groupName] = groups[groupName] || {};
+  groups[groupName][testObject.fieldName] = appendTestObject(
+    groups[groupName],
+    testObject
+  );
+
+  groups[groupName][testObject.fieldName].valid =
+    groups[groupName][testObject.fieldName].valid === false
+      ? false
+      : shouldAddValidPropertyInGroup(groupName, testObject.fieldName);
+}
+
+/**
+ * Counts the failed tests and adds global counters
+ */
+function countFailures(
+  summary: SuiteSummary<TFieldName>
+): SuiteSummary<TFieldName> {
+  for (const test in summary.tests) {
+    summary.errorCount += summary.tests[test].errorCount;
+    summary.warnCount += summary.tests[test].warnCount;
+    summary.testCount += summary.tests[test].testCount;
+  }
+  return summary;
+}
+
+/**
+ * Appends the test to a results object.
+ * Overload is only needed to satisfy typescript. No use in breaking it down to multiple
+ * functions as it is really the same, with the difference of "valid" missing in groups
+ */
+function appendTestObject(
+  summaryKey: Tests<TFieldName> | Group,
+  testObject: IsolateTest
+): SingleTestSummary;
+function appendTestObject(
+  summaryKey: Group | Tests<TFieldName>,
+  testObject: IsolateTest
+): TestsContainer<TFieldName>[keyof TestsContainer<TFieldName>] {
+  const { fieldName, message } = testObject;
+
+  summaryKey[fieldName] = summaryKey[fieldName] || baseTestStats();
+
+  const testKey = summaryKey[fieldName];
+
+  if (testObject.isNonActionable()) return testKey;
+
+  summaryKey[fieldName].testCount++;
+
+  if (testObject.isFailing()) {
+    incrementFailures(Severity.ERRORS);
+  } else if (testObject.isWarning()) {
+    incrementFailures(Severity.WARNINGS);
+  }
+
+  return testKey;
+
+  function incrementFailures(severity: Severity) {
+    const countKey = countKeyBySeverity(severity);
+    testKey[countKey]++;
+    if (message) {
+      testKey[severity] = (testKey[severity] || []).concat(message);
+    }
+  }
+}
+
+function baseStats() {
+  return {
+    errorCount: 0,
+    warnCount: 0,
+    testCount: 0,
+  };
+}
+
+function baseTestStats() {
+  return assign(baseStats(), {
+    errors: [],
+    warnings: [],
+  });
+}