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