EDIT

/**

* Copyright (C) 2009 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.service;

import java.io.FileNotFoundException;

import org.apache.log4j.Logger;

import org.junit.Assert;

import org.junit.Test;

import org.unitils.database.annotations.Transactional;

import org.unitils.database.util.TransactionMode;

import org.unitils.dbunit.annotation.DataSet;

import org.unitils.dbunit.annotation.ExpectedDataSet;

import org.unitils.spring.annotation.SpringBeanByType;

import eu.etaxonomy.cdm.api.service.dto.MarkedEntityDTO;

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

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

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

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

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

import eu.etaxonomy.cdm.model.term.TermVocabulary;

import eu.etaxonomy.cdm.model.term.VocabularyEnum;

/**

 * @author a.mueller

 *

 */

@Transactional(TransactionMode.DISABLED)

public class IdentifiableServiceBaseTest extends CdmTransactionalIntegrationTest {

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

	@SpringBeanByType

	private INameService nameService;

	@SpringBeanByType

	private ITermService termService;

	@SpringBeanByType

	private IVocabularyService vocService;

	@SpringBeanByType

	private ITaxonService taxonService;

    private IReferenceService referenceService;

	private IClassificationService classificationService;

/****************** TESTS *****************************/

	@Test

	public final void voidTestSeriveExists(){

		Assert.assertNotNull("Service shoulb be initialized", nameService);

	}

	@Test

	@DataSet

	@ExpectedDataSet

	public final void testUpdateTitleCache() {

	@Test

	public final void testFindByIdentifier(){

		UUID uuidIdentifierType2 = UUID.fromString("ef6e960f-5289-456c-b25c-cff7f4de2f63");

		DefinedTerm it1 = (DefinedTerm)termService.find(uuidIdentifierType1);

		Assert.assertNotNull("identifier type must not be null", it1);

		boolean includeEntity = true;

		Assert.assertEquals(UUID.fromString("888cded1-cadc-48de-8629-e32927919879"), taxon.getUuid());

		Assert.assertEquals(uuidIdentifierType1, type.getUuid());

				TaxonName.class, "ext-1234", null, null, includeEntity, null, null, null);

		taxonPager = taxonService.findByIdentifier(null, "ext-1234", null, null, includeEntity, null, null, null);

		Assert.assertEquals("Result size for 'ext-1234' should be 1", 1, taxonPager.getRecords().size());

		taxonPager = taxonService.findByIdentifier(Taxon.class, null, null, null, includeEntity, null, null, null);

		Assert.assertEquals("Result should not be empty", 2 , taxonPager.getRecords().size());

		//includeEntity

		includeEntity = false;

		taxonPager = taxonService.findByIdentifier(Taxon.class, "ext-1234", it1, null, includeEntity, null, null, null);

		entity = taxonPager.getRecords().get(0).getCdmEntity();

		Assert.assertNull("Taxon must not be returned with includeEntity = false", entity.getEntity());

		//Matchmode

		includeEntity = false;

		MatchMode matchmode = null;

		taxonPager = taxonService.findByIdentifier(Taxon.class, "123", null, matchmode, includeEntity, null, null, null);

		Assert.assertTrue("Result size for '123' should be 0", taxonPager.getCount() == 0);

		taxonPager = taxonService.findByIdentifier(Taxon.class, "123", null, MatchMode.EXACT, includeEntity, null, null, null);

		Assert.assertTrue("Result size for '123' should be 0", taxonPager.getCount() == 0);

		taxonPager = taxonService.findByIdentifier(Taxon.class, "123", null, MatchMode.ANYWHERE, includeEntity, null, null, null);

		Assert.assertTrue("Result size for '123' should be 1", taxonPager.getCount() == 1);

		taxonPager = taxonService.findByIdentifier(Taxon.class, "123", null, MatchMode.BEGINNING, includeEntity, null, null, null);

		Assert.assertTrue("Result size for '123' should be 0", taxonPager.getCount() == 0);

		taxonPager = taxonService.findByIdentifier(Taxon.class, "ext", null, MatchMode.BEGINNING, includeEntity, null, null, null);

		Assert.assertTrue("Result size for 'ext' should be 1", taxonPager.getCount() == 2);

		//Paging

		taxonPager = taxonService.findByIdentifier(null, "ext", null, MatchMode.BEGINNING, includeEntity, null, null, null);

		Assert.assertEquals("Total result size for starts with 'ext' should be 4", 4, taxonPager.getRecords().size());

		taxonPager = taxonService.findByIdentifier(null, "ext", null, MatchMode.BEGINNING, includeEntity, 2, 1, null);

		Assert.assertEquals("Total result size for starts with 'ext' should be 4", Long.valueOf(4), taxonPager.getCount());

		Assert.assertEquals("Result size for starts with 'ext' second page should be 2", Integer.valueOf(2), taxonPager.getPageSize());

		Assert.assertEquals("The third taxon (first on second page) should be ext-syn1", "ext-syn1", taxonPager.getRecords().get(0).getIdentifier().getIdentifier());

		taxonPager = taxonService.findByIdentifier(Taxon.class, "ext", null, MatchMode.BEGINNING, includeEntity, null, null, null);

		Assert.assertTrue("Result size for 'ext' should be 2", taxonPager.getCount() == 2);

	}

	@Test

	public final void testFindByIdentifierClassification(){

		Classification classification = classificationService.find(5000);

		TaxonNode rootNode = classification.getRootNode();

		Assert.assertEquals("Result size for 'ext' should be 1", 1, taxonPager.getRecords().size());

		Assert.assertEquals("Result size for 'ext' should be 0", 0, taxPager.getRecords().size());

		rootNode = null;  //check against missing filter

		taxPager = taxonService.findByIdentifier(Taxon.class, "ext-cache1", null, rootNode, MatchMode.EXACT, false, null, null, null);

		Assert.assertEquals("Result size for 'ext-cache1' without filter should be 1", Long.valueOf(1), taxPager.getCount());

		Assert.assertEquals("Result size for 'ext-cache1' without filter should be 1", 1, taxPager.getRecords().size());

		//TaxonBase

		rootNode = classification.getRootNode();

		Assert.assertEquals("Result size for 'ext' should be 1", 1, tbPager.getRecords().size());

		tbPager = taxonService.findByIdentifier(TaxonBase.class, "ext-cache1", null, rootNode, MatchMode.EXACT, false, null, null, null);

		Assert.assertEquals("Result size for 'ext' should be 0", Long.valueOf(0), tbPager.getCount());

		Assert.assertEquals("Result size for 'ext' should be 0", 0, tbPager.getRecords().size());

		//Synonym

		Assert.assertEquals("1 Synonym should be linked to the according classification", 1, synPager.getRecords().size());

	}

        //classification Filter

        List<IdentifiedEntityDTO<Taxon>> taxonPager = taxonService.listByIdentifier(Taxon.class, "ext-1234", null, MatchMode.EXACT, false, null, null);//.listByIdentifier(Taxon.class, "ext-1234", null, rootNode, MatchMode.EXACT, false, null, null);

        Assert.assertEquals("Result size for 'ext' should be 1", 1, taxonPager.size());

     //   Assert.assertEquals("Result size for 'ext' should be 1", 1, taxonPager.getRecords().size());

        taxonPager = taxonService.listByIdentifier(Taxon.class, "ext-1234", null, MatchMode.EXACT, true, null, null);//.listByIdentifier(Taxon.class, "ext-1234", null, rootNode, MatchMode.EXACT, false, null, null);

        Assert.assertEquals("Result size for 'ext' should be 1", 1, taxonPager.size());

        IdentifiedEntityDTO<Taxon> identifierDTO = taxonPager.get(0);

        Assert.assertTrue(identifierDTO.getCdmEntity() instanceof UuidAndTitleCache);

        List<IdentifiedEntityDTO<Taxon>> taxPager = taxonService.listByIdentifier(Taxon.class, "ext-cache1", null, MatchMode.EXACT, false, null, null);

        Assert.assertEquals("Result size for 'ext' should be 1", 1, taxPager.size());

        List<IdentifiedEntityDTO<TaxonBase>> tbPager = taxonService.listByIdentifier(TaxonBase.class, "ext-1234", null, MatchMode.EXACT, false, null, null);

        Assert.assertEquals("Result size for 'ext' should be 1",1, tbPager.size());

        //Synonym

        List<IdentifiedEntityDTO<Synonym>> synPager = taxonService.listByIdentifier(Synonym.class, "ext-syn", null,  MatchMode.BEGINNING, false, null, null);

        Assert.assertEquals("There should be 2 synonyms with identifier ext-syn", 2, synPager.size());

        List<IdentifiedEntityDTO<Reference>> referenceList = referenceService.listByIdentifier(Reference.class, "123", null, MatchMode.EXACT, false, null, null);//.listByIdentifier(Taxon.class, "ext-1234", null, rootNode, MatchMode.EXACT, false, null, null);

        Assert.assertEquals("Result size for 'ext' should be 1", 1, taxonPager.size());

        referenceList = referenceService.listByIdentifier(Reference.class, "123", null, MatchMode.EXACT, true, null, null);//.listByIdentifier(Taxon.class, "ext-1234", null, rootNode, MatchMode.EXACT, false, null, null);

        Assert.assertEquals("Result size for 'ext' should be 1", 1, referenceList.size());

        IdentifiedEntityDTO<Reference> identifierDTOReference = referenceList.get(0);

        Assert.assertTrue(identifierDTO.getCdmEntity() instanceof UuidAndTitleCache);

	}

	@Test

    @DataSet(value="IdentifiableServiceBaseTest.testFindByIdentifierOrMarker.xml")

        //classification Filter

        Classification classification = classificationService.find(5000);

        TaxonNode rootNode = classification.getRootNode();

        Boolean markerValue = true;

        UUID uuidMarkerTypeCompleted = MarkerType.uuidComplete;

        UUID uuidMarkerTypeDoubtful = UUID.fromString("b51325c8-05fe-421a-832b-d86fc249ef6e");

        MarkerType markerType1 = (MarkerType)termService.find(uuidMarkerTypeCompleted);

        MarkerType noMarkerType = null;

        MarkerType markerType2 = (MarkerType)termService.find(uuidMarkerTypeDoubtful);

        Assert.assertNotNull(markerType2);

        Assert.assertEquals("Result size for 'marker1=true' should be 1", 1, taxonPager.getRecords().size());

        MarkedEntityDTO<Taxon>.Marker marker = dto.getMarker();

        Assert.assertEquals("Flag must be true", uuidMarkerTypeCompleted, marker.getTypeUuid());

        Assert.assertEquals(5000, dto.getCdmEntity().getEntity().getId());

        markerValue = true;

        markerType = noMarkerType;

        markerType = markerType2;

        rootNode = null;

        markerType = markerType1;

        markerValue = null;

        markerValue = true;

    }

//	@Test

    @Override

    public void createTestDataSet() throws FileNotFoundException {

		TermVocabulary<DefinedTerm> voc = vocService.find(VocabularyEnum.IdentifierType.getUuid());

		DefinedTerm identifierType1 = DefinedTerm.NewIdentifierTypeInstance(null, "identifierType1", null);

    	voc.addTerm(identifierType1);

		termService.save(identifierType1);

    	DefinedTerm identifierType2 = DefinedTerm.NewIdentifierTypeInstance(null, "identifierType2", null);

    	voc.addTerm(identifierType2);

		termService.save(identifierType2);

        tb.addIdentifier("ext-1234", identifierType1);

        name.addIdentifier("ext-name12", identifierType2);

        taxonService.saveOrUpdate(tb);

        Taxon tb2 = Taxon.NewInstance(null, null);

        tb2.setTitleCache("Cached taxon", true);

        tb2.addIdentifier("ext-cache1", identifierType2);

        taxonService.saveOrUpdate(tb2);

        Classification classification = Classification.NewInstance("My classification");

        classification.addChildTaxon(tb, null, null);

        classificationService.saveOrUpdate(classification);

        commitAndStartNewTransaction(null);

        // this will write flat xml file to the same package in the test resources

        // the test file is named after the test class like: TestClassName.xml

		writeDbUnitDataSetFile(new String[] {

		        "TAXONNAME_IDENTIFIER",

		        "CLASSIFICATION", "TAXONNODE",

		        "HOMOTYPICALGROUP",

    }

}