CODEWITHSUNDEEP
javaspringjunitdependency-injection
NeplatnyUdaj
NeplatnyUdaj

Reputation: 6242

Spring JUnit: How to Mock autowired component in autowired component

I've got a Spring component I'd like to test and this component has an autowired attribute which I need to change for the purpose of unit testing. The problem is, that the class uses the autowired component inside the post-construct method so I'm not able to replace it(i.e. via ReflectionTestUtils) before it's actually used.

How should I do that?

This is the class I want to test:

@Component
public final class TestedClass{

    @Autowired
    private Resource resource;

    @PostConstruct
    private void init(){
        //I need this to return different result
        resource.getSomething();
    }
}

And this is the base of a test case:

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations= "classpath:applicationContext.xml")
public class TestedClassTest{

    @Autowired
    private TestedClass instance;

    @Before
    private void setUp(){
        //this doesn't work because it's executed after the bean is instantiated
        ReflectionTestUtils.setField(instance, "resource", new Resource("something"));
    }
}

Is there some way to replace the resource with something else before the postconstruct method is invoked? Like to tell Spring JUnit runner to autowire different instance?

Upvotes: 90

Views: 209116

Answers (8)

João Pedro Gonçalves
João Pedro Gonçalves

Reputation: 21

import org.junit.Before;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

import javax.annotation.Resource;

@Mock
    private IMyInterface yInterface;

    @InjectMocks
    @Resource
    ResourceDependant resourceDependant = new resourceDependant();


    @Before
    public void initMocksForInjection() throws Exception {
        MockitoAnnotations.openMocks(this);
    }

Upvotes: 0

Smart Coder
Smart Coder

Reputation: 1748

For Junit5, you can mock using:

@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
class MytestClass {

@Mock
MyInjectedSevice myInjservice;

@InjectMock
MyService myservice;

}

Upvotes: 3

RazvanParautiu
RazvanParautiu

Reputation: 2938

Another approach in integration testing is to define a new Configuration class and provide it as your @ContextConfiguration. Into the configuration you will be able to mock your beans and also you must define all types of beans which you are using in test/s flow. To provide an example : 

@RunWith(SpringRunner.class)
@ContextConfiguration(loader = AnnotationConfigContextLoader.class)
public class MockTest{
 @Configuration
 static class ContextConfiguration{
 // ... you beans here used in test flow
 @Bean
    public MockMvc mockMvc() {
        return MockMvcBuilders.standaloneSetup(/*you can declare your controller beans defines on top*/)
                .addFilters(/*optionally filters*/).build();
    }
 //Defined a mocked bean
 @Bean
    public MyService myMockedService() {
        return Mockito.mock(MyService.class);
    }
 }

 @Autowired
 private MockMvc mockMvc;

 @Autowired
 MyService myMockedService;

 @Before
 public void setup(){
  //mock your methods from MyService bean 
  when(myMockedService.myMethod(/*params*/)).thenReturn(/*my answer*/);
 }

 @Test
 public void test(){
  //test your controller which trigger the method from MyService
  MvcResult result = mockMvc.perform(get(CONTROLLER_URL)).andReturn();
  // do your asserts to verify
 }
}

Upvotes: 5

luboskrnac
luboskrnac

Reputation: 24571

Spring Boot 1.4 introduced testing annotation called @MockBean. So now mocking and spying on Spring beans is natively supported by Spring Boot.

Upvotes: 34

luboskrnac
luboskrnac

Reputation: 24571

I created blog post on the topic. It contains also link to Github repository with working example.

The trick is using test configuration, where you override original spring bean with fake one. You can use @Primary and @Profile annotations for this trick.

Upvotes: 9

Sergey Grigoriev
Sergey Grigoriev

Reputation: 719

You can override bean definitions with mocks with spring-reinject https://github.com/sgri/spring-reinject/

Upvotes: 8

Anna Zubenko
Anna Zubenko

Reputation: 1663

You could use Mockito. I am not sure with PostConstruct specifically, but this generally works:

// Create a mock of Resource to change its behaviour for testing
@Mock
private Resource resource;

// Testing instance, mocked `resource` should be injected here 
@InjectMocks
@Resource
private TestedClass testedClass;

@Before
public void setUp() throws Exception {
    // Initialize mocks created above
    MockitoAnnotations.initMocks(this);
    // Change behaviour of `resource`
    when(resource.getSomething()).thenReturn("Foo");   
}

Upvotes: 76

phury
phury

Reputation: 2203

You can provide a new testContext.xml in which the @Autowired bean you define is of the type you need for your test.

Upvotes: 15

Related Questions