View Javadoc

1   /*
2    * $Id: RegExFilterTestCase.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.MuleContext;
15  import org.mule.api.MuleMessage;
16  import org.mule.api.config.MuleConfiguration;
17  import org.mule.api.config.MuleProperties;
18  import org.mule.tck.junit4.AbstractMuleTestCase;
19  
20  import java.util.regex.Pattern;
21  
22  import org.junit.Test;
23  
24  import static org.junit.Assert.assertEquals;
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  import static org.mockito.Mockito.mock;
30  import static org.mockito.Mockito.when;
31  
32  public class RegExFilterTestCase extends AbstractMuleTestCase
33  {
34      private static final String PATTERN = "(.*) brown fox";
35  
36      @Test
37      public void testRegexFilterNoPattern()
38      {
39          // start with default
40          RegExFilter filter = new RegExFilter();
41          assertNull(filter.getPattern());
42          assertFalse(filter.accept("No tengo dinero"));
43  
44          // activate a pattern
45          filter.setPattern("(.*) brown fox");
46          assertTrue(filter.accept("The quick brown fox"));
47  
48          // remove pattern again, i.e. block all
49          filter.setPattern(null);
50          assertFalse(filter.accept("oh-oh"));
51      }
52  
53      @Test
54      public void testRegexFilter()
55      {
56          RegExFilter filter = new RegExFilter("The quick (.*)");
57          assertNotNull(filter.getPattern());
58  
59          assertTrue(filter.accept("The quick brown fox"));
60          assertTrue(filter.accept("The quick "));
61  
62          assertFalse(filter.accept("The quickbrown fox"));
63          assertFalse(filter.accept("he quick brown fox"));
64  
65          filter.setPattern("(.*) brown fox");
66          assertTrue(filter.accept("The quick brown fox"));
67          assertTrue(filter.accept(" brown fox"));
68  
69          assertFalse(filter.accept("The quickbrown fox"));
70          assertFalse(filter.accept("The quick brown fo"));
71  
72          filter.setPattern("(.*) brown (.*)");
73          assertTrue(filter.accept("The quick brown fox"));
74          assertTrue(filter.accept("(.*) brown fox"));
75  
76          assertFalse(filter.accept("The quickbrown fox"));
77          assertTrue(filter.accept("The quick brown fo"));
78  
79          filter.setPattern("(.*)");
80          assertTrue(filter.accept("The quick brown fox"));
81      }
82  
83      @Test
84      public void testNullInput()
85      {
86          RegExFilter filter = new RegExFilter("The quick (.*)");
87          assertNotNull(filter.getPattern());
88          assertFalse(filter.accept((Object) null));
89      }
90  
91      @Test
92      public void testMuleMessageInput()
93      {
94          RegExFilter filter = new RegExFilter("The quick (.*)");
95          assertNotNull(filter.getPattern());
96  
97          MuleConfiguration muleConfiguration = mock(MuleConfiguration.class);
98          when(muleConfiguration.isCacheMessageAsBytes()).thenReturn(false);
99          MuleContext muleContext= mock(MuleContext.class);
100         when(muleContext.getConfiguration()).thenReturn(muleConfiguration);
101 
102         MuleMessage message = new DefaultMuleMessage("The quick brown fox", muleContext);
103         assertTrue(filter.accept(message));
104     }
105 
106     @Test
107     public void testByteArrayInput()
108     {
109         System.setProperty(MuleProperties.MULE_ENCODING_SYSTEM_PROPERTY, "UTF-8");
110         RegExFilter filter = new RegExFilter("The quick (.*)");
111         assertNotNull(filter.getPattern());
112 
113         byte[] bytes = "The quick brown fox".getBytes();
114         assertTrue(filter.accept(bytes));
115     }
116 
117     @Test
118     public void testCharArrayInput()
119     {
120         RegExFilter filter = new RegExFilter("The quick (.*)");
121         assertNotNull(filter.getPattern());
122 
123         char[] chars = "The quick brown fox".toCharArray();
124         assertTrue(filter.accept(chars));
125     }
126 
127     @Test
128     public void testEqualsWithSamePattern()
129     {
130         RegExFilter filter1 = new RegExFilter(PATTERN);
131         RegExFilter filter2 = new RegExFilter(PATTERN);
132         assertEquals(filter1, filter2);
133     }
134 
135     @Test
136     public void testEqualsWithDifferentPattern()
137     {
138         RegExFilter filter1 = new RegExFilter("foo");
139         RegExFilter filter2 = new RegExFilter("bar");
140         assertFalse(filter1.equals(filter2));
141     }
142 
143     @Test
144     public void testEqualsWithEqualPatternAndDifferentFlags()
145     {
146         RegExFilter filter1 = new RegExFilter(PATTERN, Pattern.DOTALL);
147         RegExFilter filter2 = new RegExFilter(PATTERN, Pattern.CASE_INSENSITIVE);
148         assertFalse(filter1.equals(filter2));
149 
150         filter1 = new RegExFilter(PATTERN, Pattern.DOTALL);
151         filter2 = new RegExFilter(PATTERN, Pattern.DOTALL);
152         assertEquals(filter1, filter2);
153     }
154 }