1
2
3
4
5
6
7 package org.mule.expression;
8
9 import org.mule.DefaultMuleMessage;
10 import org.mule.api.MuleMessage;
11 import org.mule.api.expression.RequiredValueException;
12 import org.mule.api.transport.PropertyScope;
13 import org.mule.tck.junit4.AbstractMuleContextTestCase;
14
15 import java.util.HashMap;
16 import java.util.List;
17
18 import org.junit.Test;
19
20 import static org.junit.Assert.assertEquals;
21 import static org.junit.Assert.assertFalse;
22 import static org.junit.Assert.assertNotNull;
23 import static org.junit.Assert.assertTrue;
24
25 public class MessageHeadersListExpressionEvaluatorTestCase extends AbstractMuleContextTestCase
26 {
27 private HashMap<String, Object> messageProperties;
28 private MessageHeadersListExpressionEvaluator evaluator = new MessageHeadersListExpressionEvaluator();
29 private MuleMessage message;
30
31 public MessageHeadersListExpressionEvaluatorTestCase()
32 {
33 super();
34 setDisposeContextPerClass(true);
35 }
36
37 @Override
38 public void doSetUp()
39 {
40 messageProperties = new HashMap<String, Object>(3);
41 messageProperties.put("foo", "foovalue");
42 messageProperties.put("bar", "barvalue");
43 messageProperties.put("baz", "bazvalue");
44
45 message = new DefaultMuleMessage(TEST_MESSAGE, messageProperties, muleContext);
46 }
47
48 @Test
49 public void requiredHeadersWithExitingValueShouldReturnValue()
50 {
51 Object result = evaluator.evaluate("foo, baz", message);
52 assertTrue(result instanceof List);
53
54 List<?> list = (List<?>) result;
55 assertEquals(2, list.size());
56 assertTrue(list.contains("foovalue"));
57 assertTrue(list.contains("bazvalue"));
58 assertFalse(list.contains("barvalue"));
59 }
60
61 @Test
62 public void requiredHeadersWithExistingValuesViaExpressionManagerShouldReturnValue()
63 {
64 Object result = muleContext.getExpressionManager().evaluate("#[headers-list:foo, baz]", message);
65 assertTrue(result instanceof List);
66
67 List<?> list = (List<?>) result;
68 assertEquals(2, list.size());
69 assertTrue(list.contains("foovalue"));
70 assertTrue(list.contains("bazvalue"));
71 assertFalse(list.contains("barvalue"));
72 }
73
74 @Test(expected = RequiredValueException.class)
75 public void requiredHeadersWithMissingValuesShouldFail()
76 {
77 evaluator.evaluate("nonexistent", message);
78 }
79
80 @Test(expected = RequiredValueException.class)
81 public void requiredHeadersWithMissingValuesViaExpressionManagerShouldFail()
82 {
83 muleContext.getExpressionManager().evaluate("#[headers-list:nonexistent]", message);
84 }
85
86 @Test
87 public void optionalHeadersWithExistingValuesShouldReturnValues()
88 {
89 Object result = evaluator.evaluate("foo?, baz?", message);
90 assertTrue(result instanceof List);
91
92 List<?> list = (List<?>) result;
93 assertEquals(2, list.size());
94 assertTrue(list.contains("foovalue"));
95 assertTrue(list.contains("bazvalue"));
96 assertFalse(list.contains("barvalue"));
97 }
98
99 @Test
100 public void optionalHeadersWithExistingValuesViaExpressionManagerShouldReturnValues()
101 {
102 Object result = muleContext.getExpressionManager().evaluate("#[headers-list:foo?, baz]", message);
103 assertTrue(result instanceof List);
104
105 List<?> list = (List<?>) result;
106 assertEquals(2, list.size());
107 assertTrue(list.contains("foovalue"));
108 assertTrue(list.contains("bazvalue"));
109 assertFalse(list.contains("barvalue"));
110
111 }
112
113 @Test
114 public void optionalHeadersWithMissingValuesShouldReturnEmptyList() throws Exception
115 {
116 Object result = evaluator.evaluate("fool?", message);
117 assertTrue(result instanceof List);
118
119 List<?> list = (List<?>) result;
120 assertEquals(0, list.size());
121 }
122
123 @Test
124 public void optionalHeadersWithMissingValuesViaExpressionManagerShouldReturnEmptyList()
125 {
126 Object result = muleContext.getExpressionManager().evaluate("#[headers-list:nonexistent?]", message);
127 assertTrue(result instanceof List);
128
129 List<?> list = (List<?>) result;
130 assertEquals(0, list.size());
131 }
132
133 @Test
134 public void requiredHeadersWithExplicitScopeShouldReturnValues()
135 {
136 Object result = evaluator.evaluate("OUTBOUND:foo, OUTBOUND:baz", message);
137 assertTrue(result instanceof List);
138
139 List<?> list = (List<?>) result;
140 assertEquals(2, list.size());
141 assertTrue(list.contains("foovalue"));
142 assertTrue(list.contains("bazvalue"));
143 assertFalse(list.contains("barvalue"));
144 }
145
146 @Test
147 public void propertyScopeSpecifiedForOneKeyShouldSetScopeForAllOtherKeys()
148 {
149
150 Object result = evaluator.evaluate("OUTBOUND:foo, baz", message);
151 assertNotNull(result);
152 assertTrue(result instanceof List);
153
154 List<?> list = (List<?>) result;
155 assertEquals(2, list.size());
156 assertTrue(list.contains("foovalue"));
157 assertTrue(list.contains("bazvalue"));
158 }
159
160 @Test
161 public void propertiesFromDifferentScopesWithValuesShouldReturnValues()
162 {
163 message.setProperty("faz", "fazvalue", PropertyScope.INVOCATION);
164
165 Object result = evaluator.evaluate("OUTBOUND:foo, OUTBOUND:baz, INVOCATION:faz", message);
166 assertTrue(result instanceof List);
167
168 List<?> list = (List<?>) result;
169 assertEquals(3, list.size());
170 assertTrue(list.contains("foovalue"));
171 assertTrue(list.contains("bazvalue"));
172 assertTrue(list.contains("fazvalue"));
173 }
174
175 @Test
176 public void matchAllWildcardShouldReturnAllHeaderValues()
177 {
178 Object result = evaluator.evaluate("*", message);
179 assertTrue(result instanceof List);
180
181 List<?> list = (List<?>) result;
182 assertEquals(3, list.size());
183 assertTrue(list.contains("foovalue"));
184 assertTrue(list.contains("bazvalue"));
185 assertTrue(list.contains("barvalue"));
186 }
187
188 @Test
189 public void matchAllWildcardViaExpressionManagerShouldReturnAllHeaderValues()
190 {
191 Object result = muleContext.getExpressionManager().evaluate("#[headers-list:*]", message);
192 assertTrue(result instanceof List);
193
194 List<?> list = (List<?>) result;
195 assertEquals(3, list.size());
196 assertTrue(list.contains("foovalue"));
197 assertTrue(list.contains("bazvalue"));
198 assertTrue(list.contains("barvalue"));
199 }
200
201 @Test
202 public void matchBeginningWildcardShouldReturnValues()
203 {
204 Object result = evaluator.evaluate("ba*", message);
205 assertTrue(result instanceof List);
206
207 List<?> list = (List<?>) result;
208 assertEquals(2, list.size());
209 assertTrue(list.contains("barvalue"));
210 assertTrue(list.contains("bazvalue"));
211 }
212
213 @Test
214 public void matchBeginningWildcardViaExpressionManagerShouldReturnValues()
215 {
216 Object result = muleContext.getExpressionManager().evaluate("#[headers-list:ba*]", message);
217 assertTrue(result instanceof List);
218
219 List<?> list = (List<?>) result;
220 assertEquals(2, list.size());
221 assertFalse(list.contains("foovalue"));
222 assertTrue(list.contains("bazvalue"));
223 assertTrue(list.contains("barvalue"));
224 }
225
226 @Test
227 public void wildcardWithNoMatchShouldReturnEmptyList()
228 {
229 Object result = evaluator.evaluate("x*", message);
230 assertTrue(result instanceof List);
231
232 List<?> list = (List<?>) result;
233 assertEquals(0, list.size());
234 }
235
236 @Test
237 public void wildcardWithNoMatchViaExpressionManagerShouldReturnEmptyList()
238 {
239 Object result = muleContext.getExpressionManager().evaluate("#[headers-list:x*]", message);
240 assertTrue(result instanceof List);
241
242 List<?> list = (List<?>) result;
243 assertEquals(0, list.size());
244 }
245
246 @Test
247 public void multipleWildcardsShouldReturnValues() throws Exception
248 {
249 Object result = evaluator.evaluate("ba*, f*", message);
250 assertTrue(result instanceof List);
251
252 List<?> list = (List<?>) result;
253 assertEquals(3, list.size());
254 assertTrue(list.contains("foovalue"));
255 assertTrue(list.contains("bazvalue"));
256 assertTrue(list.contains("barvalue"));
257 }
258
259 @Test
260 public void multipleWildcardsViaExpressionManagerShouldReturnValues()
261 {
262 Object result = muleContext.getExpressionManager().evaluate("#[headers-list:ba*, f*]", message);
263 assertTrue(result instanceof List);
264
265 List<?> list = (List<?>) result;
266 assertEquals(3, list.size());
267 assertTrue(list.contains("foovalue"));
268 assertTrue(list.contains("bazvalue"));
269 assertTrue(list.contains("barvalue"));
270 }
271 }