2 * Copyright 2008 the original author or authors.
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
16 package org.wamblee.system.adapters;
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;
24 import javax.sql.DataSource;
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;
32 public class SetterConfigurationTest extends AdapterTestCase {
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());
40 ProvidedInterface provided = new DefaultProvidedInterface("janse",
42 required.get(0).setProvider(provided);
43 provided.publish("hello", _scope);
46 assertNull(obj.getValue());
47 config.inject(_scope, obj);
48 assertEquals("hello", obj.getValue());
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>() {
58 public int compare(RequiredInterface aO1, RequiredInterface aO2) {
59 return aO1.getName().compareTo(aO2.getName());
62 assertEquals(2, required.size());
63 assertEquals("value", required.get(0).getName());
64 assertEquals("xyz", required.get(1).getName());
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);
72 ProvidedInterface providedInt = new DefaultProvidedInterface("xxx",
74 assertTrue(required.get(1).implementedBy(providedInt));
75 required.get(1).setProvider(providedInt);
76 providedInt.publish(100, _scope);
79 assertNull(obj.getValue());
80 assertNull(obj.getXyz());
81 config.inject(_scope, obj);
82 assertEquals("hello", obj.getValue());
83 assertEquals(100, obj.getXyz().intValue());
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>() {
93 public int compare(RequiredInterface aO1, RequiredInterface aO2) {
94 return aO1.getName().compareTo(aO2.getName());
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());
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);
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);
114 ProvidedInterface providedInt = new DefaultProvidedInterface("xxx",
116 assertTrue(required.get(2).implementedBy(providedInt));
117 required.get(2).setProvider(providedInt);
118 providedInt.publish(100, _scope);
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());
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());
138 ProvidedInterface provided0 = new DefaultProvidedInterface("janse",
140 required.get(0).setProvider(provided0);
141 provided0.publish("hello", _scope);
143 ProvidedInterface provided1 = new DefaultProvidedInterface("port",
145 required.get(1).setProvider(provided1);
146 provided1.publish(10, _scope);
149 assertNull(obj.getHost());
150 assertNull(obj.getPort());
152 config.inject(_scope, obj);
153 assertEquals("hello", obj.getHost());
154 assertEquals(10, obj.getPort().intValue());
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());
163 ProvidedInterface provided = new DefaultProvidedInterface("janse",
165 required.get(0).setProvider(provided);
166 provided.publish("hello", _scope);
168 final X6 obj = new X6();
169 AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
171 public void run() throws Exception {
172 config.inject(_scope, obj);
174 }, IllegalArgumentException.class);
177 public void testSetExplicitValue() {
178 SetterConfiguration config = new SetterConfiguration(X5.class);
179 config.values("value").setValue(0, "bladibla");
181 List<RequiredInterface> required = config.getRequiredInterfaces();
182 assertEquals(0, required.size());
185 assertNull(obj.getValue());
186 config.inject(_scope, obj);
187 assertEquals("bladibla", obj.getValue());
190 public void testClear() {
191 SetterConfiguration config = new SetterConfiguration(X6.class);
193 List<RequiredInterface> required = config.getRequiredInterfaces();
194 Collections.sort(required, new RequiredInterfaceComparator());
195 assertEquals(0, required.size());
198 assertNull(obj.getHost());
199 assertNull(obj.getPort());
201 config.inject(_scope, obj);
203 assertNull(obj.getHost());
204 assertNull(obj.getPort());
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());
215 ProvidedInterface provided0 = new DefaultProvidedInterface("janse",
217 required.get(0).setProvider(provided0);
218 provided0.publish("hello", _scope);
221 assertNull(obj.getHost());
222 assertNull(obj.getPort());
224 config.inject(_scope, obj);
225 assertEquals("hello", obj.getHost());
226 assertNull(obj.getPort());
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());
237 ProvidedInterface provided0 = new DefaultProvidedInterface("janse",
239 required.get(0).setProvider(provided0);
240 provided0.publish("hello", _scope);
243 assertNull(obj.getHost());
244 assertNull(obj.getPort());
246 config.inject(_scope, obj);
247 assertEquals("hello", obj.getHost());
248 assertNull(obj.getPort());
251 public void testAddPrivate() {
253 final SetterConfiguration config = new SetterConfiguration(X5.class);
254 AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
256 public void run() throws Exception {
259 }, IllegalArgumentException.class);
261 config.setNonPublic(true);
264 assertEquals(1, config.getRequiredInterfaces().size());
267 public void testAddNonExisting() {
268 final SetterConfiguration config = new SetterConfiguration(X6.class);
271 AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
273 public void run() throws Exception {
274 config.add("bladibla");
276 }, IllegalArgumentException.class);
277 AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
279 public void run() throws Exception {
280 config.add(DataSource.class);
282 }, IllegalArgumentException.class);
285 public void testAddByTypeNonUnique() {
286 final SetterConfiguration config = new SetterConfiguration(X11.class);
288 AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
290 public void run() throws Exception {
291 config.add(String.class);
293 }, IllegalArgumentException.class);
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());
304 ProvidedInterface provided0 = new DefaultProvidedInterface("janse",
306 required.get(0).setProvider(provided0);
307 provided0.publish("hello", _scope);
310 assertNull(obj.getHost());
311 assertNull(obj.getPort());
313 config.inject(_scope, obj);
314 assertEquals("hello", obj.getHost());
315 assertNull(obj.getPort());
318 public void testRemoveNonExisting() {
319 final SetterConfiguration config = new SetterConfiguration(X6.class);
321 AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
323 public void run() throws Exception {
324 config.remove("bladibla");
326 }, IllegalArgumentException.class);
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());