eu.etaxonomy.taxeditor.remoting/src/test/java/eu/etaxonomy/taxeditor/lazyloading/RemotePersistentCollectionTest.java

   1 /**
   2 * Copyright (C) 2014 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 package eu.etaxonomy.taxeditor.lazyloading;
  10
  11 import java.util.Iterator;
  12 import java.util.List;
  13 import java.util.Map;
  14 import java.util.Set;
  15
  16 import org.apache.log4j.Level;
  17 import org.apache.log4j.Logger;
  18 import org.hibernate.collection.internal.AbstractPersistentCollection;
  19 import org.hibernate.collection.spi.PersistentCollection;
  20 import org.junit.Assert;
  21 import org.junit.BeforeClass;
  22 import org.junit.Test;
  23
  24 import eu.etaxonomy.cdm.api.service.IClassificationService;
  25 import eu.etaxonomy.cdm.api.service.ICommonService;
  26 import eu.etaxonomy.cdm.model.common.Language;
  27 import eu.etaxonomy.cdm.model.common.LanguageString;
  28 import eu.etaxonomy.cdm.model.description.DescriptionElementBase;
  29 import eu.etaxonomy.cdm.model.description.TaxonDescription;
  30 import eu.etaxonomy.cdm.model.description.TextData;
  31 import eu.etaxonomy.cdm.model.name.TaxonNameBase;
  32 import eu.etaxonomy.cdm.model.taxon.Classification;
  33 import eu.etaxonomy.cdm.model.taxon.Taxon;
  34 import eu.etaxonomy.cdm.model.taxon.TaxonNode;
  35 import eu.etaxonomy.taxeditor.httpinvoker.BaseRemotingTest;
  36
  37 /**
  38  * Test class which tests remoting for persistent collections.
  39  *
  40  * @author c.mathew
  41  * @created 13.03.2014
  42  */
  43 public class RemotePersistentCollectionTest extends BaseRemotingTest {
  44         private static final Logger logger = Logger.getLogger(RemotePersistentCollectionTest.class);
  45
  46         private static IClassificationService classificationService;
  47         private static ICommonService commonService;
  48
  49         @BeforeClass
  50         public static void initializeServices() {
  51                 Logger.getRootLogger().setLevel(Level.INFO);
  52                 classificationService = getRemoteApplicationController().getClassificationService();
  53                 commonService = getRemoteApplicationController().getCommonService();
  54         }
  55
  56         /**
  57          * Test method which checks remoting for persistent lists.
  58          *
  59          */
  60         @Test
  61         public void persistentListTest() {
  62
  63                 List<TaxonNode> taxonNodes = classificationService.getAllNodes();
  64                 int size = taxonNodes.size();
  65                 logger.debug("classificationService.getAllNodes() size : " + size);
  66                 TaxonNode taxonNode = null;
  67                 if(size > 0) {
  68                         Assert.assertFalse(taxonNodes.isEmpty());
  69
  70                         taxonNode = taxonNodes.get(0);
  71                         Assert.assertNotNull(taxonNode);
  72                         Assert.assertTrue(taxonNodes.contains(taxonNode));
  73
  74                         // get the list of child nodes, which will give a
  75                         // proxy list which is not yet initialised
  76                         List<TaxonNode> childNodes = taxonNode.getChildNodes();
  77                         // this size call will first initialise the list locally by internally
  78                         // calling the ICommonService.initializeCollection method and then
  79                         // call size on the initialised list
  80                         int childCount = childNodes.size();
  81
  82                         // this size call will initialise the list remotely and only return the
  83                         // size of the list
  84                         int remoteChildCount = commonService.size((PersistentCollection)childNodes);
  85                         Assert.assertEquals(childCount, remoteChildCount);
  86
  87                         String firstNodeTaxonTitle = taxonNode.getTaxon().getTitleCache();
  88                         Assert.assertNotNull(firstNodeTaxonTitle);
  89
  90                         if(childCount > 0) {
  91                                 Assert.assertFalse(childNodes.isEmpty());
  92                                 // this get call will use the already initialised list to get the
  93                                 // 0th element
  94                                 TaxonNode localTaxonNode = childNodes.get(0);
  95
  96                                 // this get call will initialise the list remotely and only return the
  97                                 // 0th element from the list
  98                                 TaxonNode remoteTaxonNode = (TaxonNode)commonService.get((PersistentCollection)childNodes,0);
  99
 100                                 // the locally and remotely retrieved taxon node should exist in the
 101                                 // (local and remote) child nodes list, should be not-null and should be equal to each other
 102                                 Assert.assertTrue(taxonNode.getChildNodes().contains(localTaxonNode));
 103                                 Assert.assertTrue(taxonNode.getChildNodes().contains(remoteTaxonNode));
 104                                 Assert.assertTrue(commonService.contains((PersistentCollection)childNodes, localTaxonNode));
 105                                 Assert.assertTrue(commonService.contains((PersistentCollection)childNodes, remoteTaxonNode));
 106                                 Assert.assertNotNull(remoteTaxonNode);
 107                                 Assert.assertNotNull(localTaxonNode);
 108                                 Assert.assertEquals(remoteTaxonNode,localTaxonNode);
 109                         }
 110                 }
 111         }
 112
 113 //      @Test
 114 //      public void persistentSetTest() {
 115 //              List<Classification> classifications = classificationService.listClassifications(1,0,null,null);
 116 //              int size = classifications.size();
 117 //              if(size > 0) {
 118 //                      Assert.assertFalse(classifications.isEmpty());
 119 //
 120 //                      Classification classification = classifications.get(0);
 121 //                      Assert.assertNotNull(classification);
 122 //                      Assert.assertTrue(classifications.contains(classification));
 123 //
 124 //                      TaxonNode rootTaxonNode = classification.getRootNode();
 125 //                      // get the list of child nodes, which will give a
 126 //                      // proxy list which is not yet initialised
 127 //                      List<TaxonNode> childNodes = rootTaxonNode.getChildNodes();
 128 //
 129 //                      // this size call will initialise the list locally by internally
 130 //                      // calling the ICommonService.initializeCollection method
 131 //                      int childCount = childNodes.size();
 132 //
 133 //                      if(childCount > 0) {
 134 //                              Assert.assertFalse(childNodes.isEmpty());
 135 //
 136 //                              // this get call will use the already initialised list to get the
 137 //                              // 0th element
 138 //                              Taxon localTaxon = childNodes.get(0).getTaxon();
 139 //                              Assert.assertNotNull(localTaxon);
 140 //
 141 //                              TaxonNameBase taxonName = localTaxon.getName();
 142 //                              Assert.assertNotNull(taxonName);
 143 //
 144 //                              // get the list of taxa, which will give a
 145 //                              // proxy set which is not yet initialised
 146 //                              Set<Taxon> taxa = taxonName.getTaxonBases();
 147 //
 148 //                              // this size call will initialise the list locally by internally
 149 //                              // calling the ICommonService.initializeCollection method
 150 //                              int taxaCount = taxa.size();
 151 //                              Assert.assertNotEquals(taxaCount,-1);
 152 //
 153 //                              if(taxaCount > 0) {
 154 //                                      Assert.assertFalse(taxa.isEmpty());
 155 //                                      // the locally retrieved taxon should exist in the
 156 //                                      // (local and remote) taxon list and should be not-null
 157 //                                      Assert.assertTrue(taxa.contains(localTaxon));
 158 //                                      Assert.assertNotNull(localTaxon);
 159 //                                      Assert.assertTrue(commonService.contains((PersistentCollection)taxa, localTaxon));
 160 //                              }
 161 //                      }
 162 //              }
 163 //      }
 164
 165         @Test
 166         public void persistentMapTest() {
 167                 List<TaxonNode> taxonNodes = classificationService.getAllNodes();
 168                 // calling iterator will initialise the collection
 169                 Iterator<TaxonNode> taxonNodesItr = taxonNodes.iterator();
 170                 while(taxonNodesItr.hasNext()) {
 171                         TaxonNode taxonNode = taxonNodesItr.next();
 172                         Taxon taxon = taxonNode.getTaxon();
 173
 174                         if(taxon != null) {
 175                                 Set<TaxonDescription> descriptions = taxon.getDescriptions();
 176                                 Iterator<TaxonDescription> descriptionsItr = descriptions.iterator();
 177                                 while(descriptionsItr.hasNext()) {
 178                                         TaxonDescription desc = descriptionsItr.next();
 179                                         if(desc != null) {
 180                                                 for (DescriptionElementBase element : desc.getElements()){
 181                                                         if (element.isInstanceOf(TextData.class)){
 182                                                                 // usually a call to 'get' collections should not initialise the collection,
 183                                                                 // but the 'getMultilanguageText' call internally calls readSize on the collection
 184                                                                 // which triggers the initialisation
 185                                                                 Map<Language, LanguageString> multilanguagetextMap = ((TextData)element).getMultilanguageText();
 186                                                                 boolean init = AbstractPersistentCollection.isInitialized(multilanguagetextMap);
 187                                                                 Assert.assertTrue(init);
 188
 189                                                                 if(!multilanguagetextMap.isEmpty()) {
 190                                                                         // found a map whcih we can test!
 191                                                                         logger.info("Found Non-empty multilanguagetextMap");
 192                                                                         boolean empty = commonService.isEmpty((PersistentCollection)multilanguagetextMap);
 193                                                                         Assert.assertFalse(empty);
 194                                                                         // test retrieval of key set, which should already by initialised
 195                                                                         Set<Language> langKeySet = multilanguagetextMap.keySet();
 196                                                                         Iterator<Language> langKeySetItr = langKeySet.iterator();
 197                                                                         while(langKeySetItr.hasNext()) {
 198                                                                                 Language key = langKeySetItr.next();
 199                                                                                 // testing 'containsKey' on locally initialised collection
 200                                                                                 boolean localContainsKey = multilanguagetextMap.containsKey(key);
 201                                                                                 Assert.assertTrue(localContainsKey);
 202                                                                                 // testing 'containsKey' on remotely initialised collection
 203                                                                                 boolean remoteContainsKey =
 204                                                                                                 commonService.containsKey((PersistentCollection)multilanguagetextMap, key);
 205                                                                                 Assert.assertTrue(remoteContainsKey);
 206
 207                                                                                 LanguageString value = multilanguagetextMap.get(key);
 208                                                                                 // testing 'containsValue' on locally initialised collection
 209                                                                                 boolean localContainsValue = multilanguagetextMap.containsValue(value);
 210                                                                                 Assert.assertTrue(localContainsValue);
 211                                                                                 // testing 'containsValue' on remotely initialised collection
 212                                                                                 boolean remoteContainsValue =
 213                                                                                                 commonService.containsValue((PersistentCollection)multilanguagetextMap, value);
 214                                                                                 Assert.assertTrue(remoteContainsValue);
 215
 216                                                                         }
 217                                                                         return;
 218                                                                 }
 219                                                         }
 220                                                 }
 221                                         }
 222                                 }
 223                         }
 224                 }
 225         }
 226 }