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.taxeditor.lazyloading;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Set;

import java.util.UUID;

import org.apache.log4j.Logger;

import org.junit.Assert;

import org.junit.BeforeClass;

import org.junit.Ignore;

import org.junit.Test;

import org.unitils.dbunit.annotation.DataSet;

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

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

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

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

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

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

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

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

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

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

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

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

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

import eu.etaxonomy.taxeditor.httpinvoker.BaseRemotingTest;

/**

 * Class to test the {@link CdmApplicationRemoteController}

 *

 */

// FIXME:Remoting need to create a proper dataset for this test

//       Could be combined with RemotePersistentCollectionTest

@Ignore

@DataSet

public class AbstractLazyInitializerTest extends BaseRemotingTest {

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

    private static IClassificationService classificationService;

    private static ITaxonService taxonService;

    private static List<TaxonNode> taxonNodes;

    private final UUID taxonUuid1 = UUID.fromString("8217ef77-2ab1-4318-bd67-ccd0cdef07c4");

    private final UUID taxonUuid2 = UUID.fromString("ef96fafa-7750-4141-b31b-1ad1daab3e76");

    @BeforeClass

    public static void initializeRemoteLazyLoading() {

        taxonService = getRemoteApplicationController().getTaxonService();

        classificationService= getRemoteApplicationController().getClassificationService();

        List<Classification> classifications = classificationService.listClassifications(1,0,null,null);

        Assert.assertFalse(classifications.isEmpty());

        Classification classification = classifications.get(0);

        Assert.assertNotNull(classification);

        taxonNodes = classificationService.getAllNodes();

        Assert.assertFalse(taxonNodes.isEmpty());

    }

    @Test

    public void testCDMEntityGet() {

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

        Iterator<TaxonNode> taxonNodeItr = taxonNodes.iterator();

        int maxcount = 30;

        int count = 0;

        while(taxonNodeItr.hasNext() && count <= maxcount) {

            TaxonNode taxonNode = taxonNodeItr.next();

            Assert.assertNotNull(taxonNode);

            Taxon taxon = taxonNode.getTaxon();

            Assert.assertNotNull(taxon);

            String taxonTitle = taxon.getTitleCache();

            logger.info("Taxon : " + taxonTitle);

            TaxonNameBase name = taxon.getName();

            Assert.assertNotNull(name);

            String nameTitle = name.getTitleCache();

            logger.info("Taxon Name : " + nameTitle);

            count++;

        }

    }

    @Test

    public void taxonReadTest() {

        Taxon taxon = (Taxon)taxonService.find(taxonUuid1);

    }

    @Test

    public void testCDMEntitySave() {

        Taxon taxon = (Taxon)taxonService.find(taxonUuid1);

        String oldTitleCache = taxon.getTitleCache();

        System.out.println("Taxon title : " + oldTitleCache);

        taxon.setTitleCache(oldTitleCache + ":updated", true);

        taxonService.merge(taxon);

        Taxon taxonNew = (Taxon)taxonService.find(taxonUuid1);

        System.out.println("New Taxon Title : " + taxonNew.getTitleCache());

        Assert.assertTrue("Title caches should not be equal",oldTitleCache.equals(taxonNew.getTitleCache()));

        taxonNew.setTitleCache(oldTitleCache, true);

        taxonService.merge(taxonNew);

        Taxon taxonOld = (Taxon)taxonService.find(taxonUuid1);

        System.out.println("Old Taxon Title : " + taxonOld.getTitleCache());

        Assert.assertEquals("Title caches should be equal",oldTitleCache,taxonOld.getTitleCache());

    }

        @Test

        public void testCDMEntitySaveLazyNew() {

            Team combAuthor = Team.NewInstance();

            combAuthor.addTeamMember(Person.NewTitledInstance("test member"));

            BotanicalName name = BotanicalName.NewInstance(null, "Test1", null, null, null, null, null, null, null);

            name.setCombinationAuthorship(combAuthor);

            Taxon tax1 = Taxon.NewInstance(name, null);

            UUID taxonUuid1 = taxonService.save(tax1).getUuid();

            Taxon taxon = (Taxon)taxonService.find(taxonUuid1);

            NonViralName nvn = CdmBase.deproxy(taxon.getName(),NonViralName.class);

            String oldTitleCache = nvn.getTitleCache();

            logger.info("Taxon Name Title : " + oldTitleCache);

            nvn.setTitleCache(oldTitleCache + ":updated",false);

            taxonService.update(taxon);

            Taxon taxonNew = (Taxon)taxonService.find(taxonUuid1);

            NonViralName nvnNew = CdmBase.deproxy(taxon.getName(),NonViralName.class);

            logger.info("New Taxon Name Title : " + nvnNew.getTitleCache());

            Assert.assertTrue("Title caches should not be equal",oldTitleCache.equals(nvnNew.getTitleCache()));

            nvnNew.setTitleCache(oldTitleCache, true);

            taxonService.update(taxon);

            Taxon taxonOld = (Taxon)taxonService.find(taxonUuid1);

            NonViralName nvnOld = CdmBase.deproxy(taxon.getName(),NonViralName.class);

            logger.info("Old Taxon Name Title : " + nvnNew.getTitleCache());

            Assert.assertEquals("Title caches should be equal",oldTitleCache,nvnOld.getTitleCache());

        }

        @Ignore

        @Test

        public void testCdmEntitySaveCollection() {

            Taxon taxon = (Taxon)taxonService.find(taxonUuid1);

            Set<TaxonRelationship> taxRelations = taxon.getTaxonRelations();

            Set<String> relToTitles = new HashSet<String>();

            Iterator<TaxonRelationship> trItr = taxRelations.iterator();

            while(trItr.hasNext()) {

                TaxonRelationship tr = trItr.next();

                System.out.println("Synonym Title Cache : " + tr.getFromTaxon().getTitleCache());

                relToTitles.add(tr.getFromTaxon().getTitleCache());

                tr.getFromTaxon().setTitleCache(tr.getFromTaxon().getTitleCache() + ":updated");

            }

            taxonService.merge(taxon);

            Taxon taxonNew = (Taxon)taxonService.find(taxonUuid1);

            Set<TaxonRelationship> taxRelationsNew = taxonNew.getTaxonRelations();

            Iterator<TaxonRelationship> trItrNew = taxRelationsNew.iterator();

            Iterator<String> relToTitlesItr = relToTitles.iterator();

            while(trItrNew.hasNext() && relToTitlesItr.hasNext()) {

                TaxonRelationship trNew = trItrNew.next();

                String relToTitle = relToTitlesItr.next();

                System.out.println("New Synonym Title Cache: " + trNew.getFromTaxon().getTitleCache());

                Assert.assertTrue("Synonym Title caches should not be equal", trNew.getFromTaxon().getTitleCache().equals(relToTitle));

                trNew.getFromTaxon().setTitleCache(relToTitle);

            }

            Taxon taxonOld = (Taxon)taxonService.find(taxonUuid1);

            Set<TaxonRelationship> taxRelationsOld = taxonNew.getTaxonRelations();

            Iterator<TaxonRelationship> trItrOld = taxRelationsOld.iterator();

            relToTitlesItr = relToTitles.iterator();

            while(trItrOld.hasNext() && relToTitlesItr.hasNext()) {

                TaxonRelationship trOld = trItrOld.next();

                String relToTitle = relToTitlesItr.next();

                System.out.println("New Synonym Title Cache: " + trOld.getFromTaxon().getTitleCache());

                Assert.assertEquals("Synonym Title caches should be equal", trOld.getFromTaxon().getTitleCache(), relToTitle);

            }

        }

}