1
2
3
4
5
6
7
8
9
10
11 package org.mule.api.annotations.param;
12
13 import org.mule.api.MuleMessage;
14 import org.mule.api.config.MuleProperties;
15 import org.mule.api.expression.RequiredValueException;
16 import org.mule.module.client.MuleClient;
17 import org.mule.tck.FunctionalTestCase;
18 import org.mule.tck.testmodels.fruit.Apple;
19 import org.mule.tck.testmodels.fruit.Banana;
20 import org.mule.tck.testmodels.fruit.Orange;
21
22 import java.util.HashMap;
23 import java.util.Iterator;
24 import java.util.List;
25 import java.util.Map;
26 import java.util.Set;
27
28 public class InboundHeadersAnnotationTestCase extends FunctionalTestCase
29 {
30 private Map<String, Object> props;
31
32 public InboundHeadersAnnotationTestCase()
33 {
34 setDisposeManagerPerSuite(true);
35 }
36
37 @Override
38 protected String getConfigResources()
39 {
40 return "org/mule/test/annotations/inbound-headers-annotation.xml";
41 }
42
43 @Override
44 public void doSetUp() throws Exception
45 {
46 super.doSetUp();
47
48 props = new HashMap<String, Object>(3);
49 props.put("foo", "fooValue");
50 props.put("bar", "barValue");
51 props.put("baz", "bazValue");
52 }
53
54 public void testSingleHeader() throws Exception
55 {
56 MuleClient client = new MuleClient(muleContext);
57 MuleMessage message = client.send("vm://header", null, props);
58 assertNotNull("return message from MuleClient.send() should not be null", message);
59 assertEquals("fooValue", message.getPayload());
60 }
61
62 public void testSingleHeaderOptional() throws Exception
63 {
64 MuleClient client = new MuleClient(muleContext);
65 MuleMessage message = client.send("vm://headerOptional", null, props);
66 assertNotNull("return message from MuleClient.send() should not be null", message);
67 assertEquals("faz not set", message.getPayload());
68 }
69
70
71 public void testSingleHeaderWithType() throws Exception
72 {
73 Apple apple = new Apple();
74 props.put("apple", apple);
75
76 MuleClient client = new MuleClient(muleContext);
77 MuleMessage message = client.send("vm://headerWithType", null, props);
78 assertNotNull("return message from MuleClient.send() should not be null", message);
79 assertEquals(apple, message.getPayload());
80 }
81
82 public void testSingleHeaderWithBaseType() throws Exception
83 {
84 Apple apple = new Apple();
85 props.put("apple", apple);
86
87 MuleClient client = new MuleClient(muleContext);
88 MuleMessage message = client.send("vm://headerWithBaseType", null, props);
89 assertNotNull("return message from MuleClient.send() should not be null", message);
90 assertEquals(apple, message.getPayload());
91 }
92
93 public void testMapHeaders() throws Exception
94 {
95 MuleClient client = new MuleClient(muleContext);
96 MuleMessage message = client.send("vm://headers", null, props);
97 assertNotNull("return message from MuleClient.send() should not be null", message);
98 assertTrue("Message payload should be a Map", message.getPayload() instanceof Map);
99 Map<?, ?> result = (Map<?, ?>) message.getPayload();
100 assertEquals(2, result.size());
101 assertEquals("fooValue", result.get("foo"));
102 assertEquals("barValue", result.get("bar"));
103 assertNull(result.get("baz"));
104 }
105
106 public void testMapHeadersMissing() throws Exception
107 {
108 props.remove("foo");
109 MuleClient client = new MuleClient(muleContext);
110 MuleMessage message = client.send("vm://headers", null, props);
111 assertNotNull("return message from MuleClient.send() should not be null", message);
112 assertNotNull(message.getExceptionPayload());
113 assertTrue(message.getExceptionPayload().getRootException() instanceof RequiredValueException);
114 }
115
116 public void testMapSingleHeader() throws Exception
117 {
118 MuleClient client = new MuleClient(muleContext);
119 MuleMessage message = client.send("vm://singleHeaderMap", null, props);
120 assertNotNull("return message from MuleClient.send() should not be null", message);
121 assertTrue("Message payload should be a Map", message.getPayload() instanceof Map);
122 Map<?, ?> result = (Map<?, ?>) message.getPayload();
123 assertEquals(1, result.size());
124 assertEquals("fooValue", result.get("foo"));
125 assertNull(result.get("bar"));
126 assertNull(result.get("baz"));
127 }
128
129 public void testMapHeadersOptional() throws Exception
130 {
131 props.remove("baz");
132
133 MuleClient client = new MuleClient(muleContext);
134 MuleMessage message = client.send("vm://headersOptional", null, props);
135 assertNotNull("return message from MuleClient.send() should not be null", message);
136 assertTrue("Message payload should be a Map", message.getPayload() instanceof Map);
137 Map<?, ?> result = (Map<?, ?>) message.getPayload();
138 assertEquals(2, result.size());
139 assertEquals("fooValue", result.get("foo"));
140 assertEquals("barValue", result.get("bar"));
141 assertNull(result.get("baz"));
142 }
143
144 public void testMapHeadersAllOptional() throws Exception
145 {
146 props.clear();
147
148 MuleClient client = new MuleClient(muleContext);
149 MuleMessage message = client.send("vm://headersAllOptional", null, props);
150 assertNotNull("return message from MuleClient.send() should not be null", message);
151 assertTrue("Message payload should be a Map", message.getPayload() instanceof Map);
152 Map<?, ?> result = (Map<?, ?>) message.getPayload();
153
154 assertEquals(0, result.size());
155 }
156
157 public void testMapHeadersUnmodifiable() throws Exception
158 {
159
160 MuleClient client = new MuleClient(muleContext);
161 MuleMessage message = client.send("vm://headersUnmodifiable", null, props);
162 assertNotNull("return message from MuleClient.send() should not be null", message);
163 assertNotNull("Exception should have been thrown", message.getExceptionPayload());
164 assertTrue(message.getExceptionPayload().getRootException() instanceof UnsupportedOperationException);
165 }
166
167 public void testMapHeadersAll() throws Exception
168 {
169 MuleClient client = new MuleClient(muleContext);
170 MuleMessage message = client.send("vm://headersAll", null, props);
171 assertNotNull("return message from MuleClient.send() should not be null", message);
172 assertTrue("Message payload should be a Map", message.getPayload() instanceof Map);
173 Map<?, ?> result = (Map<?, ?>) message.getPayload();
174
175 assertTrue(result.size() >= 3);
176 assertEquals("fooValue", result.get("foo"));
177 assertEquals("barValue", result.get("bar"));
178 assertEquals("bazValue", result.get("baz"));
179 }
180
181 public void testMapHeadersWildcard() throws Exception
182 {
183 MuleClient client = new MuleClient(muleContext);
184 MuleMessage message = client.send("vm://headersWildcard", null, props);
185 assertNotNull("return message from MuleClient.send() should not be null", message);
186 assertTrue("Message payload should be a Map", message.getPayload() instanceof Map);
187 Map<?, ?> result = (Map<?, ?>) message.getPayload();
188 printResult(result);
189
190 assertEquals(3, result.size());
191 assertEquals("vm://headersWildcard", result.get(MuleProperties.MULE_ENDPOINT_PROPERTY));
192 assertTrue(result.keySet().contains(MuleProperties.MULE_SESSION_PROPERTY));
193 }
194
195 public void testMapHeadersMultiWildcard() throws Exception
196 {
197 MuleClient client = new MuleClient(muleContext);
198 MuleMessage message = client.send("vm://headersMultiWildcard", null, props);
199 assertNotNull("return message from MuleClient.send() should not be null", message);
200 assertTrue("Message payload should be a Map", message.getPayload() instanceof Map);
201 Map<?, ?> result = (Map<?, ?>) message.getPayload();
202 printResult(result);
203
204 assertEquals(5, result.size());
205
206
207 assertEquals("vm://headersMultiWildcard", result.get(MuleProperties.MULE_ENDPOINT_PROPERTY));
208 assertTrue(result.keySet().contains(MuleProperties.MULE_SESSION_PROPERTY));
209
210
211 assertEquals(result.get("bar"), "barValue");
212 assertEquals(result.get("baz"), "bazValue");
213
214 }
215
216 public void testMapHeadersWithGenerics() throws Exception
217 {
218 props.put("apple", new Apple());
219 props.put("banana", new Banana());
220 props.put("orange", new Orange());
221
222 MuleClient client = new MuleClient(muleContext);
223 MuleMessage message = client.send("vm://headersWithGenerics", null, props);
224 assertNotNull("return message from MuleClient.send() should not be null", message);
225 assertTrue("Message payload should be a Map", message.getPayload() instanceof Map);
226 Map<?, ?> result = (Map<?, ?>) message.getPayload();
227
228 assertEquals(2, result.size());
229
230 assertEquals(new Apple(), result.get("apple"));
231 assertEquals(new Orange(), result.get("orange"));
232 assertNull(result.get("banana"));
233 }
234
235 public void testListHeaders() throws Exception
236 {
237 MuleClient client = new MuleClient(muleContext);
238 MuleMessage message = client.send("vm://headersList", null, props);
239 assertNotNull("return message from MuleClient.send() should not be null", message);
240 assertTrue("Message payload should be a List", message.getPayload() instanceof List);
241 List<?> result = (List<?>) message.getPayload();
242 assertEquals(3, result.size());
243 assertTrue(result.contains("fooValue"));
244 assertTrue(result.contains("barValue"));
245 assertTrue(result.contains("bazValue"));
246 }
247
248 public void testListHeadersWithOptional() throws Exception
249 {
250 props.remove("baz");
251 MuleClient client = new MuleClient(muleContext);
252 MuleMessage message = client.send("vm://headersListOptional", null, props);
253 assertNotNull("return message from MuleClient.send() should not be null", message);
254 assertTrue("Message payload should be a List", message.getPayload() instanceof List);
255 List<?> result = (List<?>) message.getPayload();
256 assertEquals(2, result.size());
257 assertTrue(result.contains("fooValue"));
258 assertTrue(result.contains("barValue"));
259 }
260
261 public void testListHeadersWithMissing() throws Exception
262 {
263 props.remove("bar");
264 MuleClient client = new MuleClient(muleContext);
265 MuleMessage message = client.send("vm://headersListOptional", null, props);
266 assertNotNull("return message from MuleClient.send() should not be null", message);
267 assertNotNull(message.getExceptionPayload());
268 assertTrue(message.getExceptionPayload().getRootException() instanceof RequiredValueException);
269 }
270
271 public void testSingleListHeader() throws Exception
272 {
273 MuleClient client = new MuleClient(muleContext);
274 MuleMessage message = client.send("vm://singleHeaderList", null, props);
275 assertNotNull("return message from MuleClient.send() should not be null", message);
276 assertTrue("Message payload should be a List", message.getPayload() instanceof List);
277 List<?> result = (List<?>) message.getPayload();
278 assertEquals(1, result.size());
279 assertTrue(result.contains("fooValue"));
280 }
281
282 public void testListHeadersUnmodifiable() throws Exception
283 {
284 MuleClient client = new MuleClient(muleContext);
285 MuleMessage message = client.send("vm://headersListUnmodifiable", null, props);
286 assertNotNull("return message from MuleClient.send() should not be null", message);
287 assertNotNull("Exception should have been thrown", message.getExceptionPayload());
288 assertTrue(message.getExceptionPayload().getRootException() instanceof UnsupportedOperationException);
289 }
290
291 public void testListHeadersAll() throws Exception
292 {
293 MuleClient client = new MuleClient(muleContext);
294 MuleMessage message = client.send("vm://headersListAll", null, props);
295 assertNotNull("return message from MuleClient.send() should not be null", message);
296 assertTrue("Message payload should be a List", message.getPayload() instanceof List);
297 List<?> result = (List<?>) message.getPayload();
298
299 assertTrue(result.size() >= 3);
300 assertTrue(result.contains("fooValue"));
301 assertTrue(result.contains("barValue"));
302 assertTrue(result.contains("bazValue"));
303 }
304
305 public void testMapHeadersListAllOptional() throws Exception
306 {
307 props.clear();
308
309 MuleClient client = new MuleClient(muleContext);
310 MuleMessage message = client.send("vm://headersListAllOptional", null, props);
311 assertNotNull("return message from MuleClient.send() should not be null", message);
312 assertTrue("Message payload should be a List", message.getPayload() instanceof List);
313 List<?> result = (List<?>) message.getPayload();
314
315 assertEquals(0, result.size());
316 }
317
318 public void testListHeadersWilcard() throws Exception
319 {
320 MuleClient client = new MuleClient(muleContext);
321 MuleMessage message = client.send("vm://headersListWildcard", null, props);
322 assertNotNull("return message from MuleClient.send() should not be null", message);
323 assertTrue("Message payload should be a List", message.getPayload() instanceof List);
324 List<?> result = (List<?>) message.getPayload();
325 printResult(result);
326
327 assertEquals(3, result.size());
328
329
330 assertTrue(result.contains("vm://headersListWildcard"));
331
332 }
333
334 public void testListHeadersMultiWilcard() throws Exception
335 {
336 MuleClient client = new MuleClient(muleContext);
337 MuleMessage message = client.send("vm://headersListMultiWildcard", null, props);
338 assertNotNull("return message from MuleClient.send() should not be null", message);
339 assertTrue("Message payload should be a List", message.getPayload() instanceof List);
340 List<?> result = (List<?>) message.getPayload();
341 printResult(result);
342
343 assertEquals(5, result.size());
344
345
346
347
348 assertTrue(result.contains("vm://headersListMultiWildcard"));
349
350
351
352
353 assertTrue(result.contains("barValue"));
354
355
356 assertTrue(result.contains("bazValue"));
357 }
358
359 public void testListHeadersWithGenerics() throws Exception
360 {
361 Apple apple = new Apple();
362 Banana banana = new Banana();
363 Orange orange = new Orange();
364 props.put("apple", apple);
365 props.put("banana", banana);
366 props.put("orange", orange);
367
368 MuleClient client = new MuleClient(muleContext);
369 MuleMessage message = client.send("vm://headersListWithGenerics", null, props);
370 assertNotNull("return message from MuleClient.send() should not be null", message);
371 assertTrue("Message payload should be a List", message.getPayload() instanceof List);
372 List<?> result = (List<?>) message.getPayload();
373
374 assertEquals(2, result.size());
375
376 assertTrue(result.contains(apple));
377 assertTrue(result.contains(orange));
378 assertFalse(result.contains(banana));
379 }
380
381 public void printResult(List<?> result)
382 {
383 for(int i = 0; i < result.size(); i++)
384 {
385 System.out.println("result #" + i + ": " + result.get(i));
386 }
387 }
388
389 public void printResult(Map<?, ?> result)
390 {
391 Set keys = result.keySet();
392 Iterator keyIter = keys.iterator();
393 System.out.println("The map contains the following associations:");
394 while (keyIter.hasNext())
395 {
396 Object key = keyIter.next();
397 Object value = result.get(key);
398 System.out.println( " (" + key + "," + value + ")" );
399 }
400 }
401 }