View Javadoc

1   /*
2    * $Id: AttachmentsExpressionEvaluatorTestCase.java 19191 2010-08-25 21:05:23Z tcarlson $
3    * --------------------------------------------------------------------------------------
4    * Copyright (c) MuleSoft, Inc.  All rights reserved.  http://www.mulesoft.com
5    *
6    * The software in this package is published under the terms of the CPAL v1.0
7    * license, a copy of which has been included with this distribution in the
8    * LICENSE.txt file.
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          // Value not required + found
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          // Value not required + not found
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              //Expected
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             //Expected
119         }
120 
121 
122     }
123 
124     public void testMapAttachmentsWithWildcards() throws Exception
125     {
126         MessageAttachmentsExpressionEvaluator eval = new MessageAttachmentsExpressionEvaluator();
127 
128         //Test All Wildcard
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         //Test Wildcard
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         //Test Wildcard no match
146         result = eval.evaluate("x*", message);
147         assertNotNull(result);
148         assertTrue(result instanceof Map);
149         assertEquals(0, ((Map)result).size());
150 
151         //Test comma separated Wildcards
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         //Test all
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             //Expected
201         }
202     }
203 
204     public void testListAttachmentsWithWildcards() throws Exception
205     {
206         MessageAttachmentsListExpressionEvaluator eval = new MessageAttachmentsListExpressionEvaluator();
207 
208         //Test All Wildcard
209         Object result = eval.evaluate("*", message);
210         assertNotNull(result);
211         assertTrue(result instanceof List);
212         assertEquals(3, ((List)result).size());
213 
214         //Test Wildcard
215         result = eval.evaluate("ba*", message);
216         assertNotNull(result);
217         assertTrue(result instanceof List);
218         assertEquals(2, ((List)result).size());
219 
220         //Test Wildcard no match
221         result = eval.evaluate("x*", message);
222         assertNotNull(result);
223         assertTrue(result instanceof List);
224         assertEquals(0, ((List)result).size());
225 
226         //Test comma separated Wildcards
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             //expected
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             //expected
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             //expected
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 }