Support varargs in toHaveBeenCalledOnceWith (closes #517)

src/matchers/toHaveBeenCalledOnceWith.js

@@ -1,6 +1,6 @@
 import { isJestMockOrSpy } from '../utils';
 
-export function toHaveBeenCalledOnceWith(received, expected) {
+export function toHaveBeenCalledOnceWith(received, ...expected) {
   const { printReceived, printExpected, printWithType, matcherHint } = this.utils;
 
   if (!isJestMockOrSpy(received)) {
@@ -16,7 +16,9 @@ export function toHaveBeenCalledOnceWith(received, expected) {
   }
 
   const passOnce = received.mock.calls.length === 1;
-  const pass = passOnce && this.equals(expected, received.mock.calls[0][0]);
+  const mockCall = received.mock.calls[0];
+  const receivedArray = Array.isArray(mockCall) ? mockCall : [mockCall];
+  const pass = passOnce && this.equals(expected, receivedArray);
 
   return {
     pass,
@@ -26,7 +28,7 @@ export function toHaveBeenCalledOnceWith(received, expected) {
           matcherHint('.not.toHaveBeenCalledOnceWith') +
           '\n\n' +
           `Expected mock function to have been called any amount of times but one with ${printExpected(
-            expected,
+            receivedArray,
           )}, but it was called exactly once with ${printExpected(expected)}.`
         );
       }

test/matchers/__snapshots__/toHaveBeenCalledOnceWith.test.js.snap

@@ -3,7 +3,7 @@
 exports[`.not.toHaveBeenCalledOnceWith fails if mock was invoked exactly once with the expected value 1`] = `
 "<dim>expect(</intensity><red>received</color><dim>).not.toHaveBeenCalledOnceWith(</intensity><green>expected</color><dim>)</intensity>
 
-Expected mock function to have been called any amount of times but one with <green>"hello"</color>, but it was called exactly once with <green>"hello"</color>."
+Expected mock function to have been called any amount of times but one with <green>["hello"]</color>, but it was called exactly once with <green>["hello"]</color>."
 `;
 
 exports[`.toHaveBeenCalledOnceWith fails if mock was invoked more than once, indicating how many times it was invoked 1`] = `
@@ -32,6 +32,6 @@ Received has value: <red>[Function mock1]</color>"
 exports[`.toHaveBeenCalledOnceWith fails when given value is not the expected one 1`] = `
 "<dim>expect(</intensity><red>received</color><dim>).toHaveBeenCalledOnceWith(</intensity><green>expected</color><dim>)</intensity>
 
-Expected mock function to have been called exactly once with <red>"hello"</color>, but it was called with:
+Expected mock function to have been called exactly once with <red>["hello"]</color>, but it was called with:
   <red>"not hello"</color>"
 `;

test/matchers/toHaveBeenCalledOnceWith.test.js

@@ -13,6 +13,16 @@ describe('.toHaveBeenCalledOnceWith', () => {
     expect(mock).toHaveBeenCalledOnceWith('hello');
   });
 
+  test('passes if mock was invoked exactly once with the expected values in an array', () => {
+    mock(['hello', 'there']);
+    expect(mock).toHaveBeenCalledOnceWith(['hello', 'there']);
+  });
+
+  test('passes if mock was invoked exactly once with the expected values', () => {
+    mock('hello', 'there');
+    expect(mock).toHaveBeenCalledOnceWith('hello', 'there');
+  });
+
   test('fails if mock was never invoked indicating that it was invoked 0 times', () => {
     expect(() => expect(mock).toHaveBeenCalledOnceWith('hello')).toThrowErrorMatchingSnapshot();
   });
@@ -59,4 +69,14 @@ describe('.not.toHaveBeenCalledOnceWith', () => {
     mock('not hello');
     expect(mock).not.toHaveBeenCalledOnceWith('hello');
   });
+
+  test('passes if mock was invoked exactly once without both expected values in an array', () => {
+    mock(['hello', 'there']);
+    expect(mock).not.toHaveBeenCalledOnceWith(['hello', 'not there']);
+  });
+
+  test('passes if mock was invoked exactly once without both expected values', () => {
+    mock('hello', 'there');
+    expect(mock).not.toHaveBeenCalledOnceWith('hello', 'not there');
+  });
 });

website/docs/matchers/Mock.mdx

@@ -50,7 +50,7 @@ Use `.toHaveBeenCalledOnce` to check if a `Mock` was called exactly one time.
 
 ### .toHaveBeenCalledOnceWith()
 
-Use `.toHaveBeenCalledOnceWith` to check if a `Mock` was called exactly one time with the expected value.
+Use `.toHaveBeenCalledOnceWith` to check if a `Mock` was called exactly one time with the expected values.
 
 <TestFile name="toHaveBeenCalledOnceWith">
   {`test('passes only if mock was called exactly once with the expected value', () => {