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