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