EDIT

eu.etaxonomy.taxeditor.cdmlib/src/test/java/eu/etaxonomy/cdm/api/cache/CdmClientCachingTest.java -text

eu.etaxonomy.taxeditor.cdmlib/src/test/java/eu/etaxonomy/cdm/api/cache/CdmModelGetMethodCacherTest.java -text

eu.etaxonomy.taxeditor.cdmlib/src/test/java/eu/etaxonomy/cdm/polytomouskey/PolytomousKeyTest.java -text

eu.etaxonomy.taxeditor.cdmlib/src/test/java/eu/etaxonomy/taxeditor/exception/CDMServerException.java -text

eu.etaxonomy.taxeditor.cdmlib/src/test/java/eu/etaxonomy/taxeditor/httpinvoker/BaseRemotingTest.java -text

eu.etaxonomy.taxeditor.cdmlib/src/test/java/eu/etaxonomy/taxeditor/httpinvoker/CDMServer.java -text

eu.etaxonomy.taxeditor.cdmlib/src/test/java/eu/etaxonomy/taxeditor/httpinvoker/CdmPersistentRemoteSourceTest.java -text

eu.etaxonomy.taxeditor.cdmlib/src/test/java/eu/etaxonomy/taxeditor/httpinvoker/CdmRemoteSourceTest.java -text

eu.etaxonomy.taxeditor.cdmlib/src/test/java/eu/etaxonomy/taxeditor/httpinvoker/CdmServerTest.java -text

eu.etaxonomy.taxeditor.cdmlib/src/test/java/eu/etaxonomy/taxeditor/httpinvoker/CdmServerTestManager.java -text

eu.etaxonomy.taxeditor.cdmlib/src/test/java/eu/etaxonomy/taxeditor/httpinvoker/HttpInvokerServicesTest.java -text

eu.etaxonomy.taxeditor.cdmlib/src/test/java/eu/etaxonomy/taxeditor/lazyloading/AbstractLazyInitializerTest.java -text

eu.etaxonomy.taxeditor.cdmlib/src/test/java/eu/etaxonomy/taxeditor/lazyloading/CdmEntityCacherTest.java -text

eu.etaxonomy.taxeditor.cdmlib/src/test/java/eu/etaxonomy/taxeditor/lazyloading/CdmServiceCacherTest.java -text

eu.etaxonomy.taxeditor.cdmlib/src/test/java/eu/etaxonomy/taxeditor/lazyloading/RemoteLazyLoadingTest.java -text

eu.etaxonomy.taxeditor.cdmlib/src/test/java/eu/etaxonomy/taxeditor/lazyloading/RemotePersistentCollectionTest.java -text

eu.etaxonomy.taxeditor.cdmlib/src/test/java/eu/etaxonomy/taxeditor/session/CdmEntitySessionManagerTest.java -text

eu.etaxonomy.taxeditor.cdmlib/src/test/java/eu/etaxonomy/taxeditor/session/MockSessionOwner.java -text

// $Id$

/**

* Copyright (C) 2014 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.cdm.api.cache;

import java.util.Arrays;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.UUID;

import org.apache.log4j.Level;

import org.apache.log4j.Logger;

import org.junit.Assert;

import org.junit.Before;

import org.junit.BeforeClass;

import org.junit.Test;

import org.unitils.dbunit.annotation.DataSet;

import eu.etaxonomy.cdm.api.service.ICommonService;

import eu.etaxonomy.cdm.api.service.IPolytomousKeyNodeService;

import eu.etaxonomy.cdm.api.service.IPolytomousKeyService;

import eu.etaxonomy.cdm.api.service.ITaxonService;

import eu.etaxonomy.cdm.model.common.CdmBase;

import eu.etaxonomy.cdm.model.common.Language;

import eu.etaxonomy.cdm.model.common.LanguageString;

import eu.etaxonomy.cdm.model.description.KeyStatement;

import eu.etaxonomy.cdm.model.description.PolytomousKey;

import eu.etaxonomy.cdm.model.description.PolytomousKeyNode;

import eu.etaxonomy.taxeditor.httpinvoker.BaseRemotingTest;

import eu.etaxonomy.taxeditor.httpinvoker.CDMServer;

import eu.etaxonomy.taxeditor.session.ISessionEventListener;

import eu.etaxonomy.taxeditor.session.MockSessionOwner;

/**

 * @author cmathew

 * @date 7 Oct 2014

 *

 */

@DataSet

public class CdmClientCachingTest extends BaseRemotingTest {

    private static final Logger logger = Logger.getLogger(CdmClientCachingTest.class);

    private UUID polytomousKeyUuid = UUID.fromString("0d53ba20-7de4-4baa-bd8a-401048447d66");

    private UUID taxon1Uuid = UUID.fromString("2b336df7-29e8-4f79-985f-66502739d22f");

    private UUID polytomousKeyNodeUuid1 = UUID.fromString("75e4c924-ff58-4ee7-a59d-fd9173517d08");

    private UUID polytomousKeyNodeUuid2 = UUID.fromString("b775c027-13c0-4b87-8aa9-712faeaafbdc");

    private IPolytomousKeyService polytomousKeyService = getRemoteApplicationController().getPolytomousKeyService();

    private IPolytomousKeyNodeService polytomousKeyNodeService = getRemoteApplicationController().getPolytomousKeyNodeService();

    private ICommonService commonService = getRemoteApplicationController().getCommonService();

    private ITaxonService taxonService = getRemoteApplicationController().getTaxonService();    

	private CdmTransientEntityCacher cacher;

    private ISessionEventListener sessionOwner;

    private static final List<String> PKEY_DEPTH1_INIT_STRATEGY = Arrays.asList(new String[] {

			});

    private static final List<String> PKEY_DEPTH2_INIT_STRATEGY = Arrays.asList(new String[] {

    		"root"});

    private static final List<String> PKEY_DEPTH3_INIT_STRATEGY = Arrays.asList(new String[] {    		

    		"root.statement"});

    @BeforeClass

    public static void initializePolytomousKeyTest() {

        logger.setLevel(Level.INFO);

        CDMServer.getInstance().setKeepServerRunning(true);    	        

    }

    @Before

    public void initializeSession() {

    	sessionOwner = new MockSessionOwner();    

    	cdmEntitySessionManager.bind(sessionOwner);

    	cacher = getCacher(sessionOwner);

    }    

    @Test

    public void recursiveLoadSubGraphDepth1Test() {

    	// this call will load into the session cache the graph 

    	// polytomous key  

    	// 	|- root : polytomous key node 

    	// in a recursive call    	

        PolytomousKey pkey1 = CdmBase.deproxy(polytomousKeyService.load(polytomousKeyUuid, PKEY_DEPTH1_INIT_STRATEGY),PolytomousKey.class);

        pkey1 = cdmEntitySessionManager.load(sessionOwner, pkey1);

        // checking to make sure the root object is in the session cache

        Assert.assertSame(pkey1.getRoot(), cacher.getFromCache(pkey1.getRoot()));

    }

    @Test

    public void recursiveLoadSubGraphDepth2Test() {

    	// this call will load into the session cache the graph 

    	// polytomous key  

    	// 	|- root : polytomous key node 

    	//		|- question : KeyStatement

    	//		|- statement : KeyStatement    	

    	// in a recursive call    	

        PolytomousKey pkey = CdmBase.deproxy(polytomousKeyService.load(polytomousKeyUuid, PKEY_DEPTH2_INIT_STRATEGY),PolytomousKey.class);

        pkey = cdmEntitySessionManager.load(sessionOwner, pkey);

        CdmTransientEntityCacher cacher = getCacher(sessionOwner);

        // checking to make sure the root object is in the session cache

        Assert.assertSame(pkey.getRoot(), cacher.getFromCache(pkey.getRoot()));

        Assert.assertSame(pkey.getRoot().getStatement(), cacher.getFromCache(pkey.getRoot().getStatement()));

        Assert.assertSame(pkey.getRoot().getQuestion(), cacher.getFromCache(pkey.getRoot().getQuestion()));

    }

    /**

     * when : retrieving objects using recursive caching of object graphs with different depths 

     * then : the objects in the sub-graph having the same persistence id should be the same

     */

    @Test

    public void lazyLoadRecursiveTest() {

    	// this call will load into the session cache the graph and update the objects in the sub-graph for a

    	// polytomous key  

    	// 	|- root : polytomous key node 

    	//		|- question : KeyStatement

    	//		|- statement : KeyStatement    	

        PolytomousKey pkey1 = CdmBase.deproxy(polytomousKeyService.find(polytomousKeyUuid),PolytomousKey.class);

        pkey1 = cdmEntitySessionManager.load(sessionOwner, pkey1);

        CdmTransientEntityCacher cacher = getCacher(sessionOwner);

    }

    /**

     * when : retrieving objects using recursive caching of object graphs with different depths      

     * then : the objects in the sub-graph having the same persistence id should be the same

     */

    @Test

    public void differentSubGraphDepthTest1() {

    	// this call will load into the session cache the graph and update the objects in the sub-graph for a

    	// polytomous key  

    	// 	|- root : polytomous key node 

    	// in a recursive call    

        PolytomousKey pkey1 = CdmBase.deproxy(polytomousKeyService.load(polytomousKeyUuid, PKEY_DEPTH1_INIT_STRATEGY),PolytomousKey.class);

        pkey1 = cdmEntitySessionManager.load(sessionOwner, pkey1);

        CdmTransientEntityCacher cacher = getCacher(sessionOwner);

    	// this call will load into the session cache the graph and update the objects in the sub-graph for a

    	// polytomous key  

    	// 	|- root : polytomous key node 

    	//		|- question : KeyStatement

    	//		|- statement : KeyStatement    	       

        PolytomousKey pkey2 = CdmBase.deproxy(polytomousKeyService.load(polytomousKeyUuid, PKEY_DEPTH2_INIT_STRATEGY),PolytomousKey.class);

        pkey2 = cdmEntitySessionManager.load(sessionOwner, pkey2);

        Assert.assertSame(pkey2.getRoot().getStatement(), cacher.getFromCache(pkey2.getRoot().getStatement()));

        Assert.assertSame(pkey1.getRoot().getStatement(), pkey2.getRoot().getStatement());

        Assert.assertSame(cacher.getFromCache(pkey1.getRoot().getStatement()), cacher.getFromCache(pkey2.getRoot().getStatement()));

    }

    /**

     * when : retrieving objects using recursive caching of object graphs with different depths 

     * then : the objects in the sub-graph having the same persistence id should be the same

     */

    @Test

    public void differentSubGraphDepthTest2() {

    	// this call will load into the session cache the graph and update the objects in the sub-graph for a

    	// polytomous key  

    	// 	|- root : polytomous key node 

    	//		|- question : KeyStatement

    	//		|- statement : KeyStatement    	

        PolytomousKey pkey1 = CdmBase.deproxy(polytomousKeyService.load(polytomousKeyUuid, PKEY_DEPTH2_INIT_STRATEGY),PolytomousKey.class);

        pkey1 = cdmEntitySessionManager.load(sessionOwner, pkey1);

        CdmTransientEntityCacher cacher = getCacher(sessionOwner);

    	// this call will load into the session cache the graph and update the objects in the sub-graph for a

    	// polytomous key  

    	// 	|- root : polytomous key node  

        PolytomousKey pkey2 = CdmBase.deproxy(polytomousKeyService.load(polytomousKeyUuid, PKEY_DEPTH1_INIT_STRATEGY),PolytomousKey.class);

        pkey2 = cdmEntitySessionManager.load(sessionOwner, pkey2);

        Assert.assertSame(pkey2.getRoot().getStatement(), cacher.getFromCache(pkey2.getRoot().getStatement()));

        Assert.assertSame(pkey1.getRoot().getStatement(), pkey2.getRoot().getStatement());

        Assert.assertSame(cacher.getFromCache(pkey1.getRoot().getStatement()), cacher.getFromCache(pkey2.getRoot().getStatement()));

    }

    /**

     * when : retrieving objects using (first) recursive load directly and (second) lazy loading in the same session

     * then : the objects in the sub-graph having the same persistence id should be the same

     */

    @Test

    public void recursiveLoadAndLazyLoadTest() {

    	// this call will load into the session cache the graph and update the objects in the sub-graph for a

    	// polytomous key  

    	// 	|- root : polytomous key node 

    	//		|- question : KeyStatement

    	//		|- statement : KeyStatement    	

        PolytomousKey pkey1 = CdmBase.deproxy(polytomousKeyService.load(polytomousKeyUuid, PKEY_DEPTH2_INIT_STRATEGY),PolytomousKey.class);

        pkey1 = cdmEntitySessionManager.load(sessionOwner, pkey1);

        CdmTransientEntityCacher cacher = getCacher(sessionOwner);

        // checking that the root is not null and 

        // that it exists in the cache and

        // that both the original object and the 

        // cached object are the same

        Assert.assertNotNull(pkey1.getRoot().getStatement());

        Assert.assertNotNull(cacher.getFromCache(pkey1.getRoot().getStatement()));

    	// this call will load into the session cache the graph and update the objects in the sub-graph for a

    	// polytomous key  

    	// 	|- root : polytomous key node  

        PolytomousKey pkey2 = CdmBase.deproxy(polytomousKeyService.find(polytomousKeyUuid),PolytomousKey.class);

        pkey2 = cdmEntitySessionManager.load(sessionOwner, pkey2);

        Assert.assertSame(pkey2.getRoot().getStatement(), cacher.getFromCache(pkey2.getRoot().getStatement()));

        Assert.assertSame(pkey1.getRoot().getStatement(), pkey2.getRoot().getStatement());

        Assert.assertSame(cacher.getFromCache(pkey1.getRoot().getStatement()), cacher.getFromCache(pkey2.getRoot().getStatement()));

    }

    /**

     * when : retrieving objects using (first) lazy loading  and (second) recursive load directly in the same session

     * then : the objects in the sub-graph having the same persistence id should be the same

     */

    @Test

    public void lazyLoadAndRecursiveLoadTest() {

    	// this call will load into the session cache the graph and update the objects in the sub-graph for a

    	// polytomous key  

    	// 	|- root : polytomous key node  

    	PolytomousKey pkey1 = CdmBase.deproxy(polytomousKeyService.find(polytomousKeyUuid),PolytomousKey.class);

        pkey1 = cdmEntitySessionManager.load(sessionOwner, pkey1);

        // lazy initialising root.statement

        KeyStatement st = CdmBase.deproxy(pkey1.getRoot().getStatement(), KeyStatement.class); 

        st.getLabel();

        // checking that the root is not null and 

        // that it exists in the cache and

        // that both the original object and the 

        // cached object are the same

    	Assert.assertNotNull(pkey1.getRoot().getStatement());

    	Assert.assertSame(CdmBase.deproxy(pkey1.getRoot().getStatement(), KeyStatement.class),

    			cacher.getFromCache(pkey1.getRoot().getStatement(), KeyStatement.class));

    	// this call will load into the session cache the graph and update the objects in the sub-graph for a

    	// polytomous key  

    	// 	|- root : polytomous key node 

    	//		|- question : KeyStatement

    	//		|- statement : KeyStatement    	

    	PolytomousKey pkey2 = CdmBase.deproxy(polytomousKeyService.load(polytomousKeyUuid, PKEY_DEPTH2_INIT_STRATEGY),PolytomousKey.class);

    	pkey2 = cdmEntitySessionManager.load(sessionOwner, pkey2);

    	Assert.assertSame(pkey2.getRoot().getStatement(), cacher.getFromCache(pkey2.getRoot().getStatement(), KeyStatement.class));

    	Assert.assertSame(st, pkey2.getRoot().getStatement());

    	Assert.assertSame(cacher.getFromCache(st), cacher.getFromCache(pkey2.getRoot().getStatement(), KeyStatement.class));

    }

    /**

     * when : loading an object (first) and then (second) loading a graph the object is contained in, in the same session

     * then : the object should be the same

     */

    @Test

    public void subGraphObjectLoadTest1() {

    	// this call will load into the session cache a polytomous key node object    	    	

    	PolytomousKeyNode rootPKNode = CdmBase.deproxy(polytomousKeyNodeService.find(polytomousKeyNodeUuid1),PolytomousKeyNode.class);

    	rootPKNode = cdmEntitySessionManager.load(sessionOwner, rootPKNode);

    	Assert.assertNotNull(rootPKNode);

    	Assert.assertSame(rootPKNode, cacher.getFromCache(rootPKNode));

    	PolytomousKeyNode childOfRootPKNode = CdmBase.deproxy(polytomousKeyNodeService.find(polytomousKeyNodeUuid2),PolytomousKeyNode.class);

    	childOfRootPKNode = cdmEntitySessionManager.load(sessionOwner, childOfRootPKNode);

    	Assert.assertNotNull(childOfRootPKNode);

    	Assert.assertSame(childOfRootPKNode, cacher.getFromCache(childOfRootPKNode));

    	// this call will load into the session cache the graph and update the objects in the sub-graph for a

    	// polytomous key  

    	// 	|- root : polytomous key node 

    	//		|- question : KeyStatement

    	//		|- statement : KeyStatement    	

    	PolytomousKey pkey = CdmBase.deproxy(polytomousKeyService.load(polytomousKeyUuid, PKEY_DEPTH2_INIT_STRATEGY),PolytomousKey.class);

    	pkey = cdmEntitySessionManager.load(sessionOwner, pkey);

    	Assert.assertSame(childOfRootPKNode, cacher.getFromCache(childOfRootPKNode));

    	Assert.assertSame(pkey.getRoot().getChildAt(1), childOfRootPKNode);

    }

    /**

     * when : loading a graph (first) and then (second) loading an object contained in in the graph, in the same session

     * then : the object should be the same

     */

    @Test

    public void subGraphObjectLoadTest2() {

    	// this call will load into the session cache the graph and update the objects in the sub-graph for a

    	// polytomous key  

    	// 	|- root : polytomous key node 

    	//		|- question : KeyStatement

    	//		|- statement : KeyStatement    	

    	PolytomousKey pkey = CdmBase.deproxy(polytomousKeyService.load(polytomousKeyUuid, PKEY_DEPTH2_INIT_STRATEGY),PolytomousKey.class);

    	pkey = cdmEntitySessionManager.load(sessionOwner, pkey);

    	// this call will load into the session cache a polytomous key node object    	    	

    	PolytomousKeyNode rootPKNode = CdmBase.deproxy(polytomousKeyNodeService.find(polytomousKeyNodeUuid1),PolytomousKeyNode.class);

    	rootPKNode = cdmEntitySessionManager.load(sessionOwner, rootPKNode);

    	Assert.assertNotNull(rootPKNode);

    	Assert.assertSame(rootPKNode, cacher.getFromCache(rootPKNode));

    	PolytomousKeyNode childOfRootPKNode = CdmBase.deproxy(polytomousKeyNodeService.find(polytomousKeyNodeUuid2),PolytomousKeyNode.class);

    	childOfRootPKNode = cdmEntitySessionManager.load(sessionOwner, childOfRootPKNode);

    	Assert.assertNotNull(childOfRootPKNode);

    	Assert.assertSame(childOfRootPKNode, cacher.getFromCache(childOfRootPKNode));    	

    	Assert.assertSame(childOfRootPKNode, cacher.getFromCache(childOfRootPKNode));

    	Assert.assertSame(pkey.getRoot().getChildAt(1), childOfRootPKNode);

    }

    /**

     * when : loading objects from a collection 

     * then : the object stored in the cache should be the same

     */

    @Test

    public void subGraphCollectionLoadTest() {

    	// this call will load into the session cache the graph and update the objects in the sub-graph for a

    	// polytomous key  

    	// 	|- root : polytomous key node 

    	//		|- question : KeyStatement

    	//		|- statement : KeyStatement    	

    	PolytomousKey pkey = CdmBase.deproxy(polytomousKeyService.load(polytomousKeyUuid, PKEY_DEPTH2_INIT_STRATEGY),PolytomousKey.class);

    	pkey = cdmEntitySessionManager.load(sessionOwner, pkey);

    	PolytomousKeyNode childOfRootPKNode = pkey.getRoot().getChildAt(1);

    	Assert.assertSame(childOfRootPKNode, cacher.getFromCache(childOfRootPKNode));

    	Assert.assertSame(pkey.getRoot().getChildAt(1), childOfRootPKNode);

    }

    /**

     * when : loading a non-lazy collection in a subgraph and loading the collection directly

     * then : the object stored in the cache should be the same as the object in the sub-graph collection and 

     *        the object in the directly loaded collection

     */

    @Test

    public void nonLazyCollectionLoadTest() {

    	// need to find an example of this

    }

    /**

     * when : loading objects from a map

     * then : the object stored in the cache should be the same

     */

    @Test

    public void subGraphMapLoadTest() {

    	Language english = Language.getLanguageFromUuid(Language.uuidEnglish);

        Language hindi = Language.getLanguageFromUuid(UUID.fromString("0a1d9d1d-135d-4575-b172-669b51673c39"));

    	// this call will load into the session cache the graph and update the objects in the sub-graph for a

    	// polytomous key  

    	// 	|- root : polytomous key node 

    	//		|- question : KeyStatement

    	//		|- statement : KeyStatement    	

    	PolytomousKey pkey = CdmBase.deproxy(polytomousKeyService.load(polytomousKeyUuid, PKEY_DEPTH3_INIT_STRATEGY),PolytomousKey.class);

    	pkey = cdmEntitySessionManager.load(sessionOwner, pkey);

    	Map<Language, LanguageString> labelMap = pkey.getRoot().getStatement().getLabel();

    	Set<Language> languages = labelMap.keySet();

    	Iterator<Language> languagesItr = languages.iterator();

    	while(languagesItr.hasNext()) {

    		Language lang = languagesItr.next();

    		if(lang.equals(english)) {

    			Assert.assertSame(lang, english);    			

    		}

    		if(lang.equals(hindi)) {

    			Assert.assertSame(lang, hindi);

    		}

    		Assert.assertSame(lang, cacher.getFromCache(lang));

    	}    	

    }

    /**

     * when : loading a non-lazy map in a subgraph and loading the map directly

     * then : the object stored in the cache should be the same as the object in the sub-graph map and 

     *        the object in the directly loaded map

     */

    @Test

    public void nonLazyMapLoadTest() {

    	// need to find an example of this

    }

}

package eu.etaxonomy.cdm.api.cache;

import java.io.IOException;

import java.util.List;

import net.sf.ehcache.Cache;

import org.apache.log4j.Level;

import org.apache.log4j.Logger;

import org.junit.Assert;

import org.junit.Test;

import org.springframework.core.io.ClassPathResource;

import org.springframework.core.io.Resource;

import eu.etaxonomy.cdm.api.cache.CdmRemoteCacheManager.CdmCacheManagerType;

public class CdmModelGetMethodCacherTest {

	private static final Logger logger = Logger.getLogger(CdmModelGetMethodCacherTest.class);

    public static final Resource CDMLIB_DISK_STORE_RESOURCE =

            new ClassPathResource("/eu/etaxonomy/cache");

	@Test

	public void cacheGettersTest() {

		Logger.getRootLogger().setLevel(Level.INFO);

		try {

			System.setProperty("ehcache.disk.store.dir", CDMLIB_DISK_STORE_RESOURCE.getFile().getAbsolutePath());

		} catch (IOException e) {

			throw new CdmClientCacheException(e);

		}		

		CdmModelCacher cmdmc = new CdmModelCacher();

		//cmdmc.checkGetterMethods();

		cmdmc.cacheGetterFields();

		Cache cdmlibCache = CdmRemoteCacheManager.getInstance().getCdmModelGetMethodsCache();

		List<CdmModelFieldPropertyFromClass> cmgmfcList = cmdmc.getCdmModelGetMethodFromClassList();

		List<Object> keys = cdmlibCache.getKeys();

		Assert.assertEquals(cmgmfcList.size(), keys.size());

		for(CdmModelFieldPropertyFromClass cmgmfc: cmgmfcList) {

			String className = cmgmfc.getClassName();

			Assert.assertTrue(keys.contains(className));

			logger.info("Class Name : " + className + " has been cached");

		}

		cdmlibCache.removeAll();

		cdmlibCache.flush();

		CdmRemoteCacheManager.getInstance().shutdown(CdmCacheManagerType.CDMLIB_MODEL);

	}

}

// $Id$

/**

* Copyright (C) 2014 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.cdm.polytomouskey;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.UUID;

import org.apache.log4j.Level;

import org.apache.log4j.Logger;

import org.hibernate.collection.spi.PersistentCollection;

import org.junit.Assert;

import org.junit.Before;

import org.junit.BeforeClass;

import org.junit.Test;

import org.unitils.dbunit.annotation.DataSet;

import eu.etaxonomy.cdm.api.cache.CdmTransientEntityCacher;

import eu.etaxonomy.cdm.api.service.ICommonService;

import eu.etaxonomy.cdm.api.service.IPolytomousKeyService;

import eu.etaxonomy.cdm.api.service.ITaxonService;

import eu.etaxonomy.cdm.model.agent.AgentBase;

import eu.etaxonomy.cdm.model.common.CdmBase;

import eu.etaxonomy.cdm.model.common.Credit;

import eu.etaxonomy.cdm.model.common.Extension;

import eu.etaxonomy.cdm.model.common.IdentifiableSource;

import eu.etaxonomy.cdm.model.common.Language;

import eu.etaxonomy.cdm.model.common.LanguageString;

import eu.etaxonomy.cdm.model.description.KeyStatement;

import eu.etaxonomy.cdm.model.description.PolytomousKey;

import eu.etaxonomy.cdm.model.description.PolytomousKeyNode;

import eu.etaxonomy.cdm.model.media.Rights;

import eu.etaxonomy.cdm.model.taxon.Taxon;

import eu.etaxonomy.taxeditor.httpinvoker.BaseRemotingTest;

import eu.etaxonomy.taxeditor.httpinvoker.CDMServer;

import eu.etaxonomy.taxeditor.session.ISessionEventListener;

import eu.etaxonomy.taxeditor.session.MockSessionOwner;

/**

 * @author cmathew

 * @date 7 Oct 2014

 *

 */

@DataSet

public class PolytomousKeyTest extends BaseRemotingTest {

    private static final Logger logger = Logger.getLogger(PolytomousKeyTest.class);

    UUID polytomousKeyUuid = UUID.fromString("0d53ba20-7de4-4baa-bd8a-401048447d66");

    UUID taxon1Uuid = UUID.fromString("2b336df7-29e8-4f79-985f-66502739d22f");

    IPolytomousKeyService polytomousKeyService = getRemoteApplicationController().getPolytomousKeyService();

    ICommonService commonService = getRemoteApplicationController().getCommonService();

    ITaxonService taxonService = getRemoteApplicationController().getTaxonService();

	private CdmTransientEntityCacher cacher;

    private ISessionEventListener sessionOwner;

    Language english = Language.getLanguageFromUuid(Language.uuidEnglish);

    @BeforeClass

    public static void initializePolytomousKeyTest() {

        logger.setLevel(Level.INFO);

        CDMServer.getInstance().setKeepServerRunning(true);       

    }

    @Before

    public void initializeSession() {

    	sessionOwner = new MockSessionOwner();    

    	cdmEntitySessionManager.bind(sessionOwner);

    	cacher = getCacher(sessionOwner);

    }

    @Test

    public void readAllPolytomousKeys() {

        List<PolytomousKey> pKeys = polytomousKeyService.list(PolytomousKey.class, null, null, null, null);

        Iterator<PolytomousKey> pKeysItr = pKeys.iterator();

        Assert.assertEquals(pKeysItr.next().getUuid(),UUID.fromString("9d8bf4f6-a70a-4b80-8556-2ccfb436ff01"));

        Assert.assertEquals(pKeysItr.next().getUuid(),UUID.fromString("0d53ba20-7de4-4baa-bd8a-401048447d66"));        

    }

    @Test

    //@DataSet("PolytomousKeyTest.readPolytmousKeyData.xml")

    public void readPolytmousKeyData() {

        PolytomousKey pKey = CdmBase.deproxy(polytomousKeyService.find(polytomousKeyUuid),PolytomousKey.class);

        Set<Taxon> taxonomicScope = pKey.getTaxonomicScope();

        Iterator<Taxon> tsItr = taxonomicScope.iterator();

        Taxon taxon = tsItr.next();

        Assert.assertEquals("Achillea sec. Cyprus", taxon.getTitleCache());

        Assert.assertEquals(tsItr.hasNext(), false);

        List<Credit> credits = pKey.getCredits();

        AgentBase agent = credits.get(0).getAgent();

        Assert.assertEquals(agent.getId(),4809);

        Assert.assertEquals(agent.getTitleCache(),"R. A. Graham");

        Assert.assertEquals(credits.get(0).getText(),"Credits Text Test");

        Set<Extension> exts = pKey.getExtensions();

        Iterator<Extension> extItr = exts.iterator();

        Extension ext = extItr.next();

        Assert.assertEquals(ext.getValue(), "http://test.com");

        Set<Rights> rights = pKey.getRights();

        Iterator<Rights> rightsItr = rights.iterator();

        Rights right = rightsItr.next();

        Assert.assertEquals(right.getText(),"Rights Text Test");

        Set<IdentifiableSource> sources = pKey.getSources();

        Iterator<IdentifiableSource> sourcesItr = sources.iterator();

        IdentifiableSource source = sourcesItr.next();

        Assert.assertEquals(source.getId(), 23710);

        source = sourcesItr.next();

        Assert.assertEquals(source.getId(), 23711);

        // TO DO : Added tests for Annotations , Markers

    }

    @Test

    public void readPolytomousKeyDataFromNodes() {

        PolytomousKey pKey = CdmBase.deproxy(polytomousKeyService.find(polytomousKeyUuid),PolytomousKey.class);

        PolytomousKeyNode rootNode = pKey.getRoot();

        Assert.assertEquals(rootNode.getId(), 2750);

        Assert.assertEquals(rootNode.getChildAt(0).getId(), 2751);

        Assert.assertEquals(rootNode.getChildAt(0).getParent().getId(), rootNode.getId());

        Assert.assertEquals(rootNode.getKey().getId(), pKey.getId());

        Integer sortIndex = (Integer)getFieldValueViaReflection(rootNode.getChildAt(0), "sortIndex");

        Assert.assertEquals(sortIndex, new Integer(0));

        String statement = "Capitula without ligulate ray-florets; leaves entire or subentire";

        Assert.assertEquals(rootNode.getChildAt(0).getStatement().getLabelText(english), statement);

        Assert.assertEquals(rootNode.getChildAt(1).getId(), 2753);

        Assert.assertEquals(rootNode.getChildAt(1).getParent().getId(), rootNode.getId());

        Assert.assertEquals(rootNode.getChildAt(1).getKey().getId(), pKey.getId());

        sortIndex = (Integer)getFieldValueViaReflection(rootNode.getChildAt(1), "sortIndex");

        Assert.assertEquals(sortIndex, new Integer(1));

        statement = "Capitula with ligulate ray-florets; leaves pinnatisect";

        Assert.assertEquals(rootNode.getChildAt(1).getStatement().getLabelText(english), statement);

        Assert.assertEquals(rootNode.getChildAt(1).getChildAt(0).getId(), 2754);

        Assert.assertEquals(rootNode.getChildAt(1).getChildAt(0).getParent().getId(), rootNode.getChildAt(1).getId());

        Assert.assertEquals(rootNode.getChildAt(1).getChildAt(0).getKey().getId(), pKey.getId());

        sortIndex = (Integer)getFieldValueViaReflection(rootNode.getChildAt(1).getChildAt(0), "sortIndex");

        Assert.assertEquals(sortIndex, new Integer(0));

        statement = "Ray-florets yellow";

        Assert.assertEquals(rootNode.getChildAt(1).getChildAt(0).getStatement().getLabelText(english), statement);

        Assert.assertEquals(rootNode.getChildAt(1).getChildAt(0).getChildAt(0).getTaxon().getTitleCache(), "Achillea arabica Kotschy sec. Cyprus");

    }

    @Test

    public void savePolytomousKeyNodeData() {

        PolytomousKey pkey = CdmBase.deproxy(polytomousKeyService.find(polytomousKeyUuid),PolytomousKey.class);

        pkey = cdmEntitySessionManager.load(sessionOwner, pkey);

        PolytomousKeyNode pkeynode = pkey.getRoot();

        String newQuestion = "New Question";

        String newStatement = "New Statement";

        Assert.assertEquals("Question 1",pkeynode.getQuestion().getLabel().get(english).getText());

        for(PolytomousKeyNode node : pkeynode.getChildren()) {

            node.setQuestion(null);

            node.setStatement(null);

        }

        //FIXME:Remoting Add tests for feature after fixing problem

        //Feature feature = pkeynode.getFeature();

        //Assert.assertEquals(feature.getTitleCache(),"Systematics");

        //pkeynode.setFeature(null);

        Assert.assertEquals(pkeynode.getChildAt(0).getModifyingText().get(english).getText(),"Modifying Text 1a");

        String modifyingText = "Modifying Text 1a updated";

        //pkeynode.getChildAt(0).putModifyingText(english, modifyingText);

        Assert.assertEquals(pkeynode.getChildAt(0).getSubkey().getId(),1550);

        Assert.assertEquals("Achillea", pkeynode.getChildAt(0).getSubkey().getTitleCache());

        Assert.assertNull(pkeynode.getChildAt(1).getTaxon());

        Taxon taxon = CdmBase.deproxy(taxonService.find(taxon1Uuid),Taxon.class);

        pkeynode.getChildAt(1).setTaxon(taxon);

        polytomousKeyService.merge(pkey);

        pkey = CdmBase.deproxy(polytomousKeyService.find(polytomousKeyUuid),PolytomousKey.class);

        sessionOwner = new MockSessionOwner();

        pkey = cdmEntitySessionManager.load(sessionOwner, pkey);

        pkeynode = pkey.getRoot();

        for(PolytomousKeyNode node : pkeynode.getChildren()) {

            Assert.assertNull(node.getQuestion());

            node.setQuestion(KeyStatement.NewInstance(english,newQuestion));

            Assert.assertNull(node.getStatement());

            node.setStatement(KeyStatement.NewInstance(english,newStatement));

        }

        Assert.assertEquals(pkeynode.getChildAt(1).getTaxon(), taxon);

        polytomousKeyService.merge(pkey);

        pkey = CdmBase.deproxy(polytomousKeyService.find(polytomousKeyUuid),PolytomousKey.class);

        sessionOwner = new MockSessionOwner();

        pkey = cdmEntitySessionManager.load(sessionOwner, pkey);

        pkeynode = pkey.getRoot();

        for(PolytomousKeyNode node : pkeynode.getChildren()) {

            Assert.assertNotNull(node.getQuestion());

            Map<Language, LanguageString> label = node.getQuestion().getLabel();

            Assert.assertEquals(newQuestion, label.get(english).getText());

            Assert.assertNotNull(node.getStatement());

            Assert.assertEquals(newStatement, node.getStatement().getLabel(english).getText());

        }

        //Assert.assertEquals(pkeynode.getFeature().getId(), feature.getId());

    }

    @Test

    public void savePolytomousKeyNodeDataWithSameSubKey() {

    	ISessionEventListener sessionOwner = new MockSessionOwner();

    	cdmEntitySessionManager.bind(sessionOwner);

        PolytomousKey pkey = CdmBase.deproxy(polytomousKeyService.find(polytomousKeyUuid),PolytomousKey.class);

        pkey = cdmEntitySessionManager.load(sessionOwner, pkey);

        PolytomousKeyNode pkeynode = pkey.getRoot();

        PolytomousKey subkey1 = CdmBase.deproxy(pkeynode.getChildAt(0).getSubkey(), PolytomousKey.class);

        String subkey1title = subkey1.getTitleCache();

        subkey1.setTitleCache(subkey1title + "test", true);

        PolytomousKey subkey2 = CdmBase.deproxy(pkeynode.getChildAt(1).getChildAt(0).getSubkey(), PolytomousKey.class);

        String subkey2title = subkey2.getTitleCache();

        subkey2.setTitleCache(subkey2title + "test", true);

        Assert.assertSame(subkey1, subkey2);

        polytomousKeyService.merge(pkey);

    }

    @Test

    public void savePolytomousKeyNodeDataWithSameSubKeyUsingService() {

        PolytomousKey pkey = CdmBase.deproxy(polytomousKeyService.find(polytomousKeyUuid),PolytomousKey.class);

        pkey = cdmEntitySessionManager.load(sessionOwner, pkey);

        PolytomousKeyNode pkeynode = pkey.getRoot();

        PersistentCollection children = (PersistentCollection) pkeynode.getChildren();

        PolytomousKeyNode childNode0 = (PolytomousKeyNode)commonService.get(children, 0);

        PolytomousKey subkey1 = CdmBase.deproxy(childNode0.getSubkey(),PolytomousKey.class);

        String subkey1title = subkey1.getTitleCache();

        subkey1.setTitleCache(subkey1title + "test", true);

        PolytomousKeyNode childNode1 = (PolytomousKeyNode)commonService.get(children, 1);

        PolytomousKey subkey2 = CdmBase.deproxy(childNode1.getSubkey(),PolytomousKey.class);

        String subkey2title = subkey2.getTitleCache();

        subkey2.setTitleCache(subkey2title + "test", true);

        Assert.assertNotSame(childNode0, childNode1);

        Assert.assertSame(subkey1, subkey2);

        polytomousKeyService.merge(pkey);

    }

    @Test

    public void savePolytomousKeyNodeDataWithSameLanguageInLabel() {

        PolytomousKey pkey = CdmBase.deproxy(polytomousKeyService.find(polytomousKeyUuid),PolytomousKey.class);

        PolytomousKeyNode pkeynode = pkey.getRoot();

        Map<Language, LanguageString> label1 = pkeynode.getQuestion().getLabel();

        label1.size();

        Map<Language, LanguageString> label2 = pkeynode.getChildAt(0).getStatement().getLabel();

        label2.size();

        polytomousKeyService.merge(pkey);

    }

}

// $Id$

/**

* Copyright (C) 2014 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.taxeditor.exception;

/**

 * @author cmathew

 * @date 23 Sep 2014

 *

 */

public class CDMServerException extends Exception {

    public CDMServerException(String message) {

        super(message);

    }

    public CDMServerException(Exception e) {

        super(e);

    }

    public CDMServerException(String message,Exception e) {

        super(message,e);

    }

}

/**

 * Copyright (C) 2014 EDIT

 * European Distributed Institute of Taxonomy

 * http://www.e-taxonomy.eu

 *

 * The contents of this file are subject to the Mozilla Public License Version 1.1

 * See LICENSE.TXT at the top of this package for the full license terms.

 */

package eu.etaxonomy.taxeditor.httpinvoker;

import java.io.IOException;

import java.lang.reflect.Field;

import org.junit.AfterClass;

import org.junit.Assert;

import org.junit.BeforeClass;

import org.junit.Test;

import org.springframework.core.io.ClassPathResource;

import org.springframework.core.io.Resource;

import org.unitils.UnitilsJUnit4;

import org.unitils.database.DatabaseUnitils;

import org.unitils.database.annotations.Transactional;

import org.unitils.database.util.TransactionMode;

import org.unitils.spring.annotation.SpringApplicationContext;

import eu.etaxonomy.cdm.api.application.CdmApplicationRemoteController;

import eu.etaxonomy.cdm.api.cache.CdmClientCacheException;

import eu.etaxonomy.cdm.api.cache.CdmTransientEntityCacher;

import eu.etaxonomy.cdm.model.name.NomenclaturalCode;

import eu.etaxonomy.taxeditor.remoting.source.CdmPersistentRemoteSource;

import eu.etaxonomy.taxeditor.remoting.source.CdmRemoteSource;

import eu.etaxonomy.taxeditor.remoting.source.CdmRemoteSourceException;

import eu.etaxonomy.taxeditor.remoting.source.ICdmRemoteSource;

import eu.etaxonomy.taxeditor.session.ICdmEntitySessionManager;

import eu.etaxonomy.taxeditor.session.ISessionEventListener;

/**

 * Base class for remoting tests, responsible for

 * - starting / stop the cdm server

 * - running some basic connection tests

 * - setting up the remote configuration.

 *

 */

@Transactional(TransactionMode.DISABLED)

@SpringApplicationContext("file:./target/test-classes/eu/etaxonomy/cdm/testRemotingApplicationContext.xml")

public class BaseRemotingTest extends UnitilsJUnit4 {

    //private static final Logger logger = Logger.getLogger(BaseRemotingTest.class);

    private static final Resource TEST_REMOTE_APPLICATION_CONTEXT_RESOURCE =

            new ClassPathResource("/eu/etaxonomy/cdm/testRemotingApplicationContext.xml");

    private static CdmApplicationRemoteController remoteApplicationController;

    private static ICdmRemoteSource cdmRemoteSource;

    private static CdmPersistentRemoteSource remotePersistentSource;

    public static boolean useManagedServer = true;

    public static final Resource CDMLIB_DISK_STORE_RESOURCE =

            new ClassPathResource("/eu/etaxonomy/cache");

    protected static ICdmEntitySessionManager cdmEntitySessionManager;

    @BeforeClass

    public static void initializeBaseRemotingTest() {

        //NOTE: Run this the cdmTest H2 DB whenever it needs to be

    	//      recreated e.g. after a model change

    	//DatabaseUnitils.disableConstraints();

		try {

			System.setProperty("ehcache.disk.store.dir", CDMLIB_DISK_STORE_RESOURCE.getFile().getAbsolutePath());

		} catch (IOException e) {

			throw new CdmClientCacheException(e);

		}

        useManagedServer = (System.getProperty("use.managed.server") == null) ? useManagedServer : Boolean.valueOf(System.getProperty("use.managed.server"));

        if(useManagedServer) {

            try {

                CDMServer.getInstance().start();

            } catch (Exception e) {

                e.printStackTrace();

                Assert.fail("Server failed to start. Reason : " + e.getMessage());

            }

        initializeController(CDMServer.getInstance().getName(),

                CDMServer.getInstance().getHost(),

                CDMServer.getInstance().getPort(),

                CDMServer.getInstance().getContextPath(),

                NomenclaturalCode.ICNAFP);

        }

    }

    @Test

    public void disableConstraints() {

    	// To be run on the src/test/resources/h2/cdmTest h2 db after

    	// updating the unitils.properties 'database.url' property

    	DatabaseUnitils.disableConstraints();

    }

    public static void initializeController(String sourceName, String host, int port, String contextPath, NomenclaturalCode ncode) {

        cdmRemoteSource = CdmRemoteSource.NewInstance(sourceName, host, port, contextPath, ncode);

        remoteApplicationController =

                CdmApplicationRemoteController.NewInstance(cdmRemoteSource,

                        false,

                        null,

                        null);

        try {

            remotePersistentSource = CdmPersistentRemoteSource.NewInstance(sourceName);

        } catch (CdmRemoteSourceException e) {

            Assert.fail("Default Remote Persistent Source failed to load. Reason : " + e.getMessage());

        }

        cdmEntitySessionManager = getRemoteApplicationController().getCdmEntitySessionManager();

    }

    protected static CdmApplicationRemoteController getRemoteApplicationController() {

        return remoteApplicationController;

    }

    protected static ICdmRemoteSource getCdmRemoteSource() {

        return cdmRemoteSource;

    }

    protected static CdmPersistentRemoteSource getCdmPersistentRemoteSource() {

        return remotePersistentSource;

    }

    protected static ICdmEntitySessionManager getCdmEntitySessionManager() {

    	return cdmEntitySessionManager;

    }

    protected static CdmTransientEntityCacher getCacher(ISessionEventListener sessionOwner) {

    	return (CdmTransientEntityCacher) getFieldValueViaReflection(cdmEntitySessionManager.getSession(sessionOwner), "cdmTransientEntityCacher");

    }

    @AfterClass

    public static void cleanup() {

        try {

            CDMServer.getInstance().stop();

        } catch (Exception e) {

            Assert.fail("Server could not be stopped. Reason : " + e.getMessage());

        }

    }

    protected static Object getFieldValueViaReflection(Object object, String fieldName) {

        Class<?> clazz = object.getClass();

        try {

            Field field = clazz.getDeclaredField(fieldName);

            field.setAccessible(true);

            return field.get(object);

        } catch (NoSuchFieldException e) {

            e.printStackTrace();

        } catch (SecurityException e) {

            e.printStackTrace();

        } catch (IllegalArgumentException e) {

            e.printStackTrace();

        } catch (IllegalAccessException e) {

            e.printStackTrace();

        }

        return null;

    }

}

// $Id$

/**

 * Copyright (C) 2014 EDIT

 * European Distributed Institute of Taxonomy

 * http://www.e-taxonomy.eu

 *

 * The contents of this file are subject to the Mozilla Public License Version 1.1

 * See LICENSE.TXT at the top of this package for the full license terms.

 */

package eu.etaxonomy.taxeditor.httpinvoker;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.net.Socket;

import javax.sql.DataSource;

import org.apache.log4j.Level;

import org.apache.log4j.Logger;

import org.springframework.core.io.ClassPathResource;

import org.springframework.core.io.Resource;

import org.unitils.database.annotations.TestDataSource;

import org.unitils.spring.annotation.SpringApplicationContext;

import eu.etaxonomy.taxeditor.exception.CDMServerException;

import eu.etaxonomy.taxeditor.remoting.source.CdmRemoteSourceBase;

/**

 *

 * (Singleton) Server instance which manages a compatible cdmlib-webapp-war.

 * This is done by launching a jetty instance (using jetty-runner) as an

 * executed process. The choice of the external process over a more

 * preferable 'embedded jetty' instance is due to problems arising from the

 * class loading of classes (e.g. from hibernate core) which are needed

 * for both the webapp as well as the remoting client.

 *

 * @author cmathew

 * @date 23 Sep 2014

 *

 */

public class CDMServer {

    public static final Logger logger = Logger.getLogger(CDMServer.class);

    @TestDataSource

    protected DataSource dataSource;

    private final String name = "default";

    private final String host = "127.0.0.1";

    private final int port = 9090;

    private final int stopPort = 9191;

    private final String stopKey = "jetty-cdm-server";

    private final String contextPath = "";

    private boolean keepServerRunning = false;

    public static final Resource DEFAULT_CDM_WEBAPP_RESOURCE =

            new ClassPathResource("/etc/jetty/cdmlib-remote-webapp.war");

    public static final Resource DEFAULT_JETTY_CONFIG_RESOURCE =

            new ClassPathResource("/etc/jetty/jetty.xml");

    public static final Resource DEFAULT_JETTY_TEMP_RESOURCE =

            new ClassPathResource("/etc/jetty/temp");

    public static final Resource DEFAULT_JETTY_TEMP_WAR_LIB_RESOURCE =

            new ClassPathResource("/etc/jetty/temp/webapp/WEB-INF/lib");

    public static final Resource DEFAULT_DATASOURCE_FILE =

            new ClassPathResource("datasources.xml");

    public static final Resource DEFAULT_JETTY_RUNNER_RESOURCE =

            new ClassPathResource("/etc/jetty/jetty-runner-9.2.3.v20140905.jar");

    public static final Resource DEFAULT_JETTY_RESOURCE =

            new ClassPathResource("/etc/jetty/start-9.2.3.v20140905.jar");

    private static CDMServer cdmServer = null;

    private static CDMServerException cdmse = null;

    private void CDMServer() {

        logger.setLevel(Level.INFO);

    }

    public static CDMServer getInstance() {

        if(cdmServer == null) {

            cdmServer = new CDMServer();

        }

        return cdmServer;

    }

    public String getName() {

        return name;

    }

    public String getHost() {

        return host;

    }

    public int getPort() {

        return port;

    }

    public String getContextPath() {

        return contextPath;

    }

    public boolean getKeepServerRunning() {

        return keepServerRunning;

    }

    public void setKeepServerRunning(boolean keepServerRunning) {

        this.keepServerRunning = keepServerRunning;

    }

    public static boolean isRunningInEclipse() {

        return (System.getProperty("sun.java.command") != null &&

                System.getProperty("sun.java.command").startsWith("org.eclipse.jdt.internal.junit.runner.RemoteTestRunner"));

    }

    private String getVMArgs() throws IOException {

        StringBuilder sb = new StringBuilder();

        sb.append(" -Dspring.profiles.active=remoting");

        sb.append(" -Dcdm.beanDefinitionFile=" + DEFAULT_DATASOURCE_FILE.getFile().getAbsolutePath());

        sb.append(" -Dcdm.datasource=cdmTest");

        return sb.toString();

    }

    private String getStartServerArgs() {

        StringBuilder sb = new StringBuilder();

        sb.append(" --port ");

        sb.append(port);

        return sb.toString();

    }

    private String getStopServerSettings() {

        StringBuilder sb = new StringBuilder();

        sb.append(" --stop-port ");

        sb.append(stopPort);

        sb.append(" --stop-key ");

        sb.append(stopKey);

        return sb.toString();

    }

    private String getStopServerArgs() {

        StringBuilder sb = new StringBuilder();

        sb.append(" STOP.PORT=");

        sb.append(stopPort);

        sb.append(" STOP.KEY=");

        sb.append(stopKey);

        return sb.toString();

    }

    public void start() throws CDMServerException {

        /**

         * First check if the CDM server responds to a service request, which implies that

         * the server has started properly. If no response is received then check if the

         * server is listening on specific host / port, which implies that the server

         * has started but incorrectly, in which case we try to force stop it (if we can)

         * and start a new server.

         */

        if(isRunning(1)) {

            logger.info("[CDM-Server] Server already running @ " + host + ":" + port );

            return;

        } else if (isAvailable(1)){

            logger.info("[CDM-Server] Server available, but not started correctly @ " + host + ":" + port );

            logger.info("[CDM-Server] .... trying to force stop server @ " + host + ":" + port );

            try {

                stop(true);

            } catch (Exception e) {

                throw new CDMServerException("CDM Server could not be stopped : " + e.getMessage());

            }

        }

        Thread t = new Thread() {

            @Override

            public void run() {

                StringBuffer output = new StringBuffer();

                try{

                    Process p;

                    String command = "java "

                            + getVMArgs()

                            + " -jar "

                            + DEFAULT_JETTY_RUNNER_RESOURCE.getFile().getAbsolutePath()

                            + getStartServerArgs()

                            + getStopServerSettings()

                            + " "

                            + DEFAULT_CDM_WEBAPP_RESOURCE.getFile().getAbsolutePath();

                    logger.info("[CDM-Server] Starting server with Command : " + command);

                    p = Runtime.getRuntime().exec(command);

                    BufferedReader reader =

                            new BufferedReader(new InputStreamReader(p.getInputStream()));

                    String line = "";

                    while ((line = reader.readLine())!= null) {

                        logger.info("[CDM-Server] Start : " + line);

                    }

                } catch (Exception e) {

                    e.printStackTrace();

                    cdmse = new CDMServerException(e);

                }

            }

        };

        t.setDaemon(true);

        cdmse = null;

        t.start();

        if(isRunning(50)) {

            logger.info("[CDM-Server] Started Server @ " + host + ":" + port );

        } else {

            logger.info("[CDM-Server] Server not started within given interval");

            // making sure to kill server if it is not started correctly

            try {

                stop(true);

            } catch (Exception e) {

                throw new CDMServerException("CDM Server could not be stopped : " + e.getMessage());

            }

            throw new CDMServerException("CDM Server not started : ");

        }

    }

    public boolean isAvailable(int checkingIntervals) throws CDMServerException {

        int intervalsCount = 0;

        do {

            try {

                Socket s = new Socket(host, port);

                logger.info("[CDM-Server] Available @ " + host + ":" + port );

                return true;

            } catch (IOException ioe) {

            }

            try {

                Thread.sleep(1000);

            } catch (InterruptedException ie) {

                throw new CDMServerException("Error checking CDM Server status", ie);

            }

            intervalsCount++;

        } while (intervalsCount < checkingIntervals);

        return false;

    }

    public boolean isStopped(int checkingIntervals) throws CDMServerException {

        int intervalsCount = 0;

        do {

            try {

                Socket s = new Socket(host, port);

            } catch (IOException ioe) {               

                return true;

            }

            try {

                Thread.sleep(1000);

            } catch (InterruptedException ie) {

                throw new CDMServerException("Error checking CDM Server status", ie);

            }

            intervalsCount++;

        } while (intervalsCount < checkingIntervals);

        return false;

    }

    public boolean isRunning(int checkingIntervals) throws CDMServerException  {

        CdmRemoteSourceBase crsb = new CdmRemoteSourceBase("local-cdm-server",

                host,

                port,

                contextPath,

                null);

        int intervalsCount = 0;

        do {

            try {

                if(cdmse != null) {

                    return false;

                }

                if(crsb.checkConnection()) {

                    logger.info("[CDM-Server] Running @ " + host + ":" + port );

                    return true;

                }

            } catch (Exception e) {

            }

            try {

                Thread.sleep(1000);

            } catch (InterruptedException ie) {

                throw new CDMServerException("Error checking CDM Server status", ie);

            }

            intervalsCount++;

        } while (intervalsCount < checkingIntervals);

        return false;

    }

    public void stop() throws Exception {

        stop(false);

    }

    public void stop(boolean force) throws Exception {

        if(!force) {

            if(!getInstance().isAvailable(1)) {

                logger.info("[CDM-Server] Server already stopped @ " + host + ":" + port );

                return;

            }

            if(getInstance().getKeepServerRunning()) {

                logger.info("[CDM-Server] Server @ " + host + ":" + port + " is set to keep running");

                return;

            }

        }

        Thread t = new Thread() {

            @Override

            public void run() {

                StringBuffer output = new StringBuffer();

                try{

                    Process p;

                    String command = "java -jar " + DEFAULT_JETTY_RESOURCE.getFile().getAbsolutePath()

                            + getStopServerArgs() + " --stop ";

                    logger.info("[CDM-Server] Stop Command : " + command);

                    p = Runtime.getRuntime().exec(command);

                    p.waitFor();

                    BufferedReader reader =

                            new BufferedReader(new InputStreamReader(p.getInputStream()));

                    String line = "";

                    while ((line = reader.readLine())!= null) {

                        logger.info("CDM-Server Stop : " + line + "\n");

                    }

                } catch (Exception e) {

                    e.printStackTrace();

                }

            }

        };

        t.setDaemon(true);

        t.start();

        if(isStopped(5)) {

            logger.info("[CDM-Server] Stopped Server @ " + host + ":" + port );

        } else {

            logger.info("[CDM-Server] Could not stop @ " + host + ":" + port + ". Please kill it manually");

        }

    }

}

/**

 * Copyright (C) 2014 EDIT

 * European Distributed Institute of Taxonomy

 * http://www.e-taxonomy.eu

 *

 * The contents of this file are subject to the Mozilla Public License Version 1.1

 * See LICENSE.TXT at the top of this package for the full license terms.

 */

package eu.etaxonomy.taxeditor.httpinvoker;

import static org.hamcrest.CoreMatchers.containsString;

import java.util.Map;

import org.apache.log4j.Level;

import org.apache.log4j.Logger;

import org.junit.Assert;

import org.junit.BeforeClass;

import org.junit.Test;

import eu.etaxonomy.cdm.config.CdmPersistentSourceUtils;

import eu.etaxonomy.cdm.config.CdmPersistentXMLSource.CdmSourceProperties;

import eu.etaxonomy.cdm.config.CdmSourceException;

import eu.etaxonomy.cdm.model.metadata.CdmMetaData.MetaDataPropertyName;

import eu.etaxonomy.cdm.model.name.NomenclaturalCode;

import eu.etaxonomy.taxeditor.remoting.source.CdmPersistentRemoteSource;

import eu.etaxonomy.taxeditor.remoting.source.CdmRemoteSource;

import eu.etaxonomy.taxeditor.remoting.source.CdmRemoteSourceException;

import eu.etaxonomy.taxeditor.remoting.source.ICdmRemoteSource;

/**

 * Class to test the cdm persistent source functionality, including

 * initialising / saving / updating and deleting

 *

 * Corresponding test sources settings can be found at

 * /src/text/resources/eu.etaxonomy.cdm/cdm.datasources.xml

 *

 */

public class CdmPersistentRemoteSourceTest extends BaseRemotingTest {

    private static final Logger logger = Logger.getLogger(CdmPersistentRemoteSourceTest.class);

    private CdmPersistentRemoteSource remotePersistentSource;

    @BeforeClass

    public static void initialize() {

        Logger.getRootLogger().setLevel(Level.INFO);

    }

    @Test

    public void whenLoadingExistingCompleteRemoteSourceThenLoadIsSuccessful() {

        remotePersistentSource = getCdmPersistentRemoteSource();

        String expectedServer = "127.0.0.1";

        String expectedPort = "9090";

        String expectedContextPath = "";

        logger.info("Default remote source server : " + remotePersistentSource.getServer());

        Assert.assertTrue("Default server should be " + expectedServer,

                expectedServer.equals(remotePersistentSource.getServer()));

        logger.info("Default remote source port : " + remotePersistentSource.getPort());

        Assert.assertTrue("Default port should be 9090",

                expectedPort.equals(String.valueOf(remotePersistentSource.getPort())));

        logger.info("Default remote source context path : " + remotePersistentSource.getContextPath());

        Assert.assertTrue("Default remote source context path should be " + expectedContextPath,

                expectedContextPath.equals(remotePersistentSource.getContextPath()));

        logger.info("Default remote source nomenclatural code : " + remotePersistentSource.getNomenclaturalCode().toString());

        Assert.assertTrue("Default NomenclaturalCode should be ICNAFP",

                NomenclaturalCode.ICNAFP.equals(remotePersistentSource.getNomenclaturalCode()));

    }

    @Test

    public void whenConnectingToAnActiveServerThenConnectSuccessfully() {

        // check if active server throws the right exception