/*
* Created on Feb 3, 2006
*
* 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 @2006 the original author or authors.
*/
package org.springmodules.cache.config;
import java.io.InputStream;
import java.lang.reflect.Method;
import junit.framework.TestCase;
import org.easymock.classextension.MockClassControl;
import org.w3c.dom.Element;
import org.springframework.beans.MutablePropertyValues;
import org.springframework.beans.PropertyValue;
import org.springframework.beans.factory.config.RuntimeBeanReference;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.support.RootBeanDefinition;
import org.springframework.core.io.Resource;
import org.springframework.core.io.ResourceEditor;
import org.springmodules.cache.provider.AbstractCacheManagerFactoryBean;
import org.springmodules.cache.provider.CacheProviderFacade;
import org.springmodules.cache.provider.PathUtils;
/**
* <p>
* Unit Tests for
* <code>{@link AbstractCacheManagerAndProviderFacadeParser}</code>.
* </p>
*
* @author Alex Ruiz
*/
public class CacheManagerAndProviderFacadeParserTests extends TestCase {
private static abstract class BeanName {
private static final String CACHE_MANAGER = "cacheManager";
private static final String CACHE_PROVIDER_FACADE = "cacheProvider";
}
protected class ConfigElementBuilder implements XmlElementBuilder {
String configLocation = "";
public Element toXml() {
Element element = new DomElementStub("config");
element.setAttribute("configLocation", configLocation);
return element;
}
}
private Class cacheManagerClass;
private RootBeanDefinition cacheProviderFacade;
private ConfigElementBuilder configElementBuilder;
private AbstractCacheManagerAndProviderFacadeParser parser;
private MockClassControl parserControl;
private BeanDefinitionRegistry registry;
/**
* Constructor.
*
* @param name
* the name of the test case
*/
public CacheManagerAndProviderFacadeParserTests(String name) {
super(name);
}
/**
* Verifies that the method
* <code>{@link AbstractCacheManagerAndProviderFacadeParser#doParse(String, Element, BeanDefinitionRegistry)}</code>
* does not set any value to the property "configLocation" of the cache
* manager factory definition if the XML attribute "configLocation" does not
* contain any value.
*/
public void testDoParseWithEmptyConfigLocation() {
configElementBuilder.configLocation = "";
Element element = configElementBuilder.toXml();
expectGetCacheManagerClass();
parserControl.replay();
parser.doParse(BeanName.CACHE_PROVIDER_FACADE, element, registry);
assertNull("Property 'configLocation' should be null",
getConfigLocationFromCacheManager());
assertCacheProviderFacadeHasCacheManagerAsProperty();
}
/**
* Verifies that the method
* <code>{@link AbstractCacheManagerAndProviderFacadeParser#doParse(String, Element, BeanDefinitionRegistry)}</code>
* creates a <code>{@link Resource}</code> from the path specified in the
* XML attribute "configLocation" and sets such resource as the value of the
* property "configLocation" of the cache manager factory definition.
*
* @throws Exception
* any exception thrown when reading the contents of the specified
* configuration file
*/
public void testDoParseWithExistingConfigLocation() throws Exception {
configElementBuilder.configLocation = ("classpath:"
+ PathUtils.getPackageNameAsPath(getClass()) + "/fakeConfigLocation.xml");
Element element = configElementBuilder.toXml();
expectGetCacheManagerClass();
parserControl.replay();
parser.doParse(BeanName.CACHE_PROVIDER_FACADE, element, registry);
Resource configLocation = getConfigLocationFromCacheManager();
ResourceEditor editor = new ResourceEditor();
editor.setAsText(configElementBuilder.configLocation);
String expectedContent = getResourceContent((Resource) editor.getValue());
String actualContent = getResourceContent(configLocation);
assertEquals("<Config resource content>", expectedContent, actualContent);
assertCacheProviderFacadeHasCacheManagerAsProperty();
}
protected void setUp() throws Exception {
configElementBuilder = new ConfigElementBuilder();
cacheManagerClass = AbstractCacheManagerFactoryBean.class;
Class targetClass = AbstractCacheManagerAndProviderFacadeParser.class;
Method getCacheManagerClassMethod = targetClass.getDeclaredMethod(
"getCacheManagerClass", new Class[0]);
Method[] methodsToMock = { getCacheManagerClassMethod };
parserControl = MockClassControl.createControl(targetClass, null, null,
methodsToMock);
parser = (AbstractCacheManagerAndProviderFacadeParser) parserControl
.getMock();
registry = new DefaultListableBeanFactory();
cacheProviderFacade = new RootBeanDefinition(CacheProviderFacade.class);
cacheProviderFacade.setPropertyValues(new MutablePropertyValues());
registry.registerBeanDefinition(BeanName.CACHE_PROVIDER_FACADE,
cacheProviderFacade);
}
protected void tearDown() {
parserControl.verify();
}
/**
* Asserts that the cache provider facade definition has a reference to the
* definition of a cache manager factory.
*/
private void assertCacheProviderFacadeHasCacheManagerAsProperty() {
PropertyValue cacheManagerProperty = cacheProviderFacade
.getPropertyValues().getPropertyValue("cacheManager");
RuntimeBeanReference cacheManager = (RuntimeBeanReference) cacheManagerProperty
.getValue();
assertEquals(BeanName.CACHE_MANAGER, cacheManager.getBeanName());
}
private void expectGetCacheManagerClass() {
parser.getCacheManagerClass();
parserControl.setReturnValue(cacheManagerClass);
}
private RootBeanDefinition getCacheManagerFromRegistry() {
RootBeanDefinition cacheManager = (RootBeanDefinition) registry
.getBeanDefinition(BeanName.CACHE_MANAGER);
return cacheManager;
}
private Resource getConfigLocationFromCacheManager() {
RootBeanDefinition cacheManager = getCacheManagerFromRegistry();
return (Resource) cacheManager.getPropertyValues().getPropertyValue(
"configLocation").getValue();
}
private String getResourceContent(Resource resource) throws Exception {
InputStream inputStream = resource.getInputStream();
StringBuffer out = new StringBuffer();
byte[] b = new byte[4096];
for (int n; (n = inputStream.read(b)) != -1;) {
out.append(new String(b, 0, n));
}
return out.toString();
}
}