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.util;
8   
9   import static org.junit.Assert.assertEquals;
10  import static org.junit.Assert.assertFalse;
11  import static org.junit.Assert.assertNotNull;
12  import static org.junit.Assert.assertTrue;
13  import org.mule.tck.junit4.AbstractMuleTestCase;
14  
15  import java.util.ArrayList;
16  import java.util.Collections;
17  import java.util.HashMap;
18  import java.util.List;
19  import java.util.Map;
20  
21  import org.junit.Test;
22  
23  public class TemplateParserTestCase extends AbstractMuleTestCase
24  {
25      @Test
26      public void squareBracesParserDefaultConfiguration()
27      {
28          TemplateParser tp = TemplateParser.createSquareBracesStyleParser();
29          assertNotNull(tp.getStyle());
30          assertEquals("[", tp.getStyle().getPrefix());
31          assertEquals("]", tp.getStyle().getSuffix());
32      }
33  
34      @Test
35      public void squareBracesParserShouldReplaceKnownTokens()
36      {
37          TemplateParser tp = TemplateParser.createSquareBracesStyleParser();
38  
39          Map<String, String> map = Collections.singletonMap("fromAddress", "ross.mason@symphonysoft.com");
40          String template = "smtp://[fromAddress]";
41  
42          String result = tp.parse(map, template);
43          assertEquals("smtp://ross.mason@symphonysoft.com", result);
44      }
45  
46      @Test
47      public void squareBracesParserShouldNotReplaceUnknownTokens()
48      {
49          TemplateParser tp = TemplateParser.createSquareBracesStyleParser();
50  
51          Map<String, String> map = Collections.emptyMap();
52          String template = "smtp://[toAddress]";
53  
54          String result = tp.parse(map, template);
55          assertEquals("smtp://[toAddress]", result);
56      }
57  
58      @Test
59      public void squareBracesParserShouldValidateExpressionDelimiters()
60      {
61          TemplateParser tp = TemplateParser.createSquareBracesStyleParser();
62          assertTrue(tp.isValid("[1][2]"));
63          assertFalse(tp.isValid("[[1]2]"));
64          assertFalse(tp.isValid("[[1][2]"));
65      }
66  
67      @Test
68      public void antParserDefaultConfiguration()
69      {
70          TemplateParser tp = TemplateParser.createAntStyleParser();
71          assertNotNull(tp.getStyle());
72          assertEquals("${", tp.getStyle().getPrefix());
73          assertEquals("}", tp.getStyle().getSuffix());
74      }
75  
76      @Test
77      public void antParserShouldValidateExpressionDelimiters()
78      {
79          TemplateParser tp = TemplateParser.createAntStyleParser();
80          assertTrue(tp.isValid("${1}"));
81          assertTrue(tp.isValid("${1}${2}"));
82          assertTrue(tp.isValid("${1}&{2}"));
83          assertTrue(tp.isValid("{1}${2}"));
84          assertTrue(tp.isValid("${$}${1}"));
85          assertTrue(tp.isValid("$ {1}"));
86  
87          assertFalse(tp.isValid("${${1}}${2}"));
88          assertFalse(tp.isValid("${{1}${2}"));
89      }
90  
91      @Test
92      public void antParserShouldReplaceKnownTokens()
93      {
94          TemplateParser tp = TemplateParser.createAntStyleParser();
95  
96          Map<String, Object> map = buildMap();
97          String template = "Some String with ${prop1} and ${prop2} in it";
98  
99          String result = tp.parse(map, template);
100         assertEquals("Some String with value1 and value2 in it", result);
101     }
102 
103 
104     @Test
105     public void antParserShouldNotReplaceUnknownTokens()
106     {
107         TemplateParser tp = TemplateParser.createAntStyleParser();
108 
109         Map<String, String> map = Collections.emptyMap();
110         String template = "Some String with ${prop1} in it";
111 
112         String result = tp.parse(map, template);
113         assertEquals("Some String with ${prop1} in it", result);
114     }
115 
116     @Test
117     public void antParserShouldHandleWhitespaceAndBackslashesCorrectly()
118     {
119         TemplateParser tp = TemplateParser.createAntStyleParser();
120 
121         String dir = "C:\\Documents and Settings\\";
122         Map<String, String> map = Collections.singletonMap("dir", dir);
123         String template = "start${dir}end";
124 
125         String result = tp.parse(map, template);
126         assertEquals("startC:\\Documents and Settings\\end", result);
127     }
128 
129     @Test
130     public void antParserWithListInputShouldReplaceKnownTokens()
131     {
132         TemplateParser tp = TemplateParser.createAntStyleParser();
133 
134         Map<String, Object> map = buildMap();
135 
136         List<String> templates = new ArrayList<String>();
137         templates.add("Some String with ${prop1} and ${prop2} in it");
138         templates.add("Some String with ${prop1} in it");
139 
140         List<?> result = tp.parse(map, templates);
141         assertEquals("Some String with value1 and value2 in it", result.get(0));
142         assertEquals("Some String with value1 in it", result.get(1));
143     }
144 
145     @Test
146     public void antParserWithNullListInputShouldNotReplaceTokens()
147     {
148         TemplateParser tp = TemplateParser.createAntStyleParser();
149 
150         Map<String, Object> map = buildMap();
151         List<?> result = tp.parse(map, (List<?>)null);
152         assertNotNull(result);
153         assertEquals(0, result.size());
154     }
155 
156     @Test
157     public void antParserWithSimilarTokensShouldNotBeConfused()
158     {
159         TemplateParser tp = TemplateParser.createAntStyleParser();
160 
161         Map<String, Object> map = buildMap();
162         map.put("prop1-2", "value2");
163 
164         String template = "Some String with ${prop1} and ${prop1-2} in it";
165 
166         String result = tp.parse(map, template);
167         assertEquals("Some String with value1 and value2 in it", result);
168     }
169 
170     @Test
171     public void antParserWithOptionalTokenShouldReplaceKnownTokens()
172     {
173         TemplateParser tp = TemplateParser.createAntStyleParser();
174 
175         Map<String, Object> props = new HashMap<String, Object>();
176         props.put("prop1?", "value1");
177         props.put("prop1-2", "value2");
178 
179         String template = "Some String with ${prop1?} and ${prop1-2} in it";
180 
181         String result = tp.parse(props, template);
182         assertEquals("Some String with value1 and value2 in it", result);
183     }
184 
185     @Test
186     public void muleParserManagesPipeCharacter()
187     {
188         TemplateParser tp = TemplateParser.createMuleStyleParser();
189 
190         final String expectedResult = "Hello|Hi";
191 
192         String result = tp.parse(null, "#[evaluator: 'Hello|Hi']", new TemplateParser.TemplateCallback()
193         {
194             public Object match(String token)
195             {
196 
197                 return expectedResult;
198             }
199         });
200 
201         assertEquals(expectedResult, result);
202     }
203 
204     @Test
205     public void muleParserManagesNestedSquareBrackets()
206     {
207         TemplateParser tp = TemplateParser.createMuleStyleParser();
208         final String expectedResult = "zero[one[two[three[four[five]]]]]";
209         String expression = "#[zero[one[two[three[four[five]]]]]]";
210         assertTrue(tp.isValid(expression));
211         String result = tp.parse(null, expression, new TemplateParser.TemplateCallback()
212         {
213             public Object match(String token)
214             {
215                 return expectedResult;
216             }
217         });
218         assertEquals(expectedResult, result);
219     }
220 
221     @Test
222     public void muleParserManagesNestedExpressions()
223     {
224         TemplateParser tp = TemplateParser.createMuleStyleParser();
225         final String expectedResult = "zero#[one#[two#[three#[four#[five]]]]]";
226         String expression = "#[zero#[one#[two#[three#[four#[five]]]]]]";
227         assertTrue(tp.isValid(expression));
228         String result = tp.parse(null, expression, new TemplateParser.TemplateCallback()
229         {
230             public Object match(String token)
231             {
232                 return expectedResult;
233             }
234         });
235         assertEquals(expectedResult, result);
236     }
237 
238     @Test
239     public void muleParserManagesConcatenation()
240     {
241         TemplateParser tp = TemplateParser.createMuleStyleParser();
242 
243         final String expectedResult = "'hi'+'world'";
244 
245         String result = tp.parse(null, "#['hi'+'world']", new TemplateParser.TemplateCallback()
246         {
247             public Object match(String token)
248             {
249 
250                 return expectedResult;
251             }
252         });
253 
254         assertEquals(expectedResult, result);
255     }
256 
257     @Test
258     public void muleParserManagesNullExpressions()
259     {
260         TemplateParser tp = TemplateParser.createMuleStyleParser();
261 
262         final String expectedResult = "null";
263 
264         String result = tp.parse(null, "#[expression that returns null]", new TemplateParser.TemplateCallback()
265         {
266             public Object match(String token)
267             {
268                 return null;
269             }
270         });
271 
272         assertEquals(expectedResult, result);
273     }
274 
275 
276     @Test
277     public void muleParserDefaultConfiguration()
278     {
279         TemplateParser tp = TemplateParser.createMuleStyleParser();
280         assertNotNull(tp.getStyle());
281         assertEquals("#[", tp.getStyle().getPrefix());
282         assertEquals("]", tp.getStyle().getSuffix());
283     }
284 
285     @Test
286     public void muleParserShouldValidateExpressionDelimiters()
287     {
288         TemplateParser tp = TemplateParser.createMuleStyleParser();
289 
290         assertTrue(tp.isValid("#[]"));
291         assertTrue(tp.isValid("#[]   #[]"));
292         assertTrue(tp.isValid("#[]&[]"));
293         assertTrue(tp.isValid("[]$[]#"));
294         assertTrue(tp.isValid("#[#]#[]"));
295         assertTrue(tp.isValid("#[#[]]#[]"));
296         assertTrue(tp.isValid("# []"));
297 
298         //can't have unbalanced brackets
299         assertFalse(tp.isValid("#[#[]#[]"));
300         assertFalse(tp.isValid("#[[][]"));
301 
302         assertTrue(tp.isValid("#[foo:blah[4] = 'foo']"));
303         assertTrue(tp.isValid("#[foo:blah[4] = '#foo']"));
304         assertTrue(tp.isValid("#[foo:blah4] = '#foo']"));
305         assertTrue(tp.isValid("#[foo:blah = '#[foo]']"));
306     }
307 
308     private Map<String, Object> buildMap()
309     {
310         Map<String, Object> props = new HashMap<String, Object>();
311         props.put("prop1", "value1");
312         props.put("prop2", "value2");
313         return props;
314     }
315 }