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

package/src/suite/runCallbacks.ts

@@ -0,0 +1,28 @@
+import { isArray, callEach } from 'vest-utils';
+
+import { useDoneCallbacks, useFieldCallbacks } from 'PersistedContext';
+import { TFieldName } from 'SuiteResultTypes';
+import { TestWalker } from 'TestWalker';
+
+/**
+ * Runs done callback per field when async tests are finished running.
+ */
+export function runFieldCallbacks(fieldName?: TFieldName): void {
+  const [fieldCallbacks] = useFieldCallbacks();
+
+  if (
+    fieldName &&
+    !TestWalker.hasRemainingTests(fieldName) &&
+    isArray(fieldCallbacks[fieldName])
+  ) {
+    callEach(fieldCallbacks[fieldName]);
+  }
+}
+
+/**
+ * Runs unlabelled done callback when async tests are finished running.
+ */
+export function runDoneCallbacks() {
+  const [doneCallbacks] = useDoneCallbacks();
+  callEach(doneCallbacks);
+}

package/src/suiteResult/Severity.ts

@@ -0,0 +1,15 @@
+export enum Severity {
+  WARNINGS = 'warnings',
+  ERRORS = 'errors',
+}
+
+export enum SeverityCount {
+  ERROR_COUNT = 'errorCount',
+  WARN_COUNT = 'warnCount',
+}
+
+export function countKeyBySeverity(severity: Severity): SeverityCount {
+  return severity === Severity.ERRORS
+    ? SeverityCount.ERROR_COUNT
+    : SeverityCount.WARN_COUNT;
+}

package/src/suiteResult/SuiteResultTypes.ts

@@ -0,0 +1,42 @@
+import { Done } from 'suiteRunResult';
+import { SuiteSelectors } from 'suiteSelectors';
+
+export type SuiteSummary<F extends TFieldName> = {
+  groups: Groups;
+  tests: Tests<F>;
+  valid: boolean;
+} & SummaryBase;
+
+export type TestsContainer<F extends TFieldName> = Group | Tests<F>;
+export type GroupTestSummary = SingleTestSummary;
+
+export type Groups = Record<string, Group>;
+export type Group = Record<string, GroupTestSummary>;
+export type Tests<F extends TFieldName> = Record<F, SingleTestSummary>;
+
+export type SingleTestSummary = SummaryBase & {
+  errors: string[];
+  warnings: string[];
+  valid: boolean;
+};
+
+type SummaryBase = {
+  errorCount: number;
+  warnCount: number;
+  testCount: number;
+};
+
+export type GetFailuresResponse = FailureMessages | string[];
+
+export type FailureMessages = Record<string, string[]>;
+
+export type SuiteResult<F extends TFieldName> = SuiteSummary<F> &
+  SuiteSelectors<F> & { suiteName: SuiteName };
+
+export type SuiteRunResult<F extends TFieldName> = SuiteResult<F> & {
+  done: Done<F>;
+};
+
+export type SuiteName = string | undefined;
+
+export type TFieldName<T extends string = string> = T;

package/src/suiteResult/__tests__/done.test.ts

@@ -0,0 +1,334 @@
+import wait from 'wait';
+
+import { dummyTest } from '../../../testUtils/testDummy';
+import { TestPromise } from '../../../testUtils/testPromise';
+
+import * as vest from 'vest';
+
+describe('done', () => {
+  describe('When no async tests', () => {
+    it('Should call done callback immediately', () => {
+      const result = vest.create(() => {
+        dummyTest.passing();
+        dummyTest.passing();
+        dummyTest.failing();
+        dummyTest.failing();
+        dummyTest.passing();
+        dummyTest.failingWarning('field_2');
+      })();
+
+      const doneCallback = jest.fn();
+      const fieldDoneCallback = jest.fn();
+
+      result.done(doneCallback).done('field_2', fieldDoneCallback);
+
+      expect(doneCallback).toHaveBeenCalled();
+      expect(fieldDoneCallback).toHaveBeenCalled();
+    });
+  });
+
+  describe('When suite lags and callbacks are registered again', () => {
+    it('should only run most recent registered callbacks', async () => {
+      const test = [];
+      const suite = vest.create(() => {
+        test.push(dummyTest.failingAsync('test', { time: 100 }));
+      });
+
+      const doneCallback1 = jest.fn();
+      const fieldDoneCallback1 = jest.fn();
+      const doneCallback2 = jest.fn();
+      const fieldDoneCallback2 = jest.fn();
+
+      suite().done(doneCallback1).done('test', fieldDoneCallback1);
+      await wait(10);
+      suite().done(doneCallback2).done('test', fieldDoneCallback2);
+      await wait(100);
+      expect(doneCallback2).toHaveBeenCalledTimes(1);
+      expect(fieldDoneCallback2).toHaveBeenCalledTimes(1);
+      expect(doneCallback1).toHaveBeenCalledTimes(0);
+      expect(fieldDoneCallback1).toHaveBeenCalledTimes(0);
+    });
+  });
+
+  describe('When there are async tests', () => {
+    describe('When field name is not passed', () => {
+      it('Should run the done callback after all the fields finished running', () => {
+        const check1 = jest.fn();
+        const check2 = jest.fn();
+        const check3 = jest.fn();
+        return TestPromise(done => {
+          const doneCallback = jest.fn(() => {
+            expect(check1).toHaveBeenCalled();
+            expect(check2).toHaveBeenCalled();
+            expect(check3).toHaveBeenCalled();
+            done();
+          });
+          const result = vest.create(() => {
+            dummyTest.passingAsync('field_1', { time: 1000 });
+            dummyTest.failingAsync('field_2', { time: 100 });
+            dummyTest.passingAsync('field_3', { time: 0 });
+            dummyTest.failing();
+            dummyTest.passing();
+          })();
+
+          result.done(doneCallback);
+
+          setTimeout(() => {
+            expect(doneCallback).not.toHaveBeenCalled();
+            check1();
+          });
+          setTimeout(() => {
+            expect(doneCallback).not.toHaveBeenCalled();
+            check2();
+          }, 150);
+          setTimeout(() => {
+            expect(doneCallback).not.toHaveBeenCalled();
+            check3();
+          }, 900);
+        });
+      });
+    });
+  });
+
+  describe('done arguments', () => {
+    it('Should pass down the up to date validation result', () => {
+      return TestPromise(done => {
+        const result = vest.create(() => {
+          dummyTest.failing('field_1', 'error message');
+          dummyTest.passing('field_2');
+          dummyTest.passingAsync('field_3', { time: 0 });
+          dummyTest.failingAsync('field_4', {
+            message: 'error_message',
+            time: 100,
+          });
+          dummyTest.passingAsync('field_5', { time: 1000 });
+        })();
+
+        result
+          .done('field_2', res => {
+            expect(res.getErrors()).toEqual({
+              field_1: ['error message'],
+            });
+            expect(res).toMatchObject({
+              errorCount: 1,
+              groups: {},
+              testCount: 5,
+              tests: {
+                field_1: {
+                  errorCount: 1,
+                  errors: ['error message'],
+                  testCount: 1,
+                  warnCount: 0,
+                },
+                field_2: {
+                  errorCount: 0,
+                  testCount: 1,
+                  warnCount: 0,
+                },
+                field_3: {
+                  errorCount: 0,
+                  testCount: 1,
+                  warnCount: 0,
+                },
+                field_4: {
+                  errorCount: 0,
+                  testCount: 1,
+                  warnCount: 0,
+                },
+                field_5: {
+                  errorCount: 0,
+                  testCount: 1,
+                  warnCount: 0,
+                },
+              },
+              warnCount: 0,
+            });
+          })
+          .done('field_3', res => {
+            expect(res).toMatchObject({
+              errorCount: 1,
+              groups: {},
+              testCount: 5,
+              tests: {
+                field_1: {
+                  errorCount: 1,
+                  errors: ['error message'],
+                  testCount: 1,
+                  warnCount: 0,
+                },
+                field_2: {
+                  errorCount: 0,
+                  testCount: 1,
+                  warnCount: 0,
+                },
+                field_3: {
+                  errorCount: 0,
+                  testCount: 1,
+                  warnCount: 0,
+                },
+                field_4: {
+                  errorCount: 0,
+                  testCount: 1,
+                  warnCount: 0,
+                },
+                field_5: {
+                  errorCount: 0,
+                  testCount: 1,
+                  warnCount: 0,
+                },
+              },
+              warnCount: 0,
+            });
+          })
+          .done('field_4', res => {
+            expect(res.getErrors()).toEqual({
+              field_1: ['error message'],
+              field_4: ['error_message'],
+            });
+            expect(res).toMatchObject({
+              errorCount: 2,
+              groups: {},
+              testCount: 5,
+              tests: {
+                field_1: {
+                  errorCount: 1,
+                  errors: ['error message'],
+                  testCount: 1,
+                  warnCount: 0,
+                },
+                field_2: {
+                  errorCount: 0,
+                  testCount: 1,
+                  warnCount: 0,
+                },
+                field_3: {
+                  errorCount: 0,
+                  testCount: 1,
+                  warnCount: 0,
+                },
+                field_4: {
+                  errorCount: 1,
+                  errors: ['error_message'],
+                  testCount: 1,
+                  warnCount: 0,
+                },
+                field_5: {
+                  errorCount: 0,
+                  testCount: 1,
+                  warnCount: 0,
+                },
+              },
+              warnCount: 0,
+            });
+          })
+          .done(res => {
+            expect(res).toMatchObject({
+              errorCount: 2,
+              groups: {},
+              testCount: 5,
+              tests: {
+                field_1: {
+                  errorCount: 1,
+                  errors: ['error message'],
+                  testCount: 1,
+                  warnCount: 0,
+                },
+                field_2: {
+                  errorCount: 0,
+                  testCount: 1,
+                  warnCount: 0,
+                },
+                field_3: {
+                  errorCount: 0,
+                  testCount: 1,
+                  warnCount: 0,
+                },
+                field_4: {
+                  errorCount: 1,
+                  errors: ['error_message'],
+                  testCount: 1,
+                  warnCount: 0,
+                },
+                field_5: {
+                  errorCount: 0,
+                  testCount: 1,
+                  warnCount: 0,
+                },
+              },
+              warnCount: 0,
+            });
+            done();
+          });
+      });
+    });
+  });
+
+  describe('When a different field is run while a field is pending', () => {
+    it('Should wait running done callbacks until all tests complete', () => {
+      const suite = vest.create(only => {
+        vest.only(only);
+
+        vest.test('async_1', async () => {
+          await wait(1000);
+          throw new Error();
+        });
+
+        vest.test('sync_2', () => false);
+      });
+
+      suite('async_1');
+
+      return TestPromise(done => {
+        suite('sync_2').done(res => {
+          expect(res.hasErrors('async_1')).toBe(true);
+          done();
+        });
+      });
+    });
+  });
+
+  describe('When suite re-runs and a pending test is now skipped', () => {
+    it('Should immediately call the second done callback, omit the first', async () => {
+      const done_0 = jest.fn();
+      const done_1 = jest.fn();
+
+      const suite = vest.create(username => {
+        vest.test('username', () => {
+          vest.enforce(username).isNotBlank();
+        });
+
+        vest.skipWhen(suite.get().hasErrors('username'), () => {
+          vest.test('username', async () => {
+            await wait(1000);
+            if (username === 'ealush') {
+              throw new Error();
+            }
+          });
+        });
+      });
+
+      suite('ealush').done(done_0);
+      await wait(0);
+      expect(done_0).not.toHaveBeenCalled();
+      suite('').done(done_1);
+      expect(done_0).not.toHaveBeenCalled();
+      expect(done_1).toHaveBeenCalled();
+      await wait(1000);
+      expect(done_0).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('Passing a field that does not exist', () => {
+    it('Should call the callback immedaitely', () => {
+      const cb = jest.fn();
+
+      const suite = vest.create(() => {
+        vest.test('test', () => {});
+      });
+
+      suite().done('non-existent', cb);
+
+      expect(cb).toHaveBeenCalled();
+    });
+  });
+});

package/src/suiteResult/__tests__/produce.test.ts

@@ -0,0 +1,163 @@
+import { ser } from '../../../testUtils/suiteDummy';
+import { dummyTest } from '../../../testUtils/testDummy';
+
+import * as vest from 'vest';
+
+describe('produce method Suite Result', () => {
+  describe('Base structure', () => {
+    it('Should match snapshot', () => {
+      const suite = vest.create(() => {});
+      expect(suite()).toMatchObject({
+        errorCount: 0,
+        groups: {},
+        testCount: 0,
+        tests: {},
+        warnCount: 0,
+      });
+      expect(ser(suite())).toEqual(ser(suite.get()));
+    });
+
+    it('Its methods should reflect the correct test data', () => {
+      const suite = vest.create(() => {
+        dummyTest.passing('field_1');
+        dummyTest.failing('field_1', 'message');
+        dummyTest.failing('field_1', 'failure_message');
+        dummyTest.failing('field_1', 'failure_message with group', 'group_1');
+        dummyTest.failingWarning('field_2', 'warning test');
+        dummyTest.failingWarning('field_2', 'another warning test');
+        dummyTest.passing('field_2');
+        dummyTest.passing('field_3', '', 'group_1');
+        dummyTest.failing('field_3', 'msg');
+        dummyTest.passing('field_4');
+        dummyTest.passing('field_5', '', 'group_2');
+        dummyTest.failingWarning('field_5', 'warning message', 'group_2');
+      });
+
+      const res = suite();
+
+      expect(ser(suite.get())).toEqual(ser(res));
+
+      expect(res.hasErrors()).toBe(true);
+      expect(res.hasErrors('field_1')).toBe(true);
+      expect(res.hasErrors('field_2')).toBe(false);
+      expect(res.hasErrors('field_3')).toBe(true);
+      expect(res.hasErrors('field_4')).toBe(false);
+      expect(res.hasErrors('field_5')).toBe(false);
+      expect(res.hasWarnings('field_1')).toBe(false);
+      expect(res.hasWarnings('field_2')).toBe(true);
+      expect(res.hasWarnings('field_3')).toBe(false);
+      expect(res.hasWarnings('field_4')).toBe(false);
+      expect(res.hasWarnings('field_5')).toBe(true);
+      expect(res.getErrors()).toEqual({
+        field_1: ['message', 'failure_message', 'failure_message with group'],
+        field_3: ['msg'],
+      });
+      expect(res.getWarnings()).toEqual({
+        field_2: ['warning test', 'another warning test'],
+        field_5: ['warning message'],
+      });
+      expect(res.getErrors()).toEqual({
+        field_1: ['message', 'failure_message', 'failure_message with group'],
+        field_3: ['msg'],
+      });
+      expect(res.hasErrorsByGroup('group_1')).toBe(true);
+      expect(res.hasErrorsByGroup('group_1', 'field_1')).toBe(true);
+      expect(res.hasErrorsByGroup('group_2')).toBe(false);
+      expect(res.hasErrorsByGroup('group_1', 'field_2')).toBe(false);
+      expect(res.hasErrorsByGroup('group_3')).toBe(false);
+      expect(res.hasWarningsByGroup('group_1')).toBe(false);
+      expect(res.hasWarningsByGroup('group_1', 'field_1')).toBe(false);
+      expect(res.hasWarningsByGroup('group_2')).toBe(true);
+      expect(res.hasWarningsByGroup('group_1', 'field_2')).toBe(false);
+      expect(res.hasWarningsByGroup('group_2', 'field_5')).toBe(true);
+    });
+  });
+
+  describe('Value memoization', () => {
+    it('When unchanged, should produce a memoized result', () => {
+      const suite = vest.create(() => {
+        dummyTest.passing('field_1');
+        dummyTest.failing('field_1', 'message');
+      });
+      const res = suite();
+      expect(res).toMatchObject(suite.get());
+      expect(suite.get()).toBe(suite.get());
+    });
+
+    it('When changed, should produce a new result object', () => {
+      const suite = vest.create((v1, v2) => {
+        vest.test('f1', () => {
+          vest.enforce(v1).equals(1);
+        });
+        vest.test('f2', () => {
+          vest.enforce(v2).equals(2);
+        });
+      });
+      const res1 = suite(1, 2);
+      const res2 = suite(1, 1);
+      suite(2, 1);
+      expect(res1).not.toMatchObject(suite.get());
+      expect(res1).not.toBe(suite.get());
+      expect(res2).not.toMatchObject(suite.get());
+      expect(res2).not.toBe(suite.get());
+    });
+  });
+});
+
+describe('suite.get()', () => {
+  describe('exposed methods', () => {
+    it('Should have all exposed methods', () => {
+      const suite = vest.create(() => {});
+      expect(suite.get()).toMatchInlineSnapshot(`
+        {
+          "errorCount": 0,
+          "getErrors": [Function],
+          "getErrorsByGroup": [Function],
+          "getWarnings": [Function],
+          "getWarningsByGroup": [Function],
+          "groups": {},
+          "hasErrors": [Function],
+          "hasErrorsByGroup": [Function],
+          "hasWarnings": [Function],
+          "hasWarningsByGroup": [Function],
+          "isValid": [Function],
+          "isValidByGroup": [Function],
+          "suiteName": undefined,
+          "testCount": 0,
+          "tests": {},
+          "valid": false,
+          "warnCount": 0,
+        }
+      `);
+    });
+  });
+});
+
+describe('suite()', () => {
+  describe('exposed methods', () => {
+    it('Should have all exposed methods', () => {
+      expect(vest.create(() => {})()).toMatchInlineSnapshot(`
+        {
+          "done": [Function],
+          "errorCount": 0,
+          "getErrors": [Function],
+          "getErrorsByGroup": [Function],
+          "getWarnings": [Function],
+          "getWarningsByGroup": [Function],
+          "groups": {},
+          "hasErrors": [Function],
+          "hasErrorsByGroup": [Function],
+          "hasWarnings": [Function],
+          "hasWarningsByGroup": [Function],
+          "isValid": [Function],
+          "isValidByGroup": [Function],
+          "suiteName": undefined,
+          "testCount": 0,
+          "tests": {},
+          "valid": false,
+          "warnCount": 0,
+        }
+      `);
+    });
+  });
+});

package/src/suiteResult/done/deferDoneCallback.ts

@@ -0,0 +1,28 @@
+import { assign } from 'vest-utils';
+
+import {
+  DoneCallback,
+  useDoneCallbacks,
+  useFieldCallbacks,
+} from 'PersistedContext';
+import { TFieldName } from 'SuiteResultTypes';
+
+export function deferDoneCallback(
+  doneCallback: DoneCallback,
+  fieldName?: TFieldName
+): void {
+  const [, setFieldCallbacks] = useFieldCallbacks();
+  const [, setDoneCallbacks] = useDoneCallbacks();
+
+  if (fieldName) {
+    setFieldCallbacks(fieldCallbacks =>
+      assign(fieldCallbacks, {
+        [fieldName]: (fieldCallbacks[fieldName] || []).concat(doneCallback),
+      })
+    );
+
+    return;
+  }
+
+  setDoneCallbacks(doneCallbacks => doneCallbacks.concat(doneCallback));
+}

package/src/suiteResult/done/shouldSkipDoneRegistration.ts

@@ -0,0 +1,20 @@
+/**
+ * DONE is here and not in its own module to prevent circular dependency issues.
+ */
+
+import { isFunction, numberEquals } from 'vest-utils';
+
+import { SuiteResult, SuiteRunResult, TFieldName } from 'SuiteResultTypes';
+
+export function shouldSkipDoneRegistration(
+  callback: (res: SuiteResult<TFieldName>) => void,
+
+  fieldName: TFieldName | undefined,
+  output: SuiteRunResult<TFieldName>
+): boolean {
+  // If we do not have any test runs for the current field
+  return !!(
+    !isFunction(callback) ||
+    (fieldName && numberEquals(output.tests[fieldName]?.testCount, 0))
+  );
+}