smart-exim/smart-exim-api/src/test/java/com/smartitengineering/exim/impl/DefaultAnnotationConfigScannerTest.java

   1 /*
   2  * This is a common dao with basic CRUD operations and is not limited to any
   3  * persistent layer implementation
   4  *
   5  * Copyright (C) 2008  Imran M Yousuf (imyousuf@smartitengineering.com)
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 3 of the License, or (at your option) any later version.
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  18  */
  19 package com.smartitengineering.exim.impl;
  20
  21 import com.smartitengineering.exim.AssociationConfig;
  22 import com.smartitengineering.exim.EximResourceConfig;
  23 import com.smartitengineering.exim.impl.data.IResource;
  24 import com.smartitengineering.exim.impl.data.IResourceImpl;
  25 import com.smartitengineering.exim.impl.data.InheritedResource;
  26 import com.smartitengineering.exim.impl.data.MultiResourceImpl;
  27 import com.smartitengineering.exim.impl.data.SomeResource;
  28 import com.smartitengineering.exim.impl.data.TestClass;
  29 import com.smartitengineering.exim.impl.data.TestResourceDomain;
  30 import com.smartitengineering.exim.impl.data.TestResourceDomainField;
  31 import java.util.Collection;
  32 import java.util.Map;
  33 import junit.framework.TestCase;
  34
  35 /**
  36  *
  37  * @author imyousuf
  38  */
  39 public class DefaultAnnotationConfigScannerTest
  40     extends TestCase {
  41
  42     public DefaultAnnotationConfigScannerTest(String testName) {
  43         super(testName);
  44     }
  45
  46     @Override
  47     protected void setUp()
  48         throws Exception {
  49         super.setUp();
  50     }
  51
  52     /**
  53      * Test of getInstance method, of class DefaultAnnotationConfigScanner.
  54      */
  55     public void testGetInstance() {
  56         System.out.println("getInstance");
  57         DefaultAnnotationConfigScanner expResult =
  58                                        DefaultAnnotationConfigScanner.
  59             getInstance();
  60         DefaultAnnotationConfigScanner result =
  61                                        DefaultAnnotationConfigScanner.
  62             getInstance();
  63         assertEquals(expResult,
  64                      result);
  65     }
  66
  67     /**
  68      * Test of getConfigurations method, of class DefaultAnnotationConfigScanner.
  69      */
  70     public void testGetConfigurations() {
  71         System.out.println("getConfigurations");
  72         DefaultAnnotationConfigScanner instance =
  73                                        new DefaultAnnotationConfigScanner();
  74         Map<Class, EximResourceConfig> result = instance.getConfigurations();
  75         assertEquals(0,
  76                      result.size());
  77         instance.getResourceConfigForClass(TestClass.class);
  78         assertEquals(4,
  79                      result.size());
  80         assertTrue(result.keySet().contains(TestResourceDomain.class));
  81         assertTrue(result.keySet().contains(TestResourceDomainField.class));
  82         assertTrue(result.keySet().contains(IResource.class));
  83         assertFalse(result.keySet().contains(TestClass.class));
  84         assertFalse(result.keySet().contains(SomeResource.class));
  85         instance.getResourceConfigForClass(TestResourceDomain.class);
  86         assertEquals(4,
  87                      result.size());
  88         assertTrue(result.keySet().contains(TestResourceDomain.class));
  89         assertTrue(result.keySet().contains(IResource.class));
  90         assertTrue(result.keySet().contains(TestResourceDomainField.class));
  91         assertFalse(result.keySet().contains(TestClass.class));
  92         assertFalse(result.keySet().contains(SomeResource.class));
  93     }
  94
  95     /**
  96      * Test of getConfiguredResourceClasses method, of class DefaultAnnotationConfigScanner.
  97      */
  98     public void testGetConfiguredResourceClasses() {
  99         System.out.println("getConfiguredResourceClasses");
 100         DefaultAnnotationConfigScanner instance =
 101                                        new DefaultAnnotationConfigScanner();
 102         Collection<Class> result = instance.getConfiguredResourceClasses();
 103         assertTrue(result.isEmpty());
 104         Package resourcePackage = Package.getPackage(getClass().getPackage().
 105             getName().concat(".data"));
 106         instance.scanPackageForResourceConfigs(resourcePackage);
 107         result = instance.getConfiguredResourceClasses();
 108         assertEquals(4,
 109                      result.size());
 110         assertTrue(result.contains(TestResourceDomain.class));
 111         assertTrue(result.contains(TestResourceDomainField.class));
 112         assertTrue(result.contains(IResource.class));
 113         assertFalse(result.contains(TestClass.class));
 114         assertFalse(result.contains(SomeResource.class));
 115     }
 116
 117     /**
 118      * Test of getResourceConfigForClass method, of class DefaultAnnotationConfigScanner.
 119      */
 120     public void testGetResourceConfigForClass() {
 121         System.out.println("getResourceConfigForClass");
 122         DefaultAnnotationConfigScanner instance =
 123                                        new DefaultAnnotationConfigScanner();
 124         Class resourceClass;
 125         EximResourceConfig result;
 126         Map<String, AssociationConfig> asssocConfigs;
 127         AssociationConfig associationConfig;
 128
 129         /**
 130          * Test TestResourceDomain's config
 131          */
 132         resourceClass = TestResourceDomain.class;
 133         result = instance.getResourceConfigForClass(resourceClass);
 134         assertNotNull(result);
 135         assertTrue(result.isAccessByPropertyEnabled());
 136         assertFalse(result.isAssociateExportPolicyAsUri());
 137         assertFalse(result.isIdentityCustomizerImplemented());
 138         assertFalse(result.isImporterImplemented());
 139         assertTrue(result.isExporterImplemented());
 140         assertEquals(TestResourceDomain.class, result.getDomainClass());
 141         assertEquals(TestResourceDomain.ID_PREFIX, result.getIdPrefix());
 142         assertEquals(TestResourceDomain.ID, result.getIdPropertyName());
 143         assertEquals(result.getDomainClass().getName(), result.getName());
 144         assertEquals(TestResourceDomain.PATH, result.getPathToResource());
 145         assertEquals(0, result.getPriority());
 146         asssocConfigs = result.getAssociationConfigs();
 147         assertNotNull(asssocConfigs);
 148         assertFalse(asssocConfigs.isEmpty());
 149         assertEquals(4,
 150                      asssocConfigs.size());
 151         //ID
 152         assertTrue(asssocConfigs.containsKey(TestResourceDomain.ID));
 153         associationConfig = asssocConfigs.get(TestResourceDomain.ID);
 154         assertEquals("getId", associationConfig.getAccessorName());
 155         assertEquals(AssociationConfig.AssociationType.TYPE_OBJECT,
 156                      associationConfig.getAssociationType());
 157         assertEquals(TestResourceDomain.ID, associationConfig.getName());
 158         assertFalse(associationConfig.isEagerSet());
 159         assertFalse(associationConfig.isItToBeExportedAsUri());
 160         assertFalse(associationConfig.isStringProviderImplemented());
 161         assertFalse(associationConfig.isTransient());
 162         //Some prop
 163         assertTrue(asssocConfigs.containsKey(TestResourceDomain.SOME_PROP));
 164         associationConfig = asssocConfigs.get(TestResourceDomain.SOME_PROP);
 165         assertEquals("getSomeProp", associationConfig.getAccessorName());
 166         assertEquals(AssociationConfig.AssociationType.TYPE_OBJECT,
 167                      associationConfig.getAssociationType());
 168         assertEquals(TestResourceDomain.SOME_PROP_NAME, associationConfig.
 169             getName());
 170         assertFalse(associationConfig.isEagerSet());
 171         assertTrue(associationConfig.isItToBeExportedAsUri());
 172         assertFalse(associationConfig.isStringProviderImplemented());
 173         assertFalse(associationConfig.isTransient());
 174         //Some bool prop
 175         assertTrue(asssocConfigs.containsKey(TestResourceDomain.SOME_BOOL_PROP));
 176         associationConfig = asssocConfigs.get(TestResourceDomain.SOME_BOOL_PROP);
 177         assertEquals("hasSomeBoolProp", associationConfig.getAccessorName());
 178         assertEquals(AssociationConfig.AssociationType.TYPE_OBJECT,
 179                      associationConfig.getAssociationType());
 180         assertEquals(TestResourceDomain.SOME_BOOL_PROP, associationConfig.
 181             getName());
 182         assertTrue(associationConfig.isEagerSet());
 183         assertFalse(associationConfig.isItToBeExportedAsUri());
 184         assertFalse(associationConfig.isStringProviderImplemented());
 185         assertFalse(associationConfig.isTransient());
 186         //Some transient prop
 187         assertTrue(asssocConfigs.containsKey(
 188             TestResourceDomain.SOME_TRANSIENT_PROP));
 189         associationConfig = asssocConfigs.get(
 190             TestResourceDomain.SOME_TRANSIENT_PROP);
 191         assertEquals("getSomeTransientProp", associationConfig.getAccessorName());
 192         assertEquals(AssociationConfig.AssociationType.TYPE_OBJECT,
 193                      associationConfig.getAssociationType());
 194         assertEquals(TestResourceDomain.SOME_TRANSIENT_PROP, associationConfig.
 195             getName());
 196         assertFalse(associationConfig.isEagerSet());
 197         assertFalse(associationConfig.isItToBeExportedAsUri());
 198         assertFalse(associationConfig.isStringProviderImplemented());
 199         assertTrue(associationConfig.isTransient());
 200
 201         /**
 202          * Test TestResourceDomainField's config
 203          */
 204         resourceClass = TestResourceDomainField.class;
 205         result = instance.getResourceConfigForClass(resourceClass);
 206         assertNotNull(result);
 207         assertFalse(result.isAccessByPropertyEnabled());
 208         assertTrue(result.isAssociateExportPolicyAsUri());
 209         assertTrue(result.isIdentityCustomizerImplemented());
 210         assertTrue(result.isImporterImplemented());
 211         assertFalse(result.isExporterImplemented());
 212         assertEquals(TestResourceDomainField.class, result.getDomainClass());
 213         assertEquals(null, result.getIdPrefix());
 214         assertEquals(null, result.getIdPropertyName());
 215         assertEquals(TestResourceDomainField.NAME, result.getName());
 216         assertEquals("", result.getPathToResource());
 217         assertEquals(0, result.getPriority());
 218         asssocConfigs = result.getAssociationConfigs();
 219         assertNotNull(asssocConfigs);
 220         assertFalse(asssocConfigs.isEmpty());
 221         assertEquals(2, asssocConfigs.size());
 222         //someStrProp
 223         assertTrue(asssocConfigs.containsKey(
 224             TestResourceDomainField.SOME_STR_PROP));
 225         associationConfig = asssocConfigs.get(
 226             TestResourceDomainField.SOME_STR_PROP);
 227         assertEquals(TestResourceDomainField.SOME_STR_PROP,
 228                      associationConfig.getAccessorName());
 229         assertEquals(AssociationConfig.AssociationType.TYPE_OBJECT,
 230                      associationConfig.getAssociationType());
 231         assertEquals(TestResourceDomainField.SOME_STR_PROP, associationConfig.
 232             getName());
 233         assertFalse(associationConfig.isEagerSet());
 234         assertFalse(associationConfig.isItToBeExportedAsUri());
 235         assertFalse(associationConfig.isStringProviderImplemented());
 236         assertFalse(associationConfig.isTransient());
 237         //someTransientStrProp
 238         assertTrue(asssocConfigs.containsKey(
 239             TestResourceDomainField.SOME_TRANSIENT_STR_PROP));
 240         associationConfig = asssocConfigs.get(
 241             TestResourceDomainField.SOME_TRANSIENT_STR_PROP);
 242         assertEquals(TestResourceDomainField.SOME_TRANSIENT_STR_PROP,
 243                      associationConfig.getAccessorName());
 244         assertEquals(AssociationConfig.AssociationType.TYPE_OBJECT,
 245                      associationConfig.getAssociationType());
 246         assertEquals(TestResourceDomainField.SOME_TRANSIENT_STR_PROP,
 247                      associationConfig.getName());
 248         assertFalse(associationConfig.isEagerSet());
 249         assertFalse(associationConfig.isItToBeExportedAsUri());
 250         assertFalse(associationConfig.isStringProviderImplemented());
 251         assertTrue(associationConfig.isTransient());
 252
 253         /**
 254          * Test IResource's config
 255          */
 256         resourceClass = IResource.class;
 257         result = instance.getResourceConfigForClass(resourceClass);
 258         assertNotNull(result);
 259         assertTrue(result.isAccessByPropertyEnabled());
 260         assertTrue(result.isAssociateExportPolicyAsUri());
 261         assertFalse(result.isIdentityCustomizerImplemented());
 262         assertFalse(result.isImporterImplemented());
 263         assertFalse(result.isExporterImplemented());
 264         assertEquals(IResource.class, result.getDomainClass());
 265         assertEquals("", result.getIdPrefix());
 266         assertEquals(IResource.RESOURCE_ID, result.getIdPropertyName());
 267         assertEquals(result.getDomainClass().getName(), result.getName());
 268         assertEquals("", result.getPathToResource());
 269         assertEquals(IResource.PRIORITY, result.getPriority());
 270         asssocConfigs = result.getAssociationConfigs();
 271         assertNotNull(asssocConfigs);
 272         assertFalse(asssocConfigs.isEmpty());
 273         assertEquals(7, asssocConfigs.size());
 274         //resourceId
 275         assertTrue(asssocConfigs.containsKey(IResource.RESOURCE_ID));
 276         associationConfig = asssocConfigs.get(IResource.RESOURCE_ID);
 277         assertEquals(AssociationConfig.AssociationType.TYPE_OBJECT,
 278                      associationConfig.getAssociationType());
 279         //list
 280         assertTrue(asssocConfigs.containsKey(IResource.LIST));
 281         associationConfig = asssocConfigs.get(IResource.LIST);
 282         assertEquals(AssociationConfig.AssociationType.TYPE_LIST,
 283                      associationConfig.getAssociationType());
 284         //set
 285         assertTrue(asssocConfigs.containsKey(IResource.SET));
 286         associationConfig = asssocConfigs.get(IResource.SET);
 287         assertEquals(AssociationConfig.AssociationType.TYPE_SET,
 288                      associationConfig.getAssociationType());
 289         assertEquals(IResource.SET_NAME, associationConfig.getName());
 290         //collection
 291         assertTrue(asssocConfigs.containsKey(IResource.COLLECTION));
 292         associationConfig = asssocConfigs.get(IResource.COLLECTION);
 293         assertEquals(AssociationConfig.AssociationType.TYPE_COLLECTION,
 294                      associationConfig.getAssociationType());
 295         //map
 296         assertTrue(asssocConfigs.containsKey(IResource.MAP));
 297         associationConfig = asssocConfigs.get(IResource.MAP);
 298         assertEquals(AssociationConfig.AssociationType.TYPE_MAP,
 299                      associationConfig.getAssociationType());
 300         assertTrue(associationConfig.isEagerSet());
 301         //array
 302         assertTrue(asssocConfigs.containsKey(IResource.ARRAY));
 303         associationConfig = asssocConfigs.get(IResource.ARRAY);
 304         assertEquals(AssociationConfig.AssociationType.TYPE_ARRAY,
 305                      associationConfig.getAssociationType());
 306         //bool valid
 307         assertTrue(asssocConfigs.containsKey(IResource.VALID));
 308         associationConfig = asssocConfigs.get(IResource.VALID);
 309         assertEquals(AssociationConfig.AssociationType.TYPE_OBJECT,
 310                      associationConfig.getAssociationType());
 311
 312     }
 313
 314     /**
 315      * Test of scanPackageForResourceConfigs method, of class DefaultAnnotationConfigScanner.
 316      */
 317     public void testScanPackageForResourceConfigs() {
 318         System.out.println("scanPackageForResourceConfigs");
 319         Package resourcePackage = Package.getPackage(getClass().getPackage().
 320             getName().concat(".data"));
 321         DefaultAnnotationConfigScanner instance =
 322                                        new DefaultAnnotationConfigScanner();
 323         Map<Class, EximResourceConfig> result = instance.getConfigurations();
 324         assertEquals(0, result.size());
 325         instance.scanPackageForResourceConfigs(resourcePackage);
 326         assertEquals(4, result.size());
 327         assertTrue(result.keySet().contains(TestResourceDomain.class));
 328         assertTrue(result.keySet().contains(TestResourceDomainField.class));
 329         assertTrue(result.keySet().contains(IResource.class));
 330         assertFalse(result.keySet().contains(TestClass.class));
 331         assertFalse(result.keySet().contains(SomeResource.class));
 332     }
 333
 334     public void testGetConfigForInheritence() {
 335         DefaultAnnotationConfigScanner instance =
 336                                        new DefaultAnnotationConfigScanner();
 337         Package resourcePackage = Package.getPackage(getClass().getPackage().
 338             getName().concat(".data"));
 339         instance.scanPackageForResourceConfigs(resourcePackage);
 340         EximResourceConfig config = instance.getResourceConfigForClass(
 341             IResourceImpl.class);
 342         assertNotNull(config);
 343         assertEquals(IResource.class, config.getDomainClass());
 344         config = instance.getResourceConfigForClass(InheritedResource.class);
 345         assertNotNull(config);
 346         assertEquals(IResource.class, config.getDomainClass());
 347         config = instance.getResourceConfigForClass(MultiResourceImpl.class);
 348         assertNotNull(config);
 349         assertEquals(IResource.class, config.getDomainClass());
 350     }
 351
 352     /**
 353      * Test of getPropertyNameFromMethodName method, of class DefaultAnnotationConfigScanner.
 354      */
 355     public void testGetPropertyNameFromMethodName() {
 356         System.out.println("getPropertyNameFromMethodName");
 357         String methodName = "getPropertyNameFromMethodName";
 358         DefaultAnnotationConfigScanner instance =
 359                                        new DefaultAnnotationConfigScanner();
 360         String expResult = "propertyNameFromMethodName";
 361         String result = instance.getPropertyNameFromMethodName(methodName);
 362         assertEquals(expResult, result);
 363         methodName = "isPropertyNameFromMethodName";
 364         result = instance.getPropertyNameFromMethodName(methodName);
 365         assertEquals(expResult, result);
 366         methodName = "hasPropertyNameFromMethodName";
 367         result = instance.getPropertyNameFromMethodName(methodName);
 368         assertEquals(expResult, result);
 369         methodName = "somePropertyNameFromMethodName";
 370         try {
 371             result = instance.getPropertyNameFromMethodName(methodName);
 372             fail("should not pass!");
 373         }
 374         catch (IllegalArgumentException ex) {
 375         }
 376         methodName = null;
 377         try {
 378             result = instance.getPropertyNameFromMethodName(methodName);
 379             fail("should not pass!");
 380         }
 381         catch (NullPointerException ex) {
 382         }
 383     }
 384 }