View Javadoc

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