CODEWITHSUNDEEP
javaspringintegration-testingmockitospring-java-config
jabalsad
jabalsad

Reputation: 2421

Injecting Mockito Mock objects using Spring JavaConfig and @Autowired

I'm trying to replace an @Autowired object with a Mockito mock object. The usual way of doing this was with xml using Springockito:

<mockito:mock id="SomeMock" class="com.package.MockInterface" />

Currently I'm trying to move over to using Spring's JavaConfig to do the job. All of a sudden the Java expressions are a whole lot more verbose than xml:

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
public class MyTestClass {

    @Configuration
    static class Config {
        @Bean
        public MockInterface somethingSpecial() {
            return Mockito.mock(MockInterface.class);
        }
    }

    @Autowired MockInterface mockObj;

    // test code
}

I discovered a library called Springockito-annotations, which allows you to do the following:

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(loader=SpringockitoContextLoader.class)
public class MyTestClass {

    @Autowired @ReplaceWithMock MockInterface mockObj;

    // test code
}

Clearly, a whole lot prettier :) The only problem is that this context loader doesn't allow me to use @Configuration and JavaConfig for other beans (if I do, Spring complains that there are no candidates that match those autowired fields).

Do you guys know of a way to get Spring's JavaConfig and Springockito-annotations to play nice? Alternatively, is there another shorthand for creating mocks?

As a nice bonus, using Springockito and xml config, I was able to mock out concrete classes without providing autowiring candidates to its dependencies (if it had any). Is this not possible without xml?

Upvotes: 12

Views: 10817

Answers (3)

MariuszS
MariuszS

Reputation: 31567

Outdated and deprecated!

Read about mocking and spying in Spring Boot 1.4

Please read also @ethesx answer, Springockito is unmaintaned

Old answer

This is possible now to mock Spring application without any XML file with Springockito-annotations.. This solution works also with Spring Boot.

import static org.mockito.BDDMockito.*;
import org.kubek2k.springockito.annotations.*;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = Application.class, 
     loader = SpringockitoAnnotatedContextLoader.class)
@DirtiesContext(classMode = DirtiesContext.ClassMode.AFTER_CLASS)
public class MainControllerTest {

    @Autowired
    MainController mainController;

    @Autowired
    @ReplaceWithMock
    FooService fooService;

    @Test
    public void shouldGetBar() {
        //given
        given(fooService.result("foo")).willReturn("bar");

        //when
        Bar bar build = fooService.getBar("foo");

        //then
        assertThat(bar).isNotNull();
    }
}

Dependencies: org.kubek2k:springockito-annotations:1.0.9

Upvotes: 2

ethesx
ethesx

Reputation: 1379

Moving away from the now unmaintained (as of this writing) Spingockito-annotations and to Mockito, we have a way of doing this very simply:

@RunWith(MockitoJUnitRunner.class)
@ContextConfiguration
public class MyTestClass {

    @Mock MockInterface mockObj;

    // test code
}

If you're using a real object, but would like to mock a dependency within it, for instance testing a service layer with DAO:

@RunWith(MockitoJUnitRunner.class)
@ContextConfiguration
public class MyTestClass {

    @InjectMocks RealService;

    @Mock MockDAO mockDAO;

    // test code
}

Finally, this can also be applied to Spring-boot, but using annotation initialization within setUp() until multiple class runners are supported:

@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes = MyMainSpringBootClass.class)
public class MyTestClass {

    @InjectMocks RealService;

    @Mock MockDAO mockDAO;

    @Before
    public final void setUp() throws Exception{
        MockitoAnnotations.initMocks(this);
    }

    // test code
}

Upvotes: 4

Jonathan
Jonathan

Reputation: 20375

It appears that SpringockitoContextLoader extends GenericXmlContextLoader which is described as:

Concrete implementation of AbstractGenericContextLoader that reads bean definitions from XML resources.

So you are limited to xml bean definitions at the moment.

You could write your own context loader, taking relevant parts from the SpringockitoContextLoader class. Take a look here to get started, perhaps you could extend AnnotationConfigContextLoader for example?

Upvotes: 1

Related Questions