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