Spring Cache Unit Test

Our typical business service with a cacheable method, as shown below:

@Service
public class AccountService{
@Autowired
public AccountDao accountDao;

@Cacheable(value = "accounts")
public Account getAccount(int accountId) {
return accountDao.getObjectById(accountId);
}
}

Primary concerns for this kind of service method unit test.

Concern 1: combine SpringJUnit4ClassRunner and Mockito

Solution: For common scenarios, we can apply the standard solution:

@Mock
private AccountDao dao;

@InjectMocks
@Autowired
private AccountService accountService;

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

Concern 2: Mockito and Spring proxies, the critical part is our method annotated with @Cacheable, then totally a different story now.

Solution: As we applied @Cacheable annotation(another annotations like @Transactional has same effect), Spring would generate a proxy automatically, thus direct @InjectMocks @Autowired does not work. Reference 1 taught me the following approach and it works.

import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.springframework.aop.framework.Advised;
import org.springframework.aop.support.AopUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.util.ReflectionTestUtils;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath*:spring.xml" })
@ActiveProfiles("test")
public class AccountCacheTest {

@Mock
private AccountDao dao;

@InjectMocks
@Autowired
private AccountService accountService;

@Before
public void setup() throws Exception {
MockitoAnnotations.initMocks(this);
AccountService bas = (AccountService) unwrapProxy(accountService);
ReflectionTestUtils.setField(bas, "accountDao", dao);
}

@Test
public void testAccoutCache() throws Exception {
/* Arrange. */
Account acc1 = new Account();
acc1.setId(1);

when(dao.getObjectById(1)).thenReturn(acc1, acc1);

/* Act. */
accountService.getAccount(1);
accountService.getAccount(1);

/* Assert. */
verify(dao, times(1)).getObjectById(1);
}

public static final Object unwrapProxy(Object bean) throws Exception {
/*
* If the given object is a proxy, set the return value as the object
* being proxied, otherwise return the given object.
*/
if (AopUtils.isAopProxy(bean) && bean instanceof Advised) {
Advised advised = (Advised) bean;
bean = advised.getTargetSource().getTarget();
}
return bean;
}
}

LESSON: When test cache, we'd better utilize the
assertSame.

Reference

1. http://kim.saabye-pedersen.org/2012/12/mockito-and-spring-proxies.html
2. http://www.captaindebug.com/2012/09/spring-31-caching-and-cacheable.html#.UmDsiflHK8s

http://www.captaindebug.com/2012/09/spring-31-caching-and-cacheevict.html#.UmDhNflHLQI