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

package/src/core/test/__tests__/test.test.ts

@@ -0,0 +1,226 @@
+import { faker } from '@faker-js/faker';
+
+import { TestPromise } from '../../../../testUtils/testPromise';
+
+import { create, test, warn, enforce, IsolateTest } from 'vest';
+
+let testObject: IsolateTest;
+
+describe("Test Vest's `test` function", () => {
+  describe('test callbacks', () => {
+    describe('Warn hook', () => {
+      it('Should be marked as warning when the warn hook gets called', () => {
+        create(() => {
+          testObject = test(faker.random.word(), faker.lorem.sentence(), () => {
+            warn();
+          });
+        })();
+        expect(testObject.warns()).toBe(true);
+      });
+    });
+
+    describe('Sync', () => {
+      it('Should be marked as failed after a thrown error', () => {
+        create(() => {
+          testObject = test(faker.random.word(), faker.lorem.sentence(), () => {
+            throw new Error();
+          });
+        })();
+        expect(testObject.isFailing()).toBe(true);
+        // @ts-ignore - very much intentional
+        expect(testObject == false).toBe(true); //eslint-disable-line
+      });
+
+      it('Should be marked as failed for an explicit false return', () => {
+        create(() => {
+          test(faker.random.word(), faker.lorem.sentence(), () => false);
+        })();
+        expect(testObject.isFailing()).toBe(true);
+        // @ts-ignore - very much intentional
+        expect(testObject == false).toBe(true); //eslint-disable-line
+      });
+
+      describe('Thrown with a message', () => {
+        describe('When field has a message', () => {
+          it("Should use field's own message", () => {
+            const res = create(() => {
+              test('field_with_message', 'some_field_message', () => {
+                failWithString();
+              });
+              test('warning_field_with_message', 'some_field_message', () => {
+                warn();
+                failWithString();
+              });
+            })();
+
+            expect(res.getErrors('field_with_message')).toEqual([
+              'some_field_message',
+            ]);
+            expect(res.tests['field_with_message'].errors).toEqual([
+              'some_field_message',
+            ]);
+            expect(res.getWarnings('warning_field_with_message')).toEqual([
+              'some_field_message',
+            ]);
+            expect(res.tests['warning_field_with_message'].warnings).toEqual([
+              'some_field_message',
+            ]);
+          });
+        });
+        describe('When field does not have a message', () => {
+          it('Should use message from enforce().message()', () => {
+            const res = create(() => {
+              test('field_without_message', () => {
+                enforce(100).message('some_field_message').equals(0);
+              });
+            })();
+
+            expect(res.getErrors('field_without_message')).toEqual([
+              'some_field_message',
+            ]);
+          });
+          it('Should use message from thrown error', () => {
+            const res = create(() => {
+              test('field_without_message', () => {
+                failWithString();
+              });
+              test('warning_field_without_message', () => {
+                warn();
+                failWithString();
+              });
+            })();
+
+            expect(res.getErrors('field_without_message')).toEqual([
+              'I fail with a message',
+            ]);
+            expect(res.tests['field_without_message'].errors).toEqual([
+              'I fail with a message',
+            ]);
+            expect(res.getWarnings('warning_field_without_message')).toEqual([
+              'I fail with a message',
+            ]);
+            expect(res.tests['warning_field_without_message'].warnings).toEqual(
+              ['I fail with a message']
+            );
+          });
+        });
+      });
+    });
+
+    describe('async', () => {
+      it('Should be marked as failed when a returned promise rejects', () =>
+        TestPromise(done => {
+          create(() => {
+            testObject = test(
+              faker.random.word(),
+              faker.lorem.sentence(),
+              () =>
+                new Promise((_, reject) => {
+                  expect(testObject.isFailing()).toBe(false);
+                  setTimeout(reject, 300);
+                })
+            );
+            expect(testObject.isFailing()).toBe(false);
+            setTimeout(() => {
+              expect(testObject.isFailing()).toBe(true);
+              done();
+            }, 310);
+          })();
+        }));
+    });
+  });
+
+  describe('test params', () => {
+    let testObject: IsolateTest;
+    it('creates a test without a message and without a key', () => {
+      create(() => {
+        testObject = test('field_name', () => undefined);
+      })();
+      expect(testObject.fieldName).toBe('field_name');
+      expect(testObject.key).toBeNull();
+      expect(testObject.message).toBeUndefined();
+      expect(testObject).toMatchSnapshot();
+    });
+
+    it('creates a test without a key', () => {
+      create(() => {
+        testObject = test('field_name', 'failure message', () => undefined);
+      })();
+      expect(testObject.fieldName).toBe('field_name');
+      expect(testObject.key).toBeNull();
+      expect(testObject.message).toBe('failure message');
+      expect(testObject).toMatchSnapshot();
+    });
+
+    it('creates a test without a message and with a key', () => {
+      create(() => {
+        testObject = test('field_name', () => undefined, 'keyboardcat');
+      })();
+      expect(testObject.fieldName).toBe('field_name');
+      expect(testObject.key).toBe('keyboardcat');
+      expect(testObject.message).toBeUndefined();
+      expect(testObject).toMatchSnapshot();
+    });
+
+    it('creates a test with a message and with a key', () => {
+      create(() => {
+        testObject = test(
+          'field_name',
+          'failure message',
+          () => undefined,
+          'keyboardcat'
+        );
+      })();
+      expect(testObject.fieldName).toBe('field_name');
+      expect(testObject.key).toBe('keyboardcat');
+      expect(testObject.message).toBe('failure message');
+      expect(testObject).toMatchSnapshot();
+    });
+
+    it('throws when field name is not a string', () => {
+      const control = jest.fn();
+      create(() => {
+        // @ts-ignore
+        expect(() => test(undefined, () => undefined)).toThrow(
+          'Incompatible params passed to test function. Test fieldName must be a string'
+        );
+        // @ts-expect-error
+        expect(() => test(null, 'error message', () => undefined)).toThrow(
+          'Incompatible params passed to test function. Test fieldName must be a string'
+        );
+        expect(() =>
+          // @ts-expect-error
+          test(null, 'error message', () => undefined, 'key')
+        ).toThrow(
+          'Incompatible params passed to test function. Test fieldName must be a string'
+        );
+        control();
+      })();
+      expect(control).toHaveBeenCalled();
+    });
+
+    it('throws when callback is not a function', () => {
+      const control = jest.fn();
+      create(() => {
+        // @ts-expect-error
+        expect(() => test('x')).toThrow(
+          'Incompatible params passed to test function. Test callback must be a function'
+        );
+        // @ts-expect-error
+        expect(() => test('x', 'msg', undefined)).toThrow(
+          'Incompatible params passed to test function. Test callback must be a function'
+        );
+        // @ts-expect-error
+        expect(() => test('x', 'msg', undefined, 'key')).toThrow(
+          'Incompatible params passed to test function. Test callback must be a function'
+        );
+        control();
+      })();
+      expect(control).toHaveBeenCalled();
+    });
+  });
+});
+
+function failWithString(msg?: string) {
+  throw msg ?? 'I fail with a message';
+}

package/src/core/test/helpers/__tests__/nonMatchingSeverityProfile.test.ts

@@ -0,0 +1,52 @@
+import { IsolateTest } from 'IsolateTest';
+import { IsolateTypes } from 'IsolateTypes';
+import { Severity } from 'Severity';
+import { nonMatchingSeverityProfile } from 'nonMatchingSeverityProfile';
+
+describe('nonMatchingSeverityProfile', () => {
+  let testObject: IsolateTest;
+
+  beforeEach(() => {
+    testObject = new IsolateTest(IsolateTypes.TEST, {
+      fieldName: 'field',
+      testFn: jest.fn(),
+    });
+  });
+  describe('When matching', () => {
+    describe('When both are warning', () => {
+      it('should return false', () => {
+        testObject.warn();
+        expect(nonMatchingSeverityProfile(Severity.WARNINGS, testObject)).toBe(
+          false
+        );
+      });
+    });
+
+    describe('When both are not warning', () => {
+      it('should return false', () => {
+        expect(nonMatchingSeverityProfile(Severity.ERRORS, testObject)).toBe(
+          false
+        );
+      });
+    });
+  });
+
+  describe('When non matching', () => {
+    describe('When test is warning', () => {
+      it('should return true', () => {
+        testObject.warn();
+        expect(nonMatchingSeverityProfile(Severity.ERRORS, testObject)).toBe(
+          true
+        );
+      });
+    });
+
+    describe('When severity is warning', () => {
+      it('should return true', () => {
+        expect(nonMatchingSeverityProfile(Severity.WARNINGS, testObject)).toBe(
+          true
+        );
+      });
+    });
+  });
+});

package/src/core/test/helpers/asVestTest.ts

@@ -0,0 +1,9 @@
+import { invariant } from 'vest-utils';
+
+import { ErrorStrings } from 'ErrorStrings';
+import { IsolateTest } from 'IsolateTest';
+
+export function asVestTest(value: any): IsolateTest {
+  invariant(value instanceof IsolateTest, ErrorStrings.EXPECTED_VEST_TEST);
+  return value;
+}

package/src/core/test/helpers/matchingFieldName.ts

@@ -0,0 +1,16 @@
+import { IsolateTest } from 'IsolateTest';
+import { TFieldName } from 'SuiteResultTypes';
+
+export function nonMatchingFieldName(
+  testObject: IsolateTest,
+  fieldName?: TFieldName | void
+): boolean {
+  return !!fieldName && !matchingFieldName(testObject, fieldName);
+}
+
+export default function matchingFieldName(
+  testObject: IsolateTest,
+  fieldName?: TFieldName | void
+): boolean {
+  return !!(fieldName && testObject.fieldName === fieldName);
+}

package/src/core/test/helpers/matchingGroupName.ts

@@ -0,0 +1,12 @@
+import { bindNot } from 'vest-utils';
+
+import { IsolateTest } from 'IsolateTest';
+
+export const nonMatchingGroupName = bindNot(matchingGroupName);
+
+export function matchingGroupName(
+  testObject: IsolateTest,
+  groupName: string | void
+): boolean {
+  return testObject.groupName === groupName;
+}

package/src/core/test/helpers/nonMatchingSeverityProfile.ts

@@ -0,0 +1,14 @@
+import { either } from 'vest-utils';
+
+import { IsolateTest } from 'IsolateTest';
+import { Severity } from 'Severity';
+
+/**
+ * Checks that a given test object matches the currently specified severity level
+ */
+export function nonMatchingSeverityProfile(
+  severity: Severity,
+  testObject: IsolateTest
+): boolean {
+  return either(severity === Severity.WARNINGS, testObject.warns());
+}

package/src/core/test/helpers/shouldUseErrorMessage.ts

@@ -0,0 +1,9 @@
+import { isStringValue, isUndefined } from 'vest-utils';
+
+export function shouldUseErrorAsMessage(
+  message: string | void,
+  error: unknown
+): error is string {
+  // kind of cheating with this safe guard, but it does the job
+  return isUndefined(message) && isStringValue(error);
+}

package/src/core/test/test.memo.ts

@@ -0,0 +1,81 @@
+import { isNull } from 'vest-utils';
+
+import { IsolateTest } from 'IsolateTest';
+import { useCurrentCursor, useSuiteId } from 'PersistedContext';
+import { useTestMemoCache } from 'SuiteContext';
+import { TFieldName } from 'SuiteResultTypes';
+import { TestFn } from 'TestTypes';
+import { VTest } from 'test';
+
+export function wrapTestMemo(test: VTest): TestMemo<TFieldName> {
+  /**
+   * Caches a test result based on the test's dependencies.
+   */
+  function memo<F extends TFieldName>(
+    fieldName: F,
+    ...args: ParametersWithoutMessage
+  ): IsolateTest;
+  function memo<F extends TFieldName>(
+    fieldName: F,
+    ...args: ParametersWithMessage
+  ): IsolateTest;
+  function memo<F extends TFieldName>(
+    fieldName: F,
+    ...args: ParamsOverload
+  ): IsolateTest {
+    const [deps, testFn, msg] = args.reverse() as [any[], TestFn, string];
+
+    // Implicit dependency for better specificity
+    const dependencies = [useSuiteId(), fieldName, useCurrentCursor()].concat(
+      deps
+    );
+
+    return getTestFromCache(dependencies, cacheAction);
+
+    function cacheAction() {
+      return test(fieldName, msg, testFn);
+    }
+  }
+
+  return memo;
+}
+
+function getTestFromCache(
+  dependencies: any[],
+  cacheAction: () => IsolateTest
+): IsolateTest {
+  const cache = useTestMemoCache();
+
+  const cached = cache.get(dependencies);
+
+  if (isNull(cached)) {
+    // cache miss
+    return cache(dependencies, cacheAction);
+  }
+
+  const [, cachedValue] = cached;
+
+  if (cachedValue.isCanceled()) {
+    // cache hit, but test is canceled
+    cache.invalidate(dependencies);
+    return cache(dependencies, cacheAction);
+  }
+
+  IsolateTest.setNode(cachedValue);
+
+  return cachedValue;
+}
+
+type TestMemo<F extends TFieldName> = {
+  (fieldName: F, ...args: ParametersWithoutMessage): IsolateTest;
+  (fieldName: F, ...args: ParametersWithMessage): IsolateTest;
+};
+
+type ParametersWithoutMessage = [test: TestFn, dependencies: unknown[]];
+type ParametersWithMessage = [
+  message: string,
+  test: TestFn,
+  dependencies: unknown[]
+];
+
+type ParamsOverload = ParametersWithoutMessage | ParametersWithMessage;

package/src/core/test/test.ts

@@ -0,0 +1,64 @@
+import { assign, invariant, isFunction, isStringValue } from 'vest-utils';
+
+import { IsolateTest } from 'IsolateTest';
+import { useEmit } from 'PersistedContext';
+import { useGroupName } from 'SuiteContext';
+import { TFieldName } from 'SuiteResultTypes';
+import { TestFn } from 'TestTypes';
+import { Events } from 'VestBus';
+import { IsolateKey } from 'isolate';
+import { wrapTestMemo } from 'test.memo';
+import { testObjectIsolate } from 'testObjectIsolate';
+
+function vestTest<F extends TFieldName>(
+  fieldName: F,
+  message: string,
+  cb: TestFn
+): IsolateTest;
+function vestTest<F extends TFieldName>(fieldName: F, cb: TestFn): IsolateTest;
+function vestTest<F extends TFieldName>(
+  fieldName: F,
+  message: string,
+  cb: TestFn,
+  key: IsolateKey
+): IsolateTest;
+function vestTest<F extends TFieldName>(
+  fieldName: F,
+  cb: TestFn,
+  key: IsolateKey
+): IsolateTest;
+function vestTest<F extends TFieldName>(
+  fieldName: F,
+  ...args:
+    | [message: string, cb: TestFn]
+    | [cb: TestFn]
+    | [message: string, cb: TestFn, key: IsolateKey]
+    | [cb: TestFn, key: IsolateKey]
+): IsolateTest {
+  const [message, testFn, key] = (
+    isFunction(args[1]) ? args : [undefined, ...args]
+  ) as [string | undefined, TestFn, IsolateKey];
+
+  invariant(isStringValue(fieldName), invalidParamError('fieldName', 'string'));
+  invariant(isFunction(testFn), invalidParamError('callback', 'function'));
+
+  const groupName = useGroupName();
+  const emit = useEmit();
+
+  const testObjectInput = { fieldName, groupName, key, message, testFn };
+
+  // This invalidates the suite cache.
+  emit(Events.TEST_RUN_STARTED);
+
+  return testObjectIsolate(testObjectInput);
+}
+
+export const test = assign(vestTest, {
+  memo: wrapTestMemo(vestTest),
+});
+
+export type VTest = typeof vestTest;
+
+function invalidParamError(name: string, expected: string): string {
+  return `Incompatible params passed to test function. Test ${name} must be a ${expected}`;
+}

package/src/core/test/testLevelFlowControl/runTest.ts

@@ -0,0 +1,86 @@
+import { isPromise, isStringValue } from 'vest-utils';
+
+import { IsolateTest } from 'IsolateTest';
+import { persist, useVestBus } from 'PersistedContext';
+import { SuiteContext } from 'SuiteContext';
+import { TestResult } from 'TestTypes';
+import { Events } from 'VestBus';
+import { verifyTestRun } from 'verifyTestRun';
+
+export function attemptRunTestObjectByTier(testObject: IsolateTest) {
+  verifyTestRun(testObject);
+
+  if (testObject.isNonActionable()) {
+    // TODO: Need to test that this works as expected
+    return;
+  }
+
+  if (testObject.isUntested()) {
+    runTest(testObject);
+  } else if (testObject.isAsyncTest()) {
+    testObject.setPending();
+    runAsyncTest(testObject);
+  }
+}
+
+function runSyncTest(testObject: IsolateTest): TestResult {
+  return SuiteContext.run({ currentTest: testObject }, () => testObject.run());
+}
+
+/**
+ * runs test, if async - adds to pending array
+ */
+function runTest(testObject: IsolateTest): void {
+  const VestBus = useVestBus();
+
+  // Run test callback.
+  // If a promise is returned, set as async and
+  // Move to pending list.
+  const result = runSyncTest(testObject);
+  try {
+    // try catch for safe property access
+    // in case object is an enforce chain
+    if (isPromise(result)) {
+      testObject.asyncTest = result;
+      testObject.setPending();
+      runAsyncTest(testObject);
+    } else {
+      VestBus.emit(Events.TEST_COMPLETED, testObject);
+    }
+  } catch (e) {
+    throw new Error(
+      `Unexpected error encountered during test registration.
+      Test Object: ${JSON.stringify(testObject)}.
+      Error: ${e}.`
+    );
+  }
+}
+
+/**
+ * Runs async test.
+ */
+function runAsyncTest(testObject: IsolateTest): void {
+  const { asyncTest, message } = testObject;
+
+  if (!isPromise(asyncTest)) return;
+
+  const VestBus = useVestBus();
+
+  const done = persist(() => {
+    VestBus.emit(Events.TEST_COMPLETED, testObject);
+  });
+  const fail = persist((rejectionMessage?: string) => {
+    if (testObject.isCanceled()) {
+      return;
+    }
+
+    testObject.message = isStringValue(rejectionMessage)
+      ? rejectionMessage
+      : message;
+    testObject.fail();
+
+    done();
+  });
+
+  asyncTest.then(done, fail);
+}

package/src/core/test/testLevelFlowControl/verifyTestRun.ts

@@ -0,0 +1,32 @@
+import { isOptionalFiedApplied } from 'optional';
+
+import { IsolateTest } from 'IsolateTest';
+import { isExcluded } from 'exclusive';
+import { shouldSkipBasedOnMode } from 'mode';
+import { withinActiveOmitWhen } from 'omitWhen';
+import { isExcludedIndividually } from 'skipWhen';
+
+export function verifyTestRun(testObject: IsolateTest): IsolateTest {
+  if (shouldSkipBasedOnMode(testObject)) {
+    testObject.skip();
+
+    return testObject;
+  }
+
+  if (withinActiveOmitWhen() || isOptionalFiedApplied(testObject.fieldName)) {
+    testObject.omit();
+
+    return testObject;
+  }
+
+  if (isExcluded(testObject)) {
+    // We're forcing skipping the pending test
+    // if we're directly within a skipWhen block
+    // This mostly means that we're probably giving
+    // up on this async test intentionally.
+    testObject.skip(isExcludedIndividually());
+    return testObject;
+  }
+
+  return testObject;
+}

package/src/core/test/testObjectIsolate.ts

@@ -0,0 +1,11 @@
+import { IsolateTest, IsolateTestInput } from 'IsolateTest';
+import { attemptRunTestObjectByTier } from 'runTest';
+
+export function testObjectIsolate(
+  testObjectInput: IsolateTestInput
+): IsolateTest {
+  return IsolateTest.factory(
+    (testObject: IsolateTest) => attemptRunTestObjectByTier(testObject),
+    testObjectInput
+  );
+}

package/src/errors/ErrorStrings.ts

@@ -0,0 +1,4 @@
+export enum ErrorStrings {
+  HOOK_CALLED_OUTSIDE = 'hook called outside of a running suite.',
+  EXPECTED_VEST_TEST = 'Expected value to be an instance of IsolateTest',
+}