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.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         // this is equivalent to OUTBOUND:foo, OUTBOUND,:baz
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 }