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