View Javadoc

1   /*
2    * $Id: AttachmentsExpressionEvaluatorTestCase.java 22377 2011-07-11 12:41:42Z dirk.olmes $
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.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          // Value not required + found
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          // Value not required + not found
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              //Expected
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             //Expected
128         }
129 
130 
131     }
132 
133     @Test
134     public void testMapAttachmentsWithWildcards() throws Exception
135     {
136         MessageAttachmentsExpressionEvaluator eval = new MessageAttachmentsExpressionEvaluator();
137 
138         //Test All Wildcard
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         //Test Wildcard
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         //Test Wildcard no match
156         result = eval.evaluate("x*", message);
157         assertNotNull(result);
158         assertTrue(result instanceof Map);
159         assertEquals(0, ((Map)result).size());
160 
161         //Test comma separated Wildcards
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         //Test all
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             //Expected
212         }
213     }
214 
215     @Test
216     public void testListAttachmentsWithWildcards() throws Exception
217     {
218         MessageAttachmentsListExpressionEvaluator eval = new MessageAttachmentsListExpressionEvaluator();
219 
220         //Test All Wildcard
221         Object result = eval.evaluate("*", message);
222         assertNotNull(result);
223         assertTrue(result instanceof List);
224         assertEquals(3, ((List)result).size());
225 
226         //Test Wildcard
227         result = eval.evaluate("ba*", message);
228         assertNotNull(result);
229         assertTrue(result instanceof List);
230         assertEquals(2, ((List)result).size());
231 
232         //Test Wildcard no match
233         result = eval.evaluate("x*", message);
234         assertNotNull(result);
235         assertTrue(result instanceof List);
236         assertEquals(0, ((List)result).size());
237 
238         //Test comma separated Wildcards
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             //expected
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             //expected
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             //expected
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 }