org.springmodules.cache.provider.tangosol.CoherenceFacadeTests.java Source code

Introduction

Here is the source code for org.springmodules.cache.provider.tangosol.CoherenceFacadeTests.java

Source

/*
 * Created on Jan 26, 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 @2007 the original author or authors.
 */
package org.springmodules.cache.provider.tangosol;

import com.tangosol.net.NamedCache;
import junit.framework.TestCase;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.propertyeditors.StringArrayPropertyEditor;
import org.springframework.util.StringUtils;
import org.springmodules.cache.provider.CacheModelValidator;
import org.springmodules.cache.provider.ReflectionCacheModelEditor;
import org.springmodules.cache.util.TangosolUtils;

import java.beans.PropertyEditor;
import java.util.Map;

/**
 * Unit Tests for <code>{@link CoherenceFacade}</code>.
 * <p/>
 * <Strong>Note:</Strong> This class requires
 * <a href="http://www.tangosol.com">Tangosol Coherence</a> jars in the
 * classpath to work.
 *
 * @author Omar Irbouh
 * @author Alex Ruiz
 */
public class CoherenceFacadeTests extends TestCase {

    private static final String CACHE_NAME = "VirtualCache";

    private static final String ENTRY_KEY = "KEY";

    private static final String ENTRY_VALUE = "VALUE";

    private NamedCache cache;

    private CoherenceFacade facade;

    protected final Log logger = LogFactory.getLog(getClass());

    // check whether required Tangosol API is on classpath
    public void runBare() throws Throwable {
        if (TangosolUtils.isApiPresent()) {
            super.runBare();
        } else {
            logger.info("Unable to run tests. Tangosol API is missing.");
        }
    }

    /**
     * Verifies that the method
     * <code>{@link CoherenceFacade#modelValidator()}</code> returns an
     * an instance of <code>{@link CoherenceModelValidator}</code> not equal to
     * <code>null</code>.
     */
    public void testGetCacheModelValidator() {
        CacheModelValidator validator = facade.modelValidator();
        assertNotNull(validator);
        assertEquals(CoherenceModelValidator.class, validator.getClass());
    }

    public void testGetCachingModelEditor() {
        PropertyEditor editor = facade.getCachingModelEditor();

        assertNotNull(editor);
        assertEquals(ReflectionCacheModelEditor.class, editor.getClass());

        ReflectionCacheModelEditor modelEditor = (ReflectionCacheModelEditor) editor;
        assertEquals(CoherenceCachingModel.class, modelEditor.getCacheModelClass());
        assertNull(modelEditor.getCacheModelPropertyEditors());
    }

    public void testGetFlushingModelEditor() {
        PropertyEditor editor = facade.getFlushingModelEditor();

        assertNotNull(editor);
        assertEquals(ReflectionCacheModelEditor.class, editor.getClass());

        ReflectionCacheModelEditor modelEditor = (ReflectionCacheModelEditor) editor;
        assertEquals(CoherenceFlushingModel.class, modelEditor.getCacheModelClass());
        Map propertyEditors = modelEditor.getCacheModelPropertyEditors();
        assertEquals(1, propertyEditors.size());
        assertSame(StringArrayPropertyEditor.class, propertyEditors.get("cacheNames").getClass());
    }

    public void testIsSerializableCacheElementRequired() {
        assertFalse(facade.isSerializableCacheElementRequired());
    }

    public void testOnFlushCache() {
        setUpCache();
        cache.put(ENTRY_KEY, ENTRY_VALUE);

        CoherenceFlushingModel model = new CoherenceFlushingModel(new String[] { CACHE_NAME });
        facade.onFlushCache(model);
        assertValueIsNotInCache();
        tearDownCache();
    }

    public void testOnGetFromCache() {
        setUpCache();
        cache.put(ENTRY_KEY, ENTRY_VALUE);

        CoherenceCachingModel model = defaultCachingModel();
        assertEquals("Value stored under key " + StringUtils.quote(ENTRY_KEY), ENTRY_VALUE,
                facade.onGetFromCache(ENTRY_KEY, model));

        tearDownCache();
    }

    public void testOnPutInCache() {
        setUpCache();

        CoherenceCachingModel model = defaultCachingModel();
        facade.onPutInCache(ENTRY_KEY, model, ENTRY_VALUE);
        assertValueIsInCache();

        tearDownCache();
    }

    public void testOnPutInCacheWithTimeToLeave() {
        setUpCache();

        long timeToLive = 3000;
        CoherenceCachingModel model = defaultCachingModel();
        model.setTimeToLive(timeToLive);

        facade.onPutInCache(ENTRY_KEY, model, ENTRY_VALUE);
        assertValueIsInCache();

        try {
            Thread.sleep(timeToLive * 2);
        } catch (InterruptedException exception) {
            exception.printStackTrace();
        }

        assertValueIsNotInCache();

        tearDownCache();
    }

    public void testOnRemoveFromCache() {
        setUpCache();
        cache.put(ENTRY_KEY, ENTRY_VALUE);

        CoherenceCachingModel model = defaultCachingModel();
        facade.onRemoveFromCache(ENTRY_KEY, model);
        assertValueIsNotInCache();
    }

    protected void setUp() {
        facade = new CoherenceFacade();
    }

    private void assertValueIsInCache() {
        assertEquals("Value stored under key " + StringUtils.quote(ENTRY_KEY), ENTRY_VALUE, cache.get(ENTRY_KEY));
    }

    private void assertValueIsNotInCache() {
        assertNull("There should not be any value stored under the key " + StringUtils.quote(ENTRY_KEY),
                cache.get(ENTRY_KEY));
    }

    private CoherenceCachingModel defaultCachingModel() {
        return new CoherenceCachingModel(CACHE_NAME);
    }

    private void setUpCache() {
        cache = TangosolUtils.getNamedCache(CACHE_NAME);
        assertTrue("Cache " + StringUtils.quote(CACHE_NAME) + " should be empty", cache.isEmpty());
    }

    private void tearDownCache() {
        cache.clear();
        TangosolUtils.shutdownCacheFactory();
    }

}