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