bupkis 0.7.2 → 0.9.0

package/src/expect.ts

@@ -18,11 +18,12 @@ import {
 import { createAssertion, createAsyncAssertion } from './assertion/create.js';
 import {
   AssertionError,
+  AssertionImplementationError,
   FailAssertionError,
   NegatedAssertionError,
   UnknownAssertionError,
 } from './error.js';
-import { isAssertionFailure, isString } from './guards.js';
+import { isString } from './guards.js';
 import {
   type Expect,
   type ExpectAsync,
@@ -181,44 +182,50 @@ export function createExpectAsyncFunction<
     expect?.assertions.length ?? 0,
     assertions.length + (expect?.assertions.length ?? 0),
   );
+  /**
+   * @function
+   */
   const expectAsyncFunction = async (...args: readonly unknown[]) => {
     await Promise.resolve();
-    const [isNegated, processedArgs] = maybeProcessNegation(args);
-    const candidates: Array<{
-      assertion: AnyAsyncAssertion;
-      parseResult: ParsedResult<AssertionParts>;
-    }> = [];
-    for (const assertion of [...(expect?.assertions ?? []), ...assertions]) {
-      const parseResult = await assertion.parseValuesAsync(processedArgs);
-      const { exactMatch, parsedValues, success } = parseResult;
+    const argsMatrix = conjunctify(args);
+    for (const args of argsMatrix) {
+      const { isNegated, processedArgs } = maybeProcessNegation(args);
+      const candidates: Array<{
+        assertion: AnyAsyncAssertion;
+        parseResult: ParsedResult<AssertionParts>;
+      }> = [];
+      for (const assertion of [...(expect?.assertions ?? []), ...assertions]) {
+        const parseResult = await assertion.parseValuesAsync(processedArgs);
+        const { exactMatch, parsedValues, success } = parseResult;
 
-      if (success) {
-        if (exactMatch) {
-          return executeAsync(
-            assertion,
-            parsedValues,
-            [...args],
-            expectAsyncFunction,
-            isNegated,
-            parseResult,
-          );
+        if (success) {
+          if (exactMatch) {
+            return executeAsync(
+              assertion,
+              parsedValues,
+              [...args],
+              expectAsyncFunction,
+              isNegated,
+              parseResult,
+            );
+          }
+          candidates.push({ assertion, parseResult });
         }
-        candidates.push({ assertion, parseResult });
       }
+      if (candidates.length) {
+        const { assertion, parseResult } = candidates[0]!;
+        return executeAsync(
+          assertion as any,
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+          parseResult.parsedValues as any,
+          [...args],
+          expectAsyncFunction,
+          isNegated,
+          parseResult,
+        );
+      }
+      throwInvalidParametersError(args);
     }
-    if (candidates.length) {
-      const { assertion, parseResult } = candidates[0]!;
-      return executeAsync(
-        assertion as any,
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-        parseResult.parsedValues as any,
-        [...args],
-        expectAsyncFunction,
-        isNegated,
-        parseResult,
-      );
-    }
-    throwInvalidParametersError(args);
   };
   return expectAsyncFunction;
 }
@@ -359,44 +366,52 @@ export function createExpectSyncFunction<
     expect?.assertions.length ?? 0,
     assertions.length + (expect?.assertions.length ?? 0),
   );
+  /**
+   * @function
+   */
   const expectFunction = (...args: readonly unknown[]) => {
-    const [isNegated, processedArgs] = maybeProcessNegation(args);
-    const candidates: Array<{
-      assertion: AnySyncAssertion;
-      parseResult: ParsedResult<AssertionParts>;
-    }> = [];
-    for (const assertion of [...(expect?.assertions ?? []), ...assertions]) {
-      const parseResult = assertion.parseValues(processedArgs);
-      const { exactMatch, parsedValues, success } = parseResult;
+    const argsMatrix = conjunctify(args);
 
-      if (success) {
-        if (exactMatch) {
-          return execute(
-            assertion,
-            parsedValues,
-            [...args],
-            expectFunction,
-            isNegated,
-            parseResult,
-          );
+    for (const args of argsMatrix) {
+      const { isNegated, processedArgs } = maybeProcessNegation(args);
+      const candidates: Array<{
+        assertion: AnySyncAssertion;
+        parseResult: ParsedResult<AssertionParts>;
+      }> = [];
+      for (const assertion of [...(expect?.assertions ?? []), ...assertions]) {
+        const parseResult = assertion.parseValues(processedArgs);
+        const { exactMatch, parsedValues, success } = parseResult;
+
+        if (success) {
+          if (exactMatch) {
+            return execute(
+              assertion,
+              parsedValues,
+              [...args],
+              expectFunction,
+              isNegated,
+              parseResult,
+            );
+          }
+          candidates.push({ assertion, parseResult });
         }
-        candidates.push({ assertion, parseResult });
       }
+      if (candidates.length) {
+        const { assertion, parseResult } = candidates[0]!;
+        return execute(
+          assertion as any,
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+          parseResult.parsedValues as any,
+          [...args],
+          expectFunction,
+          isNegated,
+          parseResult,
+        );
+      }
+      throwInvalidParametersError(args);
     }
-    if (candidates.length) {
-      const { assertion, parseResult } = candidates[0]!;
-      return execute(
-        assertion as any,
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-        parseResult.parsedValues as any,
-        [...args],
-        expectFunction,
-        isNegated,
-        parseResult,
-      );
-    }
-    throwInvalidParametersError(args);
   };
+
   return expectFunction;
 }
 
@@ -406,6 +421,7 @@ export function createExpectSyncFunction<
  * @privateRemarks
  * This is here because `Assertion` doesn't know anything about negation and
  * probably shouldn't.
+ * @function
  * @param assertion - The assertion to execute
  * @param parsedValues - Parsed values for the assertion
  * @param args - Original arguments passed to expect
@@ -424,47 +440,44 @@ const execute = <
   isNegated: boolean,
   parseResult?: ParsedResult<Parts>,
 ): void => {
-  if (!isNegated) {
-    return assertion.execute(parsedValues, args, stackStartFn, parseResult);
-  }
+  if (isNegated) {
+    // negation logic
+    try {
+      assertion.execute(parsedValues, args, stackStartFn, parseResult);
+    } catch (error) {
+      // success!
+      if (AssertionError.isAssertionError(error)) {
+        return;
+      }
 
-  try {
-    const result = assertion.execute(
-      parsedValues,
-      args,
-      stackStartFn,
-      parseResult,
-    );
-    if (isAssertionFailure(result)) {
-      throw new NegatedAssertionError({
-        actual: result.actual,
-        expected: result.expected,
-        message:
-          result.message ??
-          `Expected assertion ${assertion} to fail (due to negation), but it passed`,
-        stackStartFn,
-      });
+      if (AssertionImplementationError.isAssertionImplementationError(error)) {
+        throw error;
+      }
+
+      throw new AssertionImplementationError(
+        `Assertion ${assertion} threw a non-AssertionError`,
+        { cause: error },
+      );
     }
-    // If we reach here, the assertion passed but we expected it to fail
+
+    // if we reach here, then the assertion passed when it should have failed, so:
     throw new NegatedAssertionError({
-      message: `Expected assertion to fail (due to negation), but it passed: ${assertion}`,
+      message: `Expected assertion ${assertion} to fail (due to negation), but it passed`,
       stackStartFn,
     });
-  } catch (error) {
-    // Check if this is the negation error we just threw
-    if (NegatedAssertionError.isNegatedAssertionError(error)) {
-      // This is our negation error, re-throw it
-      throw error;
-    }
+  } else {
+    try {
+      assertion.execute(parsedValues, args, stackStartFn, parseResult);
+    } catch (error) {
+      if (AssertionError.isAssertionError(error)) {
+        throw error;
+      }
 
-    if (AssertionError.isAssertionError(error)) {
-      // The assertion failed as expected for negation - this is success
-      return;
+      throw new AssertionImplementationError(
+        `Assertion ${assertion} threw a non-AssertionError`,
+        { cause: error },
+      );
     }
-
-    debug('Non-assertion error thrown during negated assertion: %O', error);
-    // Re-throw non-assertion errors (like TypeErrors, etc.)
-    throw error;
   }
 };
 
@@ -474,6 +487,7 @@ const execute = <
  * @privateRemarks
  * This is here because `Assertion` doesn't know anything about negation and
  * probably shouldn't.
+ * @function
  * @param assertion - The assertion to execute
  * @param parsedValues - Parsed values for the assertion
  * @param args - Original arguments passed to expectAsync
@@ -492,39 +506,50 @@ const executeAsync = async <
   isNegated: boolean,
   parseResult?: ParsedResult<Parts>,
 ): Promise<void> => {
-  if (!isNegated) {
-    return assertion.executeAsync(
-      parsedValues,
-      args,
-      stackStartFn,
-      parseResult,
-    );
-  }
+  if (isNegated) {
+    // negation logic
+    try {
+      await assertion.executeAsync(
+        parsedValues,
+        args,
+        stackStartFn,
+        parseResult,
+      );
+    } catch (error) {
+      // success!
+      if (AssertionError.isAssertionError(error)) {
+        return;
+      }
+
+      throw new AssertionImplementationError(
+        `Assertion ${assertion} threw a non-AssertionError`,
+        { cause: error },
+      );
+    }
 
-  try {
-    await assertion.executeAsync(parsedValues, args, stackStartFn, parseResult);
-    // If we reach here, the assertion passed but we expected it to fail
+    // if we reach here, then the assertion passed when it should have failed, so:
     throw new NegatedAssertionError({
-      message: `Expected assertion to fail (due to negation), but it passed: ${assertion}`,
+      message: `Expected assertion ${assertion} to fail (due to negation), but it passed`,
       stackStartFn,
     });
-  } catch (error) {
-    // Check if this is the negation error we just threw
-    if (NegatedAssertionError.isNegatedAssertionError(error)) {
-      // This is our negation error, re-throw it
-      throw error;
-    }
+  } else {
+    try {
+      await assertion.executeAsync(
+        parsedValues,
+        args,
+        stackStartFn,
+        parseResult,
+      );
+    } catch (error) {
+      if (AssertionError.isAssertionError(error)) {
+        throw error;
+      }
 
-    if (AssertionError.isAssertionError(error)) {
-      // The assertion failed as expected for negation - this is success
-      return;
+      throw new AssertionImplementationError(
+        `Assertion ${assertion} threw a non-AssertionError`,
+        { cause: error },
+      );
     }
-    debug(
-      'Non-assertion error thrown during negated async assertion: %O',
-      error,
-    );
-    // Re-throw non-assertion errors (like TypeErrors, etc.)
-    throw error;
   }
 };
 
@@ -533,14 +558,16 @@ const executeAsync = async <
  * requested along with arguments stripped of the leading negation (to enable
  * assertion matching).
  *
+ * @function
  * @internal
  */
 const maybeProcessNegation = (
   args: readonly unknown[],
-): [isNegated: boolean, processedArgs: readonly unknown[]] => {
+): { isNegated: boolean; processedArgs: readonly unknown[] } => {
   let isNegated = false;
   let processedArgs = args;
 
+  // note: args[1] should always be a string
   if (args.length >= 2 && isString(args[1])) {
     const { cleanedPhrase, isNegated: detected } = detectNegation(args[1]);
     if (detected) {
@@ -548,13 +575,49 @@ const maybeProcessNegation = (
       processedArgs = [args[0], cleanedPhrase, ...args.slice(2)];
     }
   }
-  return [isNegated, processedArgs];
+  return { isNegated, processedArgs };
+};
+
+/**
+ * Given some args, create a matrix of args based on the presence of the
+ * conjunction operator ("and").
+ *
+ * If no "and" is present, returns the original args wrapped in an array.
+ *
+ * @function
+ */
+const conjunctify = (args: readonly unknown[]): (readonly unknown[])[] => {
+  let argsMatrix = [args];
+
+  if (args.length >= 2) {
+    // partition args by the string "and"; there may be multiple "and"s
+    const andIndices = args
+      .map((arg, index) => (arg === 'and' ? index : -1))
+      .filter((index) => index !== -1);
+
+    if (andIndices.length > 0) {
+      const parts: unknown[][] = [];
+      let lastIndex = 0;
+      for (const andIndex of andIndices) {
+        const partsArgs =
+          lastIndex > 0
+            ? [args[0], ...args.slice(lastIndex, andIndex)]
+            : [...args.slice(lastIndex, andIndex)];
+        parts.push(partsArgs);
+        lastIndex = andIndex + 1;
+      }
+      parts.push([args[0], ...args.slice(lastIndex)]);
+      argsMatrix = parts;
+    }
+  }
+  return argsMatrix;
 };
 
 /**
  * Throws an error indicating that no valid assertion could be found for the
  * provided arguments.
  *
+ * @function
  * @param args The arguments that were passed to the expect function
  * @internal
  */
@@ -571,6 +634,7 @@ const throwInvalidParametersError = (args: readonly unknown[]): never => {
  * Detects if an assertion phrase starts with "not " and returns the cleaned
  * phrase.
  *
+ * @function
  * @param phrase - The assertion phrase to check
  * @returns Object with `isNegated` flag and `cleanedPhrase`
  */
@@ -594,7 +658,9 @@ const detectNegation = (
 };
 
 /**
- * {@inheritdoc FailFn}
+ * {@inheritDoc FailFn}
+ *
+ * @function
  */
 const fail: FailFn = (reason?: string): never => {
   throw new FailAssertionError({ message: reason });