1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.commons.configuration.interpol;
18
19 import static org.junit.Assert.assertEquals;
20 import static org.junit.Assert.assertFalse;
21 import static org.junit.Assert.assertNull;
22 import static org.junit.Assert.assertTrue;
23
24 import java.util.HashMap;
25 import java.util.Map;
26 import java.util.Properties;
27
28 import org.apache.commons.lang.text.StrLookup;
29 import org.junit.After;
30 import org.junit.Before;
31 import org.junit.Test;
32
33
34
35
36
37
38 public class TestConfigurationInterpolator
39 {
40
41 private static final String TEST_PREFIX = "prefix";
42
43
44 private static final String TEST_NAME = "varname";
45
46
47 private static final String TEST_VALUE = "TestVariableValue";
48
49
50 private ConfigurationInterpolator interpolator;
51
52 @Before
53 public void setUp() throws Exception
54 {
55 interpolator = new ConfigurationInterpolator();
56 }
57
58
59
60
61
62 @After
63 public void tearDown() throws Exception
64 {
65 ConfigurationInterpolator.deregisterGlobalLookup(TEST_PREFIX);
66 }
67
68
69
70
71 @Test
72 public void testInit()
73 {
74 assertNull("A default lookup is set", interpolator.getDefaultLookup());
75 assertFalse("No predefined lookups", interpolator.prefixSet().isEmpty());
76 }
77
78
79
80
81
82 @Test(expected = IllegalArgumentException.class)
83 public void testRegisterGlobalLookupNullPrefix()
84 {
85 ConfigurationInterpolator.registerGlobalLookup(null, StrLookup
86 .noneLookup());
87 }
88
89
90
91
92 @Test(expected = IllegalArgumentException.class)
93 public void testRegisterGlobalLookupNull()
94 {
95 ConfigurationInterpolator.registerGlobalLookup(TEST_PREFIX, null);
96 }
97
98
99
100
101
102 @Test
103 public void testRegisterGlobalLookup()
104 {
105 ConfigurationInterpolator.registerGlobalLookup(TEST_PREFIX, StrLookup
106 .noneLookup());
107 ConfigurationInterpolator int2 = new ConfigurationInterpolator();
108 assertTrue("No lookup registered for test prefix", int2.prefixSet()
109 .contains(TEST_PREFIX));
110 assertFalse("Existing instance was modified", interpolator.prefixSet()
111 .contains(TEST_PREFIX));
112 }
113
114
115
116
117 @Test
118 public void testDeregisterGlobalLookup()
119 {
120 ConfigurationInterpolator.registerGlobalLookup(TEST_PREFIX, StrLookup
121 .noneLookup());
122 assertTrue("Lookup could not be deregistered",
123 ConfigurationInterpolator.deregisterGlobalLookup(TEST_PREFIX));
124 ConfigurationInterpolator int2 = new ConfigurationInterpolator();
125 assertFalse("Deregistered lookup still available", int2.prefixSet()
126 .contains(TEST_PREFIX));
127 }
128
129
130
131
132 @Test
133 public void testDeregisterGlobalLookupNonExisting()
134 {
135 assertFalse("Could deregister unknown global lookup",
136 ConfigurationInterpolator.deregisterGlobalLookup(TEST_PREFIX));
137 }
138
139
140
141
142 @Test
143 public void testRegisterLookup()
144 {
145 int cnt = interpolator.prefixSet().size();
146 interpolator.registerLookup(TEST_PREFIX, StrLookup.noneLookup());
147 assertTrue("New lookup not registered", interpolator.prefixSet()
148 .contains(TEST_PREFIX));
149 assertEquals("Wrong number of registered lookups", cnt + 1,
150 interpolator.prefixSet().size());
151 ConfigurationInterpolator int2 = new ConfigurationInterpolator();
152 assertFalse("Local registration has global impact", int2.prefixSet()
153 .contains(TEST_PREFIX));
154 }
155
156
157
158
159 @Test(expected = IllegalArgumentException.class)
160 public void testRegisterLookupNull()
161 {
162 interpolator.registerLookup(TEST_PREFIX, null);
163 }
164
165
166
167
168
169 @Test(expected = IllegalArgumentException.class)
170 public void testRegisterLookupNullPrefix()
171 {
172 interpolator.registerLookup(null, StrLookup.noneLookup());
173 }
174
175
176
177
178 @Test
179 public void testDeregisterLookup()
180 {
181 interpolator.registerLookup(TEST_PREFIX, StrLookup.noneLookup());
182 assertTrue("Derigstration not successfull", interpolator
183 .deregisterLookup(TEST_PREFIX));
184 assertFalse("Deregistered prefix still contained", interpolator
185 .prefixSet().contains(TEST_PREFIX));
186 }
187
188
189
190
191 @Test
192 public void testDeregisterLookupNonExisting()
193 {
194 assertFalse("Could deregister unknown lookup", interpolator
195 .deregisterLookup(TEST_PREFIX));
196 }
197
198
199
200
201
202 @Test
203 public void testLookupWithPrefix()
204 {
205 interpolator.registerLookup(TEST_PREFIX, setUpTestLookup());
206 assertEquals("Wrong variable value", TEST_VALUE, interpolator
207 .lookup(TEST_PREFIX + ':' + TEST_NAME));
208 }
209
210
211
212
213
214 @Test
215 public void testLookupWithUnknownPrefix()
216 {
217 interpolator.registerLookup(TEST_PREFIX, setUpTestLookup());
218 assertNull("Variable could be resolved", interpolator
219 .lookup("UnknownPrefix:" + TEST_NAME));
220 assertNull("Variable with empty prefix could be resolved", interpolator
221 .lookup(":" + TEST_NAME));
222 }
223
224
225
226
227
228 @Test
229 public void testLookupDefault()
230 {
231 interpolator.setDefaultLookup(setUpTestLookup());
232 assertEquals("Wrong variable value", TEST_VALUE, interpolator
233 .lookup(TEST_NAME));
234 }
235
236
237
238
239
240 @Test
241 public void testLookupNoDefault()
242 {
243 assertNull("Variable could be resolved", interpolator.lookup(TEST_NAME));
244 }
245
246
247
248
249 @Test
250 public void testLookupEmptyPrefix()
251 {
252 interpolator.registerLookup("", setUpTestLookup());
253 assertEquals("Wrong variable value", TEST_VALUE, interpolator
254 .lookup(":" + TEST_NAME));
255 }
256
257
258
259
260 @Test
261 public void testLookupEmptyVarName()
262 {
263 Map<String, String> map = new HashMap<String, String>();
264 map.put("", TEST_VALUE);
265 interpolator.registerLookup(TEST_PREFIX, StrLookup.mapLookup(map));
266 assertEquals("Wrong variable value", TEST_VALUE, interpolator
267 .lookup(TEST_PREFIX + ":"));
268 }
269
270
271
272
273 @Test
274 public void testLookupDefaultEmptyVarName()
275 {
276 Map<String, String> map = new HashMap<String, String>();
277 map.put("", TEST_VALUE);
278 interpolator.setDefaultLookup(StrLookup.mapLookup(map));
279 assertEquals("Wrong variable value", TEST_VALUE, interpolator
280 .lookup(""));
281 }
282
283
284
285
286 @Test
287 public void testLookupNull()
288 {
289 assertNull("Could resolve null variable", interpolator.lookup(null));
290 }
291
292
293
294
295
296
297 private StrLookup setUpTestLookup()
298 {
299 Map<String, String> map = new HashMap<String, String>();
300 map.put(TEST_NAME, TEST_VALUE);
301 return StrLookup.mapLookup(map);
302 }
303
304
305
306
307 @Test
308 public void testLookupSysProperties()
309 {
310 Properties sysProps = System.getProperties();
311 for (Object prop : sysProps.keySet())
312 {
313 String key = (String) prop;
314 assertEquals("Wrong value for system property " + key, sysProps
315 .getProperty(key), interpolator
316 .lookup(ConfigurationInterpolator.PREFIX_SYSPROPERTIES
317 + ":" + key));
318 }
319 }
320
321
322
323
324 @Test
325 public void testLookupConstants()
326 {
327 String varName = ConfigurationInterpolator.class.getName()
328 + ".PREFIX_CONSTANTS";
329 assertEquals("Wrong constant value",
330 ConfigurationInterpolator.PREFIX_CONSTANTS, interpolator
331 .lookup(ConfigurationInterpolator.PREFIX_CONSTANTS
332 + ":" + varName));
333 }
334
335
336
337
338
339
340 @Test
341 public void testLookupDefaultAfterPrefixFails()
342 {
343 final String varName = TEST_PREFIX + ':' + TEST_NAME + "2";
344 interpolator.registerLookup(TEST_PREFIX, setUpTestLookup());
345 Map<String, Object> map = new HashMap<String, Object>();
346 map.put(varName, TEST_VALUE);
347 interpolator.setDefaultLookup(StrLookup.mapLookup(map));
348 assertEquals("Variable is not resolved by default lookup", TEST_VALUE,
349 interpolator.lookup(varName));
350 }
351 }