#Value on a field in a #Service injected with #MockBean results in null value - spring

Question

I have this service:
#Service
public class MyService {
#Value("${my.value}")
private String myValue;
public String someMethodWhichUsesMyValueField() {
return myValue;
}
// Also contains other methods that use some external services accessed with a `RestTemplate`
}
And this integration test:
#RunWith(SpringRunner.class)
#SpringBootTest(classes = MyApplication.class)
public class MyControllerTest {
private MockMvc myControllerMockMvc;
#Autowired
private MyController myController; // This controller injects an instance of MyService
#MockBean
private MyService myServiceMock;
#Before
public void setup() {
this.myControllerMockMvc = MockMvcBuilders.standaloneSetup(myController).build();
when(myServiceMock.someMethodWhichUsesMyValueField()).thenCallRealMethod();
// Also mock the other methods in myServiceMock that call the external webservices
}
#Test
public void someTest() throws Exception {
// use the myControllerMockMvc to call a POST method that calls myService.someMethodWhichUsesMyValueField()
}
}
The problem is that when myService.someMethodWhichUsesMyValueField() is called from the MyController method called from the someTest() method, the field myValue (and all the field annotated with #Autowired) is null even if my application.properties correctly defines my.value=some value.
Is there a way to correctly make myValue inject the value described in the application.properties like any normal #Autowired component?

Answer 1

Use a #SpyBean instead of a #MockBean because then you will have the real Spring object injected with some method that you can mock (thanks for #thomas-andolf's answer for the #Spy hint):
// [...] Nothing to change in annotations
public class MyControllerTest {
// [...] Nothing to change in the other fields
#SpyBean
private MyService myServiceMock;
#Before
public void setup() throws NoSuchFieldException, IllegalAccessException {
// [...] Nothing to change before mocking
// Then, do not mock anymore with .thenCallRealMethod() which is the default behavior with the spy
// And when mocking the other methods in myServiceMock that call the external webservices, use this kind of declaration:
doAnswer(invocation -> /* reply something */).when(myServiceMock).someMethodWhichUsesExternalWebService(any());
// instead of when(myServiceMock.someMethodWhichUsesExternalWebService(any())).thenAnswer(invocation -> /* reply something */);
}
// [...] Nothing to change in the test methods
}
The other (ugly?) way is to inject the field manually directly from the test class, like this for example:
// [...] Nothing to change in annotations
public class MyControllerTest {
// [...] Nothing to change in the other fields
#Value("${my.value}")
private String myValue;
#Before
public void setup() throws NoSuchFieldException, IllegalAccessException {
ReflectionTestUtils.setField(myServiceMock, "myValue", myValue); // thanks to #thomas-andolf's [answer](https://stackoverflow.com/a/55148170/535203)
// // Equivalent with traditional reflection tools:
// Field myValueField = MyService.class.getDeclaredField("myValue");
// myValueField.setAccessible(true);
// myValueField.set(myServiceMock, myValue);
// [...] the rest of the original method
}
// [...] Nothing to change in the test methods
}

Answer 2

You can set your properties in a test class
#TestPropertySource(properties = {"my.value=value"})
public class MyControllerTest {
//
}

Answer 3

A couple of ways you can solve this is the following, you can either use:
Constructor injection:
#Service
public class MyService {
private final myValue;
public MyService(#Value("${my.value}") myValue) {
this.myValue = myValue;
}
public String someMethodWhichUsesMyValueField() {
return myValue;
}
}
And instead of using a mock, just use the class and feed it it's value.
Or you can use:
ReflectionTestUtils.setField(myService, "myValue", "FooBar");
to set the myValue property to foobar.
Or you could change it to use a #Spy instead, which is a "partial mock". A spy is the original class with its original methods and then you can choose to mock some of the methods but keep the logic from the original class in some of the methods.