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

package/src/suiteResult/selectors/shouldAddValidProperty.ts

@@ -0,0 +1,148 @@
+import { isOptionalFiedApplied } from 'optional';
+
+import { IsolateTest } from 'IsolateTest';
+import { OptionalFieldTypes } from 'OptionalTypes';
+import { useOptionalField } from 'PersistedContext';
+import { Severity } from 'Severity';
+import { TFieldName } from 'SuiteResultTypes';
+import { TestWalker } from 'TestWalker';
+import {
+  hasErrorsByTestObjects,
+  hasGroupFailuresByTestObjects,
+} from 'hasFailuresByTestObjects';
+import { nonMatchingFieldName } from 'matchingFieldName';
+import { nonMatchingGroupName } from 'matchingGroupName';
+
+export function shouldAddValidProperty(fieldName?: TFieldName): boolean {
+  // Is the field optional, and the optional condition is applied
+  if (isOptionalFiedApplied(fieldName)) {
+    return true;
+  }
+
+  // Are there no tests?
+  if (TestWalker.hasNoTests()) {
+    return false;
+  }
+
+  // // Does the field have any tests with errors?
+  if (hasErrorsByTestObjects(fieldName)) {
+    return false;
+  }
+
+  // Does the given field have any pending tests that are not optional?
+  if (hasNonOptionalIncomplete(fieldName)) {
+    return false;
+  }
+
+  // Does the field have no missing tests?
+  return noMissingTests(fieldName);
+}
+
+export function shouldAddValidPropertyInGroup(
+  groupName: string,
+  fieldName: TFieldName
+): boolean {
+  if (isOptionalFiedApplied(fieldName)) {
+    return true;
+  }
+
+  if (hasGroupFailuresByTestObjects(Severity.ERRORS, groupName, fieldName)) {
+    return false;
+  }
+
+  // Do the given group/field have any pending tests that are not optional?
+  if (hasNonOptionalIncompleteByGroup(groupName, fieldName)) {
+    return false;
+  }
+
+  return noMissingTestsByGroup(groupName, fieldName);
+}
+
+// Does the given field have any pending tests that are not optional?
+function hasNonOptionalIncomplete(fieldName?: TFieldName) {
+  return TestWalker.someIncompleteTests(testObject => {
+    return isTestObjectOptional(testObject, fieldName);
+  });
+}
+
+// Do the given group/field have any pending tests that are not optional?
+function hasNonOptionalIncompleteByGroup(
+  groupName: string,
+  fieldName: TFieldName
+): boolean {
+  return TestWalker.someIncompleteTests(testObject => {
+    if (nonMatchingGroupName(testObject, groupName)) {
+      return false;
+    }
+
+    return isTestObjectOptional(testObject, fieldName);
+  });
+}
+
+function isTestObjectOptional(
+  testObject: IsolateTest,
+  fieldName?: TFieldName
+): boolean {
+  if (nonMatchingFieldName(testObject, fieldName)) {
+    return false;
+  }
+
+  return isOptionalFiedApplied(fieldName);
+}
+
+// Did all of the tests for the provided field run/omit?
+// This makes sure that the fields are not skipped or pending.
+function noMissingTests(fieldName?: string): boolean {
+  return TestWalker.everyTest(testObject => {
+    return noMissingTestsLogic(testObject, fieldName);
+  });
+}
+
+// Does the group have no missing tests?
+function noMissingTestsByGroup(
+  groupName: string,
+  fieldName?: TFieldName
+): boolean {
+  return TestWalker.everyTest(testObject => {
+    if (nonMatchingGroupName(testObject, groupName)) {
+      return true;
+    }
+
+    return noMissingTestsLogic(testObject, fieldName);
+  });
+}
+
+function noMissingTestsLogic(
+  testObject: IsolateTest,
+  fieldName?: TFieldName
+): boolean {
+  if (nonMatchingFieldName(testObject, fieldName)) {
+    return true;
+  }
+
+  /**
+   * The reason we're checking for the optional field here and not in "omitOptionalFields"
+   * is because that unlike the bool/function check we do there, here it only depends on
+   * whether the field was tested alredy or not.
+   *
+   * We qualify the test as not missing only if it was already run, if it is omitted,
+   * or if it is marked as optional, even if the optional check did not apply yet -
+   * but the test did not reach its final state.
+   */
+
+  return (
+    optionalTestAwaitsResolution(testObject) ||
+    testObject.isTested() ||
+    testObject.isOmitted()
+  );
+}
+
+function optionalTestAwaitsResolution(testObject: IsolateTest): boolean {
+  // Does the test belong to an optional field,
+  // and the test itself is still in an indeterminate state?
+
+  return (
+    useOptionalField(testObject.fieldName).type ===
+      OptionalFieldTypes.Delayed && testObject.awaitsResolution()
+  );
+}

package/src/suiteResult/selectors/suiteSelectors.ts

@@ -0,0 +1,199 @@
+import { isPositive } from 'vest-utils';
+
+import { Severity, SeverityCount } from 'Severity';
+import {
+  FailureMessages,
+  GetFailuresResponse,
+  SuiteSummary,
+  TFieldName,
+  TestsContainer,
+} from 'SuiteResultTypes';
+import { gatherFailures } from 'collectFailures';
+
+// eslint-disable-next-line max-lines-per-function, max-statements
+export function suiteSelectors<F extends TFieldName>(
+  summary: SuiteSummary<F>
+): SuiteSelectors<F> {
+  const selectors = {
+    getErrors,
+    getErrorsByGroup,
+    getWarnings,
+    getWarningsByGroup,
+    hasErrors,
+    hasErrorsByGroup,
+    hasWarnings,
+    hasWarningsByGroup,
+    isValid,
+    isValidByGroup,
+  };
+
+  return selectors;
+
+  // Booleans
+
+  function isValid(fieldName?: F): boolean {
+    return fieldName ? Boolean(summary.tests[fieldName]?.valid) : summary.valid;
+  }
+
+  function isValidByGroup(groupName: string, fieldName?: F): boolean {
+    const group = summary.groups[groupName];
+
+    if (!group) {
+      return false;
+    }
+
+    if (fieldName) {
+      return isFieldValid(group, fieldName);
+    }
+    for (const fieldName in group) {
+      if (!isFieldValid(group, fieldName)) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  function hasWarnings(fieldName?: F): boolean {
+    return hasFailures(summary, SeverityCount.WARN_COUNT, fieldName);
+  }
+
+  function hasErrors(fieldName?: F): boolean {
+    return hasFailures(summary, SeverityCount.ERROR_COUNT, fieldName);
+  }
+
+  function hasWarningsByGroup(groupName: string, fieldName?: F): boolean {
+    return hasFailuresByGroup(
+      summary,
+      SeverityCount.WARN_COUNT,
+      groupName,
+      fieldName
+    );
+  }
+
+  function hasErrorsByGroup(groupName: string, fieldName?: F): boolean {
+    return hasFailuresByGroup(
+      summary,
+      SeverityCount.ERROR_COUNT,
+      groupName,
+      fieldName
+    );
+  }
+
+  // Responses
+
+  function getWarnings(): FailureMessages;
+  function getWarnings(fieldName: F): string[];
+  function getWarnings(fieldName?: F): GetFailuresResponse {
+    return getFailures(summary, Severity.WARNINGS, fieldName);
+  }
+
+  function getErrors(): FailureMessages;
+  function getErrors(fieldName: F): string[];
+  function getErrors(fieldName?: F): GetFailuresResponse {
+    return getFailures(summary, Severity.ERRORS, fieldName);
+  }
+  function getErrorsByGroup(groupName: string): FailureMessages;
+  function getErrorsByGroup(groupName: string, fieldName: F): string[];
+  function getErrorsByGroup(
+    groupName: string,
+    fieldName?: F
+  ): GetFailuresResponse {
+    return getFailuresByGroup(summary, Severity.ERRORS, groupName, fieldName);
+  }
+
+  function getWarningsByGroup(groupName: string): FailureMessages;
+  function getWarningsByGroup(groupName: string, fieldName: F): string[];
+  function getWarningsByGroup(
+    groupName: string,
+    fieldName?: F
+  ): GetFailuresResponse {
+    return getFailuresByGroup(summary, Severity.WARNINGS, groupName, fieldName);
+  }
+}
+
+export interface SuiteSelectors<F extends TFieldName> {
+  getErrors(fieldName: F): string[];
+  getErrors(): FailureMessages;
+  getWarnings(): FailureMessages;
+  getWarnings(fieldName: F): string[];
+  getErrorsByGroup(groupName: string, fieldName: F): string[];
+  getErrorsByGroup(groupName: string): FailureMessages;
+  getWarningsByGroup(groupName: string): FailureMessages;
+  getWarningsByGroup(groupName: string, fieldName: F): string[];
+  hasErrors(fieldName?: F): boolean;
+  hasWarnings(fieldName?: F): boolean;
+  hasErrorsByGroup(groupName: string, fieldName?: F): boolean;
+  hasWarningsByGroup(groupName: string, fieldName?: F): boolean;
+  isValid(fieldName?: F): boolean;
+  isValidByGroup(groupName: string, fieldName?: F): boolean;
+}
+
+// Gathers all failures of a given severity
+// With a fieldName, it will only gather failures for that field
+function getFailures(
+  summary: SuiteSummary<TFieldName>,
+  severityKey: Severity,
+  fieldName?: TFieldName
+): GetFailuresResponse {
+  return gatherFailures(summary.tests, severityKey, fieldName);
+}
+
+// Gathers all failures of a given severity within a group
+// With a fieldName, it will only gather failures for that field
+function getFailuresByGroup(
+  summary: SuiteSummary<TFieldName>,
+  severityKey: Severity,
+  groupName: string,
+  fieldName?: TFieldName
+): GetFailuresResponse {
+  return gatherFailures(summary.groups[groupName], severityKey, fieldName);
+}
+// Checks if a field is valid within a container object - can be within a group or top level
+function isFieldValid(
+  testContainer: TestsContainer<TFieldName>,
+  fieldName: TFieldName
+): boolean {
+  return !!testContainer[fieldName]?.valid;
+}
+
+// Checks if a there are any failures of a given severity within a group
+// If a fieldName is provided, it will only check for failures within that field
+function hasFailuresByGroup(
+  summary: SuiteSummary<TFieldName>,
+  severityCount: SeverityCount,
+  groupName: string,
+  fieldName?: TFieldName
+): boolean {
+  const group = summary.groups[groupName];
+
+  if (!group) {
+    return false;
+  }
+
+  if (fieldName) {
+    return isPositive(group[fieldName]?.[severityCount]);
+  }
+
+  for (const field in group) {
+    if (isPositive(group[field]?.[severityCount])) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+// Checks if there are any failures of a given severity
+// If a fieldName is provided, it will only check for failures within that field
+function hasFailures(
+  summary: SuiteSummary<TFieldName>,
+  countKey: SeverityCount,
+  fieldName?: TFieldName
+): boolean {
+  const failureCount = fieldName
+    ? summary.tests[fieldName]?.[countKey]
+    : summary[countKey] || 0;
+
+  return isPositive(failureCount);
+}

package/src/suiteResult/suiteResult.ts

@@ -0,0 +1,15 @@
+import { assign } from 'vest-utils';
+
+import { useSuiteName, useSuiteResultCache } from 'PersistedContext';
+import { SuiteResult, TFieldName } from 'SuiteResultTypes';
+import { produceSuiteSummary } from 'produceSuiteSummary';
+import { suiteSelectors } from 'suiteSelectors';
+
+export function createSuiteResult<F extends TFieldName>(): SuiteResult<F> {
+  const summary = produceSuiteSummary();
+  const suiteName = useSuiteName();
+
+  return useSuiteResultCache(() =>
+    assign(summary, suiteSelectors(summary), { suiteName })
+  );
+}

package/src/suiteResult/suiteRunResult.ts

@@ -0,0 +1,43 @@
+import { assign } from 'vest-utils';
+
+import { persist } from 'PersistedContext';
+import { SuiteResult, SuiteRunResult, TFieldName } from 'SuiteResultTypes';
+import { TestWalker } from 'TestWalker';
+import { deferDoneCallback } from 'deferDoneCallback';
+import { shouldSkipDoneRegistration } from 'shouldSkipDoneRegistration';
+import { createSuiteResult } from 'suiteResult';
+
+export function suiteRunResult<F extends TFieldName>(): SuiteRunResult<F> {
+  return assign({}, createSuiteResult(), {
+    done: persist(done),
+  });
+}
+
+/**
+ * Registers done callbacks.
+ * @register {Object} Vest output object.
+ */
+function done<F extends TFieldName>(...args: any[]): SuiteRunResult<F> {
+  const [callback, fieldName] = args.reverse() as [
+    (res: SuiteResult<F>) => void,
+    string
+  ];
+  const output = suiteRunResult();
+  if (shouldSkipDoneRegistration(callback, fieldName, output)) {
+    return output;
+  }
+  const doneCallback = () => callback(createSuiteResult());
+  if (!TestWalker.hasRemainingTests(fieldName)) {
+    doneCallback();
+    return output;
+  }
+  deferDoneCallback(doneCallback, fieldName);
+  return output;
+}
+
+export interface Done<F extends TFieldName> {
+  (...args: [cb: (res: SuiteResult<F>) => void]): SuiteRunResult<F>;
+  (
+    ...args: [fieldName: F, cb: (res: SuiteResult<F>) => void]
+  ): SuiteRunResult<F>;
+}

package/src/vest.ts

@@ -0,0 +1,36 @@
+import { enforce } from 'n4s';
+import { optional } from 'optional';
+
+import { IsolateTest } from 'IsolateTest';
+import type { SuiteResult, SuiteRunResult } from 'SuiteResultTypes';
+import { SuiteSummary } from 'SuiteResultTypes';
+import { createSuite, Suite } from 'createSuite';
+import { each } from 'each';
+import { skip, only } from 'exclusive';
+import { group } from 'group';
+import { include } from 'include';
+import { eager } from 'mode';
+import { omitWhen } from 'omitWhen';
+import { skipWhen } from 'skipWhen';
+import { suiteSelectors } from 'suiteSelectors';
+import { test } from 'test';
+import { warn } from 'warn';
+
+export {
+  createSuite as create,
+  test,
+  group,
+  optional,
+  enforce,
+  skip,
+  skipWhen,
+  omitWhen,
+  only,
+  warn,
+  include,
+  suiteSelectors,
+  eager,
+  each,
+};
+
+export type { SuiteResult, SuiteRunResult, SuiteSummary, IsolateTest, Suite };

package/testUtils/TVestMock.ts

@@ -0,0 +1,5 @@
+import * as vest from 'vest';
+
+export type TVestMock = typeof vest;
+
+export type TTestSuite = vest.Suite<(...args: any[]) => void, string>;

package/testUtils/__tests__/partition.test.ts

@@ -1,17 +1,17 @@
-import { partition } from 'vest-utils';
+import partition from '../partition';
 
 describe('partition', () => {
   it('Should correctly partition array', () => {
     expect(partition([300, 200, 10, 50, 0, -500], v => v <= 100))
       .toMatchInlineSnapshot(`
-      Array [
-        Array [
+      [
+        [
           10,
           50,
           0,
           -500,
         ],
-        Array [
+        [
           300,
           200,
         ],

package/testUtils/mockThrowError.ts

@@ -1,11 +1,13 @@
+import { TVestMock } from './TVestMock';
+
 export default function mockThrowError() {
-  const deferThrow = jest.fn();
+  const deferThrow = jest.fn<string, any>();
   jest.resetModules();
   jest.mock('vest-utils', () => ({
     ...jest.requireActual('vest-utils'),
     deferThrow,
   }));
-  const vest = require('vest');
+  const vest = require('vest') as TVestMock;
 
   return {
     deferThrow,

package/testUtils/suiteDummy.ts

@@ -2,6 +2,7 @@ import { asArray } from 'vest-utils';
 
 import { dummyTest } from './testDummy';
 
+import { TFieldName } from 'SuiteResultTypes';
 import { optional, create, skip, SuiteResult } from 'vest';
 
 export function failing(failingFields?: string | string[]) {
@@ -103,6 +104,6 @@ function createSuite(
   });
 }
 
-export function ser(res: SuiteResult) {
+export function ser<F extends TFieldName>(res: SuiteResult<F>) {
   return JSON.parse(JSON.stringify(res));
 }

package/testUtils/testDummy.ts

@@ -1,7 +1,7 @@
 /* eslint-disable jest/valid-title */
-import faker from 'faker';
+import { faker } from '@faker-js/faker';
 
-import { test, warn } from 'vest';
+import { test as vestTest, warn } from 'vest';
 
 /**
  * Generates dummy vest tests.
@@ -12,7 +12,7 @@ const testDummy = () => {
     message: string = faker.random.words(),
     groupName?: string
   ) => {
-    const to = test(
+    const to = vestTest(
       name,
       message,
       jest.fn(() => {
@@ -32,7 +32,7 @@ const testDummy = () => {
     message = faker.random.words(),
     groupName?: string
   ) => {
-    const to = test(
+    const to = vestTest(
       name,
       message,
       jest.fn(() => {
@@ -53,7 +53,7 @@ const testDummy = () => {
     message = faker.random.words(),
     groupName?: string
   ) => {
-    const to = test(name, message, jest.fn());
+    const to = vestTest(name, message, jest.fn());
 
     if (groupName) {
       to.groupName = groupName;
@@ -67,7 +67,7 @@ const testDummy = () => {
     message = faker.random.words(),
     groupName?: string
   ) => {
-    const to = test(
+    const to = vestTest(
       name,
       message,
       jest.fn(() => {
@@ -84,7 +84,7 @@ const testDummy = () => {
     name = faker.random.word(),
     { message = faker.random.words(), time = 0 } = {}
   ) =>
-    test(
+    vestTest(
       name,
       message,
       jest.fn(
@@ -99,7 +99,7 @@ const testDummy = () => {
     name = faker.random.word(),
     { message = faker.random.words(), time = 0 } = {}
   ) =>
-    test(
+    vestTest(
       name,
       message,
       jest.fn(() => {
@@ -114,7 +114,7 @@ const testDummy = () => {
     name = faker.random.word(),
     { message = faker.random.words(), time = 0 } = {}
   ) =>
-    test(
+    vestTest(
       name,
       message,
       jest.fn(
@@ -129,7 +129,7 @@ const testDummy = () => {
     name = faker.random.word(),
     { message = faker.random.words(), time = 0 } = {}
   ) =>
-    test(
+    vestTest(
       name,
       message,
       jest.fn(() => {
@@ -153,3 +153,5 @@ const testDummy = () => {
 };
 
 export const dummyTest = testDummy();
+
+export type TDummyTest = typeof dummyTest;

package/testUtils/testPromise.ts

@@ -0,0 +1,3 @@
+export function TestPromise(cb: (done: () => void) => void): Promise<void> {
+  return new Promise<void>(done => cb(done));
+}

package/tsconfig.json

@@ -1,8 +1,90 @@
 {
   "extends": "../../tsconfig.json",
+  "rootDir": ".",
   "compilerOptions": {
-    "declarationMap": true,
+    "baseUrl": ".",
     "declarationDir": "./types",
-    "outDir": "./dist"
+    "declarationMap": true,
+    "outDir": "./dist",
+    "paths": {
+      "PersistedContext": ["src/core/context/PersistedContext.ts"],
+      "SuiteContext": ["src/core/context/SuiteContext.ts"],
+      "isIsolate": ["src/core/isolate/isIsolate.ts"],
+      "isolate": ["src/core/isolate/isolate.ts"],
+      "IsolateTest": ["src/core/isolate/IsolateTest/IsolateTest.ts"],
+      "IsolateTestReconciler": [
+        "src/core/isolate/IsolateTest/IsolateTestReconciler.ts"
+      ],
+      "IsolateTestStateMachine": [
+        "src/core/isolate/IsolateTest/IsolateTestStateMachine.ts"
+      ],
+      "SimpleStateMachine": [
+        "src/core/isolate/IsolateTest/SimpleStateMachine.ts"
+      ],
+      "TestWalker": ["src/core/isolate/IsolateTest/TestWalker.ts"],
+      "IsolateTypes": ["src/core/isolate/IsolateTypes.ts"],
+      "cancelOverriddenPendingTest": [
+        "src/core/isolate/reconciler/cancelOverriddenPendingTest.ts"
+      ],
+      "isSameProfileTest": ["src/core/isolate/reconciler/isSameProfileTest.ts"],
+      "Reconciler": ["src/core/isolate/reconciler/Reconciler/Reconciler.ts"],
+      "walker": ["src/core/isolate/walker.ts"],
+      "SuiteWalker": ["src/core/SuiteWalker/SuiteWalker.ts"],
+      "asVestTest": ["src/core/test/helpers/asVestTest.ts"],
+      "matchingFieldName": ["src/core/test/helpers/matchingFieldName.ts"],
+      "matchingGroupName": ["src/core/test/helpers/matchingGroupName.ts"],
+      "nonMatchingSeverityProfile": [
+        "src/core/test/helpers/nonMatchingSeverityProfile.ts"
+      ],
+      "shouldUseErrorMessage": [
+        "src/core/test/helpers/shouldUseErrorMessage.ts"
+      ],
+      "test.memo": ["src/core/test/test.memo.ts"],
+      "test": ["src/core/test/test.ts"],
+      "runTest": ["src/core/test/testLevelFlowControl/runTest.ts"],
+      "verifyTestRun": ["src/core/test/testLevelFlowControl/verifyTestRun.ts"],
+      "testObjectIsolate": ["src/core/test/testObjectIsolate.ts"],
+      "TestTypes": ["src/core/test/TestTypes.ts"],
+      "VestBus": ["src/core/VestBus/VestBus.ts"],
+      "ErrorStrings": ["src/errors/ErrorStrings.ts"],
+      "classnames": ["src/exports/classnames.ts"],
+      "enforce@compose": ["src/exports/enforce@compose.ts"],
+      "enforce@compounds": ["src/exports/enforce@compounds.ts"],
+      "enforce@schema": ["src/exports/enforce@schema.ts"],
+      "parser": ["src/exports/parser.ts"],
+      "promisify": ["src/exports/promisify.ts"],
+      "exclusive": ["src/hooks/exclusive.ts"],
+      "include": ["src/hooks/include.ts"],
+      "mode": ["src/hooks/mode.ts"],
+      "optional": ["src/hooks/optional/optional.ts"],
+      "OptionalTypes": ["src/hooks/optional/OptionalTypes.ts"],
+      "warn": ["src/hooks/warn.ts"],
+      "each": ["src/isolates/each.ts"],
+      "group": ["src/isolates/group.ts"],
+      "omitWhen": ["src/isolates/omitWhen.ts"],
+      "skipWhen": ["src/isolates/skipWhen.ts"],
+      "createSuite": ["src/suite/createSuite.ts"],
+      "runCallbacks": ["src/suite/runCallbacks.ts"],
+      "deferDoneCallback": ["src/suiteResult/done/deferDoneCallback.ts"],
+      "shouldSkipDoneRegistration": [
+        "src/suiteResult/done/shouldSkipDoneRegistration.ts"
+      ],
+      "collectFailures": ["src/suiteResult/selectors/collectFailures.ts"],
+      "hasFailuresByTestObjects": [
+        "src/suiteResult/selectors/hasFailuresByTestObjects.ts"
+      ],
+      "produceSuiteSummary": [
+        "src/suiteResult/selectors/produceSuiteSummary.ts"
+      ],
+      "shouldAddValidProperty": [
+        "src/suiteResult/selectors/shouldAddValidProperty.ts"
+      ],
+      "suiteSelectors": ["src/suiteResult/selectors/suiteSelectors.ts"],
+      "Severity": ["src/suiteResult/Severity.ts"],
+      "suiteResult": ["src/suiteResult/suiteResult.ts"],
+      "SuiteResultTypes": ["src/suiteResult/SuiteResultTypes.ts"],
+      "suiteRunResult": ["src/suiteResult/suiteRunResult.ts"],
+      "vest": ["src/vest.ts"]
+    }
   }
 }