1
2
3
4
5
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
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 }