View Javadoc
1   /*
2    * Copyright (c) MuleSoft, Inc.  All rights reserved.  http://www.mulesoft.com
3    * The software in this package is published under the terms of the CPAL v1.0
4    * license, a copy of which has been included with this distribution in the
5    * LICENSE.txt file.
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         // this is equivalent to OUTBOUND:foo, OUTBOUND:baz
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 }