1   /*
2    * $Id: AttachmentsExpressionEvaluatorTestCase.java 11290 2008-03-09 12:01:48Z rossmason $
3    * --------------------------------------------------------------------------------------
4    * Copyright (c) MuleSource, Inc.  All rights reserved.  http://www.mulesource.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.tck.AbstractMuleTestCase;
15  import org.mule.util.expression.ExpressionEvaluatorManager;
16  import org.mule.util.expression.MessageAttachmentExpressionEvaluator;
17  import org.mule.util.expression.MessageAttachmentsExpressionEvaluator;
18  import org.mule.util.expression.MessageAttachmentsListExpressionEvaluator;
19  
20  import java.io.ByteArrayInputStream;
21  import java.io.ByteArrayOutputStream;
22  import java.io.IOException;
23  import java.io.InputStream;
24  import java.io.OutputStream;
25  import java.util.List;
26  import java.util.Map;
27  
28  import javax.activation.DataHandler;
29  import javax.activation.DataSource;
30  
31  public class AttachmentsExpressionEvaluatorTestCase extends AbstractMuleTestCase
32  {
33      private MuleMessage message;
34  
35      //@Override
36      protected void doSetUp() throws Exception
37      {
38          message = new DefaultMuleMessage("test");
39  
40          try
41          {
42              message.addAttachment("foo", new DataHandler(new StringDataSource("moo")));
43              message.addAttachment("bar", new DataHandler(new StringDataSource("mar")));
44              message.addAttachment("baz", new DataHandler(new StringDataSource("maz")));
45          }
46          catch (Exception e)
47          {
48              e.printStackTrace();
49              fail(e.getMessage());
50          }
51      }
52  
53      public void testSingleAttachment() throws Exception
54      {
55          MessageAttachmentExpressionEvaluator eval = new MessageAttachmentExpressionEvaluator();
56  
57          Object result = eval.evaluate("foo", message);
58          assertNotNull(result);
59          assertTrue(result instanceof DataHandler);
60          ByteArrayOutputStream baos = new ByteArrayOutputStream(4);
61          ((DataHandler)result).writeTo(baos);
62          assertEquals("moo", baos.toString());
63          
64          result = eval.evaluate("fool", message);
65          assertNull(result);
66  
67          result = eval.evaluate("foo", new Object());
68          assertNull(result);
69  
70      }
71  
72      public void testMapHeaders() throws Exception
73      {
74          MessageAttachmentsExpressionEvaluator eval = new MessageAttachmentsExpressionEvaluator();
75  
76          Object result = eval.evaluate("foo, baz", message);
77          assertNotNull(result);
78          assertTrue(result instanceof Map);
79          assertEquals(2, ((Map)result).size());
80  
81          assertNotNull(((Map)result).get("foo"));
82          assertTrue(((Map)result).get("foo") instanceof DataHandler);
83          DataHandler dh = (DataHandler)((Map)result).get("foo");
84          ByteArrayOutputStream baos = new ByteArrayOutputStream(4);
85          dh.writeTo(baos);
86          assertEquals("moo", baos.toString());
87  
88          assertNotNull(((Map)result).get("baz"));
89          assertTrue(((Map)result).get("baz") instanceof DataHandler);
90          dh = (DataHandler)((Map)result).get("baz");
91          baos = new ByteArrayOutputStream(4);
92          dh.writeTo(baos);
93          assertEquals("maz", baos.toString());
94  
95          result = eval.evaluate("fool", message);
96          assertNull(result);
97  
98          result = eval.evaluate("foo", new Object());
99          assertNull(result);
100 
101     }
102 
103     public void testListHeaders() throws Exception
104     {
105         MessageAttachmentsListExpressionEvaluator eval = new MessageAttachmentsListExpressionEvaluator();
106 
107         Object result = eval.evaluate("foo, baz", message);
108         assertNotNull(result);
109         assertTrue(result instanceof List);
110         assertEquals(2, ((List)result).size());
111 
112         assertTrue(((List)result).get(0) instanceof DataHandler);
113         DataHandler dh = (DataHandler)((List)result).get(0);
114         ByteArrayOutputStream baos = new ByteArrayOutputStream(4);
115         dh.writeTo(baos);
116         assertEquals("moo", baos.toString());
117 
118         assertTrue(((List)result).get(1) instanceof DataHandler);
119         dh = (DataHandler)((List)result).get(1);
120         baos = new ByteArrayOutputStream(4);
121         dh.writeTo(baos);
122         assertEquals("maz", baos.toString());
123 
124         result = eval.evaluate("fool", message);
125         assertNull(result);
126 
127         result = eval.evaluate("foo", new Object());
128         assertNull(result);
129 
130     }
131 
132     public void testSingleAttachmentUsingManager() throws Exception
133     {
134         Object result = ExpressionEvaluatorManager.evaluate("${attachment:foo}", message);
135         assertNotNull(result);
136         assertTrue(result instanceof DataHandler);
137         ByteArrayOutputStream baos = new ByteArrayOutputStream(4);
138         ((DataHandler)result).writeTo(baos);
139         assertEquals("moo", baos.toString());
140 
141         result = ExpressionEvaluatorManager.evaluate("${attachment:fool}", message);
142         assertNull(result);
143 
144         result = ExpressionEvaluatorManager.evaluate("${attachment:foo}", new Object());
145         assertNull(result);
146 
147     }
148 
149     public void testMapHeadersUsingManager() throws Exception
150     {
151         Object result = ExpressionEvaluatorManager.evaluate("${attachments:foo, baz}", message);
152         assertNotNull(result);
153         assertTrue(result instanceof Map);
154         assertEquals(2, ((Map)result).size());
155 
156         assertNotNull(((Map)result).get("foo"));
157         assertTrue(((Map)result).get("foo") instanceof DataHandler);
158         DataHandler dh = (DataHandler)((Map)result).get("foo");
159         ByteArrayOutputStream baos = new ByteArrayOutputStream(4);
160         dh.writeTo(baos);
161         assertEquals("moo", baos.toString());
162 
163         assertNotNull(((Map)result).get("baz"));
164         assertTrue(((Map)result).get("baz") instanceof DataHandler);
165         dh = (DataHandler)((Map)result).get("baz");
166         baos = new ByteArrayOutputStream(4);
167         dh.writeTo(baos);
168         assertEquals("maz", baos.toString());
169 
170         result = ExpressionEvaluatorManager.evaluate("${attachments:fool}", message);
171         assertNull(result);
172 
173         result = ExpressionEvaluatorManager.evaluate("${attachments:foo}", new Object());
174         assertNull(result);
175 
176     }
177 
178     public void testListHeadersUsingManager() throws Exception
179     {
180         Object result = ExpressionEvaluatorManager.evaluate("${attachments-list:foo,baz}", message);
181         assertNotNull(result);
182         assertTrue(result instanceof List);
183         assertEquals(2, ((List)result).size());
184 
185         assertTrue(((List)result).get(0) instanceof DataHandler);
186         DataHandler dh = (DataHandler)((List)result).get(0);
187         ByteArrayOutputStream baos = new ByteArrayOutputStream(4);
188         dh.writeTo(baos);
189         assertEquals("moo", baos.toString());
190 
191         assertTrue(((List)result).get(1) instanceof DataHandler);
192         dh = (DataHandler)((List)result).get(1);
193         baos = new ByteArrayOutputStream(4);
194         dh.writeTo(baos);
195         assertEquals("maz", baos.toString());
196 
197         result = ExpressionEvaluatorManager.evaluate("${attachments-list:fool}", message);
198         assertNull(result);
199 
200         result = ExpressionEvaluatorManager.evaluate("${attachments-list:foo}", new Object());
201         assertNull(result);
202 
203     }
204 
205     // silly little fake DataSource so that we don't need to use javamail
206     protected static class StringDataSource implements DataSource
207     {
208         protected String content;
209 
210         public StringDataSource(String payload)
211         {
212             super();
213             content = payload;
214         }
215 
216         public InputStream getInputStream() throws IOException
217         {
218             return new ByteArrayInputStream(content.getBytes());
219         }
220 
221         public OutputStream getOutputStream()
222         {
223             throw new UnsupportedOperationException("Read-only javax.activation.DataSource");
224         }
225 
226         public String getContentType()
227         {
228             return "text/plain";
229         }
230 
231         public String getName()
232         {
233             return "StringDataSource";
234         }
235     }
236 }