org.springmodules.cache.config.CacheManagerAndProviderFacadeParserTests.java Source code

Introduction

Here is the source code for org.springmodules.cache.config.CacheManagerAndProviderFacadeParserTests.java

Source

/* 
 * 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();
    }

}