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.util.ArrayList;
  19 import java.util.Collections;
  20 import java.util.Comparator;
  21 import java.util.List;
  22
  23 import org.wamblee.system.core.DefaultProvidedInterface;
  24 import org.wamblee.system.core.ProvidedInterface;
  25 import org.wamblee.system.core.RequiredInterface;
  26 import org.wamblee.system.core.RequiredInterfaceComparator;
  27 import org.wamblee.test.AssertionUtils;
  28
  29 public class SetterConfigurationTest extends AdapterTestCase {
  30
  31         public void testOneSetter() {
  32                 SetterConfiguration config = new SetterConfiguration(X5.class);
  33                 List<RequiredInterface> required = config.getRequiredInterfaces();
  34                 assertEquals(1, required.size());
  35                 assertEquals("value", required.get(0).getName());
  36
  37                 ProvidedInterface provided = new DefaultProvidedInterface("janse",
  38                                 String.class);
  39                 required.get(0).setProvider(provided);
  40                 provided.publish("hello", _scope);
  41
  42                 X5 obj = new X5();
  43                 assertNull(obj.getValue());
  44                 config.inject(_scope, obj);
  45                 assertEquals("hello", obj.getValue());
  46         }
  47
  48         public void testPrivateSetter() {
  49                 SetterConfiguration config = new SetterConfiguration(X5.class);
  50                 config.setNonPublic(true);
  51                 List<RequiredInterface> required = new ArrayList<RequiredInterface>(
  52                                 config.getRequiredInterfaces());
  53                 Collections.sort(required, new Comparator<RequiredInterface>() {
  54                         @Override
  55                         public int compare(RequiredInterface aO1, RequiredInterface aO2) {
  56                                 return aO1.getName().compareTo(aO2.getName());
  57                         }
  58                 });
  59                 assertEquals(2, required.size());
  60                 assertEquals("value", required.get(0).getName());
  61                 assertEquals("xyz", required.get(1).getName());
  62
  63                 ProvidedInterface providedString = new DefaultProvidedInterface(
  64                                 "janse", String.class);
  65                 assertTrue(required.get(0).implementedBy(providedString));
  66                 required.get(0).setProvider(providedString);
  67                 providedString.publish("hello", _scope);
  68
  69                 ProvidedInterface providedInt = new DefaultProvidedInterface("xxx",
  70                                 Integer.class);
  71                 assertTrue(required.get(1).implementedBy(providedInt));
  72                 required.get(1).setProvider(providedInt);
  73                 providedInt.publish(100, _scope);
  74
  75                 X5 obj = new X5();
  76                 assertNull(obj.getValue());
  77                 assertNull(obj.getXyz());
  78                 config.inject(_scope, obj);
  79                 assertEquals("hello", obj.getValue());
  80                 assertEquals(100, obj.getXyz().intValue());
  81         }
  82
  83         public void testInheritance() {
  84                 SetterConfiguration config = new SetterConfiguration(X9.class);
  85                 config.setNonPublic(true);
  86                 List<RequiredInterface> required = new ArrayList<RequiredInterface>(
  87                                 config.getRequiredInterfaces());
  88                 Collections.sort(required, new Comparator<RequiredInterface>() {
  89                         @Override
  90                         public int compare(RequiredInterface aO1, RequiredInterface aO2) {
  91                                 return aO1.getName().compareTo(aO2.getName());
  92                         }
  93                 });
  94                 assertEquals(3, required.size());
  95                 assertEquals("flag", required.get(0).getName());
  96                 assertEquals("value", required.get(1).getName());
  97                 assertEquals("xyz", required.get(2).getName());
  98
  99                 ProvidedInterface providedBoolean = new DefaultProvidedInterface(
 100                                 "janse", Boolean.class);
 101                 assertTrue(required.get(0).implementedBy(providedBoolean));
 102                 required.get(0).setProvider(providedBoolean);
 103                 providedBoolean.publish(true, _scope);
 104
 105                 ProvidedInterface providedString = new DefaultProvidedInterface(
 106                                 "janse", String.class);
 107                 assertTrue(required.get(1).implementedBy(providedString));
 108                 required.get(1).setProvider(providedString);
 109                 providedString.publish("hello", _scope);
 110
 111                 ProvidedInterface providedInt = new DefaultProvidedInterface("xxx",
 112                                 Integer.class);
 113                 assertTrue(required.get(2).implementedBy(providedInt));
 114                 required.get(2).setProvider(providedInt);
 115                 providedInt.publish(100, _scope);
 116
 117                 X9 obj = new X9();
 118                 assertNull(obj.getValue());
 119                 assertNull(obj.getXyz());
 120                 assertFalse(obj.isFlag());
 121                 config.inject(_scope, obj);
 122                 assertEquals("hello", obj.getValue());
 123                 assertEquals(100, obj.getXyz().intValue());
 124                 assertTrue(obj.isFlag());
 125         }
 126
 127         public void testMultipleSetters() {
 128                 SetterConfiguration config = new SetterConfiguration(X6.class);
 129                 List<RequiredInterface> required = config.getRequiredInterfaces();
 130                 Collections.sort(required, new RequiredInterfaceComparator());
 131                 assertEquals(2, required.size());
 132                 assertEquals("host", required.get(0).getName());
 133                 assertEquals("port", required.get(1).getName());
 134
 135                 ProvidedInterface provided0 = new DefaultProvidedInterface("janse",
 136                                 String.class);
 137                 required.get(0).setProvider(provided0);
 138                 provided0.publish("hello", _scope);
 139
 140                 ProvidedInterface provided1 = new DefaultProvidedInterface("port",
 141                                 Integer.class);
 142                 required.get(1).setProvider(provided1);
 143                 provided1.publish(10, _scope);
 144
 145                 X6 obj = new X6();
 146                 assertNull(obj.getHost());
 147                 assertNull(obj.getPort());
 148
 149                 config.inject(_scope, obj);
 150                 assertEquals("hello", obj.getHost());
 151                 assertEquals(10, obj.getPort().intValue());
 152         }
 153
 154         public void testInvokeWrongType() {
 155                 final SetterConfiguration config = new SetterConfiguration(X5.class);
 156                 List<RequiredInterface> required = config.getRequiredInterfaces();
 157                 assertEquals(1, required.size());
 158                 assertEquals("value", required.get(0).getName());
 159
 160                 ProvidedInterface provided = new DefaultProvidedInterface("janse",
 161                                 String.class);
 162                 required.get(0).setProvider(provided);
 163                 provided.publish("hello", _scope);
 164
 165                 final X6 obj = new X6();
 166                 AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
 167                         @Override
 168                         public void run() throws Exception {
 169                                 config.inject(_scope, obj);
 170                         }
 171                 }, IllegalArgumentException.class);
 172         }
 173
 174         public void testSetExplicitValue() {
 175                 SetterConfiguration config = new SetterConfiguration(X5.class);
 176                 config.values("value").setValue(0, "bladibla");
 177
 178                 List<RequiredInterface> required = config.getRequiredInterfaces();
 179                 assertEquals(0, required.size());
 180
 181                 X5 obj = new X5();
 182                 assertNull(obj.getValue());
 183                 config.inject(_scope, obj);
 184                 assertEquals("bladibla", obj.getValue());
 185         }
 186
 187         public void testClear() {
 188                 SetterConfiguration config = new SetterConfiguration(X6.class);
 189                 config.clear();
 190                 List<RequiredInterface> required = config.getRequiredInterfaces();
 191                 Collections.sort(required, new RequiredInterfaceComparator());
 192                 assertEquals(0, required.size());
 193
 194                 X6 obj = new X6();
 195                 assertNull(obj.getHost());
 196                 assertNull(obj.getPort());
 197
 198                 config.inject(_scope, obj);
 199
 200                 assertNull(obj.getHost());
 201                 assertNull(obj.getPort());
 202         }
 203
 204         public void testAdd() {
 205                 SetterConfiguration config = new SetterConfiguration(X6.class);
 206                 config.clear().add("host");
 207                 List<RequiredInterface> required = config.getRequiredInterfaces();
 208                 Collections.sort(required, new RequiredInterfaceComparator());
 209                 assertEquals(1, required.size());
 210                 assertEquals("host", required.get(0).getName());
 211
 212                 ProvidedInterface provided0 = new DefaultProvidedInterface("janse",
 213                                 String.class);
 214                 required.get(0).setProvider(provided0);
 215                 provided0.publish("hello", _scope);
 216
 217                 X6 obj = new X6();
 218                 assertNull(obj.getHost());
 219                 assertNull(obj.getPort());
 220
 221                 config.inject(_scope, obj);
 222                 assertEquals("hello", obj.getHost());
 223                 assertNull(obj.getPort());
 224         }
 225
 226         public void testAddNonExisting() {
 227                 final SetterConfiguration config = new SetterConfiguration(X6.class);
 228                 config.clear();
 229
 230                 AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
 231                         @Override
 232                         public void run() throws Exception {
 233                                 config.add("bladibla");
 234                         }
 235                 }, IllegalArgumentException.class);
 236         }
 237
 238         public void testRemove() {
 239                 SetterConfiguration config = new SetterConfiguration(X6.class);
 240                 config.remove("port");
 241                 List<RequiredInterface> required = config.getRequiredInterfaces();
 242                 Collections.sort(required, new RequiredInterfaceComparator());
 243                 assertEquals(1, required.size());
 244                 assertEquals("host", required.get(0).getName());
 245
 246                 ProvidedInterface provided0 = new DefaultProvidedInterface("janse",
 247                                 String.class);
 248                 required.get(0).setProvider(provided0);
 249                 provided0.publish("hello", _scope);
 250
 251                 X6 obj = new X6();
 252                 assertNull(obj.getHost());
 253                 assertNull(obj.getPort());
 254
 255                 config.inject(_scope, obj);
 256                 assertEquals("hello", obj.getHost());
 257                 assertNull(obj.getPort());
 258         }
 259
 260         public void testRemoveNonExisting() {
 261                 final SetterConfiguration config = new SetterConfiguration(X6.class);
 262
 263                 AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
 264                         @Override
 265                         public void run() throws Exception {
 266                                 config.remove("bladibla");
 267                         }
 268                 }, IllegalArgumentException.class);
 269         }
 270 }