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.DefaultMuleMessage;
20 import org.mule.api.MuleMessage;
21 import org.mule.api.expression.RequiredValueException;
22 import org.mule.module.client.MuleClient;
23 import org.mule.tck.AbstractServiceAndFlowTestCase;
24 import org.mule.transformer.types.DataTypeFactory;
25 import org.mule.util.ExceptionUtils;
26 import org.mule.util.StringDataSource;
27
28 import java.util.Arrays;
29 import java.util.Collection;
30 import java.util.HashMap;
31 import java.util.List;
32 import java.util.Map;
33
34 import javax.activation.DataHandler;
35
36 import org.junit.Test;
37 import org.junit.runners.Parameterized.Parameters;
38
39 public class InboundAttachmentsAnnotationTestCase extends AbstractServiceAndFlowTestCase
40 {
41 private MuleMessage muleMessage;
42
43 @Parameters
44 public static Collection<Object[]> parameters()
45 {
46 return Arrays.asList(new Object[][]{
47 {ConfigVariant.SERVICE, "org/mule/test/annotations/inbound-attachments-annotation-service.xml"},
48 {ConfigVariant.FLOW, "org/mule/test/annotations/inbound-attachments-annotation-flow.xml"}
49
50 });
51 }
52
53 public InboundAttachmentsAnnotationTestCase(ConfigVariant variant, String configResources)
54 {
55 super(variant, configResources);
56 setDisposeContextPerClass(true);
57 }
58
59 @Override
60 public void doSetUp() throws Exception
61 {
62 super.doSetUp();
63 muleMessage = createMessage(null, null);
64
65 muleContext.getRegistry().registerObject("dataHandlerTransformers", new DataHandlerTransformer());
66 }
67
68 protected MuleMessage createMessage(Map<String, Object> headers, Map<String, DataHandler> attachments) throws Exception
69 {
70 if(headers==null)
71 {
72 headers = new HashMap<String, Object>();
73 headers.put("foo", "fooValue");
74 headers.put("bar", "barValue");
75 headers.put("baz", "bazValue");
76 }
77
78 if(attachments==null)
79 {
80 attachments = new HashMap<String, DataHandler>();
81 attachments.put("foo", new DataHandler(new StringDataSource("fooValue")));
82 attachments.put("bar", new DataHandler(new StringDataSource("barValue")));
83 attachments.put("baz", new DataHandler(new StringDataSource("bazValue")));
84 }
85 MuleMessage message;
86 message = new DefaultMuleMessage("test", muleContext);
87 for (Map.Entry<String, DataHandler> attachment : attachments.entrySet())
88 {
89 message.addOutboundAttachment(attachment.getKey(), attachment.getValue());
90 }
91 for (String s : headers.keySet())
92 {
93 message.setOutboundProperty(s, headers.get(s));
94 }
95 return message;
96 }
97
98 @Test
99 public void testSingleAttachment() throws Exception
100 {
101 MuleClient client = new MuleClient(muleContext);
102 MuleMessage message = client.send("vm://attachment", muleMessage);
103 assertNotNull("return message from MuleClient.send() should not be null", message);
104 assertTrue(message.getPayload() instanceof DataHandler);
105 assertEquals("fooValue", ((DataHandler)message.getPayload()).getContent());
106 }
107
108 @Test
109 public void testSingleAttachmentWithType() throws Exception
110 {
111 MuleClient client = new MuleClient(muleContext);
112 MuleMessage message = client.send("vm://attachmentWithType", muleMessage);
113 assertNotNull("return message from MuleClient.send() should not be null", message);
114 assertTrue(message.getPayload() instanceof String);
115 assertEquals("fooValue", message.getPayload());
116 }
117
118 @Test
119 public void testSingleAttachmentOptional() throws Exception
120 {
121 MuleClient client = new MuleClient(muleContext);
122 MuleMessage message = client.send("vm://attachmentOptional", muleMessage);
123 assertNotNull("return message from MuleClient.send() should not be null", message);
124 assertEquals("faz not set", message.getPayload());
125 }
126
127 @Test
128 public void testSingleAttachmentWithTypeNoMatchingTransform() throws Exception
129 {
130
131 MuleClient client = new MuleClient(muleContext);
132 MuleMessage message = client.send("vm://attachmentWithType", muleMessage);
133 assertNotNull("return message from MuleClient.send() should not be null", message);
134 assertTrue(message.getPayload() instanceof String);
135 assertEquals("fooValue", message.getPayload());
136 }
137
138 @Test
139 public void testMapAttachments() throws Exception
140 {
141 MuleClient client = new MuleClient(muleContext);
142 MuleMessage message = client.send("vm://attachments", muleMessage);
143 assertNotNull("return message from MuleClient.send() should not be null", message);
144 assertTrue("Message payload should be a Map", message.getPayload() instanceof Map);
145 Map<String, DataHandler> result = getMapPayload(message);
146 assertEquals(2, result.size());
147 assertEquals("fooValue", result.get("foo").getContent());
148 assertEquals("barValue", result.get("bar").getContent());
149 assertNull(result.get("baz"));
150 }
151
152 @Test
153 public void testMapAttachmentsMissing() throws Exception
154 {
155
156 muleMessage = createMessage(null, new HashMap<String, DataHandler>());
157 MuleMessage message = muleContext.getClient().send("vm://attachments", muleMessage);
158 assertNotNull(message);
159 assertNotNull(message.getExceptionPayload());
160 assertEquals(RequiredValueException.class,
161 ExceptionUtils.getRootCause(message.getExceptionPayload().getException()).getClass());
162 }
163
164 @Test
165 public void testMapSingleAttachment() throws Exception
166 {
167 MuleClient client = new MuleClient(muleContext);
168 MuleMessage message = client.send("vm://singleAttachmentMap", muleMessage);
169 assertNotNull("return message from MuleClient.send() should not be null", message);
170 assertTrue("Message payload should be a Map", message.getPayload() instanceof Map);
171 Map<String, DataHandler> result = getMapPayload(message);
172 assertEquals(1, result.size());
173 assertEquals("fooValue", result.get("foo").getContent());
174 assertNull(result.get("bar"));
175 assertNull(result.get("baz"));
176 }
177
178 @Test
179 public void testMapAttachmentsOptional() throws Exception
180 {
181
182 Map<String, DataHandler> attachments = new HashMap<String, DataHandler>();
183 attachments.put("foo", new DataHandler(new StringDataSource("fooValue")));
184 attachments.put("bar", new DataHandler(new StringDataSource("barValue")));
185 muleMessage = createMessage(null, attachments);
186
187 MuleClient client = new MuleClient(muleContext);
188 MuleMessage message = client.send("vm://attachmentsOptional", muleMessage);
189 assertNotNull("return message from MuleClient.send() should not be null", message);
190 assertTrue("Message payload should be a Map", message.getPayload() instanceof Map);
191 Map<String, DataHandler> result = getMapPayload(message);
192 assertEquals(2, result.size());
193 assertEquals("fooValue", result.get("foo").getContent());
194 assertEquals("barValue", result.get("bar").getContent());
195 assertNull(result.get("baz"));
196 }
197
198 @Test
199 public void testMapAttachmentsAllOptional() throws Exception
200 {
201
202 muleMessage = createMessage(null, new HashMap<String, DataHandler>());
203
204 MuleClient client = new MuleClient(muleContext);
205 MuleMessage message = client.send("vm://attachmentsAllOptional", muleMessage);
206 assertNotNull("return message from MuleClient.send() should not be null", message);
207 assertTrue("Message payload should be a Map", message.getPayload() instanceof Map);
208 Map<?, ?> result = (Map<?, ?>) message.getPayload();
209 assertEquals(0, result.size());
210 }
211
212 @Test
213 public void testMapAttachmentsUnmodifiable() throws Exception
214 {
215 MuleMessage message = muleContext.getClient().send("vm://attachmentsUnmodifiable", muleMessage);
216 assertNotNull(message);
217 assertNotNull(message.getExceptionPayload());
218 assertEquals(UnsupportedOperationException.class,
219 ExceptionUtils.getRootCause(message.getExceptionPayload().getException()).getClass());
220 }
221
222 @Test
223 public void testMapAttachmentsAll() throws Exception
224 {
225 MuleClient client = new MuleClient(muleContext);
226 MuleMessage message = client.send("vm://attachmentsAll", muleMessage);
227 assertNotNull("return message from MuleClient.send() should not be null", message);
228 assertTrue("Message payload should be a Map", message.getPayload() instanceof Map);
229 Map<String, DataHandler> result = getMapPayload(message);
230
231 assertTrue(result.size() >= 3);
232 assertEquals("fooValue", result.get("foo").getContent());
233 assertEquals("barValue", result.get("bar").getContent());
234 assertEquals("bazValue", result.get("baz").getContent());
235 }
236
237 @Test
238 public void testMapAttachmentsWildcard() throws Exception
239 {
240 MuleClient client = new MuleClient(muleContext);
241 MuleMessage message = client.send("vm://attachmentsWildcard", muleMessage);
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 = message.getPayload(DataTypeFactory.create(Map.class));
245
246 assertEquals(2, result.size());
247 assertNull(result.get("foo"));
248 assertNotNull(result.get("bar"));
249 assertNotNull(result.get("baz"));
250 }
251
252 @Test
253 public void testMapAttachmentsMultiWildcard() throws Exception
254 {
255 MuleClient client = new MuleClient(muleContext);
256 MuleMessage message = client.send("vm://attachmentsMultiWildcard", muleMessage);
257 assertNotNull("return message from MuleClient.send() should not be null", message);
258 assertTrue("Message payload should be a Map", message.getPayload() instanceof Map);
259 Map<?, ?> result = (Map<?, ?>) message.getPayload();
260
261 assertEquals(3, result.size());
262
263 assertNotNull(result.get("foo"));
264 assertNotNull(result.get("bar"));
265 assertNotNull(result.get("baz"));
266 }
267
268 @Test
269 public void testListAttachments() throws Exception
270 {
271 MuleClient client = new MuleClient(muleContext);
272 MuleMessage message = client.send("vm://attachmentsList", muleMessage);
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(3, result.size());
277 assertTrue(result.contains("fooValue"));
278 assertTrue(result.contains("barValue"));
279 assertTrue(result.contains("bazValue"));
280 }
281
282 @Test
283 public void testListAttachmentsWithOptional() throws Exception
284 {
285
286 Map<String, DataHandler> attachments = new HashMap<String, DataHandler>();
287 attachments.put("foo", new DataHandler(new StringDataSource("fooValue")));
288 attachments.put("bar", new DataHandler(new StringDataSource("barValue")));
289 muleMessage = createMessage(null, attachments);
290
291 MuleClient client = new MuleClient(muleContext);
292 MuleMessage message = client.send("vm://attachmentsListOptional", muleMessage);
293 assertNotNull("return message from MuleClient.send() should not be null", message);
294 assertTrue("Message payload should be a List", message.getPayload() instanceof List);
295 List<?> result = (List<?>) message.getPayload();
296 assertEquals(2, result.size());
297 assertTrue(result.contains("fooValue"));
298 assertTrue(result.contains("barValue"));
299 }
300
301 @Test
302 public void testListAttachmentsWithAllOptional() throws Exception
303 {
304
305 muleMessage = createMessage(null, new HashMap<String, DataHandler>());
306
307 MuleClient client = new MuleClient(muleContext);
308 MuleMessage message = client.send("vm://attachmentsListAllOptional", muleMessage);
309 assertNotNull("return message from MuleClient.send() should not be null", message);
310 assertTrue("Message payload should be a List", message.getPayload() instanceof List);
311 List<?> result = (List<?>) message.getPayload();
312 assertEquals(0, result.size());
313 }
314
315 @Test
316 public void testListAttachmentsWithMissing() throws Exception
317 {
318
319 Map<String, DataHandler> attachments = new HashMap<String, DataHandler>();
320 attachments.put("foo", new DataHandler(new StringDataSource("fooValue")));
321 attachments.put("baz", new DataHandler(new StringDataSource("bazValue")));
322 muleMessage = createMessage(null, attachments);
323 MuleMessage result = muleContext.getClient().send("vm://attachmentsListOptional", muleMessage);
324 assertNotNull(result);
325 assertNotNull(result.getExceptionPayload());
326 assertEquals(RequiredValueException.class,
327 ExceptionUtils.getRootCause(result.getExceptionPayload().getException()).getClass());
328
329 }
330
331 @Test
332 public void testSingleListAttachment() throws Exception
333 {
334 MuleClient client = new MuleClient(muleContext);
335 MuleMessage message = client.send("vm://singleAttachmentList", muleMessage);
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 assertEquals(1, result.size());
340 assertTrue(result.contains("fooValue"));
341 }
342
343 @Test
344 public void testListAttachmentsUnmodifiable() throws Exception
345 {
346 MuleMessage result = muleContext.getClient().send("vm://attachmentsListUnmodifiable", muleMessage);
347 assertNotNull(result);
348 assertNotNull(result.getExceptionPayload());
349 assertEquals(UnsupportedOperationException.class,
350 ExceptionUtils.getRootCause(result.getExceptionPayload().getException()).getClass());
351 }
352
353 @Test
354 public void testListAttachmentsAll() throws Exception
355 {
356 MuleClient client = new MuleClient(muleContext);
357 MuleMessage message = client.send("vm://attachmentsListAll", muleMessage);
358 assertNotNull("return message from MuleClient.send() should not be null", message);
359 assertTrue("Message payload should be a List", message.getPayload() instanceof List);
360 List<?> result = (List<?>) message.getPayload();
361
362 assertTrue(result.size() >= 3);
363 assertTrue(result.contains("fooValue"));
364 assertTrue(result.contains("barValue"));
365 assertTrue(result.contains("bazValue"));
366 }
367
368 @Test
369 public void testListAttachmentsWilcard() throws Exception
370 {
371 MuleClient client = new MuleClient(muleContext);
372 MuleMessage message = client.send("vm://attachmentsListWildcard", muleMessage);
373 assertNotNull("return message from MuleClient.send() should not be null", message);
374 assertTrue("Message payload should be a List", message.getPayload() instanceof List);
375 List<?> result = (List<?>) message.getPayload();
376
377 assertEquals(2, result.size());
378 assertFalse(result.contains("fooValue"));
379 assertTrue(result.contains("barValue"));
380 assertTrue(result.contains("bazValue"));
381
382 }
383
384 @Test
385 public void testListAttachmentsMultiWilcard() throws Exception
386 {
387 MuleClient client = new MuleClient(muleContext);
388 MuleMessage message = client.send("vm://attachmentsListMultiWildcard", muleMessage);
389 assertNotNull("return message from MuleClient.send() should not be null", message);
390 assertTrue("Message payload should be a List", message.getPayload() instanceof List);
391 List<?> result = (List<?>) message.getPayload();
392
393 assertEquals(3, result.size());
394 assertTrue(result.contains("fooValue"));
395 assertTrue(result.contains("barValue"));
396 assertTrue(result.contains("bazValue"));
397 }
398
399 @SuppressWarnings("unchecked")
400 private Map<String, DataHandler> getMapPayload(MuleMessage message)
401 {
402 return (Map<String, DataHandler>) message.getPayload();
403 }
404 }