Add ignoreExtraArgs option

Author: sirlancelot

README.md

@@ -205,9 +205,10 @@ expect(mock()).toBe(undefined)
 import type { WhenOptions } from 'vitest-when'
 ```
 
-| option  | default | type    | description                                        |
-| ------- | ------- | ------- | -------------------------------------------------- |
-| `times` | N/A     | integer | Only trigger configured behavior a number of times |
+| option            | default | type    | description                                        |
+| ----------------- | ------- | ------- | -------------------------------------------------- |
+| `ignoreExtraArgs` | `false` | boolean | Ignore extra arguments when matching arguments     |
+| `times`           | N/A     | integer | Only trigger configured behavior a number of times |
 
 ### `.calledWith(...args: Parameters<TFunc>): Stub<TFunc>`
 
@@ -306,6 +307,17 @@ expect(mock('hello')).toEqual('sup?')
 expect(mock('hello')).toEqual('sup?')
 ```
 
+You can also ignore extra arguments when matching arguments.
+
+```ts
+const mock = when(vi.fn(), { ignoreExtraArgs: true })
+  .calledWith('hello')
+  .thenReturn('world')
+
+expect(mock('hello')).toEqual('world')
+expect(mock('hello', 'jello')).toEqual('world')
+```
+
 ### `.thenResolve(value: TReturn) -> Mock<TFunc>`
 
 When the stubbing is satisfied, resolve a `Promise` with `value`

src/behaviors.ts

@@ -10,6 +10,7 @@ import type {
 } from './types.ts'
 
 export interface WhenOptions {
+  ignoreExtraArgs?: boolean
   times?: number
 }
 
@@ -40,6 +41,7 @@ export interface BehaviorEntry<TArgs extends unknown[]> {
   args: WithMatchers<TArgs>
   behavior: Behavior
   calls: TArgs[]
+  ignoreExtraArgs: boolean
   maxCallCount?: number | undefined
 }
 
@@ -60,6 +62,7 @@ export type Behavior =
 
 export interface BehaviorOptions<TValue> {
   value: TValue
+  ignoreExtraArgs: boolean
   maxCallCount: number | undefined
 }
 
@@ -92,8 +95,9 @@ export const createBehaviorStack = <
       addReturn: (values) => {
         behaviors.unshift(
           ...getBehaviorOptions(values, options).map(
-            ({ value, maxCallCount }) => ({
+            ({ value, ignoreExtraArgs, maxCallCount }) => ({
               args,
+              ignoreExtraArgs,
               maxCallCount,
               behavior: { type: BehaviorType.RETURN, value },
               calls: [],
@@ -104,8 +108,9 @@ export const createBehaviorStack = <
       addResolve: (values) => {
         behaviors.unshift(
           ...getBehaviorOptions(values, options).map(
-            ({ value, maxCallCount }) => ({
+            ({ value, ignoreExtraArgs, maxCallCount }) => ({
               args,
+              ignoreExtraArgs,
               maxCallCount,
               behavior: { type: BehaviorType.RESOLVE, value },
               calls: [],
@@ -116,8 +121,9 @@ export const createBehaviorStack = <
       addThrow: (values) => {
         behaviors.unshift(
           ...getBehaviorOptions(values, options).map(
-            ({ value, maxCallCount }) => ({
+            ({ value, ignoreExtraArgs, maxCallCount }) => ({
               args,
+              ignoreExtraArgs,
               maxCallCount,
               behavior: { type: BehaviorType.THROW, error: value },
               calls: [],
@@ -128,8 +134,9 @@ export const createBehaviorStack = <
       addReject: (values) => {
         behaviors.unshift(
           ...getBehaviorOptions(values, options).map(
-            ({ value, maxCallCount }) => ({
+            ({ value, ignoreExtraArgs, maxCallCount }) => ({
               args,
+              ignoreExtraArgs,
               maxCallCount,
               behavior: { type: BehaviorType.REJECT, error: value },
               calls: [],
@@ -140,8 +147,9 @@ export const createBehaviorStack = <
       addDo: (values) => {
         behaviors.unshift(
           ...getBehaviorOptions(values, options).map(
-            ({ value, maxCallCount }) => ({
+            ({ value, ignoreExtraArgs, maxCallCount }) => ({
               args,
+              ignoreExtraArgs,
               maxCallCount,
               behavior: {
                 type: BehaviorType.DO,
@@ -158,14 +166,15 @@ export const createBehaviorStack = <
 
 const getBehaviorOptions = <TValue>(
   values: TValue[],
-  { times }: WhenOptions,
+  { ignoreExtraArgs, times }: WhenOptions,
 ): BehaviorOptions<TValue>[] => {
   if (values.length === 0) {
     values = [undefined as TValue]
   }
 
   return values.map((value, index) => ({
     value,
+    ignoreExtraArgs: ignoreExtraArgs ?? false,
     maxCallCount: times ?? (index < values.length - 1 ? 1 : undefined),
   }))
 }
@@ -179,18 +188,17 @@ const behaviorAvailable = <TArgs extends unknown[]>(
   )
 }
 
-const behaviorMatches = <TArgs extends unknown[]>(args: TArgs) => {
+const behaviorMatches = <TArgs extends unknown[]>(actualArguments: TArgs) => {
   return (behavior: BehaviorEntry<TArgs>): boolean => {
-    let index = 0
-
-    while (index < args.length || index < behavior.args.length) {
-      if (!equals(args[index], behavior.args[index])) {
-        return false
-      }
-
-      index += 1
-    }
-
-    return true
+    // Check arity
+    const expectedArguments = behavior.args
+    const { ignoreExtraArgs } = behavior
+    if (expectedArguments.length !== actualArguments.length && !ignoreExtraArgs)
+      return false
+
+    // Check arguments
+    return expectedArguments.every((expectedArgument, index) => {
+      return equals(actualArguments[index], expectedArgument)
+    })
   }
 }

test/vitest-when.test.ts

@@ -279,4 +279,28 @@ describe('vitest-when', () => {
     // intentionally do not call the spy
     expect(true).toBe(true)
   })
+
+  it('should ignore extra args if configured', () => {
+    const spy = subject
+      .when(vi.fn(), { ignoreExtraArgs: true })
+      .calledWith('Outcomes are:')
+      .thenReturn('loggy')
+
+    expect(spy('Outcomes are:')).toEqual('loggy')
+    expect(spy('Outcomes are:', 'stuff')).toEqual('loggy')
+    expect(spy('Outcomes are:', 'stuff', 'that', 'keeps', 'going')).toEqual(
+      'loggy',
+    )
+    expect(spy('Outcomes are not:', 'stuff')).toEqual(undefined)
+  })
+
+  it('should ignore all args if configured', () => {
+    const spy = subject
+      .when(vi.fn(), { ignoreExtraArgs: true })
+      .calledWith()
+      .thenReturn('yesss')
+
+    expect(spy()).toEqual('yesss')
+    expect(spy(1, 2, 3, 4, 5)).toEqual('yesss')
+  })
 })