Nrthugu

I am trying to match this method which I have used in my Dao class. But I always get the following exception indicating that the call was not made on the method.

It's either the method is not matched, or I am doing something wrong.

String pSql = "SELECT * FROM employee";

Object pArgs = new Object {""};

int pArgTypes =  new int {};



/* Return 1 when the call to update() is made indicating a successful database update */

when(mJdbcTemplate.update(anyString(), aryEq(pArgs), aryEq(pArgTypes))).thenReturn(1);

Here is the stack trace of the exception:

Wanted but not invoked:

jdbcTemplate.update(<any>, <any>, <any>);

-> at com.test.GenericDaoJdbcImplTest$WhenInsertUpdateDeleteIsCalledWith.successfulUpdateShouldReturnTrue(GenericDaoJdbcImplTest.java:197)



However, there were other interactions with this mock:

-> at com.test.GenericDaoJdbcImplTest.insertUpdateDelete(GenericDaoJdbcImpl.java:121)



    at org.mockito.exceptions.Reporter.wantedButNotInvoked(Reporter.java:269)

    at org.mockito.internal.verification.checkers.MissingInvocationChecker.check(MissingInvocationChecker.java:42)

    at org.mockito.internal.verification.Times.verify(Times.java:36)

    at org.mockito.internal.verification.MockAwareVerificationMode.verify(MockAwareVerificationMode.java:21)

    at org.mockito.internal.MockHandler.handle(MockHandler.java:80)

    at org.mockito.internal.InvocationNotifierHandler.handle(InvocationNotifierHandler.java:36)

    at org.mockito.internal.creation.MethodInterceptorFilter.intercept(MethodInterceptorFilter.java:48)

    at org.springframework.jdbc.core.JdbcTemplate$$EnhancerByMockitoWithCGLIB$$92326890.update(<generated>)

    at com.test.GenericDaoJdbcImplTestTest$WhenInsertUpdateDeleteIsCalledWith.successfulUpdateShouldReturnTrue(GenericDaoJdbcImplTest.java:197)

    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)

    at java.lang.reflect.Method.invoke(Method.java:597)

    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)

    at java.lang.reflect.Method.invoke(Method.java:597)

    at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:50)

    at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)

    at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:467)

    at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:683)

    at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:390)

    at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:197)

My GenericDaoJdbcImplTest is an abstract class. Here is the class which I am testing.

public abstract class GenericDaoJdbcImpl<MODEL, PRIMARYKEY extends Serializable>

        implements GenericJdbcDao<MODEL, PRIMARYKEY> {



    @Autowired

    @Qualifier(value = "jdbcTemplate")

    private JdbcTemplate mJdbcTemplate;



    private Class<MODEL> mType;



    public JdbcTemplate getJdbcTemplate() {

        return mJdbcTemplate;

    }



    public void setJdbcTemplate(final JdbcTemplate pJdbcTemplate) {

        this.mJdbcTemplate = pJdbcTemplate;

    }



    public GenericDaoJdbcImpl(final Class<MODEL> pType) {

        this.mType = pType;

    }



    public abstract MODEL add(final MODEL mModel);



    public abstract MODEL modify(final MODEL mModel);



    public abstract MODEL read(PRIMARYKEY pId);



    public abstract List<MODEL> list();



    public abstract void delete(PRIMARYKEY pId);



    @Override

    public boolean insertUpdateDelete(final String pSql, final Object pArgs,

            final int pArgTypes) {



        Assert.hasLength(pSql, "No SQL provided to execute");

        Assert.notNull(pArgs, "No data provided to insert/update/delete");

        Assert.notNull(pArgTypes, "No data types provided for");

        Assert.isTrue(pArgs.length == pArgTypes.length, "Mis-match in data and data type count");



        return (mJdbcTemplate.update(pSql, pArgs, pArgTypes) > 0);

    }

}

Try using an ArgumentCaptor, these conditions tend to be less restrictive and allow for validating complex arguments after the call.

@Captor

ArgumentCaptor<Object> objCap;

@Captor

ArgumentCaptor<int> intCap;



when(mJdbcTemplate.update(anyString(), objCap.capture(), intCap.capture())).thenReturn(1);

You have to cast the arguments in your when call. Otherwise the arguments will be ambiguous and the compiler is unable to resolve it to a specific update method.

So:

Mockito.when(jdbcTemplate.update((String)Mockito.anyString(), (Object)Mockito.anyVararg())).thenReturn(var);

should resolve your issue. At least it did for me.

Don't mock type you don't own! That's one of the big principle. Mocking these types have a a negative impact the the tests in more than just one way :

1. It complexify your test, potentially making it difficult to craft, read, understand or refactor


2. You have to understand how is used this type.


3. It augments the coupling of the test with this implementation, version, etc


4. It gives you a false sense of security, because you have mokced the behavior so the test is passing, but the real code might have changed the behavior or see new behavior for a new version, and then you'll see a boom on the server!

In your case you are testing something at the boundary of your system, so the thumb rule would be to write integration test when dealing with databases, etc. and write unit test for your business code.

I heavily recommend the Growing Object Oriented Software - Guided by tests book. I think it's probably one of the most useful book to help write good software using TDD. Plus it has been written by the authors of the first mock framework, Steve Freeman and Nat Pryce.