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.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
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
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 }