First of all, let me say out louder,
you need to design your code to be testable, so you test your private fields through your public methods.
But, ("buts" are the reasons why humans are still programming instead of the computer itself, so be happy here) sometimes you want to and should alter some private fields in order to test all the possible boundaries.
Often private fields can be modified through public getter and setters or using the class constructor and in those cases the tests are easy to create and everybody is happy.
But when you use external frameworks like Spring, it may be possible that you do not have control over injected private fields.
I already explain
how to mock spring components in your tests without the need of maintaining and creating ad-hoc test spring configuraitons in a previous post, here I will show you how to modify a private variable for your tests.
Let speak code:
import javax.annotation.PostConstruct;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import com.google.common.collect.ImmutableSet;
@Service
public class SomeService {
@Value("${whitelist.api.users:A,B,C}")
private String apiUsers;
private ImmutableSet<String> acceptableAPIBUsers;
@PostConstruct
public void init() {
acceptableAPIBUsers = ImmutableSet.copyOf(apiUsers.replaceAll(" ", "").split(","));
}
public boolean isAnAcceptableUser(String user) {
return user == null ? false : acceptableAPIBUsers.contains(user.toUpperCase());
}
}
We do not have control over the apiUsers String, so we have couple of straightforward options, one is to create a Spring configuration for your test, modify the Spring context and mock the property, two is to create a setter to change the value of the property from your test.
I discourage from creating public assessors only for you tests, it is confusing for other people looking at your code and creating and maintaing Spring configurations for your tests can be a pain.
I know what you are thinking, "if I cannot do either of the above I'm going to get fired, my girlfriend will leave me and my life is finished", but don't you worry, I'm here to show you another option ;)
You can create a groovy class with a static method to assess your private field in your test :
import groovy.transform.CompileStatic
@CompileStatic
class SomeServiceAccessor {
public static void setApiUsers(SomeService someService,String apiUsers){
someService.@apiUsers = apiUsers
}
}
And use it in your unit test:
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
import org.junit.Before;
import org.junit.Test;
public class SomeServiceTest {
private SomeService service;
@Before
public void setUp() {
service = new SomeSercvice();
SomeSercviceAccessor.setApiUsers(service, "pippo,pluto,bungabunga");
service.init();
}
@Test
public void testIsNotApiUser() {
assertThat(service.isAnRTBUser(""), is(false));
assertThat(service.isAnRTBUser(null), is(false));
assertThat(service.isAnRTBUser("random"), is(false));
}
@Test
public void testIsRTBUser() {
assertThat(service.isAnRTBUser("pippo"), is(true));
assertThat(service.isAnRTBUser("PIPPO"), is(true));
assertThat(service.isAnRTBUser("pluto"), is(true));
assertThat(service.isAnRTBUser("bungabunga"), is(true));
}
}
Of course you can do the same in java changing the visibility of the field with reflection, but I think the groovy solution can be a cleaner and easier way.
Now, I ll finish this post with the following recommendation:
Do not use this solution unless you really really really need to modify private variables to unit test your class!
