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

   1 /*
   2  * Copyright 2005-2010 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 java.lang.reflect.Method;
  19 import java.util.ArrayList;
  20 import java.util.Collections;
  21 import java.util.Comparator;
  22 import java.util.List;
  23
  24 import javax.sql.DataSource;
  25
  26 import org.wamblee.system.core.DefaultProvidedInterface;
  27 import org.wamblee.system.core.ProvidedInterface;
  28 import org.wamblee.system.core.RequiredInterface;
  29 import org.wamblee.system.core.RequiredInterfaceComparator;
  30 import org.wamblee.system.core.Scope;
  31 import org.wamblee.test.AssertionUtils;
  32
  33 /**
  34  *
  35  * @author $author$
  36  * @version $Revision$
  37  */
  38 public class SetterConfigurationTest extends AdapterTestCase {
  39     public void testOneSetter() {
  40         SetterConfiguration config = new SetterConfiguration(X5.class);
  41         config.initAllSetters();
  42
  43         List<RequiredInterface> required = config.getRequiredInterfaces();
  44         assertEquals(1, required.size());
  45         assertEquals("setValue.0", required.get(0).getName());
  46
  47         ProvidedInterface provided = new DefaultProvidedInterface("janse",
  48             String.class);
  49         required.get(0).setProvider(provided);
  50         Scope scope = getScope();
  51         scope.publishInterface(provided, "hello");
  52
  53         X5 obj = new X5();
  54         assertNull(obj.getValue());
  55         config.inject(scope, obj);
  56         assertEquals("hello", obj.getValue());
  57     }
  58
  59     public void testPrivateSetter() {
  60         SetterConfiguration config = new SetterConfiguration(X5.class);
  61         config.setNonPublic(true);
  62         config.initAllSetters();
  63
  64         List<RequiredInterface> required = new ArrayList<RequiredInterface>(
  65             config.getRequiredInterfaces());
  66         Collections.sort(required, new Comparator<RequiredInterface>() {
  67             @Override
  68             public int compare(RequiredInterface aO1, RequiredInterface aO2) {
  69                 return aO1.getName().compareTo(aO2.getName());
  70             }
  71         });
  72         assertEquals(2, required.size());
  73         assertEquals("setValue.0", required.get(0).getName());
  74         assertEquals("setXyz.0", required.get(1).getName());
  75
  76         ProvidedInterface providedString = new DefaultProvidedInterface(
  77             "janse", String.class);
  78         assertTrue(required.get(0).implementedBy(providedString));
  79         required.get(0).setProvider(providedString);
  80         Scope scope = getScope();
  81         scope.publishInterface(providedString, "hello");
  82
  83         ProvidedInterface providedInt = new DefaultProvidedInterface("xxx",
  84             Integer.class);
  85         assertTrue(required.get(1).implementedBy(providedInt));
  86         required.get(1).setProvider(providedInt);
  87         scope.publishInterface(providedInt, 100);
  88
  89         X5 obj = new X5();
  90         assertNull(obj.getValue());
  91         assertNull(obj.getXyz());
  92         config.inject(scope, obj);
  93         assertEquals("hello", obj.getValue());
  94         assertEquals(100, obj.getXyz().intValue());
  95     }
  96
  97     public void testInheritance() {
  98         SetterConfiguration config = new SetterConfiguration(X9.class);
  99         config.setNonPublic(true);
 100         config.initAllSetters();
 101
 102         List<RequiredInterface> required = new ArrayList<RequiredInterface>(
 103             config.getRequiredInterfaces());
 104         Collections.sort(required, new Comparator<RequiredInterface>() {
 105             @Override
 106             public int compare(RequiredInterface aO1, RequiredInterface aO2) {
 107                 return aO1.getName().compareTo(aO2.getName());
 108             }
 109         });
 110         assertEquals(3, required.size());
 111         assertEquals("setFlag.0", required.get(0).getName());
 112         assertEquals("setValue.0", required.get(1).getName());
 113         assertEquals("setXyz.0", required.get(2).getName());
 114
 115         ProvidedInterface providedBoolean = new DefaultProvidedInterface(
 116             "janse", Boolean.class);
 117         assertTrue(required.get(0).implementedBy(providedBoolean));
 118         required.get(0).setProvider(providedBoolean);
 119         Scope scope = getScope();
 120         scope.publishInterface(providedBoolean, true);
 121
 122         ProvidedInterface providedString = new DefaultProvidedInterface(
 123             "janse", String.class);
 124         assertTrue(required.get(1).implementedBy(providedString));
 125         required.get(1).setProvider(providedString);
 126         scope.publishInterface(providedString, "hello");
 127
 128         ProvidedInterface providedInt = new DefaultProvidedInterface("xxx",
 129             Integer.class);
 130         assertTrue(required.get(2).implementedBy(providedInt));
 131         required.get(2).setProvider(providedInt);
 132         scope.publishInterface(providedInt, 100);
 133
 134         X9 obj = new X9();
 135         assertNull(obj.getValue());
 136         assertNull(obj.getXyz());
 137         assertFalse(obj.isFlag());
 138         config.inject(scope, obj);
 139         assertEquals("hello", obj.getValue());
 140         assertEquals(100, obj.getXyz().intValue());
 141         assertTrue(obj.isFlag());
 142     }
 143
 144     public void testMultipleSetters() {
 145         SetterConfiguration config = new SetterConfiguration(X6.class)
 146             .initAllSetters();
 147         List<RequiredInterface> required = config.getRequiredInterfaces();
 148         Collections.sort(required, new RequiredInterfaceComparator());
 149         assertEquals(2, required.size());
 150         assertEquals("setHost.0", required.get(0).getName());
 151         assertEquals("setPort.0", required.get(1).getName());
 152
 153         ProvidedInterface provided0 = new DefaultProvidedInterface("janse",
 154             String.class);
 155         required.get(0).setProvider(provided0);
 156         Scope scope = getScope();
 157         scope.publishInterface(provided0, "hello");
 158
 159         ProvidedInterface provided1 = new DefaultProvidedInterface("port",
 160             Integer.class);
 161         required.get(1).setProvider(provided1);
 162         scope.publishInterface(provided1, 10);
 163
 164         X6 obj = new X6();
 165         assertNull(obj.getHost());
 166         assertNull(obj.getPort());
 167
 168         config.inject(scope, obj);
 169         assertEquals("hello", obj.getHost());
 170         assertEquals(10, obj.getPort().intValue());
 171     }
 172
 173     public void testInvokeWrongType() {
 174         final SetterConfiguration config = new SetterConfiguration(X5.class)
 175             .initAllSetters();
 176         List<RequiredInterface> required = config.getRequiredInterfaces();
 177         assertEquals(1, required.size());
 178         assertEquals("setValue.0", required.get(0).getName());
 179
 180         ProvidedInterface provided = new DefaultProvidedInterface("janse",
 181             String.class);
 182         required.get(0).setProvider(provided);
 183         final Scope scope = getScope();
 184         scope.publishInterface(provided, "hello");
 185
 186         final X6 obj = new X6();
 187         AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
 188             @Override
 189             public void run() throws Exception {
 190                 config.inject(scope, obj);
 191             }
 192         }, IllegalArgumentException.class);
 193     }
 194
 195     public void testSetExplicitValue() {
 196         SetterConfiguration config = new SetterConfiguration(X5.class)
 197             .initAllSetters();
 198         config.values("setValue").setValue(0, "bladibla");
 199
 200         List<RequiredInterface> required = config.getRequiredInterfaces();
 201         assertEquals(0, required.size());
 202
 203         X5 obj = new X5();
 204         assertNull(obj.getValue());
 205         Scope scope = getScope();
 206         config.inject(scope, obj);
 207         assertEquals("bladibla", obj.getValue());
 208     }
 209
 210     public void testClear() {
 211         SetterConfiguration config = new SetterConfiguration(X6.class);
 212         config.clear();
 213
 214         List<RequiredInterface> required = config.getRequiredInterfaces();
 215         Collections.sort(required, new RequiredInterfaceComparator());
 216         assertEquals(0, required.size());
 217
 218         X6 obj = new X6();
 219         assertNull(obj.getHost());
 220         assertNull(obj.getPort());
 221
 222         Scope scope = getScope();
 223         config.inject(scope, obj);
 224
 225         assertNull(obj.getHost());
 226         assertNull(obj.getPort());
 227     }
 228
 229     public void testAddByName() {
 230         SetterConfiguration config = new SetterConfiguration(X6.class);
 231         config.clear().add("setHost");
 232
 233         List<RequiredInterface> required = config.getRequiredInterfaces();
 234         Collections.sort(required, new RequiredInterfaceComparator());
 235         assertEquals(1, required.size());
 236         assertEquals("setHost.0", required.get(0).getName());
 237
 238         ProvidedInterface provided0 = new DefaultProvidedInterface("janse",
 239             String.class);
 240         required.get(0).setProvider(provided0);
 241         Scope scope = getScope();
 242         scope.publishInterface(provided0, "hello");
 243
 244         X6 obj = new X6();
 245         assertNull(obj.getHost());
 246         assertNull(obj.getPort());
 247
 248         config.inject(scope, obj);
 249         assertEquals("hello", obj.getHost());
 250         assertNull(obj.getPort());
 251     }
 252
 253     public void testAddByType() {
 254         SetterConfiguration config = new SetterConfiguration(X6.class);
 255         config.clear().addSetter(String.class);
 256
 257         List<RequiredInterface> required = config.getRequiredInterfaces();
 258         Collections.sort(required, new RequiredInterfaceComparator());
 259         assertEquals(1, required.size());
 260         assertEquals("setHost.0", required.get(0).getName());
 261
 262         ProvidedInterface provided0 = new DefaultProvidedInterface("janse",
 263             String.class);
 264         required.get(0).setProvider(provided0);
 265         Scope scope = getScope();
 266         scope.publishInterface(provided0, "hello");
 267
 268         X6 obj = new X6();
 269         assertNull(obj.getHost());
 270         assertNull(obj.getPort());
 271
 272         config.inject(scope, obj);
 273         assertEquals("hello", obj.getHost());
 274         assertNull(obj.getPort());
 275     }
 276
 277     public void testAddPrivate() {
 278         final SetterConfiguration config = new SetterConfiguration(X5.class);
 279         AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
 280             @Override
 281             public void run() throws Exception {
 282                 config.add("xyz");
 283             }
 284         }, IllegalArgumentException.class);
 285
 286         config.setNonPublic(true);
 287         config.clear();
 288         config.add("setXyz");
 289         assertEquals(1, config.getRequiredInterfaces().size());
 290     }
 291
 292     public void testAddNonExisting() {
 293         final SetterConfiguration config = new SetterConfiguration(X6.class);
 294         config.clear();
 295
 296         AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
 297             @Override
 298             public void run() throws Exception {
 299                 config.add("bladibla");
 300             }
 301         }, IllegalArgumentException.class);
 302         AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
 303             @Override
 304             public void run() throws Exception {
 305                 config.addSetter(DataSource.class);
 306             }
 307         }, IllegalArgumentException.class);
 308     }
 309
 310     public void testAddByTypeNonUnique() {
 311         final SetterConfiguration config = new SetterConfiguration(X11.class);
 312         config.clear();
 313         AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
 314             @Override
 315             public void run() throws Exception {
 316                 config.addSetter(String.class);
 317             }
 318         }, IllegalArgumentException.class);
 319     }
 320
 321     public void testRemove() {
 322         SetterConfiguration config = new SetterConfiguration(X6.class)
 323             .initAllSetters();
 324         config.remove("setPort");
 325
 326         List<RequiredInterface> required = config.getRequiredInterfaces();
 327         Collections.sort(required, new RequiredInterfaceComparator());
 328         assertEquals(1, required.size());
 329         assertEquals("setHost.0", required.get(0).getName());
 330
 331         ProvidedInterface provided0 = new DefaultProvidedInterface("janse",
 332             String.class);
 333         required.get(0).setProvider(provided0);
 334         Scope scope = getScope();
 335         scope.publishInterface(provided0, "hello");
 336
 337         X6 obj = new X6();
 338         assertNull(obj.getHost());
 339         assertNull(obj.getPort());
 340
 341         config.inject(scope, obj);
 342         assertEquals("hello", obj.getHost());
 343         assertNull(obj.getPort());
 344     }
 345
 346     public void testRemoveByMethodObject() throws NoSuchMethodException {
 347         SetterConfiguration config = new SetterConfiguration(X6.class)
 348             .initAllSetters();
 349         config.remove(X6.class.getMethod("setPort", Integer.class));
 350
 351         List<RequiredInterface> required = config.getRequiredInterfaces();
 352         Collections.sort(required, new RequiredInterfaceComparator());
 353         assertEquals(1, required.size());
 354         assertEquals("setHost.0", required.get(0).getName());
 355
 356         ProvidedInterface provided0 = new DefaultProvidedInterface("janse",
 357             String.class);
 358         required.get(0).setProvider(provided0);
 359         Scope scope = getScope();
 360         scope.publishInterface(provided0, "hello");
 361
 362         X6 obj = new X6();
 363         assertNull(obj.getHost());
 364         assertNull(obj.getPort());
 365
 366         config.inject(scope, obj);
 367         assertEquals("hello", obj.getHost());
 368         assertNull(obj.getPort());
 369     }
 370
 371     public void testRemoveNonExisting() {
 372         final SetterConfiguration config = new SetterConfiguration(X6.class);
 373
 374         AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
 375             @Override
 376             public void run() throws Exception {
 377                 config.remove("bladibla");
 378             }
 379         }, IllegalArgumentException.class);
 380     }
 381
 382     public void testOverridingSetters() {
 383         SetterConfiguration config = new SetterConfiguration(X10.class)
 384             .initAllSetters();
 385         assertEquals(2, config.getRequiredInterfaces().size());
 386
 387         List<Method> methods = config.getSetters();
 388         assertEquals(2, methods.size());
 389
 390         for (Method method : methods) {
 391             assertEquals(X10.class, method.getDeclaringClass());
 392         }
 393     }
 394 }