View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *     http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  package org.apache.commons.configuration2.builder.combined;
18  
19  import static org.junit.jupiter.api.Assertions.assertEquals;
20  import static org.junit.jupiter.api.Assertions.assertFalse;
21  import static org.junit.jupiter.api.Assertions.assertNotNull;
22  import static org.junit.jupiter.api.Assertions.assertNotSame;
23  import static org.junit.jupiter.api.Assertions.assertNull;
24  import static org.junit.jupiter.api.Assertions.assertSame;
25  import static org.junit.jupiter.api.Assertions.assertThrows;
26  import static org.junit.jupiter.api.Assertions.assertTrue;
27  import static org.mockito.Mockito.mock;
28  import static org.mockito.Mockito.verify;
29  
30  import java.util.Collections;
31  import java.util.HashMap;
32  import java.util.Map;
33  
34  import org.apache.commons.configuration2.ConfigurationAssert;
35  import org.apache.commons.configuration2.XMLConfiguration;
36  import org.apache.commons.configuration2.beanutils.BeanHelper;
37  import org.apache.commons.configuration2.builder.BasicBuilderParameters;
38  import org.apache.commons.configuration2.builder.BasicConfigurationBuilder;
39  import org.apache.commons.configuration2.builder.BuilderParameters;
40  import org.apache.commons.configuration2.builder.ConfigurationBuilder;
41  import org.apache.commons.configuration2.builder.DefaultParametersHandler;
42  import org.apache.commons.configuration2.builder.DefaultParametersManager;
43  import org.apache.commons.configuration2.builder.XMLBuilderParametersImpl;
44  import org.apache.commons.configuration2.builder.fluent.FileBasedBuilderParameters;
45  import org.junit.jupiter.api.Test;
46  
47  /**
48   * Test class for {@code CombinedBuilderParametersImpl}.
49   */
50  public class TestCombinedBuilderParametersImpl {
51      /**
52       * Creates a mock for a defaults handler.
53       *
54       * @return the handler mock
55       */
56      @SuppressWarnings("unchecked")
57      private static DefaultParametersHandler<BuilderParameters> createDefaultsHandlerMock() {
58          return mock(DefaultParametersHandler.class);
59      }
60  
61      /**
62       * Tests whether cloning works as expected.
63       */
64      @Test
65      public void testClone() {
66          final CombinedBuilderParametersImpl params = new CombinedBuilderParametersImpl();
67          params.setBasePath("some base path");
68          final XMLBuilderParametersImpl defParams = new XMLBuilderParametersImpl();
69          defParams.setSystemID("someSysID");
70          params.setDefinitionBuilderParameters(defParams);
71          final CombinedBuilderParametersImpl clone = params.clone();
72          assertEquals(params.getBasePath(), clone.getBasePath());
73          assertNotSame(params.getDefinitionBuilderParameters(), clone.getDefinitionBuilderParameters());
74          assertEquals(params.getDefinitionBuilderParameters().getParameters().get("systemID"),
75                  clone.getDefinitionBuilderParameters().getParameters().get("systemID"));
76      }
77  
78      /**
79       * Tests whether a new instance can be created if none is found in the parameters map.
80       */
81      @Test
82      public void testFromParametersCreate() {
83          final CombinedBuilderParametersImpl params = CombinedBuilderParametersImpl.fromParameters(new HashMap<>(), true);
84          assertNotNull(params);
85          assertNull(params.getDefinitionBuilder());
86      }
87  
88      /**
89       * Tests whether an instance can be obtained from a parameters map.
90       */
91      @Test
92      public void testFromParametersExisting() {
93          final CombinedBuilderParametersImpl params = new CombinedBuilderParametersImpl();
94          final Map<String, Object> map = params.getParameters();
95          assertSame(params, CombinedBuilderParametersImpl.fromParameters(map));
96      }
97  
98      /**
99       * Tests fromParameters() if the map does not contain an instance.
100      */
101     @Test
102     public void testFromParametersNotFound() {
103         assertNull(CombinedBuilderParametersImpl.fromParameters(new HashMap<>()));
104     }
105 
106     /**
107      * Tests whether a default parameters manager can be set and queried.
108      */
109     @Test
110     public void testGetChildDefaultParametersManagerSpecific() {
111         final DefaultParametersManager manager = mock(DefaultParametersManager.class);
112         final CombinedBuilderParametersImpl params = new CombinedBuilderParametersImpl();
113         assertSame(params, params.setChildDefaultParametersManager(manager));
114         assertSame(manager, params.getChildDefaultParametersManager());
115     }
116 
117     /**
118      * Tests whether a default parameters manager is dynamically created if it has not been set.
119      */
120     @Test
121     public void testGetChildDefaultParametersManagerUndefined() {
122         final CombinedBuilderParametersImpl params = new CombinedBuilderParametersImpl();
123         assertNotNull(params.getChildDefaultParametersManager());
124     }
125 
126     /**
127      * Tests that inherited properties are also stored in the parameters map.
128      */
129     @Test
130     public void testGetParametersInherited() {
131         final CombinedBuilderParametersImpl params = new CombinedBuilderParametersImpl();
132         params.setThrowExceptionOnMissing(true);
133         final Map<String, Object> map = params.getParameters();
134         assertEquals(Boolean.TRUE, map.get("throwExceptionOnMissing"));
135     }
136 
137     /**
138      * Tests whether the map with providers is initially empty.
139      */
140     @Test
141     public void testGetProvidersInitial() {
142         final CombinedBuilderParametersImpl params = new CombinedBuilderParametersImpl();
143         assertEquals(Collections.emptyMap(), params.getProviders());
144     }
145 
146     /**
147      * Tests that the map with providers cannot be modified.
148      */
149     @Test
150     public void testGetProvidersModify() {
151         final CombinedBuilderParametersImpl params = new CombinedBuilderParametersImpl();
152         final Map<String, ConfigurationBuilderProvider> providers = params.getProviders();
153         final ConfigurationBuilderProvider provider = mock(ConfigurationBuilderProvider.class);
154         assertThrows(UnsupportedOperationException.class, () -> providers.put("tag", provider));
155     }
156 
157     /**
158      * Tests whether properties can be inherited.
159      */
160     @Test
161     public void testInheritFrom() {
162         final DefaultParametersManager manager = mock(DefaultParametersManager.class);
163         final CombinedBuilderParametersImpl params = new CombinedBuilderParametersImpl().setInheritSettings(false).setChildDefaultParametersManager(manager);
164         params.setThrowExceptionOnMissing(true);
165         final CombinedBuilderParametersImpl params2 = new CombinedBuilderParametersImpl();
166 
167         params2.inheritFrom(params.getParameters());
168         final Map<String, Object> parameters = params2.getParameters();
169         assertEquals(Boolean.TRUE, parameters.get("throwExceptionOnMissing"));
170         assertEquals(manager, params2.getChildDefaultParametersManager());
171         assertFalse(params2.isInheritSettings());
172     }
173 
174     /**
175      * Tests that inheritFrom() can handle a map which does not contain a parameters object.
176      */
177     @Test
178     public void testInheritFromNoParametersInMap() {
179         final BasicBuilderParameters params = new BasicBuilderParameters().setThrowExceptionOnMissing(true);
180         final CombinedBuilderParametersImpl params2 = new CombinedBuilderParametersImpl();
181 
182         params2.inheritFrom(params.getParameters());
183         final Map<String, Object> parameters = params2.getParameters();
184         assertEquals(Boolean.TRUE, parameters.get("throwExceptionOnMissing"));
185     }
186 
187     /**
188      * Tests the result for an unknown provider.
189      */
190     @Test
191     public void testProviderForUnknown() {
192         final CombinedBuilderParametersImpl params = new CombinedBuilderParametersImpl();
193         assertNull(params.providerForTag("someTag"));
194     }
195 
196     /**
197      * Tests whether a defaults handler for a child source can be registered.
198      */
199     @Test
200     public void testRegisterChildDefaultsHandler() {
201         final DefaultParametersManager manager = mock(DefaultParametersManager.class);
202         final DefaultParametersHandler<BuilderParameters> handler = createDefaultsHandlerMock();
203         final CombinedBuilderParametersImpl params = new CombinedBuilderParametersImpl();
204         params.setChildDefaultParametersManager(manager);
205         assertSame(params, params.registerChildDefaultsHandler(BuilderParameters.class, handler));
206 
207         verify(manager).registerDefaultsHandler(BuilderParameters.class, handler);
208     }
209 
210     /**
211      * Tests whether a defaults handler for a child source with a class restriction can be registered.
212      */
213     @Test
214     public void testRegisterChildDefaultsHandlerWithStartClass() {
215         final DefaultParametersManager manager = mock(DefaultParametersManager.class);
216         final DefaultParametersHandler<BuilderParameters> handler = createDefaultsHandlerMock();
217         final CombinedBuilderParametersImpl params = new CombinedBuilderParametersImpl();
218         params.setChildDefaultParametersManager(manager);
219         assertSame(params, params.registerChildDefaultsHandler(BuilderParameters.class, handler, FileBasedBuilderParameters.class));
220 
221         verify(manager).registerDefaultsHandler(BuilderParameters.class, handler, FileBasedBuilderParameters.class);
222     }
223 
224     /**
225      * Tests whether missing providers can be registered.
226      */
227     @Test
228     public void testRegisterMissingProviders() {
229         final ConfigurationBuilderProvider provider1 = mock(ConfigurationBuilderProvider.class);
230         final ConfigurationBuilderProvider provider2 = mock(ConfigurationBuilderProvider.class);
231         final ConfigurationBuilderProvider provider3 = mock(ConfigurationBuilderProvider.class);
232         final String tagPrefix = "testTag";
233         final CombinedBuilderParametersImpl params = new CombinedBuilderParametersImpl();
234         params.registerProvider(tagPrefix, provider1);
235         final Map<String, ConfigurationBuilderProvider> map = new HashMap<>();
236         map.put(tagPrefix, provider2);
237         map.put(tagPrefix + 1, provider3);
238         assertSame(params, params.registerMissingProviders(map));
239         assertEquals(2, params.getProviders().size());
240         assertSame(provider1, params.providerForTag(tagPrefix));
241         assertSame(provider3, params.providerForTag(tagPrefix + 1));
242     }
243 
244     /**
245      * Tries to register a map with missing providers containing a null entry.
246      */
247     @Test
248     public void testRegisterMissingProvidersNullEntry() {
249         final Map<String, ConfigurationBuilderProvider> map = new HashMap<>();
250         map.put("tag", null);
251         final CombinedBuilderParametersImpl builderParameters = new CombinedBuilderParametersImpl();
252         assertThrows(IllegalArgumentException.class, () -> builderParameters.registerMissingProviders(map));
253     }
254 
255     /**
256      * Tries to register a null map with missing providers.
257      */
258     @Test
259     public void testRegisterMissingProvidersNullMap() {
260         final Map<String, ConfigurationBuilderProvider> map = null;
261         final CombinedBuilderParametersImpl builderParameters = new CombinedBuilderParametersImpl();
262         assertThrows(IllegalArgumentException.class, () -> builderParameters.registerMissingProviders(map));
263     }
264 
265     /**
266      * Tests whether missing providers can be copied from a parameters object.
267      */
268     @Test
269     public void testRegisterMissingProvidersParams() {
270         final ConfigurationBuilderProvider provider1 = mock(ConfigurationBuilderProvider.class);
271         final ConfigurationBuilderProvider provider2 = mock(ConfigurationBuilderProvider.class);
272         final ConfigurationBuilderProvider provider3 = mock(ConfigurationBuilderProvider.class);
273         final String tagPrefix = "testTag";
274         final CombinedBuilderParametersImpl params = new CombinedBuilderParametersImpl();
275         final CombinedBuilderParametersImpl params2 = new CombinedBuilderParametersImpl();
276         params.registerProvider(tagPrefix, provider1);
277         params2.registerProvider(tagPrefix, provider2);
278         params2.registerProvider(tagPrefix + 1, provider3);
279         assertSame(params, params.registerMissingProviders(params2));
280         assertEquals(2, params.getProviders().size());
281         assertSame(provider1, params.providerForTag(tagPrefix));
282         assertSame(provider3, params.providerForTag(tagPrefix + 1));
283     }
284 
285     /**
286      * Tries to copy providers from a null parameters object.
287      */
288     @Test
289     public void testRegisterMissingProvidersParamsNull() {
290         final CombinedBuilderParametersImpl builderParameters = new CombinedBuilderParametersImpl();
291         assertThrows(IllegalArgumentException.class, () -> builderParameters.registerMissingProviders((CombinedBuilderParametersImpl) null));
292     }
293 
294     /**
295      * Tests whether a new builder provider can be registered.
296      */
297     @Test
298     public void testRegisterProvider() {
299         final ConfigurationBuilderProvider provider = mock(ConfigurationBuilderProvider.class);
300         final String tagName = "testTag";
301         final CombinedBuilderParametersImpl params = new CombinedBuilderParametersImpl();
302         assertSame(params, params.registerProvider(tagName, provider));
303         final Map<String, ConfigurationBuilderProvider> providers = params.getProviders();
304         assertEquals(1, providers.size());
305         assertSame(provider, providers.get(tagName));
306         assertSame(provider, params.providerForTag(tagName));
307     }
308 
309     /**
310      * Tries to register a null provider.
311      */
312     @Test
313     public void testRegisterProviderNoProvider() {
314         final CombinedBuilderParametersImpl builderParameters = new CombinedBuilderParametersImpl();
315         assertThrows(IllegalArgumentException.class, () -> builderParameters.registerProvider("aTag", null));
316     }
317 
318     /**
319      * Tries to register a provider without a tag name.
320      */
321     @Test
322     public void testRegisterProviderNoTag() {
323         final CombinedBuilderParametersImpl builderParameters = new CombinedBuilderParametersImpl();
324         final ConfigurationBuilderProvider provider = mock(ConfigurationBuilderProvider.class);
325         assertThrows(IllegalArgumentException.class, () -> builderParameters.registerProvider(null, provider));
326     }
327 
328     /**
329      * Tests whether the base path can be set.
330      */
331     @Test
332     public void testSetBasePath() {
333         final CombinedBuilderParametersImpl params = new CombinedBuilderParametersImpl();
334         final String basePath = ConfigurationAssert.OUT_DIR.getAbsolutePath();
335         assertSame(params, params.setBasePath(basePath));
336         assertEquals(basePath, params.getBasePath());
337     }
338 
339     /**
340      * Tests whether properties can be set using BeanUtils.
341      */
342     @Test
343     public void testSetBeanProperties() throws Exception {
344         final BuilderParameters defparams = mock(BuilderParameters.class);
345         final CombinedBuilderParametersImpl params = new CombinedBuilderParametersImpl();
346         BeanHelper.setProperty(params, "basePath", "testPath");
347         BeanHelper.setProperty(params, "definitionBuilderParameters", defparams);
348         BeanHelper.setProperty(params, "inheritSettings", false);
349         assertEquals("testPath", params.getBasePath());
350         assertSame(defparams, params.getDefinitionBuilderParameters());
351         assertFalse(params.isInheritSettings());
352     }
353 
354     /**
355      * Tests whether the definition builder can be set.
356      */
357     @Test
358     public void testSetDefinitionBuilder() {
359         final CombinedBuilderParametersImpl params = new CombinedBuilderParametersImpl();
360         assertNull(params.getDefinitionBuilder());
361         final ConfigurationBuilder<XMLConfiguration> builder = new BasicConfigurationBuilder<>(XMLConfiguration.class);
362         assertSame(params, params.setDefinitionBuilder(builder));
363         assertSame(builder, params.getDefinitionBuilder());
364     }
365 
366     /**
367      * Tests whether a parameters object for the definition builder can be set.
368      */
369     @Test
370     public void testSetDefinitionBuilderParameters() {
371         final BuilderParameters defparams = mock(BuilderParameters.class);
372         final CombinedBuilderParametersImpl params = new CombinedBuilderParametersImpl();
373         assertSame(params, params.setDefinitionBuilderParameters(defparams));
374         assertSame(defparams, params.getDefinitionBuilderParameters());
375     }
376 
377     /**
378      * Tests whether the flag that controls settings inheritance can be set.
379      */
380     @Test
381     public void testSetInheritSettings() {
382         final CombinedBuilderParametersImpl params = new CombinedBuilderParametersImpl();
383         assertTrue(params.isInheritSettings());
384         assertSame(params, params.setInheritSettings(false));
385         assertFalse(params.isInheritSettings());
386     }
387 }