Java 使用EhCache3进行JUnit测试

我创建了简单的缓存应用程序，如下所示：

import org.ehcache.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import javax.cache.CacheException;
import java.util.Map;
import java.util.concurrent.TimeUnit;

public class JsonObjectCacheManager {
    private static final Logger logger = LoggerFactory.getLogger(JsonObjectCacheManager.class);
    private final Cache<String, JsonObjectWrapper> objectCache;

    //setting up cache
    public JsonObjectCacheManager() {
        CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder()
                .withCache("jsonCache",
                        CacheConfigurationBuilder.newCacheConfigurationBuilder(String.class, JsonObjectWrapper.class,
                                ResourcePoolsBuilder.newResourcePoolsBuilder()
                                        .heap(100, EntryUnit.ENTRIES)
                                        .offheap(10, MemoryUnit.MB))
                                .withExpiry(Expirations.timeToLiveExpiration(Duration.of(5, TimeUnit.MINUTES)))
                                .withValueSerializingCopier()
                                .build())
                .build(true);

        objectCache = cacheManager.getCache("jsonCache", String.class, JsonObjectWrapper.class);
    }

    public void putInCache(String key, Object value) {
        try {
            JsonObjectWrapper objectWrapper = new JsonObjectWrapper(value);
            objectCache.put(key, objectWrapper);
        } catch (CacheException e) {
            logger.error(String.format("Problem occurred while putting data into cache: %s", e.getMessage()));
        }
    }

    public Object retrieveFromCache(String key) {
        try {
            JsonObjectWrapper objectWrapper = objectCache.get(key);
            if (objectWrapper != null)
                return objectWrapper.getJsonObject();
        } catch (CacheException ce) {
            logger.error(String.format("Problem occurred while trying to retrieveSpecific from cache: %s", ce.getMessage()));
        }
        logger.error(String.format("No data found in cache."));
        return null;
    }

    public boolean isKeyPresent(String key){
        return objectCache.containsKey(key);
    }

}

import org.junit.*;
import org.mockito.*;

import java.util.*;

import static org.junit.Assert.*;

@RunWith(MockitoJUnitRunner.class)
public class JsonObjectCacheManagerTest {

    private JsonObjectCacheManager cacheManager;

    private Map<String, Object> names;

    @Before
    public void setup(){
        /*names = new HashMap(){
            {
                    put("name1", "Spirit Air Lines");
                    put("name2", "American Airlines");
                    put("name3", "United Airlines");
                }
            };*/

        //edited as per Henri's point and worked
        names = new HashMap();
        names.put("name1", "Spirit Air Lines");
        names.put("name2", "American Airlines");
        names.put("name3", "United Airlines");
           cacheManager = new JsonObjectCacheManager();
        }
    @Test
    public void isPresentReturnsTrueIfObjectsPutInCache() throws Exception {
        //put in cache
        cacheManager.putInCache("names",names);
        assertTrue(cacheManager.isKeyPresent("names"));
    }

    @Test
    public void cacheTest() throws Exception {
        //put in cache
        cacheManager.putInCache("names",names);

        //retrieve from cache
        Map<String, Object> namesFromCache = (Map<String, Object>) cacheManager.retrieveFromCache("names");
        //validate against the cached object
//        assertEquals(3, namesFromCache.size());
//        assertEquals("American Airlines", namesFromCache.get("name2"));

    }
}

我编写了JUnit测试，如下所示：

import org.ehcache.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import javax.cache.CacheException;
import java.util.Map;
import java.util.concurrent.TimeUnit;

public class JsonObjectCacheManager {
    private static final Logger logger = LoggerFactory.getLogger(JsonObjectCacheManager.class);
    private final Cache<String, JsonObjectWrapper> objectCache;

    //setting up cache
    public JsonObjectCacheManager() {
        CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder()
                .withCache("jsonCache",
                        CacheConfigurationBuilder.newCacheConfigurationBuilder(String.class, JsonObjectWrapper.class,
                                ResourcePoolsBuilder.newResourcePoolsBuilder()
                                        .heap(100, EntryUnit.ENTRIES)
                                        .offheap(10, MemoryUnit.MB))
                                .withExpiry(Expirations.timeToLiveExpiration(Duration.of(5, TimeUnit.MINUTES)))
                                .withValueSerializingCopier()
                                .build())
                .build(true);

        objectCache = cacheManager.getCache("jsonCache", String.class, JsonObjectWrapper.class);
    }

    public void putInCache(String key, Object value) {
        try {
            JsonObjectWrapper objectWrapper = new JsonObjectWrapper(value);
            objectCache.put(key, objectWrapper);
        } catch (CacheException e) {
            logger.error(String.format("Problem occurred while putting data into cache: %s", e.getMessage()));
        }
    }

    public Object retrieveFromCache(String key) {
        try {
            JsonObjectWrapper objectWrapper = objectCache.get(key);
            if (objectWrapper != null)
                return objectWrapper.getJsonObject();
        } catch (CacheException ce) {
            logger.error(String.format("Problem occurred while trying to retrieveSpecific from cache: %s", ce.getMessage()));
        }
        logger.error(String.format("No data found in cache."));
        return null;
    }

    public boolean isKeyPresent(String key){
        return objectCache.containsKey(key);
    }

}

import org.junit.*;
import org.mockito.*;

import java.util.*;

import static org.junit.Assert.*;

@RunWith(MockitoJUnitRunner.class)
public class JsonObjectCacheManagerTest {

    private JsonObjectCacheManager cacheManager;

    private Map<String, Object> names;

    @Before
    public void setup(){
        /*names = new HashMap(){
            {
                    put("name1", "Spirit Air Lines");
                    put("name2", "American Airlines");
                    put("name3", "United Airlines");
                }
            };*/

        //edited as per Henri's point and worked
        names = new HashMap();
        names.put("name1", "Spirit Air Lines");
        names.put("name2", "American Airlines");
        names.put("name3", "United Airlines");
           cacheManager = new JsonObjectCacheManager();
        }
    @Test
    public void isPresentReturnsTrueIfObjectsPutInCache() throws Exception {
        //put in cache
        cacheManager.putInCache("names",names);
        assertTrue(cacheManager.isKeyPresent("names"));
    }

    @Test
    public void cacheTest() throws Exception {
        //put in cache
        cacheManager.putInCache("names",names);

        //retrieve from cache
        Map<String, Object> namesFromCache = (Map<String, Object>) cacheManager.retrieveFromCache("names");
        //validate against the cached object
//        assertEquals(3, namesFromCache.size());
//        assertEquals("American Airlines", namesFromCache.get("name2"));

    }
}

import org.junit.*；
导入org.mockito.*；
导入java.util.*；
导入静态org.junit.Assert.*；
@RunWith（MockitoJUnitRunner.class）
公共类JsonObjectCacheManagerTest{
私有JSONObject cacheManager cacheManager；
私人地图名称；
@以前
公共作废设置（）{
/*names=newhashmap（）{
{
放置（“名称1”，“精神空气管线”）；
put（“名称2”，“美国航空公司”）；
出售（“名称3”，“联合航空”）；
}
};*/
//根据亨利的观点编辑并工作
name=新的HashMap（）；
名称。填写（“名称1”、“精神航空公司”）；
名称。填写（“名称2”，“美国航空公司”）；
名称。填写（“名称3”，“联合航空”）；
cacheManager=新的JsonObjectCacheManager（）；
}
@试验
public void isPresentReturnsTrueIfObjectsPutInCache（）引发异常{
//缓存
cacheManager.putInCache（“名称”，名称）；
assertTrue（cacheManager.isKeyPresent（“名称”）；
}
@试验
public void cacheTest（）引发异常{
//缓存
cacheManager.putInCache（“名称”，名称）；
//从缓存中检索
映射名称FromCache=（映射）cacheManager.retrieveFromCache（“名称”）；
//针对缓存对象进行验证
//assertEquals（3，namesFromCache.size（））；
//assertEquals（“美国航空公司”，namesFromCache.get（“name2”）；
}
}

我收到断言错误，说缓存中不存在密钥。这意味着没有将对象添加到缓存中

有什么方法可以进行junit测试吗？谢谢你的帮助

编辑： “嘿，伙计们，”亨利指出了我的错误，解决了我的问题

---

您必须不要模拟测试中的类。

问题在于您的HashMap。实例化它的方式会创建一个匿名内部类。它保留对外部类实例的引用。哪一个是测试类。测试类是不可序列化的

如果使用以下代码，则所有测试都能顺利通过

    names = new HashMap();
    names.put("name1", "Spirit Air Lines");
    names.put("name2", "American Airlines");
    names.put("name3", "United Airlines");

---

我的错，我忘了取下那个。。。即使我删除了那个，测试也失败了。我关心的是这是测试缓存的方法还是我遗漏了什么。。。但是感谢您的时间：）@Timonthy Truckle，我忘了在评论中提到您的

JsonObjectWrapper

类是什么，它的

getJsonObject

方法做什么？它的名称表明，它可能不是您希望在

retrieveFromCache

中调用的方法-如果您希望通过此测试，您希望原始（非JSON）对象在那里。@DavidWallace我希望防止缓存对象的变异，因此缓存的对象应该实现可序列化接口，doc在此处。getJsonObject（）只是getter方法-->请看，我正在使用Lombok插件生成getter/setter/cons。调用它只是为了打开缓存的json对象。感谢您指出这一点。是啊，那真是我犯的愚蠢的错误。它解决了我的问题。再次感谢。