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