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