/*
* Created on Nov 10, 2004
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*
* Copyright @2007 the original author or authors.
*/
package org.springmodules.cache.provider;
import junit.framework.TestCase;
import org.easymock.MockControl;
import org.easymock.classextension.MockClassControl;
import org.springmodules.cache.CacheException;
import org.springmodules.cache.CachingModel;
import org.springmodules.cache.FatalCacheException;
import org.springmodules.cache.FlushingModel;
import org.springmodules.cache.mock.MockCachingModel;
import org.springmodules.cache.mock.MockFlushingModel;
import org.springmodules.cache.serializable.SerializableFactory;
import java.io.Serializable;
import java.lang.reflect.Method;
import java.net.Socket;
/**
* Unit Tests for <code>{@link AbstractCacheProviderFacade}</code>.
*
* @author Omar Irbouh
* @author Alex Ruiz
*/
public final class CacheProviderFacadeTests extends TestCase {
private AbstractCacheProviderFacade cacheProviderFacade;
private MockControl cacheProviderFacadeControl;
private CachingModel cachingModel;
private FlushingModel flushingModel;
/**
* Key of the cached object to be retrieved from
* <code>{@link #cacheProviderFacade}</code>.
*/
private Serializable key;
public CacheProviderFacadeTests(String name) {
super(name);
}
public void testAfterPropertiesSet() throws Exception {
cacheProviderFacade.validateCacheManager();
cacheProviderFacade.onAfterPropertiesSet();
cacheProviderFacadeControl.replay();
cacheProviderFacade.afterPropertiesSet();
cacheProviderFacadeControl.verify();
}
public void testAssertCacheManagerIsNotNullWithCacheManagerEqualToNull() {
try {
cacheProviderFacade.assertCacheManagerIsNotNull(null);
fail();
} catch (FatalCacheException exception) {
// we are expecting this exception.
}
}
public void testAssertCacheManagerIsNotNullWithCacheManagerNotEqualToNull() {
// shouldn't throw an exception
cacheProviderFacade.assertCacheManagerIsNotNull(new Object());
}
public void testCancelCacheUpdate() throws Exception {
cacheProviderFacade.onCancelCacheUpdate(key);
cacheProviderFacadeControl.replay();
cacheProviderFacade.cancelCacheUpdate(key);
cacheProviderFacadeControl.verify();
}
public void testCancelCacheUpdateWhenCacheAccessThrowsExceptionAndFailQuietlyIsFalse()
throws Exception {
cacheProviderFacade.setFailQuietlyEnabled(false);
CacheException expected = expectOnCancelCacheUpdateToThrowException();
cacheProviderFacadeControl.replay();
try {
cacheProviderFacade.cancelCacheUpdate(key);
fail();
} catch (CacheException exception) {
assertSame(expected, exception);
}
cacheProviderFacadeControl.verify();
}
public void testCancelCacheUpdateWhenCacheAccessThrowsExceptionAndFailQuietlyIsTrue()
throws Exception {
cacheProviderFacade.setFailQuietlyEnabled(true);
expectOnCancelCacheUpdateToThrowException();
cacheProviderFacadeControl.replay();
// shouldn't throw exceptions.
cacheProviderFacade.cancelCacheUpdate(key);
cacheProviderFacadeControl.verify();
}
public void testFlushCacheWhenAccessToCacheThrowsExceptionAndFailQuietlyIsFalse()
throws Exception {
cacheProviderFacade.setFailQuietlyEnabled(false);
CacheException expected = expectOnFlushCacheToThrowException();
cacheProviderFacadeControl.replay();
try {
cacheProviderFacade.flushCache(flushingModel);
fail();
} catch (CacheException exception) {
assertSame(expected, exception);
}
cacheProviderFacadeControl.verify();
}
public void testFlushCacheWhenAccessToCacheThrowsExceptionAndFailQuietlyIsTrue()
throws Exception {
cacheProviderFacade.setFailQuietlyEnabled(true);
expectOnFlushCacheToThrowException();
cacheProviderFacadeControl.replay();
cacheProviderFacade.flushCache(flushingModel);
cacheProviderFacadeControl.verify();
}
/**
* Verifies that the method
* <code>{@link AbstractCacheProviderFacade#flushCache(FlushingModel)}</code>
* does not flush the cache if the model is <code>null</code>.
*/
public void testFlushCacheWhenModelIsNull() throws Exception {
cacheProviderFacadeControl.replay();
cacheProviderFacade.flushCache(null);
cacheProviderFacadeControl.verify();
}
public void testGetFromCacheWhenAccessToCacheThrowsExceptionAndFailQuietlyIsFalse()
throws Exception {
cacheProviderFacade.setFailQuietlyEnabled(false);
CacheException expectedException = expectOnGetFromCacheToThrowException();
cacheProviderFacadeControl.replay();
try {
cacheProviderFacade.getFromCache(key, cachingModel);
fail();
} catch (CacheException exception) {
assertSame(expectedException, exception);
}
cacheProviderFacadeControl.verify();
}
public void testGetFromCacheWhenAccessToCacheThrowsExceptionAndFailQuietlyIsTrue()
throws Exception {
cacheProviderFacade.setFailQuietlyEnabled(true);
expectOnGetFromCacheToThrowException();
cacheProviderFacadeControl.replay();
Object cachedObject = cacheProviderFacade.getFromCache(key, cachingModel);
assertNull(cachedObject);
cacheProviderFacadeControl.verify();
}
/**
* Verifies that the method
* <code>{@link AbstractCacheProviderFacade#getFromCache(Serializable,CachingModel)}</code>
* does not try to access the cache if the model is <code>null</code>.
*/
public void testGetFromCacheWhenModelIsNull() throws Exception {
cacheProviderFacadeControl.replay();
Object cachedObject = cacheProviderFacade.getFromCache(key, null);
assertNull(cachedObject);
cacheProviderFacadeControl.verify();
}
public void testHandleCacheAccessExceptionWhenFailedQuietlyIsFalse() {
cacheProviderFacade.setFailQuietlyEnabled(false);
CacheException expectedException = createCacheException();
try {
cacheProviderFacade.handleCatchedException(expectedException);
fail();
} catch (CacheException exception) {
assertSame(expectedException, exception);
}
}
public void testHandleCacheAccessExceptionWhenFailedQuietlyIsTrue() {
cacheProviderFacade.setFailQuietlyEnabled(true);
CacheException cacheException = createCacheException();
// should not throw exceptions.
cacheProviderFacade.handleCatchedException(cacheException);
}
/**
* Verifies that the method
* <code>{@link AbstractCacheProviderFacade#makeSerializableIfNecessary(Object)}</code>
* does not make the given non-serializable object serializable if the cache
* does not require serializable entries.
*/
public void testMakeSerializableIfNecessaryWhenSerializableIsNotRequiredAndEntryIsNotSerializable() {
cacheProviderFacadeControl.expectAndReturn(cacheProviderFacade
.isSerializableCacheElementRequired(), false);
Object objectToStore = new Socket();
assertIsNotSerializable(objectToStore);
assertSame(objectToStore, cacheProviderFacade
.makeSerializableIfNecessary(objectToStore));
}
public void testMakeSerializableIfNecessaryWhenSerializableIsRequiredAndSerializableFactoryIsNotNullAndEntryIsNotSerializable() {
MockControl factoryControl = MockControl
.createControl(SerializableFactory.class);
SerializableFactory factory = (SerializableFactory) factoryControl
.getMock();
cacheProviderFacade.setSerializableFactory(factory);
cacheProviderFacadeControl.expectAndReturn(cacheProviderFacade
.isSerializableCacheElementRequired(), true);
cacheProviderFacadeControl.replay();
Serializable expected = "Leia";
Object objectToStore = new Object();
factoryControl.expectAndReturn(factory
.makeSerializableIfNecessary(objectToStore), expected);
factoryControl.replay();
Object actual = cacheProviderFacade
.makeSerializableIfNecessary(objectToStore);
assertSame(expected, actual);
cacheProviderFacadeControl.verify();
factoryControl.verify();
}
public void testMakeSerializableIfNecessaryWhenSerializableIsRequiredAndSerializableFactoryIsNotNullAndEntryIsSerializable() {
cacheProviderFacadeControl.expectAndReturn(cacheProviderFacade
.isSerializableCacheElementRequired(), true);
cacheProviderFacadeControl.replay();
Object objectToStore = "Luke Skywalker";
assertSame(objectToStore, cacheProviderFacade
.makeSerializableIfNecessary(objectToStore));
cacheProviderFacadeControl.verify();
}
/**
* Verifies that the method
* <code>{@link AbstractCacheProviderFacade#makeSerializableIfNecessary(Object)}</code>
* throws a <code>{@link ObjectCannotBeCachedException}</code> if:
* <ul>
* <li>the cache requires serializable entries</li>
* <li>the serializable factory of the facade is <code>null</code></li>
* <li>the given object is not serializable</li>
* </ul>
*/
public void testMakeSerializableIfNecessaryWhenSerializableIsRequiredAndSerializableFactoryIsNullAndEntryIsNotSerializable() {
cacheProviderFacadeControl.expectAndReturn(cacheProviderFacade
.isSerializableCacheElementRequired(), true);
cacheProviderFacadeControl.replay();
Object objectToStore = new Socket();
assertIsNotSerializable(objectToStore);
try {
cacheProviderFacade.makeSerializableIfNecessary(objectToStore);
fail();
} catch (ObjectCannotBeCachedException exception) {
// we are expecting this exception.
}
cacheProviderFacadeControl.verify();
}
public void testMakeSerializableIfNecessaryWhenSerializableIsRequiredAndSerializableFactoryIsNullAndEntryIsSerializable() {
cacheProviderFacadeControl.expectAndReturn(cacheProviderFacade
.isSerializableCacheElementRequired(), true);
cacheProviderFacadeControl.replay();
Object objectToStore = "R2-D2";
assertSame(objectToStore, cacheProviderFacade
.makeSerializableIfNecessary(objectToStore));
cacheProviderFacadeControl.verify();
}
public void testPutInCacheWhenAccessToCacheThrowsExceptionAndFailQuietlyIsFalse()
throws Exception {
cacheProviderFacade.setFailQuietlyEnabled(false);
Object objectToStore = new Object();
cacheProviderFacadeControl.expectAndReturn(cacheProviderFacade
.isSerializableCacheElementRequired(), false);
CacheException expectedException = expectOnPutInCacheThrowsException(objectToStore);
cacheProviderFacadeControl.replay();
try {
cacheProviderFacade.putInCache(key, cachingModel, objectToStore);
fail();
} catch (CacheException exception) {
assertSame(expectedException, exception);
}
cacheProviderFacadeControl.verify();
}
public void testPutInCacheWhenAccessToCacheThrowsExceptionAndFailQuietlyIsTrue()
throws Exception {
Object objectToStore = new Object();
cacheProviderFacade.setFailQuietlyEnabled(true);
cacheProviderFacadeControl.expectAndReturn(cacheProviderFacade
.isSerializableCacheElementRequired(), false);
expectOnPutInCacheThrowsException(objectToStore);
cacheProviderFacadeControl.replay();
cacheProviderFacade.putInCache(key, cachingModel, objectToStore);
cacheProviderFacadeControl.verify();
}
public void testPutInCacheWhenMakeSerializableThrowsExceptionAndFailQuietlyIsFalse() {
cacheProviderFacadeControl.expectAndReturn(cacheProviderFacade
.isSerializableCacheElementRequired(), true);
cacheProviderFacade.setFailQuietlyEnabled(false);
Object objectToStore = new Object();
assertIsNotSerializable(objectToStore);
cacheProviderFacadeControl.replay();
try {
cacheProviderFacade.putInCache(key, cachingModel, objectToStore);
fail();
} catch (ObjectCannotBeCachedException exception) {
// expecting exception.
}
cacheProviderFacadeControl.verify();
}
public void testPutInCacheWhenMakeSerializableThrowsExceptionAndFailQuietlyIsTrue() {
cacheProviderFacade.setFailQuietlyEnabled(true);
Object objectToStore = new Object();
assertIsNotSerializable(objectToStore);
cacheProviderFacadeControl.expectAndReturn(cacheProviderFacade
.isSerializableCacheElementRequired(), true);
cacheProviderFacadeControl.replay();
cacheProviderFacade.putInCache(key, cachingModel, objectToStore);
cacheProviderFacadeControl.verify();
}
/**
* Verifies that the method
* <code>{@link AbstractCacheProviderFacade#putInCache(Serializable,CachingModel,Object)}</code>.
* does not try to access the cache if the model is <code>null</code>.
*/
public void testPutInCacheWhenModelIsNull() throws Exception {
cacheProviderFacadeControl.expectAndReturn(cacheProviderFacade
.isSerializableCacheElementRequired(), false);
cacheProviderFacadeControl.replay();
cacheProviderFacade.putInCache(key, null, new Object());
cacheProviderFacadeControl.verify();
}
public void testRemoveFromCacheWhenAccessToCacheThrowsExceptionAndFailQuietlyIsFalse()
throws Exception {
cacheProviderFacade.setFailQuietlyEnabled(false);
CacheException expectedException = expectOnRemoveFromCacheThrowsException();
cacheProviderFacadeControl.replay();
try {
cacheProviderFacade.removeFromCache(key, cachingModel);
fail();
} catch (CacheException exception) {
assertSame(expectedException, exception);
}
cacheProviderFacadeControl.verify();
}
public void testRemoveFromCacheWhenAccessToCacheThrowsExceptionAndFailQuietlyIsTrue()
throws Exception {
cacheProviderFacade.setFailQuietlyEnabled(true);
expectOnRemoveFromCacheThrowsException();
cacheProviderFacadeControl.replay();
cacheProviderFacade.removeFromCache(key, cachingModel);
cacheProviderFacadeControl.verify();
}
/**
* Verifies that the method
* <code>{@link AbstractCacheProviderFacade#removeFromCache(Serializable,CachingModel)}</code>.
* does not try to access the cache if the model is <code>null</code>.
*/
public void testRemoveFromCacheWhenModelIsNull() throws Exception {
cacheProviderFacadeControl.replay();
cacheProviderFacade.removeFromCache(key, null);
cacheProviderFacadeControl.verify();
}
protected void setUp() throws Exception {
setUpCacheProviderFacadeAsMockObject();
key = "Key";
cachingModel = new MockCachingModel();
flushingModel = new MockFlushingModel();
}
private void assertIsNotSerializable(Object obj) {
assertFalse(obj.getClass().getName() + " should not be serializable",
obj instanceof Serializable);
}
private CacheException createCacheException() {
return new CacheNotFoundException("someCache");
}
private CacheException expectOnCancelCacheUpdateToThrowException() {
CacheException expected = createCacheException();
cacheProviderFacade.onCancelCacheUpdate(key);
cacheProviderFacadeControl.setThrowable(expected);
return expected;
}
private CacheException expectOnFlushCacheToThrowException() {
CacheException expected = createCacheException();
cacheProviderFacade.onFlushCache(flushingModel);
cacheProviderFacadeControl.setThrowable(expected);
return expected;
}
private CacheException expectOnGetFromCacheToThrowException() {
CacheException expected = createCacheException();
cacheProviderFacade.onGetFromCache(key, cachingModel);
cacheProviderFacadeControl.setThrowable(expected);
return expected;
}
private CacheException expectOnPutInCacheThrowsException(Object objectToStore) {
CacheException expected = createCacheException();
cacheProviderFacade.onPutInCache(key, cachingModel, objectToStore);
cacheProviderFacadeControl.setThrowable(expected);
return expected;
}
private CacheException expectOnRemoveFromCacheThrowsException() {
CacheException expected = createCacheException();
cacheProviderFacade.onRemoveFromCache(key, cachingModel);
cacheProviderFacadeControl.setThrowable(expected);
return expected;
}
private void setUpCacheProviderFacadeAsMockObject() throws Exception {
Class classToMock = AbstractCacheProviderFacade.class;
Method isSerializableCacheElementRequired = classToMock.getDeclaredMethod(
"isSerializableCacheElementRequired", new Class[0]);
Method onAfterPropertiesSet = classToMock.getDeclaredMethod(
"onAfterPropertiesSet", new Class[0]);
Method onCancelCacheUpdate = classToMock.getDeclaredMethod(
"onCancelCacheUpdate", new Class[]{Serializable.class});
Method onFlushCache = classToMock.getDeclaredMethod("onFlushCache",
new Class[]{FlushingModel.class});
Method onGetFromCache = classToMock.getDeclaredMethod("onGetFromCache",
new Class[]{Serializable.class, CachingModel.class});
Method onPutInCache = classToMock.getDeclaredMethod("onPutInCache",
new Class[]{Serializable.class, CachingModel.class, Object.class});
Method onRemoveFromCache = classToMock.getDeclaredMethod(
"onRemoveFromCache", new Class[]{Serializable.class,
CachingModel.class});
Method validateCacheManager = classToMock.getDeclaredMethod(
"validateCacheManager", new Class[0]);
Method[] methodsToMock = new Method[]{isSerializableCacheElementRequired,
onAfterPropertiesSet, onCancelCacheUpdate, onFlushCache,
onGetFromCache, onPutInCache, onRemoveFromCache, validateCacheManager};
cacheProviderFacadeControl = MockClassControl.createStrictControl(
classToMock, null, null, methodsToMock);
// cacheProviderFacadeControl = MockClassControl.createNiceControl(classToMock, methodsToMock);
cacheProviderFacade = (AbstractCacheProviderFacade) cacheProviderFacadeControl
.getMock();
//
// initialize logger (avoid EasyMock ClassExt issue)
// Field logger = classToMock.getDeclaredField("logger");
// logger.setAccessible(true);
// logger.set(cacheProviderFacade, LogFactory.getLog(classToMock));
}
}