/*
 * Created on Sep 1, 2005
 *
 * 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.jboss;

import junit.framework.TestCase;
import org.easymock.classextension.MockClassControl;
import org.jboss.cache.Node;
import org.jboss.cache.TreeCache;
import org.springframework.beans.propertyeditors.StringArrayPropertyEditor;
import org.springmodules.cache.FatalCacheException;
import org.springmodules.cache.provider.CacheAccessException;
import org.springmodules.cache.provider.CacheModelValidator;
import org.springmodules.cache.provider.ReflectionCacheModelEditor;

import java.beans.PropertyEditor;
import java.lang.reflect.Method;
import java.util.Map;

/**
 * Unit Tests for <code>{@link JbossCacheFacade}</code>.
 *
 * @author Omar Irbouh
 * @author Alex Ruiz
 */
public class JbossCacheFacadeTests extends TestCase {

	private static final String KEY = "key";

	private static final String NODE_FQN = "a/b/c/d";

	private JbossCacheFacade cacheFacade;

	private JbossCacheCachingModel cachingModel;

	private JbossCacheFlushingModel flushingModel;

	private TreeCache treeCache;

	private MockClassControl treeCacheControl;

	public JbossCacheFacadeTests(String name) {
		super(name);
	}

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

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

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

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

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

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

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

	public void testOnFlushCache() throws Exception {
		setUpTreeCache();
		cacheFacade.onFlushCache(flushingModel);
		Node cacheNode = treeCache.get(NODE_FQN);
		assertNull(cacheNode);
	}

	public void testOnFlushCacheWhenCacheAccessThrowsException() throws Exception {
		Method removeMethod = getRemoveMethodFromTreeCache();
		setUpTreeCacheAsMockObject(removeMethod);

		RuntimeException expected = new RuntimeException();

		treeCache.remove(NODE_FQN);
		treeCacheControl.setThrowable(expected);
		treeCacheControl.replay();

		try {
			cacheFacade.onFlushCache(flushingModel);
			fail();

		} catch (CacheAccessException exception) {
			assertSameNestedException(expected, exception);
		}

		treeCacheControl.verify();
	}

	public void testOnFlushCacheWithModelNotHavingNodes() throws Exception {
		Method removeMethod = getRemoveMethodFromTreeCache();
		setUpTreeCacheAsMockObject(removeMethod);

		flushingModel.setNodes((String[]) null);
		treeCacheControl.replay();

		cacheFacade.onFlushCache(flushingModel);

		treeCacheControl.verify();
	}

	public void testOnGetFromCache() throws Exception {
		setUpTreeCache();

		String objectToCache = "R2-D2";
		putInTreeCache(KEY, objectToCache);

		Object cachedObject = cacheFacade.onGetFromCache(KEY, cachingModel);

		assertEquals(objectToCache, cachedObject);
	}

	public void testOnGetFromCacheWhenCacheAccessThrowsException()
			throws Exception {
		Method getMethod = TreeCache.class.getDeclaredMethod("get", new Class[]{
				String.class, Object.class});
		setUpTreeCacheAsMockObject(getMethod);

		RuntimeException expected = new RuntimeException();

		treeCacheControl.expectAndThrow(treeCache.get(NODE_FQN, KEY), expected);

		treeCacheControl.replay();

		try {
			cacheFacade.onGetFromCache(KEY, cachingModel);
			fail();

		} catch (CacheAccessException exception) {
			assertSameNestedException(expected, exception);
		}

		treeCacheControl.verify();
	}

	public void testOnPutInCache() throws Exception {
		setUpTreeCache();

		String objectToCache = "Luke Skywalker";
		cacheFacade.onPutInCache(KEY, cachingModel, objectToCache);

		Object cachedObject = getFromTreeCache(KEY);
		assertEquals(objectToCache, cachedObject);
	}

	public void testOnPutInCacheWhenCacheAccessThrowsException() throws Exception {
		Method putMethod = TreeCache.class.getDeclaredMethod("put", new Class[]{
				String.class, Object.class, Object.class});
		setUpTreeCacheAsMockObject(putMethod);

		String objectToCache = "Luke";
		RuntimeException expected = new RuntimeException();

		treeCacheControl.expectAndThrow(
				treeCache.put(NODE_FQN, KEY, objectToCache), expected);

		treeCacheControl.replay();

		try {
			cacheFacade.onPutInCache(KEY, cachingModel, objectToCache);
			fail();

		} catch (CacheAccessException exception) {
			assertSameNestedException(expected, exception);
		}

		treeCacheControl.verify();
	}

	public void testOnRemoveFromCache() throws Exception {
		setUpTreeCache();

		String objectToCache = "Falcon Millenium";
		putInTreeCache(KEY, objectToCache);

		cacheFacade.onRemoveFromCache(KEY, cachingModel);

		Object cachedObject = getFromTreeCache(KEY);
		assertNull(cachedObject);
	}

	public void testOnRemoveFromCacheWhenCacheAccessThrowsException()
			throws Exception {
		Method removeMethod = TreeCache.class.getDeclaredMethod("remove",
				new Class[]{String.class, Object.class});
		setUpTreeCacheAsMockObject(removeMethod);

		RuntimeException expected = new RuntimeException();

		treeCacheControl.expectAndThrow(treeCache.remove(NODE_FQN, KEY), expected);

		treeCacheControl.replay();

		try {
			cacheFacade.onRemoveFromCache(KEY, cachingModel);
			fail();

		} catch (CacheAccessException exception) {
			assertSameNestedException(expected, exception);
		}

		treeCacheControl.verify();
	}

	public void testValidateCacheManagerWithCacheManagerEqualToNull() {
		cacheFacade.setCacheManager(null);
		try {
			cacheFacade.validateCacheManager();
			fail();

		} catch (FatalCacheException exception) {
			// we are expecting this exception.
		}
	}

	/**
	 * Verifies that the method
	 * <code>{@link JbossCacheFacade#validateCacheManager()}</code> does not
	 * throw any exception if the cache manager is not <code>null</code>.
	 */
	public void testValidateCacheManagerWithCacheManagerNotEqualToNull()
			throws Exception {
		setUpTreeCache();

		cacheFacade.validateCacheManager();
	}

	protected void setUp() {
		cacheFacade = new JbossCacheFacade();
		cachingModel = new JbossCacheCachingModel(NODE_FQN);
		flushingModel = new JbossCacheFlushingModel(NODE_FQN);
	}

	protected void tearDown() {
		if (treeCache != null) {
			treeCache.stopService();
			treeCache.destroyService();
		}
	}

	private void assertSameNestedException(Exception expected,
										   CacheAccessException root) {
		assertSame(expected, root.getCause());
	}

	private Object getFromTreeCache(Object key) throws Exception {
		return treeCache.get(cachingModel.getNode(), key);
	}

	private Method getRemoveMethodFromTreeCache() throws NoSuchMethodException, SecurityException {
		return TreeCache.class.getDeclaredMethod("remove",
				new Class[]{String.class});
	}

	private void putInTreeCache(Object key, Object value) throws Exception {
		treeCache.put(cachingModel.getNode(), key, value);
	}

	private void setUpTreeCache() throws Exception {
		treeCache = new TreeCache();
		startTreeCache();
		cacheFacade.setCacheManager(treeCache);
	}

	private void setUpTreeCacheAsMockObject(Method methodToMock) throws Exception {
		setUpTreeCacheAsMockObject(new Method[]{methodToMock});
	}

	private void setUpTreeCacheAsMockObject(Method[] methodsToMock)
			throws Exception {
		Class targetClass = TreeCache.class;

		treeCacheControl = MockClassControl.createControl(targetClass, null, null,
				methodsToMock);
		treeCache = (TreeCache) treeCacheControl.getMock();
		startTreeCache();

		cacheFacade.setCacheManager(treeCache);
	}

	private void startTreeCache() throws Exception {
		treeCache.createService();
		treeCache.startService();
	}

}