1   /*
2    * $Id: HeadersExpressionEvaluatorTestCase.java 11290 2008-03-09 12:01:48Z rossmason $
3    * --------------------------------------------------------------------------------------
4    * Copyright (c) MuleSource, Inc.  All rights reserved.  http://www.mulesource.com
5    *
6    * The software in this package is published under the terms of the CPAL v1.0
7    * license, a copy of which has been included with this distribution in the
8    * LICENSE.txt file.
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.MessageHeaderExpressionEvaluator;
16  import org.mule.util.expression.MessageHeadersExpressionEvaluator;
17  import org.mule.util.expression.MessageHeadersListExpressionEvaluator;
18  import org.mule.util.expression.ExpressionEvaluatorManager;
19  
20  import java.util.HashMap;
21  import java.util.List;
22  import java.util.Map;
23  
24  public class HeadersExpressionEvaluatorTestCase extends AbstractMuleTestCase
25  {
26      private Map props;
27  
28      //@Override
29      public void doSetUp()
30      {
31          props = new HashMap(3);
32          props.put("foo", "moo");
33          props.put("bar", "mar");
34          props.put("baz", "maz");
35      }
36  
37      public void testSingleHeader() throws Exception
38      {
39          MessageHeaderExpressionEvaluator eval = new MessageHeaderExpressionEvaluator();
40          MuleMessage message = new DefaultMuleMessage("test", props);
41  
42          Object result = eval.evaluate("foo", message);
43          assertNotNull(result);
44          assertEquals("moo", result);
45  
46          result = eval.evaluate("fool", message);
47          assertNull(result);
48  
49          result = eval.evaluate("foo", new Object());
50          assertNull(result);
51  
52      }
53  
54      public void testMapHeaders() throws Exception
55      {
56          MessageHeadersExpressionEvaluator eval = new MessageHeadersExpressionEvaluator();
57  
58          MuleMessage message = new DefaultMuleMessage("test", props);
59  
60          Object result = eval.evaluate("foo, baz", message);
61          assertNotNull(result);
62          assertTrue(result instanceof Map);
63          assertEquals(2, ((Map)result).size());
64          assertTrue(((Map)result).values().contains("moo"));
65          assertTrue(((Map)result).values().contains("maz"));
66          assertFalse(((Map)result).values().contains("mar"));
67  
68          result = eval.evaluate("fool", message);
69          assertNull(result);
70  
71          result = eval.evaluate("foo", new Object());
72          assertNull(result);
73  
74      }
75  
76      public void testListHeaders() throws Exception
77      {
78          MessageHeadersListExpressionEvaluator eval = new MessageHeadersListExpressionEvaluator();
79          MuleMessage message = new DefaultMuleMessage("test", props);
80  
81          Object result = eval.evaluate("foo, baz", message);
82          assertNotNull(result);
83          assertTrue(result instanceof List);
84          assertEquals(2, ((List)result).size());
85          assertTrue(((List)result).contains("moo"));
86          assertTrue(((List)result).contains("maz"));
87          assertFalse(((List)result).contains("mar"));
88  
89          result = eval.evaluate("fool", message);
90          assertNull(result);
91  
92          result = eval.evaluate("foo", new Object());
93          assertNull(result);
94  
95      }
96  
97  
98      public void testSingleHeaderUsingManager() throws Exception
99      {
100         MuleMessage message = new DefaultMuleMessage("test", props);
101 
102         Object result = ExpressionEvaluatorManager.evaluate("${header:foo}", message);
103         assertNotNull(result);
104         assertEquals("moo", result);
105 
106         result = ExpressionEvaluatorManager.evaluate("${header:fool}", message);
107         assertNull(result);
108 
109         result = ExpressionEvaluatorManager.evaluate("${header:foo}", new Object());
110         assertNull(result);
111 
112     }
113 
114     public void testMapHeadersUsingManager() throws Exception
115     {
116 
117         MuleMessage message = new DefaultMuleMessage("test", props);
118 
119         Object result = ExpressionEvaluatorManager.evaluate("${headers:foo, baz}", message);
120         assertNotNull(result);
121         assertTrue(result instanceof Map);
122         assertEquals(2, ((Map)result).size());
123         assertTrue(((Map)result).values().contains("moo"));
124         assertTrue(((Map)result).values().contains("maz"));
125         assertFalse(((Map)result).values().contains("mar"));
126 
127         result = ExpressionEvaluatorManager.evaluate("${headers:fool}", message);
128         assertNull(result);
129 
130         result = ExpressionEvaluatorManager.evaluate("${headers:foo}", new Object());
131         assertNull(result);
132 
133     }
134 
135     public void testListHeadersUsingManager() throws Exception
136     {
137         MuleMessage message = new DefaultMuleMessage("test", props);
138 
139         Object result = ExpressionEvaluatorManager.evaluate("${headers-list:foo, baz}", message);
140         assertNotNull(result);
141         assertTrue(result instanceof List);
142         assertEquals(2, ((List)result).size());
143         assertTrue(((List)result).contains("moo"));
144         assertTrue(((List)result).contains("maz"));
145         assertFalse(((List)result).contains("mar"));
146 
147         result = ExpressionEvaluatorManager.evaluate("${headers-list:fool}", message);
148         assertNull(result);
149 
150         result = ExpressionEvaluatorManager.evaluate("${headers-list:foo}", new Object());
151         assertNull(result);
152 
153     }
154 }