Easymock - nested void method testing (spying)

Question

How to spy parameter 'param' in nested method during getData() mock testing ? Is it possible with Easymock 3 ?

Source code

public class ServiceLogic {

 public void getData(){

  // some business logic

  serviceDAO.executeStatement(param);   

 }

}

Easymock test :

ServiceLogic _serviceLogicMock = EasyMock.createNiceMock(ServiceLogic.class);
ServiceDAO _serviceDAOMock = EasyMock.createNiceMock(ServiceDAO .class);

_serviceLogicMock.setServiceDAO(_serviceDAOMock);

//some other method calls -> .execute(...).andReturn(...);
EasyMock.replay(_serviceLogicMock);

//run
_serviceLogicMock.getData();

How to check with EasyMock whether executeStatement() method is called with correct parameter ?!

what do you mean by spy? you can expect serviceDAO.executeStatement and give constraints for param. — aishwarya, Dec 22 '11 at 08:12
Where is param set? Can you pass it to the ServiceLogic in constructor? Or is there a setter? If there is you can use when and verify. — Sid Malani, Dec 22 '11 at 08:18

score 2 · Accepted Answer · answered Dec 22 '11 at 09:54

Your test does seem wrong:

Your unit test is about testing ServiceLogic why do you mock it then ?
Also you don't have any expectations on any interaction with your ServiceDAO mock.

As the question is tagged Mockito, I propose the following solution (minus the imports) that you can adapt to your code :

@RunWith(MockitoJUnitRunner.class)
public class ServiceLogicTest {
    @Mock ServiceDAO serviceDAO;
    @InjectMocks ServiceLogic serviceLogic;

    @Test
    public void ensure_executeStatement_is_called_with_right_param() throws Exception {
        // given
        String input = "Some input";

        // when
        serviceLogic.getDataFrom(input);

        // then
        verify(serviceDAO).executeStatement("expected param");
    }
}

When writing tests, I like to use the BDD (Behavior Driven Development) style to guide me to what I want to test. I encourage you to practice it, you can have look at the wiki page.

So for your question, you should take a look at the verify line, it put the mock in a verification mode, so can actually verify that the method executeStatement is actually called with the argument value "expected param".

If you have more complex parameters, you can use some matchers using the Hamcrest library:

verify(serviceDAO).executeStatement(argThat(hasProperty("propertyName")));

Or you can use a Mockito's ArgumentCaptor in combination with the FEST-Assert library (usually my preferred approach):

ArgumentCaptor<ComplexArgument> argCaptor = ArgumentCaptor.forClass(ComplexArgument.class);
verify(serviceDAO).executeStatement(argCaptor.capture());
assertThat(argCaptor.getValue()).isNotNull().satisfies(myComplexArgumentCondition());

The main idea is to have understandable code, in production code and in test code.

For further reading have a look at the Mockito Javadoc.

+1 for introduction to FEST-Assert library. Very interesting alternative to Hamcrest (which I like and currently use). — jhericks, Dec 22 '11 at 17:01

score 2 · Answer 2 · answered Dec 22 '11 at 16:50

Like @Brice, I prefer Mockito to EasyMock, but here's the EasyMock version that is closer to your original example since your example was EasyMock.

public class ServiceLogicTest {

    @Test
    public void ensure_executeStatement_is_called_with_right_param() throws Exception {
        ServiceLogic _serviceLogicUT = new ServiceLogic();
        ServiceDAO _serviceDAOMock = EasyMock.createNiceMock(ServiceDAO .class);

        _serviceLogicUT.setServiceDAO(_serviceDAOMock);

        String input = "Some input";

        //some other method calls -> .execute(...).andReturn(...);
        _serviceDaoMock.executeStatement("expected para");  // assuming a void method
        EasyMock.replay(_serviceDaoMock);            
        // run
        _serviceLogicUT.getDataFrom(input);

        // verifies that the expected calls were made
        EasyMock.verify(_serviceDaoMock);  
    }
}

EasyMock also has argument capture functionality. That would look like this:

public class ServiceLogicTest {

    @Test
    public void ensure_executeStatement_is_called_with_right_param() throws Exception {
        ServiceLogic _serviceLogicUT = new ServiceLogic();
        ServiceDAO _serviceDAOMock = EasyMock.createNiceMock(ServiceDAO .class);

        _serviceLogicUT.setServiceDAO(_serviceDAOMock);

        String input = "Some input";

        //some other method calls -> .execute(...).andReturn(...);
        Capture<ComplexParam> capturedParam = new Capture<ComplexParam>();
        _serviceDaoMock.executeStatement(EasyMock.capture(capturedParam));  // assuming a void method
        EasyMock.replay(_serviceDaoMock);            
        // run
        _serviceLogicUT.getDataFrom(input);

        ComplexParam actualParam = capturedParam.getValue();

        // make various assertions on actual param
    }
}

I think you can see from the two examples why many people prefer Mockito, but if there's some reason you prefer or are mandated to use EasyMock, you can do just about anything you can do with Mockito, just with more lines of code.

score 0 · Answer 3 · answered Dec 22 '11 at 08:16

This should be possible with jmockit, unless you DAO has final methods. However, this is better and easier done with jMockit:

@Test
public void testMethod(@Mocked final ServiceDAO serviceDAO) {
       new Expectations() {{
            serviceDAO.executeStatement(expectedOParams);returns(expectedReturnValue)
       }};

     (new ServiceLogic(serviceDAO)).getData();
}

That's almost complete test save assertions. And it works with final, static, abstract and whatever methods.

Easymock - nested void method testing (spying)

3 Answers3