EDIT

/**

* 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.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;

import org.junit.Assert;

import org.junit.Test;

import org.unitils.dbunit.annotation.DataSet;

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

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

import eu.etaxonomy.cdm.cache.CdmTransientEntityCacher;

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.RemotingSessionAwareTest;

/**

 * @author cmathew

 * @date 7 Oct 2014

 */

@DataSet

public class CdmClientCachingTest extends RemotingSessionAwareTest {

    @SuppressWarnings("unused")

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

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

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

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

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

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

    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"});

    @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));

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

        Assert.assertSame(CdmBase.deproxy(pkey1.getRoot(),PolytomousKeyNode.class), 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));

        CdmTransientEntityCacher cacher = getCacher(sessionOwner);

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

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

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

        Assert.assertSame(CdmBase.deproxy(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));

        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));

        KeyStatement ks1 = CdmBase.deproxy(pkey1.getRoot().getStatement());

        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_DEPTH3_INIT_STRATEGY));

        KeyStatement ks2 = CdmBase.deproxy(pkey2.getRoot().getStatement());

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

        Assert.assertSame(cacher.getFromCache(ks1), cacher.getFromCache(ks2));

    }

    /**

     * 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));

        KeyStatement ks1 = pkey1.getRoot().getStatement();

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

        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));

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

        pkey2.getRoot().getStatement().getCreatedBy();

        Assert.assertSame(cacher.getFromCache(ks1), 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));

        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(CdmBase.deproxy(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));

        KeyStatement ks2 =  CdmBase.deproxy(pkey2.getRoot().getStatement());

        Assert.assertSame(ks2, 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));

        // lazy initialising root.statement

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

        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()),

    			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

    	//		|- question : KeyStatement

    	//		|- statement : KeyStatement

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

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

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

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

    }

    /**

     * 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));

    	Assert.assertNotNull(rootPKNode);

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

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

    	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));

    	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));

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

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

    	Assert.assertNotNull(rootPKNode);

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

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

    	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));

    	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));

    	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

    }

}