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

package/src/hooks/exclusive.ts

@@ -0,0 +1,179 @@
+import {
+  isStringValue,
+  asArray,
+  hasOwnProperty,
+  optionalFunctionValue,
+} from 'vest-utils';
+
+import { ErrorStrings } from 'ErrorStrings';
+import { IsolateTest } from 'IsolateTest';
+import { useExclusion, useInclusion } from 'SuiteContext';
+import { TFieldName } from 'SuiteResultTypes';
+import { isExcludedIndividually } from 'skipWhen';
+
+type ExclusionItem = string | string[] | undefined;
+type FieldExclusion<F extends TFieldName> = F | F[] | undefined;
+
+/**
+ * Adds a field or a list of fields into the inclusion list
+ *
+ * @example
+ *
+ * only('username');
+ */
+export function only<F extends TFieldName>(item: FieldExclusion<F>): void {
+  return addTo(ExclusionGroup.ONLY, 'tests', item);
+}
+
+only.group = (item: ExclusionItem) =>
+  addTo(ExclusionGroup.ONLY, 'groups', item);
+
+/**
+ * Adds a field or a list of fields into the exclusion list
+ *
+ * @example
+ *
+ * skip('username');
+ */
+export function skip<F extends TFieldName>(item: FieldExclusion<F>): void {
+  return addTo(ExclusionGroup.SKIP, 'tests', item);
+}
+
+skip.group = (item: ExclusionItem) =>
+  addTo(ExclusionGroup.SKIP, 'groups', item);
+
+//Checks whether a certain test profile excluded by any of the exclusion groups.
+
+// eslint-disable-next-line complexity, max-statements
+export function isExcluded(testObject: IsolateTest): boolean {
+  const { fieldName, groupName } = testObject;
+
+  if (isExcludedIndividually()) return true;
+
+  const exclusion = useExclusion();
+  const inclusion = useInclusion();
+  const keyTests = exclusion.tests;
+  const testValue = keyTests[fieldName];
+
+  // if test is skipped
+  // no need to proceed
+  if (testValue === false) return true;
+
+  const isTestIncluded = testValue === true;
+
+  // If inside a group
+  if (groupName) {
+    if (isGroupExcluded(groupName)) {
+      return true; // field excluded by group
+
+      // if group is `only`ed
+    } else if (exclusion.groups[groupName] === true) {
+      if (isTestIncluded) return false;
+
+      // If there is _ANY_ `only`ed test (and we already know this one isn't)
+      if (hasIncludedTests(keyTests)) return true; // Excluded implicitly
+
+      return keyTests[fieldName] === false;
+    }
+  }
+
+  if (isTopLevelWhenThereIsAnIncludedGroup(groupName)) {
+    return true;
+  }
+
+  // if field is only'ed
+  if (isTestIncluded) return false;
+
+  // If there is _ANY_ `only`ed test (and we already know this one isn't) return true
+  if (hasIncludedTests(keyTests)) {
+    // Check if inclusion rules for this field (`include` hook)
+    // TODO: Check if this may need to be moved outside of the condition.
+    // What if there are no included tests? This shouldn't run then?
+    return !optionalFunctionValue(inclusion[fieldName]);
+  }
+
+  // We're done here. This field is not excluded
+  return false;
+}
+
+/**
+ * Checks whether a given group is excluded from running.
+ */
+export function isGroupExcluded(groupName: string): boolean {
+  const exclusion = useExclusion();
+  const keyGroups = exclusion.groups;
+
+  const groupPresent = hasOwnProperty(keyGroups, groupName);
+
+  // When group is either only'ed or skipped
+  if (groupPresent) {
+    // Return true if group is skipped and false if only'ed
+    return keyGroups[groupName] === false;
+  }
+
+  // Group is not present
+
+  // Return whether other groups are included
+  return hasIncludedGroups();
+}
+
+/**
+ * Adds fields to a specified exclusion group.
+ */
+function addTo(
+  exclusionGroup: ExclusionGroup,
+  itemType: 'tests' | 'groups',
+  item: ExclusionItem
+) {
+  const exclusion = useExclusion(ErrorStrings.HOOK_CALLED_OUTSIDE);
+
+  if (!item) {
+    return;
+  }
+
+  asArray(item).forEach((itemName: string): void => {
+    if (!isStringValue(itemName)) {
+      return;
+    }
+
+    exclusion[itemType][itemName] = exclusionGroup === ExclusionGroup.ONLY;
+  });
+}
+
+/**
+ * Checks if context has included tests
+ */
+function hasIncludedTests(keyTests: Record<string, boolean>): boolean {
+  for (const test in keyTests) {
+    if (keyTests[test] === true) {
+      return true; // excluded implicitly
+    }
+  }
+  return false;
+}
+
+// are we not in a group and there is an included group?
+function isTopLevelWhenThereIsAnIncludedGroup(groupName?: string): boolean {
+  if (!hasIncludedGroups()) {
+    return false;
+  }
+
+  // Return whether there's an included group, and we're not inside a group
+  return !groupName;
+}
+
+function hasIncludedGroups(): boolean {
+  const exclusion = useExclusion();
+
+  for (const group in exclusion.groups) {
+    if (exclusion.groups[group]) {
+      return true;
+    }
+  }
+  return false;
+}
+
+const enum ExclusionGroup {
+  ONLY,
+  SKIP,
+}

package/src/hooks/include.ts

@@ -0,0 +1,54 @@
+import {
+  isStringValue,
+  defaultTo,
+  hasOwnProperty,
+  invariant,
+  optionalFunctionValue,
+} from 'vest-utils';
+
+import { useExclusion, useInclusion } from 'SuiteContext';
+import { SuiteResult, TFieldName } from 'SuiteResultTypes';
+import { createSuiteResult } from 'suiteResult';
+
+export function include<F extends TFieldName>(
+  fieldName: F
+): {
+  when: (
+    condition: F | TFieldName | boolean | ((draft: SuiteResult<F>) => boolean)
+  ) => void;
+} {
+  const inclusion = useInclusion();
+  const exclusion = useExclusion();
+
+  invariant(isStringValue(fieldName));
+
+  inclusion[fieldName] = defaultTo(exclusion.tests[fieldName], true);
+
+  return { when };
+
+  function when(
+    condition: F | TFieldName | ((draft: SuiteResult<F>) => boolean) | boolean
+  ): void {
+    const inclusion = useInclusion();
+    const exclusion = useExclusion();
+
+    // This callback will run as part of the "isExcluded" series of checks
+    inclusion[fieldName] = (): boolean => {
+      if (hasOwnProperty(exclusion.tests, fieldName)) {
+        // I suspect this code is technically unreachable because
+        // if there are any skip/only rules applied to the current
+        // field, the "isExcluded" function will have already bailed
+        return defaultTo(exclusion.tests[fieldName], true);
+      }
+
+      if (isStringValue(condition)) {
+        return Boolean(exclusion.tests[condition]);
+      }
+
+      return optionalFunctionValue(
+        condition,
+        optionalFunctionValue(createSuiteResult)
+      );
+    };
+  }
+}

package/src/hooks/mode.ts

@@ -0,0 +1,47 @@
+import { IsolateTest } from 'IsolateTest';
+import { useMode } from 'SuiteContext';
+import { hasErrorsByTestObjects } from 'hasFailuresByTestObjects';
+
+export enum Modes {
+  ALL,
+  EAGER,
+}
+
+/**
+ * Sets the suite to "eager" (fail fast) mode.
+ * Eager mode will skip running subsequent tests of a failing fields.
+ *
+ * @example
+ *  // in the following example, the second test of username will not run
+ *  // if the first test of username failed.
+ * const suite = create((data) => {
+ *  eager();
+ *
+ *  test('username', 'username is required', () => {
+ *   enforce(data.username).isNotBlank();
+ *  });
+ *
+ *  test('username', 'username is too short', () => {
+ *   enforce(data.username).longerThan(2);
+ *  });
+ * });
+ */
+export function eager() {
+  const [, setMode] = useMode();
+
+  setMode(Modes.EAGER);
+}
+
+function isMode(mode: Modes): boolean {
+  const [currentMode] = useMode();
+
+  return currentMode === mode;
+}
+
+function isEager(): boolean {
+  return isMode(Modes.EAGER);
+}
+
+export function shouldSkipBasedOnMode(testObject: IsolateTest): boolean {
+  return isEager() && hasErrorsByTestObjects(testObject.fieldName);
+}

package/src/hooks/optional/OptionalTypes.ts

@@ -0,0 +1,31 @@
+import { TFieldName } from 'SuiteResultTypes';
+
+export type OptionalFields = Record<string, OptionalFieldDeclaration>;
+
+export type OptionalsInput<F extends TFieldName> = F | F[] | OptionalsObject<F>;
+
+type OptionalsObject<F extends TFieldName> = Record<
+  F,
+  (() => boolean) | boolean
+>;
+
+type ImmediateOptionalFieldDeclaration = {
+  type: OptionalFieldTypes.Immediate;
+  rule: boolean | (() => boolean);
+  applied: boolean;
+};
+
+type DelayedOptionalFieldDeclaration = {
+  type: OptionalFieldTypes.Delayed;
+  applied: boolean;
+  rule: null;
+};
+
+export type OptionalFieldDeclaration =
+  | ImmediateOptionalFieldDeclaration
+  | DelayedOptionalFieldDeclaration;
+
+export enum OptionalFieldTypes {
+  Immediate,
+  Delayed,
+}

package/src/hooks/optional/optional.ts

@@ -0,0 +1,69 @@
+import {
+  isArray,
+  isStringValue,
+  asArray,
+  optionalFunctionValue,
+  assign,
+} from 'vest-utils';
+
+import {
+  OptionalFieldDeclaration,
+  OptionalFieldTypes,
+  OptionalsInput,
+} from 'OptionalTypes';
+import { useOptionalField, useOptionalFields } from 'PersistedContext';
+import { TFieldName } from 'SuiteResultTypes';
+
+export function optional<F extends TFieldName>(
+  optionals: OptionalsInput<F>
+): void {
+  // There are two types of optional field declarations:
+
+  // 1. Delayed: A string, which is the name of the field to be optional.
+  // We will only determine whether to omit the test after the suite is done running
+  //
+  // 2. Immediate: Either a boolean or a function, which is used to determine
+  // if the field should be optional.
+
+  // Delayed case (field name)
+  if (isArray(optionals) || isStringValue(optionals)) {
+    asArray(optionals).forEach(optionalField => {
+      useSetOptionalField(optionalField, () => ({
+        type: OptionalFieldTypes.Delayed,
+        applied: false,
+        rule: null,
+      }));
+    });
+  } else {
+    // Immediately case (function or boolean)
+    for (const field in optionals) {
+      const value = optionals[field];
+
+      useSetOptionalField(field, () => ({
+        type: OptionalFieldTypes.Immediate,
+        rule: value,
+        applied: optionalFunctionValue(value),
+      }));
+    }
+  }
+}
+
+export function isOptionalFiedApplied(fieldName?: TFieldName) {
+  if (!fieldName) {
+    return false;
+  }
+
+  return useOptionalField(fieldName).applied;
+}
+
+function useSetOptionalField(
+  fieldName: TFieldName,
+  setter: (current: OptionalFieldDeclaration) => OptionalFieldDeclaration
+): void {
+  const current = useOptionalFields();
+  const currentField = useOptionalField(fieldName);
+
+  assign(current, {
+    [fieldName]: assign({}, currentField, setter(currentField)),
+  });
+}

package/src/hooks/warn.ts

@@ -0,0 +1,19 @@
+import { invariant } from 'vest-utils';
+
+import { ErrorStrings } from 'ErrorStrings';
+import { useCurrentTest } from 'SuiteContext';
+
+const ERROR_OUTSIDE_OF_TEST = __DEV__
+  ? "warn hook called outside of a test callback. It won't have an effect."
+  : 'warn called outside of a test.';
+
+/**
+ * Sets a running test to warn only mode.
+ */
+export function warn(): void {
+  const currentTest = useCurrentTest(ErrorStrings.HOOK_CALLED_OUTSIDE);
+
+  invariant(currentTest, ERROR_OUTSIDE_OF_TEST);
+
+  currentTest.warn();
+}

package/src/isolates/__tests__/__snapshots__/each.test.ts.snap

@@ -0,0 +1,3 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`each When callback is not a function should throw 1`] = `"each callback must be a function"`;

package/src/isolates/__tests__/__snapshots__/group.test.ts.snap

@@ -0,0 +1,114 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`group: base case Group validity 1`] = `
+{
+  "done": [Function],
+  "errorCount": 4,
+  "getErrors": [Function],
+  "getErrorsByGroup": [Function],
+  "getWarnings": [Function],
+  "getWarningsByGroup": [Function],
+  "groups": {
+    "group_1": {
+      "field_1": {
+        "errorCount": 0,
+        "errors": [],
+        "testCount": 1,
+        "valid": true,
+        "warnCount": 0,
+        "warnings": [],
+      },
+      "field_2": {
+        "errorCount": 1,
+        "errors": [],
+        "testCount": 2,
+        "valid": false,
+        "warnCount": 0,
+        "warnings": [],
+      },
+    },
+    "group_2": {
+      "field_1": {
+        "errorCount": 1,
+        "errors": [],
+        "testCount": 1,
+        "valid": false,
+        "warnCount": 0,
+        "warnings": [],
+      },
+      "field_2": {
+        "errorCount": 0,
+        "errors": [],
+        "testCount": 1,
+        "valid": true,
+        "warnCount": 0,
+        "warnings": [],
+      },
+    },
+    "group_3": {
+      "field_1": {
+        "errorCount": 1,
+        "errors": [],
+        "testCount": 1,
+        "valid": false,
+        "warnCount": 0,
+        "warnings": [],
+      },
+      "field_2": {
+        "errorCount": 1,
+        "errors": [],
+        "testCount": 1,
+        "valid": false,
+        "warnCount": 0,
+        "warnings": [],
+      },
+    },
+    "group_4": {
+      "field_1": {
+        "errorCount": 0,
+        "errors": [],
+        "testCount": 1,
+        "valid": true,
+        "warnCount": 0,
+        "warnings": [],
+      },
+      "field_2": {
+        "errorCount": 0,
+        "errors": [],
+        "testCount": 1,
+        "valid": true,
+        "warnCount": 0,
+        "warnings": [],
+      },
+    },
+  },
+  "hasErrors": [Function],
+  "hasErrorsByGroup": [Function],
+  "hasWarnings": [Function],
+  "hasWarningsByGroup": [Function],
+  "isValid": [Function],
+  "isValidByGroup": [Function],
+  "suiteName": undefined,
+  "testCount": 9,
+  "tests": {
+    "field_1": {
+      "errorCount": 2,
+      "errors": [],
+      "testCount": 4,
+      "valid": false,
+      "warnCount": 0,
+      "warnings": [],
+    },
+    "field_2": {
+      "errorCount": 2,
+      "errors": [],
+      "testCount": 5,
+      "valid": false,
+      "warnCount": 0,
+      "warnings": [],
+    },
+  },
+  "valid": false,
+  "warnCount": 0,
+}
+`;