How do you configure mocks before Autowired? - spring

Question

I want to set up mock data using Mockito before my test. However, the autowire happens before the #Before so my tests that expect data to be present is missing. Is there a way around it?
#RunWith(SpringRunner.class)
#ContextConfiguration(
classes = {
Foo.class
}
)
public class FooTest {
#MockBean
final Programs programs;
#Autowired
final Foo foo;
#Before
public void setPrograms() {
when(programs.findAll())
.thenReturn(
List.of(
"A", "B", "C"
)
);
}
#Test
public void foo() {
assertThat(foo.getBlah()).isNotEmpty();
}
}
interface Programs {
List<String> findAll();
}
class Foo {
// I have more complicated structures than a list, for example only.
private List<String> blah;
#Autowired
private Programs programs;
public List<String> getBlah() { return blah; }
#PostConstruct
public void init() {
blah = programs.findAll();
}
}

Answer 1

Following your example I have developed the next ones:
public interface Programs {
List<String> findAll();
}
public class Foo {
// I have more complicated structures than a list, for example only.
private List<String> blah;
#Autowired
private Programs programs;
public List<String> getBlah() { return blah; }
#PostConstruct
public void init() {
blah = programs.findAll();
}
}
Above ones equals to your provided code. Now, "the changes":
// Only for testing purpose, you can use any of your own ones
public class ProgramsImpl implements Programs {
#Override
public List<String> findAll() {
return asList("1", "2", "3");
}
}
And the junit test:
#RunWith(SpringRunner.class)
#ContextConfiguration(
classes = {
Foo.class, ProgramsImpl.class
}
)
public class FooTest {
#SpyBean
Programs programs;
#Autowired
Foo foo;
#Before
public void prepare() {
when(programs.findAll())
.thenReturn(
List.of(
"A", "B", "C"
)
);
this.foo.init();
}
#Test
public void foo() {
assertEquals(asList("A", "B", "C"), foo.getBlah());
}
}
The above test works as expected, that is, although ProgramsImpl.findAll returns "1", "2", "3" the when clause included will overwrite it with your own one.
However, as you probably will figure out really the #PostConstruct is invoked twice: one due to #Autowire and the second one due to init.
If you want to avoid it, you need to remove #Autowire in your test and create your custom instance of foo inside #Before (using a "normal constructor"). For example:
public class Foo {
...
private Programs programs;
#Autowired
public Foo(Programs programs) {
this.programs = programs;
}
...
}
#RunWith(SpringRunner.class)
#ContextConfiguration(
classes = {
ProgramsImpl.class
}
)
public class FooTest {
#SpyBean
Programs programs;
Foo foo;
#Before
public void prepare() {
when(programs.findAll())
.thenReturn(
List.of(
"A", "B", "C"
)
);
this.foo = new Foo(programs);
this.foo.init();
}
#Test
public void foo() {
assertEquals(asList("A", "B", "C"), foo.getBlah());
}
}

Answer 2

As Programs is an interface; in reality it's extends CrudRepository I am able to instantiate a copy of it even a mock with a #Configuration/#Bean. This solution ensures that everything (except the mocks) are managed by Spring including the PostConstruct lifecycle.
This approach allows me to have Spring components that contain PostConstructs that use JPA without having to set up an initial database with the proper data.
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;
import javax.annotation.PostConstruct;
import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
#RunWith(SpringRunner.class)
#ContextConfiguration(
classes = {
Foo.class,
StackOverflowTest.ProgramsConfiguration.class
}
)
public class StackOverflowTest {
#Autowired
private Foo foo;
#Configuration
static class ProgramsConfiguration {
#Bean
public Programs programs() {
final Programs mock = mock(Programs.class);
when(mock.findAll()).thenReturn(List.of("A", "B", "C"));
return mock;
}
}
#Test
public void foo() {
assertThat(foo.getBlah())
.isNotEmpty()
.containsExactly("A", "B", "C");
}
}
interface Programs {
List<String> findAll();
}
class Foo {
private List<String> blah;
#Autowired
private Programs programs;
public List<String> getBlah() {
return blah;
}
#PostConstruct
public void init() {
blah = programs.findAll();
}
}
I actually found that I had solved this problem a while back when I was trying to get JOOQ working with PostConstructs as well using a MockDslContextConfiguration. Took me a bit of time to realize it was the same situation.
#Configuration
public class MockDslContextConfiguration {
#Bean
public DSLContext dslContext() {
return DSL.using(new MockConnection(mockExecuteContext -> new MockResult[]{
new MockResult(0, Mockito.mock(Result.class)),
new MockResult(0, Mockito.mock(Result.class))
}), SQLDialect.MYSQL);
}
}
Though this Q&A is more general and not limited to JOOQ.
This has a limitation of that I can only have one set of data for the test per test class.