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