View Javadoc

1   /*
2    * $Id: ExpressionFilterTestCase.java 20497 2010-12-07 21:57:27Z dfeist $
3    * --------------------------------------------------------------------------------------
4    * Copyright (c) MuleSoft, Inc.  All rights reserved.  http://www.mulesoft.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  
11  package org.mule.routing.filters;
12  
13  import org.mule.DefaultMuleMessage;
14  import org.mule.api.MuleMessage;
15  import org.mule.message.DefaultExceptionPayload;
16  import org.mule.tck.AbstractMuleTestCase;
17  import org.mule.tck.testmodels.fruit.Apple;
18  
19  import java.io.IOException;
20  import java.util.HashMap;
21  import java.util.Map;
22  
23  public class ExpressionFilterTestCase extends AbstractMuleTestCase
24  {
25  
26      public void testHeaderFilter() throws Exception
27      {
28          ExpressionFilter filter = new ExpressionFilter("header", "foo=bar");
29          filter.setMuleContext(muleContext);
30          MuleMessage message = new DefaultMuleMessage("blah", muleContext);
31          assertTrue(!filter.accept(message));
32          message.setOutboundProperty("foo", "bar");
33          assertTrue(filter.accept(message));
34      }
35      
36      public void testVariableFilter() throws Exception
37      {
38          ExpressionFilter filter = new ExpressionFilter("variable", "foo=bar");
39          filter.setMuleContext(muleContext);
40          MuleMessage message = new DefaultMuleMessage("blah", muleContext);
41          assertTrue(!filter.accept(message));
42          message.setInvocationProperty("foo", "bar");
43          assertTrue(filter.accept(message));
44      }
45  
46      public void testHeaderFilterWithNot() throws Exception
47      {
48          ExpressionFilter filter = new ExpressionFilter("header", "foo!=bar");
49          filter.setMuleContext(muleContext);
50  
51          MuleMessage message = new DefaultMuleMessage("blah", muleContext);
52  
53          assertTrue(filter.accept(message));
54          message.setOutboundProperty("foo", "bar");
55          assertTrue(!filter.accept(message));
56          message.setOutboundProperty("foo", "car");
57          assertTrue(filter.accept(message));
58      }
59  
60      public void testVariableFilterWithNot() throws Exception
61      {
62          ExpressionFilter filter = new ExpressionFilter("variable", "foo!=bar");
63          filter.setMuleContext(muleContext);
64  
65          MuleMessage message = new DefaultMuleMessage("blah", muleContext);
66  
67          assertTrue(filter.accept(message));
68          message.setInvocationProperty("foo", "bar");
69          assertTrue(!filter.accept(message));
70          message.setInvocationProperty("foo", "car");
71          assertTrue(filter.accept(message));
72      }
73      
74      public void testHeaderFilterWithNotNull() throws Exception
75      {
76          ExpressionFilter filter = new ExpressionFilter("header", "foo!=null");
77          filter.setMuleContext(muleContext);
78  
79          MuleMessage message = new DefaultMuleMessage("blah", muleContext);
80  
81          assertTrue(!filter.accept(message));
82          message.removeProperty("foo");
83          assertTrue(!filter.accept(message));
84          message.setOutboundProperty("foo", "car");
85          assertTrue(filter.accept(message));
86      }
87      
88      public void testVariableFilterWithNotNull() throws Exception
89      {
90          ExpressionFilter filter = new ExpressionFilter("variable", "foo!=null");
91          filter.setMuleContext(muleContext);
92  
93          MuleMessage message = new DefaultMuleMessage("blah", muleContext);
94  
95          assertTrue(!filter.accept(message));
96          message.removeProperty("foo");
97          assertTrue(!filter.accept(message));
98          message.setInvocationProperty("foo", "car");
99          assertTrue(filter.accept(message));
100     }
101 
102     public void testRegexFilterNoPattern()
103     {
104         // start with default
105         RegExFilter filter = new RegExFilter();
106         assertNull(filter.getPattern());
107         assertFalse(filter.accept("No tengo dinero"));
108 
109         // activate a pattern
110         filter.setPattern("(.*) brown fox");
111         assertTrue(filter.accept("The quick brown fox"));
112 
113         // remove pattern again, i.e. block all
114         filter.setPattern(null);
115         assertFalse(filter.accept("oh-oh"));
116     }
117 
118     public void testRegexFilter()
119     {
120 
121         ExpressionFilter filter = new ExpressionFilter("regex", "The quick (.*)");
122         filter.setMuleContext(muleContext);
123 
124         assertNotNull(filter.getExpression());
125 
126         assertTrue(filter.accept(new DefaultMuleMessage("The quick brown fox", muleContext)));
127         assertTrue(filter.accept(new DefaultMuleMessage("The quick ", muleContext)));
128 
129         assertTrue(!filter.accept(new DefaultMuleMessage("The quickbrown fox", muleContext)));
130         assertTrue(!filter.accept(new DefaultMuleMessage("he quick brown fox", muleContext)));
131     }
132 
133     public void testRegexFilterWithAngleBrackets()
134     {
135 
136         ExpressionFilter filter = new ExpressionFilter("#[regex:The number is [1-9]]");
137         filter.setMuleContext(muleContext);
138 
139         assertNotNull(filter.getExpression());
140 
141         assertTrue(filter.accept(new DefaultMuleMessage("The number is 4", muleContext)));
142         assertFalse(filter.accept(new DefaultMuleMessage("Say again?", muleContext)));
143 
144         assertFalse(filter.accept(new DefaultMuleMessage("The number is 0", muleContext)));
145     }
146 
147     public void testExceptionTypeFilter()
148     {
149         ExpressionFilter filter = new ExpressionFilter("exception-type:java.lang.Exception");
150         filter.setMuleContext(muleContext);
151 
152         MuleMessage m = new DefaultMuleMessage("test", muleContext);
153         assertTrue(!filter.accept(m));
154         m.setExceptionPayload(new DefaultExceptionPayload(new IllegalArgumentException("test")));
155         assertTrue(filter.accept(m));
156 
157         filter = new ExpressionFilter("exception-type:java.io.IOException");
158         assertTrue(!filter.accept(m));
159         m.setExceptionPayload(new DefaultExceptionPayload(new IOException("test")));
160         assertTrue(filter.accept(m));
161     }
162 
163     public void testPayloadTypeFilter()
164     {
165         ExpressionFilter filter = new ExpressionFilter("payload-type:org.mule.tck.testmodels.fruit.Apple");
166         filter.setMuleContext(muleContext);
167 
168         assertTrue(filter.accept(new DefaultMuleMessage(new Apple(), muleContext)));
169         assertTrue(!filter.accept(new DefaultMuleMessage("test", muleContext)));
170 
171         filter = new ExpressionFilter("payload-type:java.lang.String");
172         assertTrue(filter.accept(new DefaultMuleMessage("test", muleContext)));
173         assertTrue(!filter.accept(new DefaultMuleMessage(new Exception("test"), muleContext)));
174     }
175 
176     public void testWildcardFilterMultiplePatterns()
177     {
178         ExpressionFilter filter = new ExpressionFilter("wildcard:* brown*, The*");
179         filter.setMuleContext(muleContext);
180 
181         assertTrue(filter.accept(new DefaultMuleMessage("The quick brown fox", muleContext)));
182         assertTrue(filter.accept(new DefaultMuleMessage(" brown fox", muleContext)));
183         assertTrue(filter.accept(new DefaultMuleMessage("The quickbrown fox", muleContext)));
184     }
185 
186     public void testTrueString()
187     {
188         ExpressionFilter filter = new ExpressionFilter("payload:");
189         filter.setMuleContext(muleContext);
190 
191         filter.setNullReturnsTrue(true);
192 
193         assertTrue(filter.accept(new DefaultMuleMessage("true", muleContext)));
194         assertTrue(filter.accept(new DefaultMuleMessage("TRUE", muleContext)));
195         assertTrue(filter.accept(new DefaultMuleMessage("tRuE", muleContext)));
196     }
197 
198     public void testFalseString()
199     {
200         ExpressionFilter filter = new ExpressionFilter("payload:");
201         filter.setMuleContext(muleContext);
202 
203         filter.setNullReturnsTrue(false);
204 
205         assertFalse(filter.accept(new DefaultMuleMessage("false", muleContext)));
206         assertFalse(filter.accept(new DefaultMuleMessage("FALSE", muleContext)));
207         assertFalse(filter.accept(new DefaultMuleMessage("faLSe", muleContext)));
208     }
209 
210     public void testExpressionFilter()
211     {
212         ExpressionFilter filter = new ExpressionFilter("mule:message.header(foo?)");
213         filter.setMuleContext(muleContext);
214 
215         filter.setNullReturnsTrue(false);
216 
217         assertFalse(filter.accept(new DefaultMuleMessage("x", muleContext)));
218         Map headers = new HashMap(1);
219         headers.put("foo", "bar");
220         assertTrue(filter.accept(new DefaultMuleMessage("x", headers, muleContext)));
221     }
222 
223     public void testExpressionFilterWithFullSyntax()
224     {
225         ExpressionFilter filter = new ExpressionFilter("#[mule:message.header(foo?)]");
226         filter.setMuleContext(muleContext);
227 
228         filter.setNullReturnsTrue(false);
229 
230         assertFalse(filter.accept(new DefaultMuleMessage("x", muleContext)));
231         Map headers = new HashMap(1);
232         headers.put("foo", "bar");
233         assertTrue(filter.accept(new DefaultMuleMessage("x", headers, muleContext)));
234     }
235 }