eu.etaxonomy.taxeditor.editor/src/test/java/eu/etaxonomy/taxeditor/editor/name/operation/SwapSynonymAndAcceptedOperationTest.java

   1 /**
   2 * Copyright (C) 2007 EDIT
   3 * European Distributed Institute of Taxonomy
   4 * http://www.e-taxonomy.eu
   5 *
   6 * The contents of this file are subject to the Mozilla Public License Version 1.1
   7 * See LICENSE.TXT at the top of this package for the full license terms.
   8 */
   9
  10 package eu.etaxonomy.taxeditor.editor.name.operation;
  11
  12 import org.apache.log4j.Logger;
  13 import org.eclipse.core.commands.ExecutionException;
  14 import org.junit.Assert;
  15 import org.junit.BeforeClass;
  16 import org.junit.Test;
  17
  18 import eu.etaxonomy.cdm.model.common.DefaultTermInitializer;
  19 import eu.etaxonomy.cdm.model.common.ICdmBase;
  20 import eu.etaxonomy.cdm.model.description.TaxonDescription;
  21 import eu.etaxonomy.cdm.model.name.HomotypicalGroup;
  22 import eu.etaxonomy.cdm.model.name.NonViralName;
  23 import eu.etaxonomy.cdm.model.name.TaxonNameBase;
  24 import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
  25 import eu.etaxonomy.cdm.model.taxon.Synonym;
  26 import eu.etaxonomy.cdm.model.taxon.SynonymType;
  27 import eu.etaxonomy.cdm.model.taxon.Taxon;
  28 import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;
  29 import eu.etaxonomy.taxeditor.operation.AbstractPostOperation;
  30 import eu.etaxonomy.taxeditor.store.operations.AbstractTaxeditorOperationTestBase;
  31
  32 /**
  33  * @author n.hoffmann
  34  * @created 02.04.2009
  35  */
  36 public class SwapSynonymAndAcceptedOperationTest extends AbstractTaxeditorOperationTestBase {
  37         private static final Logger logger = Logger
  38                         .getLogger(SwapSynonymAndAcceptedOperationTest.class);
  39
  40         private static AbstractPostOperation operation;
  41
  42         private static Taxon taxon;
  43
  44         private static Taxon parentTaxon;
  45
  46         private static Synonym homotypicSynonym;
  47
  48         private static Synonym oldHeterotypicSynonym;
  49
  50         private static HomotypicalGroup heteroypicalGroup;
  51
  52         private static Taxon misapplication;
  53
  54         private static Taxon concept;
  55
  56         private static TaxonRelationshipType conceptRelationshipType;
  57
  58         private static Taxon childTaxon;
  59
  60         private static TaxonDescription description;
  61
  62         private static NonViralName<?> oldSynonymName;
  63
  64         private static NonViralName<?> oldTaxonName;
  65
  66
  67         /**
  68          * @throws java.lang.Exception
  69          */
  70         @BeforeClass
  71         public static void setUpBeforeClass() throws Exception {
  72
  73                 (new DefaultTermInitializer()).initialize();
  74
  75                 // Create the original accepted taxon
  76                 oldTaxonName = TaxonNameFactory.NewNonViralInstance(null);
  77                 taxon = Taxon.NewInstance(oldTaxonName, null);
  78
  79 //              // Create its parent taxon
  80 //              parentTaxon = Taxon.NewInstance(TaxonNameBase.NewNonViralInstance(null), null);
  81 //              parentTaxon.addTaxonomicChild(taxon, null, null);
  82 //
  83 //              // Give it a child taxon
  84 //              childTaxon = Taxon.NewInstance(TaxonNameBase.NewNonViralInstance(null), null);
  85 //              childTaxon.setTaxonomicParent(taxon, null, null);
  86
  87                 // Create a homotypic synonym for the accepted taxon
  88                 taxon.addHomotypicSynonymName(TaxonNameFactory.NewNonViralInstance(null));
  89 //              homotypicSynonym = Synonym.NewInstance(TaxonNameBase.NewNonViralInstance(null), null);
  90 //              HomotypicalGroup acceptedHomotypicalGroup = HomotypicalGroup.NewInstance();
  91 //              acceptedHomotypicalGroup.addTypifiedName(oldTaxon.getName());
  92 //              acceptedHomotypicalGroup.addTypifiedName(homotypicSynonym.getName());
  93
  94                 // Create a heterotypic synonym that will be used to create the new accepted taxon
  95                 oldSynonymName = TaxonNameFactory.NewNonViralInstance(null);
  96                 oldHeterotypicSynonym = Synonym.NewInstance(oldSynonymName, null);
  97 //              oldTaxon.addS .addHeterotypicSynonym(oldHeterotypicSynonym, null, null);
  98                 heteroypicalGroup = HomotypicalGroup.NewInstance();
  99                 heteroypicalGroup.addTypifiedName(oldHeterotypicSynonym.getName());
 100                 taxon.addSynonym(oldHeterotypicSynonym, SynonymType.HETEROTYPIC_SYNONYM_OF());
 101
 102                 // Create a misapplication
 103                 misapplication = Taxon.NewInstance(TaxonNameFactory.NewNonViralInstance(null), null);
 104                 taxon.addMisappliedName(misapplication, null, null);
 105
 106                 // Create a concept relation
 107                 concept = Taxon.NewInstance(TaxonNameFactory.NewNonViralInstance(null), null);
 108                 conceptRelationshipType = TaxonRelationshipType.CONGRUENT_TO();
 109                 concept.addTaxonRelation(taxon, conceptRelationshipType, null, null);
 110
 111                 // Create a description
 112                 description = TaxonDescription.NewInstance();
 113                 taxon.addDescription(description);
 114
 115                 operation = new SwapSynonymAndAcceptedOperation
 116                                 (null, undoContext, taxon, oldHeterotypicSynonym, postOperation, cdmEntitySessionEnabled);
 117         }
 118
 119
 120         /**
 121          * Test method for {@link eu.etaxonomy.taxeditor.editor.name.operation.ChangeHomotypicGroupOperation#execute(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)}.
 122          * @throws ExecutionException
 123          */
 124         @Test
 125         public void testExecute() throws ExecutionException {
 126                 operation.execute(null, null);
 127
 128                 // New taxon has correct name?
 129                 Assert.assertEquals(taxon.getName(), oldSynonymName);
 130
 131 //              // New taxon has correct parent?
 132 //              Assert.assertEquals(taxon.getTaxonomicParent(), parentTaxon);
 133 //
 134 //              // New taxon has correct child?
 135 //              Assert.assertTrue(taxon.getTaxonomicChildren().contains(childTaxon));
 136
 137                 // New taxon has 2 synonyms?
 138                 Assert.assertEquals(taxon.getSynonyms().size(), 2);
 139
 140                 // New taxon has a synonym with the name of the previous accepted taxon?
 141                 Assert.assertTrue(taxon.getSynonymNames().contains(oldTaxonName));
 142
 143                 // New taxon has misapplication?
 144                 Assert.assertTrue(taxon.getMisappliedNames().contains(misapplication));
 145
 146 //              // New taxon has 1 concept relation?
 147 //              int conceptRelCount = 0;
 148 //              for (TaxonRelationship relation : taxon.getTaxonRelations()) {
 149 //                      if (relation.getType().equals(TaxonRelationshipType.MISAPPLIED_NAME_FOR()) ||
 150 //                                      relation.getType().equals(TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN())) {
 151 //                              continue;
 152 //                      }
 153 //                      conceptRelCount++;
 154 //              }
 155 //              Assert.assertEquals(conceptRelCount, 1);
 156
 157                 // New taxon has description?
 158                 taxon.getDescriptions().contains(description);
 159         }
 160
 161         /**
 162          * Test method for {@link eu.etaxonomy.taxeditor.editor.name.operation.ChangeHomotypicGroupOperation#undo(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)}.
 163          * @throws ExecutionException
 164          */
 165         @Test
 166         public void testUndo() throws ExecutionException {
 167                 operation.undo(null, null);
 168
 169 //              Assert.assertEquals(oldHomotypicalGroup, synonym.getHomotypicGroup());
 170         }
 171
 172         /**
 173          * Test method for {@link eu.etaxonomy.taxeditor.editor.name.operation.ChangeHomotypicGroupOperation#redo(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)}.
 174          * @throws ExecutionException
 175          */
 176         @Test
 177         public void testRedo() throws ExecutionException {
 178                 operation.redo(null, null);
 179
 180 //              Assert.assertEquals(newHomotypicalGroup, synonym.getHomotypicGroup());
 181         }
 182
 183         /**
 184          * Test method for {@link eu.etaxonomy.taxeditor.operation.AbstractPostTaxonOperation#postExecute(ICdmBase)}.
 185          */
 186         @Test
 187         public void testPostExecute() {
 188                 // TODO there is not post operation functionality for this class
 189                 // at the moment. Implement test when there is.
 190                 logger.warn("No post operation functionality for this class");
 191         }
 192 }