2 * Copyright 2005-2010 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.system.core.Scope;
31 import org.wamblee.test.AssertionUtils;
38 public class SetterConfigurationTest extends AdapterTestCase {
39 public void testOneSetter() {
40 SetterConfiguration config = new SetterConfiguration(X5.class);
41 config.initAllSetters();
43 List<RequiredInterface> required = config.getRequiredInterfaces();
44 assertEquals(1, required.size());
45 assertEquals("setValue.0", required.get(0).getName());
47 ProvidedInterface provided = new DefaultProvidedInterface("janse",
49 required.get(0).setProvider(provided);
50 Scope scope = getScope();
51 scope.publishInterface(provided, "hello");
54 assertNull(obj.getValue());
55 config.inject(scope, obj);
56 assertEquals("hello", obj.getValue());
59 public void testPrivateSetter() {
60 SetterConfiguration config = new SetterConfiguration(X5.class);
61 config.setNonPublic(true);
62 config.initAllSetters();
64 List<RequiredInterface> required = new ArrayList<RequiredInterface>(
65 config.getRequiredInterfaces());
66 Collections.sort(required, new Comparator<RequiredInterface>() {
68 public int compare(RequiredInterface aO1, RequiredInterface aO2) {
69 return aO1.getName().compareTo(aO2.getName());
72 assertEquals(2, required.size());
73 assertEquals("setValue.0", required.get(0).getName());
74 assertEquals("setXyz.0", required.get(1).getName());
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");
83 ProvidedInterface providedInt = new DefaultProvidedInterface("xxx",
85 assertTrue(required.get(1).implementedBy(providedInt));
86 required.get(1).setProvider(providedInt);
87 scope.publishInterface(providedInt, 100);
90 assertNull(obj.getValue());
91 assertNull(obj.getXyz());
92 config.inject(scope, obj);
93 assertEquals("hello", obj.getValue());
94 assertEquals(100, obj.getXyz().intValue());
97 public void testInheritance() {
98 SetterConfiguration config = new SetterConfiguration(X9.class);
99 config.setNonPublic(true);
100 config.initAllSetters();
102 List<RequiredInterface> required = new ArrayList<RequiredInterface>(
103 config.getRequiredInterfaces());
104 Collections.sort(required, new Comparator<RequiredInterface>() {
106 public int compare(RequiredInterface aO1, RequiredInterface aO2) {
107 return aO1.getName().compareTo(aO2.getName());
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());
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);
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");
128 ProvidedInterface providedInt = new DefaultProvidedInterface("xxx",
130 assertTrue(required.get(2).implementedBy(providedInt));
131 required.get(2).setProvider(providedInt);
132 scope.publishInterface(providedInt, 100);
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());
144 public void testMultipleSetters() {
145 SetterConfiguration config = new SetterConfiguration(X6.class)
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());
153 ProvidedInterface provided0 = new DefaultProvidedInterface("janse",
155 required.get(0).setProvider(provided0);
156 Scope scope = getScope();
157 scope.publishInterface(provided0, "hello");
159 ProvidedInterface provided1 = new DefaultProvidedInterface("port",
161 required.get(1).setProvider(provided1);
162 scope.publishInterface(provided1, 10);
165 assertNull(obj.getHost());
166 assertNull(obj.getPort());
168 config.inject(scope, obj);
169 assertEquals("hello", obj.getHost());
170 assertEquals(10, obj.getPort().intValue());
173 public void testInvokeWrongType() {
174 final SetterConfiguration config = new SetterConfiguration(X5.class)
176 List<RequiredInterface> required = config.getRequiredInterfaces();
177 assertEquals(1, required.size());
178 assertEquals("setValue.0", required.get(0).getName());
180 ProvidedInterface provided = new DefaultProvidedInterface("janse",
182 required.get(0).setProvider(provided);
183 final Scope scope = getScope();
184 scope.publishInterface(provided, "hello");
186 final X6 obj = new X6();
187 AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
189 public void run() throws Exception {
190 config.inject(scope, obj);
192 }, IllegalArgumentException.class);
195 public void testSetExplicitValue() {
196 SetterConfiguration config = new SetterConfiguration(X5.class)
198 config.values("setValue").setValue(0, "bladibla");
200 List<RequiredInterface> required = config.getRequiredInterfaces();
201 assertEquals(0, required.size());
204 assertNull(obj.getValue());
205 Scope scope = getScope();
206 config.inject(scope, obj);
207 assertEquals("bladibla", obj.getValue());
210 public void testClear() {
211 SetterConfiguration config = new SetterConfiguration(X6.class);
214 List<RequiredInterface> required = config.getRequiredInterfaces();
215 Collections.sort(required, new RequiredInterfaceComparator());
216 assertEquals(0, required.size());
219 assertNull(obj.getHost());
220 assertNull(obj.getPort());
222 Scope scope = getScope();
223 config.inject(scope, obj);
225 assertNull(obj.getHost());
226 assertNull(obj.getPort());
229 public void testAddByName() {
230 SetterConfiguration config = new SetterConfiguration(X6.class);
231 config.clear().add("setHost");
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());
238 ProvidedInterface provided0 = new DefaultProvidedInterface("janse",
240 required.get(0).setProvider(provided0);
241 Scope scope = getScope();
242 scope.publishInterface(provided0, "hello");
245 assertNull(obj.getHost());
246 assertNull(obj.getPort());
248 config.inject(scope, obj);
249 assertEquals("hello", obj.getHost());
250 assertNull(obj.getPort());
253 public void testAddByType() {
254 SetterConfiguration config = new SetterConfiguration(X6.class);
255 config.clear().addSetter(String.class);
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());
262 ProvidedInterface provided0 = new DefaultProvidedInterface("janse",
264 required.get(0).setProvider(provided0);
265 Scope scope = getScope();
266 scope.publishInterface(provided0, "hello");
269 assertNull(obj.getHost());
270 assertNull(obj.getPort());
272 config.inject(scope, obj);
273 assertEquals("hello", obj.getHost());
274 assertNull(obj.getPort());
277 public void testAddPrivate() {
279 final SetterConfiguration config = new SetterConfiguration(X5.class);
280 AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
282 public void run() throws Exception {
285 }, IllegalArgumentException.class);
287 config.setNonPublic(true);
289 config.add("setXyz");
290 assertEquals(1, config.getRequiredInterfaces().size());
293 public void testAddNonExisting() {
294 final SetterConfiguration config = new SetterConfiguration(X6.class);
297 AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
299 public void run() throws Exception {
300 config.add("bladibla");
302 }, IllegalArgumentException.class);
303 AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
305 public void run() throws Exception {
306 config.addSetter(DataSource.class);
308 }, IllegalArgumentException.class);
311 public void testAddByTypeNonUnique() {
312 final SetterConfiguration config = new SetterConfiguration(X11.class);
314 AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
316 public void run() throws Exception {
317 config.addSetter(String.class);
319 }, IllegalArgumentException.class);
322 public void testRemove() {
323 SetterConfiguration config = new SetterConfiguration(X6.class)
325 config.remove("setPort");
327 List<RequiredInterface> required = config.getRequiredInterfaces();
328 Collections.sort(required, new RequiredInterfaceComparator());
329 assertEquals(1, required.size());
330 assertEquals("setHost.0", required.get(0).getName());
332 ProvidedInterface provided0 = new DefaultProvidedInterface("janse",
334 required.get(0).setProvider(provided0);
335 Scope scope = getScope();
336 scope.publishInterface(provided0, "hello");
339 assertNull(obj.getHost());
340 assertNull(obj.getPort());
342 config.inject(scope, obj);
343 assertEquals("hello", obj.getHost());
344 assertNull(obj.getPort());
347 public void testRemoveByMethodObject() throws NoSuchMethodException {
348 SetterConfiguration config = new SetterConfiguration(X6.class)
350 config.remove(X6.class.getMethod("setPort", Integer.class));
352 List<RequiredInterface> required = config.getRequiredInterfaces();
353 Collections.sort(required, new RequiredInterfaceComparator());
354 assertEquals(1, required.size());
355 assertEquals("setHost.0", required.get(0).getName());
357 ProvidedInterface provided0 = new DefaultProvidedInterface("janse",
359 required.get(0).setProvider(provided0);
360 Scope scope = getScope();
361 scope.publishInterface(provided0, "hello");
364 assertNull(obj.getHost());
365 assertNull(obj.getPort());
367 config.inject(scope, obj);
368 assertEquals("hello", obj.getHost());
369 assertNull(obj.getPort());
372 public void testRemoveNonExisting() {
373 final SetterConfiguration config = new SetterConfiguration(X6.class);
375 AssertionUtils.assertException(new AssertionUtils.ErroneousCode() {
377 public void run() throws Exception {
378 config.remove("bladibla");
380 }, IllegalArgumentException.class);
383 public void testOverridingSetters() {
384 SetterConfiguration config = new SetterConfiguration(X10.class)
386 assertEquals(2, config.getRequiredInterfaces().size());
388 List<Method> methods = config.getSetters();
389 assertEquals(2, methods.size());
391 for (Method method : methods) {
392 assertEquals(X10.class, method.getDeclaringClass());