eu.etaxonomy.taxeditor.cdmlib/src/test/java/eu/etaxonomy/taxeditor/remoting/RemoteLazyLoadingTest.java

   1 /**
   2 * Copyright (C) 2009 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.remoting;
  11
  12 import java.util.HashSet;
  13 import java.util.Iterator;
  14 import java.util.Set;
  15 import java.util.UUID;
  16
  17 import org.junit.Assert;
  18 import org.junit.Test;
  19 import org.unitils.UnitilsJUnit4;
  20 import org.unitils.database.annotations.Transactional;
  21 import org.unitils.database.util.TransactionMode;
  22 import org.unitils.spring.annotation.SpringApplicationContext;
  23 import org.unitils.spring.annotation.SpringBeanByType;
  24
  25 import eu.etaxonomy.cdm.api.service.ITaxonService;
  26 import eu.etaxonomy.cdm.model.common.CdmBase;
  27 import eu.etaxonomy.cdm.model.name.NonViralName;
  28 import eu.etaxonomy.cdm.model.taxon.SynonymRelationship;
  29 import eu.etaxonomy.cdm.model.taxon.Taxon;
  30
  31
  32 /**
  33  * This test class is a testing ground for solving the hibernate lazy loading problem using aspects
  34  *
  35  * @author c.mathew
  36  *
  37  */
  38 @SpringApplicationContext("classpath:/eu/etaxonomy/cdm/remotingApplicationContext.xml")
  39 @Transactional(TransactionMode.DISABLED)
  40 public class RemoteLazyLoadingTest extends UnitilsJUnit4 {
  41
  42         @SpringBeanByType
  43         private ITaxonService taxonService;
  44
  45         private UUID taxonUuid1 = UUID.fromString("8217ef77-2ab1-4318-bd67-ccd0cdef07c4");
  46         private UUID taxonUuid2 = UUID.fromString("ef96fafa-7750-4141-b31b-1ad1daab3e76");
  47
  48         /**
  49          */
  50
  51 //      @Test
  52 //      public void testLazyLoading(){
  53 //
  54 //              Taxon taxon = (Taxon)taxonService.find(taxonUuid1);
  55 //              System.out.println("Taxon title : " + taxon.getTitleCache());
  56 //              taxon.setTitleCache("Taxon Title Cache 1");
  57 //              taxonService.merge(taxon);
  58 //
  59 //              NonViralName nvn = CdmBase.deproxy(taxon.getName(),NonViralName.class);
  60 //
  61 //
  62 //              System.out.println("name : " + nvn.getTitleCache());
  63 //              nvn.setTitleCache("Taxon Name Title Cache 1");
  64 //              taxonService.merge(taxon);
  65 //
  66 //              Reference ref = taxon.getSec();
  67 //              System.out.println("Secundum : " + ref.getTitleCache());
  68 //
  69 //              Rank rank = nvn.getRank();
  70 //              System.out.println("rank : " + rank.getTitleCache());
  71 //
  72 //              Set<SynonymRelationship> synRelations = taxon.getSynonymRelations();
  73 //              Iterator<SynonymRelationship> srItr = synRelations.iterator();
  74 //              while(srItr.hasNext()) {
  75 //                      SynonymRelationship sr = srItr.next();
  76 //                      System.out.println("Synonym Relationship : " + sr.getType().getTitleCache());
  77 //                      sr.getType().setTitleCache(sr.getType().getTitleCache() + "*");
  78 //              }
  79 //              taxonService.merge(taxon);
  80 //
  81 //              Set<TaxonRelationship> taxonRelationsFrom = taxon.getRelationsFromThisTaxon();
  82 //              Iterator<TaxonRelationship> trItrFrom = taxonRelationsFrom.iterator();
  83 //              while(trItrFrom.hasNext()) {
  84 //                      TaxonRelationship tr = trItrFrom.next();
  85 //                      System.out.println("Taxon From Relationship : " + tr.getType().getTitleCache());
  86 //                      tr.getType().setTitleCache(tr.getType().getTitleCache() + "*");
  87 //              }
  88 //              taxonService.merge(taxon);
  89 //              Set<TaxonRelationship> taxonRelationsTo = taxon.getRelationsToThisTaxon();
  90 //              Iterator<TaxonRelationship> trItrTo = taxonRelationsTo.iterator();
  91 //              while(trItrTo.hasNext()) {
  92 //                      TaxonRelationship tr = trItrTo.next();
  93 //                      System.out.println("Taxon To Relationship : " + tr.getType().getTitleCache());
  94 //                      tr.getType().setTitleCache(tr.getType().getTitleCache() + "*");
  95 //              }
  96 //              taxonService.merge(taxon);
  97 //      }
  98
  99         @Test
 100         public void testCDMEntityGet() {
 101                 Taxon taxon = (Taxon)taxonService.find(taxonUuid1);
 102                 System.out.println("Taxon title : " + taxon.getTitleCache());
 103
 104                 NonViralName nvn = CdmBase.deproxy(taxon.getName(),NonViralName.class);
 105                 System.out.println("name : " + nvn.getTitleCache());
 106
 107         }
 108
 109         @Test
 110         public void testCDMCollectionGet() {
 111                 Taxon taxon = (Taxon)taxonService.find(taxonUuid1);
 112                 System.out.println("Taxon title : " + taxon.getTitleCache());
 113
 114                 Set<SynonymRelationship> synRelations = taxon.getSynonymRelations();
 115                 Iterator<SynonymRelationship> srItr = synRelations.iterator();
 116                 while(srItr.hasNext()) {
 117                         SynonymRelationship sr = srItr.next();
 118                         System.out.println("Synonym Relationship : " + sr.getType().getTitleCache());
 119                 }
 120         }
 121
 122         @Test
 123         public void testCDMEntitySaveEager() {
 124                 Taxon taxon = (Taxon)taxonService.find(taxonUuid1);
 125                 String oldTitleCache = taxon.getTitleCache();
 126
 127                 System.out.println("Taxon title : " + oldTitleCache);
 128
 129                 taxon.setTitleCache(oldTitleCache + ":updated");
 130                 taxonService.merge(taxon);
 131
 132                 Taxon taxonNew = (Taxon)taxonService.find(taxonUuid1);
 133                 System.out.println("New Taxon Title : " + taxonNew.getTitleCache());
 134
 135                 Assert.assertNotEquals("Title caches should not be equal",oldTitleCache,taxonNew.getTitleCache());
 136
 137                 taxonNew.setTitleCache(oldTitleCache);
 138                 taxonService.merge(taxonNew);
 139
 140                 Taxon taxonOld = (Taxon)taxonService.find(taxonUuid1);
 141                 System.out.println("Old Taxon Title : " + taxonOld.getTitleCache());
 142
 143                 Assert.assertEquals("Title caches should be equal",oldTitleCache,taxonOld.getTitleCache());
 144
 145         }
 146
 147         @Test
 148         public void testCDMEntitySaveLazy() {
 149                 Taxon taxon = (Taxon)taxonService.find(taxonUuid1);
 150
 151                 NonViralName nvn = CdmBase.deproxy(taxon.getName(),NonViralName.class);
 152                 String oldTitleCache = nvn.getTitleCache();
 153                 System.out.println("Taxon Name Title : " + oldTitleCache);
 154                 nvn.setTitleCache(oldTitleCache + ":updated");
 155                 taxonService.merge(taxon);
 156
 157                 Taxon taxonNew = (Taxon)taxonService.find(taxonUuid1);
 158                 NonViralName nvnNew = CdmBase.deproxy(taxon.getName(),NonViralName.class);
 159                 System.out.println("New Taxon Name Title : " + nvnNew.getTitleCache());
 160
 161                 Assert.assertNotEquals("Title caches should not be equal",oldTitleCache,nvnNew.getTitleCache());
 162
 163                 nvnNew.setTitleCache(oldTitleCache);
 164                 taxonService.merge(taxon);
 165
 166                 Taxon taxonOld = (Taxon)taxonService.find(taxonUuid1);
 167                 NonViralName nvnOld = CdmBase.deproxy(taxon.getName(),NonViralName.class);
 168                 System.out.println("Old Taxon Name Title : " + nvnNew.getTitleCache());
 169
 170                 Assert.assertEquals("Title caches should be equal",oldTitleCache,nvnOld.getTitleCache());
 171         }
 172
 173         @Test
 174         public void testCDMEntitySaveCollection() {
 175                 Taxon taxon = (Taxon)taxonService.find(taxonUuid1);
 176
 177                 Set<SynonymRelationship> synRelations = taxon.getSynonymRelations();
 178                 Set<String> relToTitles = new HashSet<String>();
 179                 Iterator<SynonymRelationship> srItr = synRelations.iterator();
 180                 while(srItr.hasNext()) {
 181                         SynonymRelationship sr = srItr.next();
 182                         System.out.println("Synonym Title Cache : " + sr.getSynonym().getTitleCache());
 183                         relToTitles.add(sr.getSynonym().getTitleCache());
 184                         sr.getSynonym().setTitleCache(sr.getSynonym().getTitleCache() + ":updated");
 185
 186                 }
 187                 taxonService.merge(taxon);
 188
 189                 Taxon taxonNew = (Taxon)taxonService.find(taxonUuid1);
 190                 Set<SynonymRelationship> synRelationsNew = taxonNew.getSynonymRelations();
 191
 192                 Iterator<SynonymRelationship> srItrNew = synRelationsNew.iterator();
 193                 Iterator<String> relToTitlesItr = relToTitles.iterator();
 194                 while(srItrNew.hasNext() && relToTitlesItr.hasNext()) {
 195                         SynonymRelationship srNew = srItrNew.next();
 196                         String relToTitle = relToTitlesItr.next();
 197                         System.out.println("New Synonym Title Cache: " + srNew.getSynonym().getTitleCache());
 198                         Assert.assertNotEquals("Synonym Title caches should not be equal", srNew.getSynonym().getTitleCache(), relToTitle);
 199                         srNew.getSynonym().setTitleCache(relToTitle);
 200                 }
 201
 202                 Taxon taxonOld = (Taxon)taxonService.find(taxonUuid1);
 203
 204                 Set<SynonymRelationship> synRelationsOld = taxonNew.getSynonymRelations();
 205                 Iterator<SynonymRelationship> srItrOld = synRelationsOld.iterator();
 206                 relToTitlesItr = relToTitles.iterator();
 207                 while(srItrOld.hasNext() && relToTitlesItr.hasNext()) {
 208                         SynonymRelationship srOld = srItrOld.next();
 209                         String relToTitle = relToTitlesItr.next();
 210                         System.out.println("New Synonym Title Cache: " + srOld.getSynonym().getTitleCache());
 211                         Assert.assertEquals("Synonym Title caches should be equal", srOld.getSynonym().getTitleCache(), relToTitle);
 212
 213                 }
 214         }
 215 }