1
2
3
4
5
6
7
8
9
10 package org.mule.expression;
11
12 import org.mule.DefaultMuleMessage;
13 import org.mule.api.MuleMessage;
14 import org.mule.api.expression.ExpressionRuntimeException;
15 import org.mule.tck.junit4.AbstractMuleContextTestCase;
16 import org.mule.util.StringDataSource;
17
18 import java.io.ByteArrayOutputStream;
19 import java.util.HashMap;
20 import java.util.List;
21 import java.util.Map;
22
23 import javax.activation.DataHandler;
24
25 import org.junit.Test;
26
27 import static org.junit.Assert.assertEquals;
28 import static org.junit.Assert.assertNotNull;
29 import static org.junit.Assert.assertNull;
30 import static org.junit.Assert.assertTrue;
31 import static org.junit.Assert.fail;
32
33 public class AttachmentsExpressionEvaluatorTestCase extends AbstractMuleContextTestCase
34 {
35 private MuleMessage message;
36
37 @Override
38 protected void doSetUp() throws Exception
39 {
40 try
41 {
42 Map<String, DataHandler> attachments = new HashMap<String, DataHandler>();
43 attachments.put("foo", new DataHandler(new StringDataSource("foovalue")));
44 attachments.put("bar", new DataHandler(new StringDataSource("barvalue")));
45 attachments.put("baz", new DataHandler(new StringDataSource("bazvalue")));
46 message = new DefaultMuleMessage("test", null, attachments, muleContext);
47
48 }
49 catch (Exception e)
50 {
51 e.printStackTrace();
52 fail(e.getMessage());
53 }
54 }
55
56 @Test
57 public void testSingleAttachment() throws Exception
58 {
59 MessageAttachmentExpressionEvaluator eval = new MessageAttachmentExpressionEvaluator();
60
61 Object result = eval.evaluate("foo", message);
62 assertNotNull(result);
63 assertTrue(result instanceof DataHandler);
64 ByteArrayOutputStream baos = new ByteArrayOutputStream(4);
65 ((DataHandler)result).writeTo(baos);
66 assertEquals("foovalue", baos.toString());
67
68
69 result = eval.evaluate("foo?", message);
70 assertNotNull(result);
71 assertTrue(result instanceof DataHandler);
72 baos = new ByteArrayOutputStream(4);
73 ((DataHandler)result).writeTo(baos);
74 assertEquals("foovalue", baos.toString());
75
76
77 result = eval.evaluate("fool?", message);
78 assertNull(result);
79
80 try
81 {
82 eval.evaluate("fool", message);
83 fail("required value");
84 }
85 catch (Exception e)
86 {
87
88 }
89 }
90
91 @Test
92 public void testMapAttachments() throws Exception
93 {
94 MessageAttachmentsExpressionEvaluator eval = new MessageAttachmentsExpressionEvaluator();
95
96 Object result = eval.evaluate("foo, baz", message);
97 assertNotNull(result);
98 assertTrue(result instanceof Map);
99 assertEquals(2, ((Map)result).size());
100
101 assertNotNull(((Map)result).get("foo"));
102 assertTrue(((Map)result).get("foo") instanceof DataHandler);
103 DataHandler dh = (DataHandler)((Map)result).get("foo");
104 ByteArrayOutputStream baos = new ByteArrayOutputStream(4);
105 dh.writeTo(baos);
106 assertEquals("foovalue", baos.toString());
107
108 assertNotNull(((Map)result).get("baz"));
109 assertTrue(((Map)result).get("baz") instanceof DataHandler);
110 dh = (DataHandler)((Map)result).get("baz");
111 baos = new ByteArrayOutputStream(4);
112 dh.writeTo(baos);
113 assertEquals("bazvalue", baos.toString());
114
115 result = eval.evaluate("fool?", message);
116 assertNotNull(result);
117 assertTrue(result instanceof Map);
118 assertEquals(0, ((Map)result).size());
119
120 try
121 {
122 eval.evaluate("fool", message);
123 fail("required value");
124 }
125 catch (Exception e)
126 {
127
128 }
129
130
131 }
132
133 @Test
134 public void testMapAttachmentsWithWildcards() throws Exception
135 {
136 MessageAttachmentsExpressionEvaluator eval = new MessageAttachmentsExpressionEvaluator();
137
138
139 Object result = eval.evaluate("*", message);
140 assertNotNull(result);
141 assertTrue(result instanceof Map);
142 assertEquals(3, ((Map)result).size());
143 assertNotNull(((Map)result).get("foo"));
144 assertNotNull(((Map)result).get("bar"));
145 assertNotNull(((Map)result).get("baz"));
146
147
148 result = eval.evaluate("ba*", message);
149 assertNotNull(result);
150 assertTrue(result instanceof Map);
151 assertEquals(2, ((Map)result).size());
152 assertNotNull(((Map)result).get("bar"));
153 assertNotNull(((Map)result).get("baz"));
154
155
156 result = eval.evaluate("x*", message);
157 assertNotNull(result);
158 assertTrue(result instanceof Map);
159 assertEquals(0, ((Map)result).size());
160
161
162 result = eval.evaluate("ba*, f*", message);
163 assertNotNull(result);
164 assertTrue(result instanceof Map);
165 assertEquals(3, ((Map)result).size());
166 assertNotNull(((Map)result).get("foo"));
167 assertNotNull(((Map)result).get("bar"));
168 assertNotNull(((Map)result).get("baz"));
169 }
170
171 @Test
172 public void testListAttachments() throws Exception
173 {
174 MessageAttachmentsListExpressionEvaluator eval = new MessageAttachmentsListExpressionEvaluator();
175
176 Object result = eval.evaluate("foo, baz", message);
177 assertNotNull(result);
178 assertTrue(result instanceof List);
179 assertEquals(2, ((List)result).size());
180
181 assertTrue(((List)result).get(0) instanceof DataHandler);
182 DataHandler dh = (DataHandler)((List)result).get(0);
183 ByteArrayOutputStream baos = new ByteArrayOutputStream(4);
184 dh.writeTo(baos);
185 assertEquals("foovalue", baos.toString());
186
187 assertTrue(((List)result).get(1) instanceof DataHandler);
188 dh = (DataHandler)((List)result).get(1);
189 baos = new ByteArrayOutputStream(4);
190 dh.writeTo(baos);
191 assertEquals("bazvalue", baos.toString());
192
193
194 result = eval.evaluate("*", message);
195 assertNotNull(result);
196 assertTrue(result instanceof List);
197 assertEquals(3, ((List)result).size());
198
199 result = eval.evaluate("fool?", message);
200 assertNotNull(result);
201 assertTrue(result instanceof List);
202 assertEquals(0, ((List)result).size());
203
204 try
205 {
206 eval.evaluate("fool", message);
207 fail("required value");
208 }
209 catch (Exception e)
210 {
211
212 }
213 }
214
215 @Test
216 public void testListAttachmentsWithWildcards() throws Exception
217 {
218 MessageAttachmentsListExpressionEvaluator eval = new MessageAttachmentsListExpressionEvaluator();
219
220
221 Object result = eval.evaluate("*", message);
222 assertNotNull(result);
223 assertTrue(result instanceof List);
224 assertEquals(3, ((List)result).size());
225
226
227 result = eval.evaluate("ba*", message);
228 assertNotNull(result);
229 assertTrue(result instanceof List);
230 assertEquals(2, ((List)result).size());
231
232
233 result = eval.evaluate("x*", message);
234 assertNotNull(result);
235 assertTrue(result instanceof List);
236 assertEquals(0, ((List)result).size());
237
238
239 result = eval.evaluate("ba*, f*", message);
240 assertNotNull(result);
241 assertTrue(result instanceof List);
242 assertEquals(3, ((List)result).size());
243 }
244
245 @Test
246 public void testSingleAttachmentUsingManager() throws Exception
247 {
248 Object result = muleContext.getExpressionManager().evaluate("#[attachment:foo]", message);
249 assertNotNull(result);
250 assertTrue(result instanceof DataHandler);
251 ByteArrayOutputStream baos = new ByteArrayOutputStream(4);
252 ((DataHandler)result).writeTo(baos);
253 assertEquals("foovalue", baos.toString());
254
255 result = muleContext.getExpressionManager().evaluate("#[attachment:fool?]", message);
256 assertNull(result);
257
258 try
259 {
260 muleContext.getExpressionManager().evaluate("#[attachment:fool]", message);
261 fail("Required value");
262 }
263 catch (ExpressionRuntimeException e)
264 {
265
266 }
267 }
268
269 @Test
270 public void testMapAttachmentsUsingManager() throws Exception
271 {
272 Object result = muleContext.getExpressionManager().evaluate("#[attachments:foo, baz]", message);
273 assertNotNull(result);
274 assertTrue(result instanceof Map);
275 assertEquals(2, ((Map)result).size());
276
277 assertNotNull(((Map)result).get("foo"));
278 assertTrue(((Map)result).get("foo") instanceof DataHandler);
279 DataHandler dh = (DataHandler)((Map)result).get("foo");
280 ByteArrayOutputStream baos = new ByteArrayOutputStream(4);
281 dh.writeTo(baos);
282 assertEquals("foovalue", baos.toString());
283
284 assertNotNull(((Map)result).get("baz"));
285 assertTrue(((Map)result).get("baz") instanceof DataHandler);
286 dh = (DataHandler)((Map)result).get("baz");
287 baos = new ByteArrayOutputStream(4);
288 dh.writeTo(baos);
289 assertEquals("bazvalue", baos.toString());
290
291 result = muleContext.getExpressionManager().evaluate("#[attachments:fool?]", message);
292 assertNotNull(result);
293 assertTrue(result instanceof Map);
294 assertEquals(0, ((Map)result).size());
295
296 try
297 {
298 muleContext.getExpressionManager().evaluate("#[attachments:fool]", message);
299 fail("Required value");
300 }
301 catch (ExpressionRuntimeException e)
302 {
303
304 }
305 }
306
307 @Test
308 public void testMapAttachmentsWithWildcardsUsingManager() throws Exception
309 {
310 Object result = muleContext.getExpressionManager().evaluate("#[attachments:*]", message);
311 assertNotNull(result);
312 assertTrue(result instanceof Map);
313 assertEquals(3, ((Map)result).size());
314 assertNotNull(((Map)result).get("foo"));
315 assertNotNull(((Map)result).get("bar"));
316 assertNotNull(((Map)result).get("baz"));
317
318 result = muleContext.getExpressionManager().evaluate("#[attachments:ba*]", message);
319 assertNotNull(result);
320 assertTrue(result instanceof Map);
321 assertEquals(2, ((Map)result).size());
322 assertNotNull(((Map)result).get("bar"));
323 assertNotNull(((Map)result).get("baz"));
324
325 result = muleContext.getExpressionManager().evaluate("#[attachments:x*]", message);
326 assertNotNull(result);
327 assertTrue(result instanceof Map);
328 assertEquals(0, ((Map)result).size());
329
330 result = muleContext.getExpressionManager().evaluate("#[attachments:ba*, f*]", message);
331 assertNotNull(result);
332 assertTrue(result instanceof Map);
333 assertEquals(3, ((Map)result).size());
334 assertNotNull(((Map)result).get("foo"));
335 assertNotNull(((Map)result).get("bar"));
336 assertNotNull(((Map)result).get("baz"));
337 }
338
339 @Test
340 public void testListAttachmentsUsingManager() throws Exception
341 {
342 Object result = muleContext.getExpressionManager().evaluate("#[attachments-list:foo,baz]", message);
343 assertNotNull(result);
344 assertTrue(result instanceof List);
345 assertEquals(2, ((List)result).size());
346
347 assertTrue(((List)result).get(0) instanceof DataHandler);
348 DataHandler dh = (DataHandler)((List)result).get(0);
349 ByteArrayOutputStream baos = new ByteArrayOutputStream(4);
350 dh.writeTo(baos);
351 assertEquals("foovalue", baos.toString());
352
353 assertTrue(((List)result).get(1) instanceof DataHandler);
354 dh = (DataHandler)((List)result).get(1);
355 baos = new ByteArrayOutputStream(4);
356 dh.writeTo(baos);
357 assertEquals("bazvalue", baos.toString());
358
359 result = muleContext.getExpressionManager().evaluate("#[attachments-list:fool?]", message);
360 assertNotNull(result);
361 assertTrue(result instanceof List);
362 assertEquals(0, ((List)result).size());
363
364 try
365 {
366 muleContext.getExpressionManager().evaluate("#[attachments-list:fool]", message);
367 fail("Required value");
368 }
369 catch (ExpressionRuntimeException e)
370 {
371
372 }
373 }
374
375 @Test
376 public void testListAttachmentsWithWildcardsUsingManager() throws Exception
377 {
378 Object result = muleContext.getExpressionManager().evaluate("#[attachments-list:*]", message);
379 assertNotNull(result);
380 assertTrue(result instanceof List);
381 assertEquals(3, ((List)result).size());
382
383 result = muleContext.getExpressionManager().evaluate("#[attachments-list:ba*]", message);
384 assertNotNull(result);
385 assertTrue(result instanceof List);
386 assertEquals(2, ((List)result).size());
387
388 result = muleContext.getExpressionManager().evaluate("#[attachments-list:x*]", message);
389 assertNotNull(result);
390 assertTrue(result instanceof List);
391 assertEquals(0, ((List)result).size());
392
393 result = muleContext.getExpressionManager().evaluate("#[attachments-list:ba*, f*]", message);
394 assertNotNull(result);
395 assertTrue(result instanceof List);
396 assertEquals(3, ((List)result).size());
397 }
398 }