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