wamblee.org Git - utils/blob - system/general/src/test/java/org/wamblee/system/adapters/SetterConfigurationTest.java

   1 /*
   2  * Copyright 2008 the original author or authors.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.wamblee.system.adapters;
  17
  18 import org.wamblee.system.core.DefaultProvidedInterface;
  19 import org.wamblee.system.core.ProvidedInterface;
  20 import org.wamblee.system.core.RequiredInterface;
  21 import org.wamblee.system.core.RequiredInterfaceComparator;
  22
  23 import org.wamblee.test.AssertionUtils;
  24
  25 import java.lang.reflect.Method;
  26
  27 import java.util.ArrayList;
  28 import java.util.Collections;
  29 import java.util.Comparator;
  30 import java.util.List;
  31
  32 import javax.sql.DataSource;
  33
  34
  35 /**
  36  * DOCUMENT ME!
  37  *
  38  * @author $author$
  39  * @version $Revision$
  40   */
  41 public class SetterConfigurationTest extends AdapterTestCase {
  42     /**
  43      * DOCUMENT ME!
  44      */
  45     public void testOneSetter() {
  46         SetterConfiguration config = new SetterConfiguration(X5.class);
  47         config.initAllSetters();
  48
  49         List<RequiredInterface> required = config.getRequiredInterfaces();
  50         assertEquals(1, required.size());
  51         assertEquals("setValue.0", required.get(0).getName());
  52
  53         ProvidedInterface provided = new DefaultProvidedInterface("janse",
  54                 String.class);
  55         required.get(0).setProvider(provided);
  56         scope.publishInterface(provided, "hello");
  57
  58         X5 obj = new X5();
  59         assertNull(obj.getValue());
  60         config.inject(scope, obj);
  61         assertEquals("hello", obj.getValue());
  62     }
  63
  64     /**
  65      * DOCUMENT ME!
  66      */
  67     public void testPrivateSetter() {
  68         SetterConfiguration config = new SetterConfiguration(X5.class);
  69         config.setNonPublic(true);
  70         config.initAllSetters();
  71
  72         List<RequiredInterface> required = new ArrayList<RequiredInterface>(config
  73                 .getRequiredInterfaces());
  74         Collections.sort(required,
  75             new Comparator<RequiredInterface>() {
  76                 @Override
  77                 public int compare(RequiredInterface aO1, RequiredInterface aO2) {
  78                     return aO1.getName().compareTo(aO2.getName());
  79                 }
  80             });
  81         assertEquals(2, required.size());
  82         assertEquals("setValue.0", required.get(0).getName());
  83         assertEquals("setXyz.0", required.get(1).getName());
  84
  85         ProvidedInterface providedString = new DefaultProvidedInterface("janse",
  86                 String.class);
  87         assertTrue(required.get(0).implementedBy(providedString));
  88         required.get(0).setProvider(providedString);
  89         scope.publishInterface(providedString, "hello");
  90
  91         ProvidedInterface providedInt = new DefaultProvidedInterface("xxx",
  92                 Integer.class);
  93         assertTrue(required.get(1).implementedBy(providedInt));
  94         required.get(1).setProvider(providedInt);
  95         scope.publishInterface(providedInt, 100);
  96
  97         X5 obj = new X5();
  98         assertNull(obj.getValue());
  99         assertNull(obj.getXyz());
 100         config.inject(scope, obj);
 101         assertEquals("hello", obj.getValue());
 102         assertEquals(100, obj.getXyz().intValue());
 103     }
 104
 105     /**
 106      * DOCUMENT ME!
 107      */
 108     public void testInheritance() {
 109         SetterConfiguration config = new SetterConfiguration(X9.class);
 110         config.setNonPublic(true);
 111         config.initAllSetters();
 112
 113         List<RequiredInterface> required = new ArrayList<RequiredInterface>(config
 114                 .getRequiredInterfaces());
 115         Collections.sort(required,
 116             new Comparator<RequiredInterface>() {
 117                 @Override
 118                 public int compare(RequiredInterface aO1, RequiredInterface aO2) {
 119                     return aO1.getName().compareTo(aO2.getName());
 120                 }
 121             });
 122         assertEquals(3, required.size());
 123         assertEquals("setFlag.0", required.get(0).getName());
 124         assertEquals("setValue.0", required.get(1).getName());
 125         assertEquals("setXyz.0", required.get(2).getName());
 126
 127         ProvidedInterface providedBoolean = new DefaultProvidedInterface("janse",
 128                 Boolean.class);
 129         assertTrue(required.get(0).implementedBy(providedBoolean));
 130         required.get(0).setProvider(providedBoolean);
 131         scope.publishInterface(providedBoolean, true);
 132
 133         ProvidedInterface providedString = new DefaultProvidedInterface("janse",
 134                 String.class);
 135         assertTrue(required.get(1).implementedBy(providedString));
 136         required.get(1).setProvider(providedString);
 137         scope.publishInterface(providedString, "hello");
 138
 139         ProvidedInterface providedInt = new DefaultProvidedInterface("xxx",
 140                 Integer.class);
 141         assertTrue(required.get(2).implementedBy(providedInt));
 142         required.get(2).setProvider(providedInt);
 143         scope.publishInterface(providedInt, 100);
 144
 145         X9 obj = new X9();
 146         assertNull(obj.getValue());
 147         assertNull(obj.getXyz());
 148         assertFalse(obj.isFlag());
 149         config.inject(scope, obj);
 150         assertEquals("hello", obj.getValue());
 151         assertEquals(100, obj.getXyz().intValue());
 152         assertTrue(obj.isFlag());
 153     }
 154
 155     /**
 156      * DOCUMENT ME!
 157      */
 158     public void testMultipleSetters() {
 159         SetterConfiguration     config   = new SetterConfiguration(X6.class)
 160             .initAllSetters();
 161         List<RequiredInterface> required = config.getRequiredInterfaces();
 162         Collections.sort(required, new RequiredInterfaceComparator());
 163         assertEquals(2, required.size());
 164         assertEquals("setHost.0", required.get(0).getName());
 165         assertEquals("setPort.0", required.get(1).getName());
 166
 167         ProvidedInterface provided0 = new DefaultProvidedInterface("janse",
 168                 String.class);
 169         required.get(0).setProvider(provided0);
 170         scope.publishInterface(provided0, "hello");
 171
 172         ProvidedInterface provided1 = new DefaultProvidedInterface("port",
 173                 Integer.class);
 174         required.get(1).setProvider(provided1);
 175         scope.publishInterface(provided1, 10);
 176
 177         X6 obj = new X6();
 178         assertNull(obj.getHost());
 179         assertNull(obj.getPort());
 180
 181         config.inject(scope, obj);
 182         assertEquals("hello", obj.getHost());
 183         assertEquals(10, obj.getPort().intValue());
 184     }
 185
 186     /**
 187      * DOCUMENT ME!
 188      */
 189     public void testInvokeWrongType() {
 190         final SetterConfiguration config   = new SetterConfiguration(X5.class)
 191             .initAllSetters();
 192         List<RequiredInterface>   required = config.getRequiredInterfaces();
 193         assertEquals(1, required.size());
 194         assertEquals("setValue.0", required.get(0).getName());
 195
 196         ProvidedInterface provided = new DefaultProvidedInterface("janse",
 197                 String.class);
 198         required.get(0).setProvider(provided);
 199         scope.publishInterface(provided, "hello");
 200
 201         final X6 obj = new X6();
 202         AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
 203                 @Override
 204                 public void run() throws Exception {
 205                     config.inject(scope, obj);
 206                 }
 207             }, IllegalArgumentException.class);
 208     }
 209
 210     /**
 211      * DOCUMENT ME!
 212      */
 213     public void testSetExplicitValue() {
 214         SetterConfiguration config = new SetterConfiguration(X5.class)
 215             .initAllSetters();
 216         config.values("setValue").setValue(0, "bladibla");
 217
 218         List<RequiredInterface> required = config.getRequiredInterfaces();
 219         assertEquals(0, required.size());
 220
 221         X5 obj = new X5();
 222         assertNull(obj.getValue());
 223         config.inject(scope, obj);
 224         assertEquals("bladibla", obj.getValue());
 225     }
 226
 227     /**
 228      * DOCUMENT ME!
 229      */
 230     public void testClear() {
 231         SetterConfiguration config = new SetterConfiguration(X6.class);
 232         config.clear();
 233
 234         List<RequiredInterface> required = config.getRequiredInterfaces();
 235         Collections.sort(required, new RequiredInterfaceComparator());
 236         assertEquals(0, required.size());
 237
 238         X6 obj = new X6();
 239         assertNull(obj.getHost());
 240         assertNull(obj.getPort());
 241
 242         config.inject(scope, obj);
 243
 244         assertNull(obj.getHost());
 245         assertNull(obj.getPort());
 246     }
 247
 248     /**
 249      * DOCUMENT ME!
 250      */
 251     public void testAddByName() {
 252         SetterConfiguration config = new SetterConfiguration(X6.class);
 253         config.clear().add("setHost");
 254
 255         List<RequiredInterface> required = config.getRequiredInterfaces();
 256         Collections.sort(required, new RequiredInterfaceComparator());
 257         assertEquals(1, required.size());
 258         assertEquals("setHost.0", required.get(0).getName());
 259
 260         ProvidedInterface provided0 = new DefaultProvidedInterface("janse",
 261                 String.class);
 262         required.get(0).setProvider(provided0);
 263         scope.publishInterface(provided0, "hello");
 264
 265         X6 obj = new X6();
 266         assertNull(obj.getHost());
 267         assertNull(obj.getPort());
 268
 269         config.inject(scope, obj);
 270         assertEquals("hello", obj.getHost());
 271         assertNull(obj.getPort());
 272     }
 273
 274     /**
 275      * DOCUMENT ME!
 276      */
 277     public void testAddByType() {
 278         SetterConfiguration config = new SetterConfiguration(X6.class);
 279         config.clear().addSetter(String.class);
 280
 281         List<RequiredInterface> required = config.getRequiredInterfaces();
 282         Collections.sort(required, new RequiredInterfaceComparator());
 283         assertEquals(1, required.size());
 284         assertEquals("setHost.0", required.get(0).getName());
 285
 286         ProvidedInterface provided0 = new DefaultProvidedInterface("janse",
 287                 String.class);
 288         required.get(0).setProvider(provided0);
 289         scope.publishInterface(provided0, "hello");
 290
 291         X6 obj = new X6();
 292         assertNull(obj.getHost());
 293         assertNull(obj.getPort());
 294
 295         config.inject(scope, obj);
 296         assertEquals("hello", obj.getHost());
 297         assertNull(obj.getPort());
 298     }
 299
 300     /**
 301      * DOCUMENT ME!
 302      */
 303     public void testAddPrivate() {
 304         X5                        obj    = new X5();
 305         final SetterConfiguration config = new SetterConfiguration(X5.class);
 306         AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
 307                 @Override
 308                 public void run() throws Exception {
 309                     config.add("xyz");
 310                 }
 311             }, IllegalArgumentException.class);
 312
 313         config.setNonPublic(true);
 314         config.clear();
 315         config.add("setXyz");
 316         assertEquals(1, config.getRequiredInterfaces().size());
 317     }
 318
 319     /**
 320      * DOCUMENT ME!
 321      */
 322     public void testAddNonExisting() {
 323         final SetterConfiguration config = new SetterConfiguration(X6.class);
 324         config.clear();
 325
 326         AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
 327                 @Override
 328                 public void run() throws Exception {
 329                     config.add("bladibla");
 330                 }
 331             }, IllegalArgumentException.class);
 332         AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
 333                 @Override
 334                 public void run() throws Exception {
 335                     config.addSetter(DataSource.class);
 336                 }
 337             }, IllegalArgumentException.class);
 338     }
 339
 340     /**
 341      * DOCUMENT ME!
 342      */
 343     public void testAddByTypeNonUnique() {
 344         final SetterConfiguration config = new SetterConfiguration(X11.class);
 345         config.clear();
 346         AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
 347                 @Override
 348                 public void run() throws Exception {
 349                     config.addSetter(String.class);
 350                 }
 351             }, IllegalArgumentException.class);
 352     }
 353
 354     /**
 355      * DOCUMENT ME!
 356      */
 357     public void testRemove() {
 358         SetterConfiguration config = new SetterConfiguration(X6.class)
 359             .initAllSetters();
 360         config.remove("setPort");
 361
 362         List<RequiredInterface> required = config.getRequiredInterfaces();
 363         Collections.sort(required, new RequiredInterfaceComparator());
 364         assertEquals(1, required.size());
 365         assertEquals("setHost.0", required.get(0).getName());
 366
 367         ProvidedInterface provided0 = new DefaultProvidedInterface("janse",
 368                 String.class);
 369         required.get(0).setProvider(provided0);
 370         scope.publishInterface(provided0, "hello");
 371
 372         X6 obj = new X6();
 373         assertNull(obj.getHost());
 374         assertNull(obj.getPort());
 375
 376         config.inject(scope, obj);
 377         assertEquals("hello", obj.getHost());
 378         assertNull(obj.getPort());
 379     }
 380
 381     /**
 382      * DOCUMENT ME!
 383      *
 384      * @throws NoSuchMethodException DOCUMENT ME!
 385      */
 386     public void testRemoveByMethodObject() throws NoSuchMethodException {
 387         SetterConfiguration config = new SetterConfiguration(X6.class)
 388             .initAllSetters();
 389         config.remove(X6.class.getMethod("setPort", Integer.class));
 390
 391         List<RequiredInterface> required = config.getRequiredInterfaces();
 392         Collections.sort(required, new RequiredInterfaceComparator());
 393         assertEquals(1, required.size());
 394         assertEquals("setHost.0", required.get(0).getName());
 395
 396         ProvidedInterface provided0 = new DefaultProvidedInterface("janse",
 397                 String.class);
 398         required.get(0).setProvider(provided0);
 399         scope.publishInterface(provided0, "hello");
 400
 401         X6 obj = new X6();
 402         assertNull(obj.getHost());
 403         assertNull(obj.getPort());
 404
 405         config.inject(scope, obj);
 406         assertEquals("hello", obj.getHost());
 407         assertNull(obj.getPort());
 408     }
 409
 410     /**
 411      * DOCUMENT ME!
 412      */
 413     public void testRemoveNonExisting() {
 414         final SetterConfiguration config = new SetterConfiguration(X6.class);
 415
 416         AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
 417                 @Override
 418                 public void run() throws Exception {
 419                     config.remove("bladibla");
 420                 }
 421             }, IllegalArgumentException.class);
 422     }
 423
 424     /**
 425      * DOCUMENT ME!
 426      */
 427     public void testOverridingSetters() {
 428         SetterConfiguration config = new SetterConfiguration(X10.class)
 429             .initAllSetters();
 430         assertEquals(2, config.getRequiredInterfaces().size());
 431
 432         List<Method> methods = config.getSetters();
 433         assertEquals(2, methods.size());
 434
 435         for (Method method : methods) {
 436             assertEquals(X10.class, method.getDeclaringClass());
 437         }
 438     }
 439 }