Mockito ArgumentMatcher 说 Arguments 是不同的

Question

I am using Mockito for Unit testing and I am using ArgumentMatcher to check if a particular field of an argument has a particular value.

I have a StatusMatcher class that extends ArgumentMatcher and checks whether an object of class MyClass has a particular value in status field. The way I am invoking this in the tests is:

verify(myDAO, times(1)).update(argThat(new StatusMatcher("SomeStatus")));

Here update is the method of the DAO that is getting called with some MyClass object. I want to see if it has the correct status or not. This is what I get:

Argument(s) are different! Wanted:
myDAO.update(
    <Status matcher>
);
-> at com.foo.bar.MyTest.test1 
Actual invocation has different arguments:
myDAO.update(
    com.foo.bar.MyClass
);

Note that this is working perfectly for all the test cases except one test case. So I know the StatusMatcher etc. have been coded correctly. I am not sure what is different about the method where its getting this exception.

What I want to know is: under what conditions will the ArgumentMatcher throw such exception so I can find out what I am missing (It is not for me to paste the actual method codes) Please tell me if the explanation is not clear enough, and I will try to improve it. Thanks for reading this far:)

EDIT: Here is the code for my StatusMatcher class

    private class StatusMatcher extends ArgumentMatcher<MyClass> {

    private String status;
    public StatusMatcher(String hs) { 
        status = hs;
    }

    @Override
    public boolean matches(Object argument) {

        return status.equals(((MyClass)argument).getStatus());
    } 
}

Answer 1

Like you said, it fails because the arguments are different. Take a look at the test below and you'll see that the second test method will fail because the status in your MyClass instance is different from SomeStatus that you passed in the matcher.

public class MatcherTest {

    class MyClass{
        private String status;

        MyClass(String status) {
            this.status = status;
        }

        public String getStatus(){
            return status;
        }
    }

    class MyDao {
        public void update(MyClass myClass){}
    }

    class StatusMatcher extends ArgumentMatcher<MyClass> {
        private String status;
        public StatusMatcher(String hs) {
            status = hs;
        }

        @Override
        public boolean matches(Object argument) {
            return status.equals(((MyClass)argument).getStatus());
        }
    }

    @Test
    public void shouldMatchStatus(){
        MyDao mock = mock(MyDao.class);
        mock.update(new MyClass("expectedStatus"));
        verify(mock, times(1)).update(argThat(new StatusMatcher("expectedStatus")));
    }

    @Test
    public void shouldNotMatchStatus(){
        MyDao mock = mock(MyDao.class);
        mock.update(new MyClass("unexpectedStatus"));
        /* THE BELLOW WILL FAIL BECAUSE ARGUMENTS ARE DIFFERENT */
        verify(mock, times(1)).update(argThat(new StatusMatcher("expectedStatus")));
    }
}

I could take a wild guess that you could be reusing variables, or have a static field, etc. But without seeing your test code, no one can tell.

Answer 2

• Try to simplify the test / code under test. Do you really need to mutate arguments and also verify stubbing? Both of those actions
• might indicate a code smell. Relax the argument verification and
• use some kind of any() matcher Perform validation of arguments in the

Answer 3

For others that are facing a similar issue here is how I fixed it.

The code below will throw the following error if you pass in a new instance of an object. All you have to do in this case is create a variable since it will not create a new reference in memory.

@Test
void shouldLogExceptionWithType() {
    mongoDao = mock(MongoDao.class);
    StepDetail stepDetail = StepDetail.builder()
            .table("some table")
            .batchType("Some batch type")
            .build();
    doCallRealMethod().when(mongoDao).logException(new Exception(), stepDetail.getBatchType().getName());
    mongoDao.logException(new Exception(), stepDetail.getBatchType().getName());
    verify(mongoDao, times(1)).logException(new Exception(), stepDetail.getBatchType().getName());
}

Code Fixed:

@Test
void shouldLogExceptionWithType() {
    mongoDao = mock(MongoDao.class);
    StepDetail stepDetail = StepDetail.builder()
            .table("some table")
            .batchType("Some batch type")
            .build();
    Exception exception = new Exception();
    doCallRealMethod().when(mongoDao).logException(exception, stepDetail.getBatchType().getName());
    mongoDao.logException(exception, stepDetail.getBatchType().getName());
    verify(mongoDao, times(1)).logException(exception, stepDetail.getBatchType().getName());
}

Answer 4

I also faced this issue. Below is the error and its solution:

error: Argument(s) are different! Wanted:

    tradeMaintenanceDao.updateTradesMaintData(.....

I used the following statement to resolve it:

verify(tradeMaintenanceDao, times(1))
    .updateTradesMaintData(anyString(), anyList(), anyList(), anyString(), anyString());

The original cause was:

verify(tradeMaintenanceDao, times(1)).updateTradesMaintData(userName, tradeStatusList, tradeReasonList, notes, pendStatus);