common/onap-common-configuration-management/onap-configuration-management-core/src/test/java/org/onap/config/ConfigurationUtilsTest.java

   1 /*
   2  * Copyright © 2016-2018 European Support Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  * Modifications Copyright (c) 2019 Samsung
  17  *
  18  */
  19
  20 package org.onap.config;
  21
  22 import static java.util.stream.Collectors.toList;
  23 import static org.junit.Assert.assertArrayEquals;
  24 import static org.junit.Assert.assertEquals;
  25 import static org.junit.Assert.assertNull;
  26 import static org.junit.Assert.assertNotNull;
  27 import static org.junit.Assert.assertTrue;
  28 import static org.junit.Assert.assertFalse;
  29
  30 import java.io.File;
  31 import java.io.IOException;
  32 import java.lang.reflect.Array;
  33 import java.lang.reflect.Field;
  34 import java.nio.file.Path;
  35 import java.nio.file.Paths;
  36 import java.util.ArrayDeque;
  37 import java.util.ArrayList;
  38 import java.util.Arrays;
  39 import java.util.Collection;
  40 import java.util.Collections;
  41 import java.util.Deque;
  42 import java.util.HashMap;
  43 import java.util.HashSet;
  44 import java.util.List;
  45 import java.util.Map;
  46 import java.util.Queue;
  47 import java.util.Set;
  48 import java.util.SortedSet;
  49 import java.util.TreeSet;
  50 import java.util.concurrent.BlockingQueue;
  51 import java.util.concurrent.ConcurrentLinkedQueue;
  52 import java.util.concurrent.LinkedBlockingQueue;
  53 import java.util.concurrent.LinkedTransferQueue;
  54 import java.util.concurrent.TransferQueue;
  55 import java.util.stream.Collectors;
  56 import java.util.stream.IntStream;
  57 import java.util.stream.Stream;
  58
  59 import org.apache.commons.configuration2.BaseConfiguration;
  60 import org.apache.commons.configuration2.CompositeConfiguration;
  61 import org.apache.commons.configuration2.Configuration;
  62 import org.apache.commons.configuration2.PropertiesConfiguration;
  63 import org.junit.Test;
  64 import org.onap.config.util.TestUtil;
  65 import org.onap.config.api.Hint;
  66 import org.onap.config.impl.ConfigurationRepository;
  67
  68 public class ConfigurationUtilsTest {
  69
  70     public static final String TMP_DIR_PREFIX = "sdc-testing-";
  71     private static final String TEST_NAME_SPACE = "testNameSpaceOne";
  72     private static final String TEST_COMPOSITE_NAMESPACE = "testCOmpositeConfig";
  73
  74     @Test
  75     public void testCommaList() {
  76         List<?> list = Arrays.asList("1", "2", 3);
  77         String commaSeparatedList = ConfigurationUtils.getCommaSeparatedList(list);
  78         list.forEach(o -> assertTrue(commaSeparatedList.contains(o.toString())));
  79     }
  80
  81     @Test
  82     public void testCommaListWithNullAndEmptyStrings() {
  83         List<String> list = Arrays.asList(null, "", " ");
  84         String commaSeparatedList = ConfigurationUtils.getCommaSeparatedList(list);
  85         assertTrue(commaSeparatedList.isEmpty());
  86     }
  87
  88     @Test
  89     public void testGetArrayClassFunction() {
  90         assertEquals(String[].class, ConfigurationUtils.getArrayClass(String.class));
  91         assertNull(ConfigurationUtils.getArrayClass(ConfigurationUtilsTest.class));
  92     }
  93
  94     @Test
  95     public void testGetCollectionGenericType() throws NoSuchFieldException {
  96
  97         class DummyClass {
  98             public Map<String, String> testParameterizedTypeField;
  99         }
 100         Field field = DummyClass.class.getField("testParameterizedTypeField");
 101         assertEquals(String.class, ConfigurationUtils.getCollectionGenericType(field));
 102     }
 103
 104     @Test
 105     public void testCastingArray() {
 106         int arraySize = 2;
 107         final Class<?>[] primitiveType = new Class[]{boolean.class, byte.class,
 108                 double.class, float.class, int.class, long.class, short.class};
 109
 110         for (Class<?> clazz : primitiveType) {
 111             Class<?> expectedResultClass = Array.newInstance(clazz, 0).getClass();
 112             List<?> defaultCollection = IntStream.range(0, arraySize).mapToObj(i ->
 113                     ConfigurationUtils.getDefaultFor(clazz)).collect(toList());
 114
 115             Object resultArray = ConfigurationUtils.getPrimitiveArray(defaultCollection, clazz);
 116
 117             assertNotNull(resultArray);
 118             assertFalse(ConfigurationUtils.isZeroLengthArray(expectedResultClass, resultArray));
 119             assertNotNull(expectedResultClass.cast(resultArray));
 120         }
 121     }
 122
 123     @Test(expected = IllegalArgumentException.class)
 124     public void testGetCompatibleCollection() {
 125         final Map<Class<?>, Class<?>> testClasses = Stream.of(new Class<?>[][]{
 126                 {BlockingQueue.class, LinkedBlockingQueue.class},
 127                 {TransferQueue.class, LinkedTransferQueue.class},
 128                 {Deque.class, ArrayDeque.class},
 129                 {Queue.class, ConcurrentLinkedQueue.class},
 130                 {SortedSet.class, TreeSet.class},
 131                 {Set.class, HashSet.class},
 132                 {List.class, ArrayList.class}
 133         }).collect(Collectors.toMap(data -> data[0], data -> data[1]));
 134
 135         testClasses.forEach((entryClass, expResultClass) -> {
 136                     Class<?> resultClass = ConfigurationUtils.getCompatibleCollectionForAbstractDef(entryClass).getClass();
 137                     assertEquals(expResultClass, resultClass);
 138                 }
 139         );
 140
 141         ConfigurationUtils.getCompatibleCollectionForAbstractDef(Collection.class);
 142
 143     }
 144
 145     @Test
 146     public void testGetPrimitivesArrayZeroLength() {
 147             assertArrayEquals(new int[0], (int[]) ConfigurationUtils.getPrimitiveArray(Collections.emptyList(), int.class));
 148             assertArrayEquals(new byte[0], (byte[]) ConfigurationUtils.getPrimitiveArray(Collections.emptyList(), byte.class));
 149             assertArrayEquals(new short[0], (short[]) ConfigurationUtils.getPrimitiveArray(Collections.emptyList(), short.class));
 150             assertArrayEquals(new long[0], (long[]) ConfigurationUtils.getPrimitiveArray(Collections.emptyList(), long.class));
 151             assertArrayEquals(new double[0], (double[]) ConfigurationUtils.getPrimitiveArray(Collections.emptyList(), double.class), 0);
 152             assertArrayEquals(new float[0], (float[]) ConfigurationUtils.getPrimitiveArray(Collections.emptyList(), float.class), 0);
 153             assertArrayEquals(new boolean[0], (boolean[]) ConfigurationUtils.getPrimitiveArray(Collections.emptyList(), boolean.class));
 154             assertArrayEquals(new char[0], (char[]) ConfigurationUtils.getPrimitiveArray(Collections.emptyList(), char.class));
 155             assertNull(ConfigurationUtils.getPrimitiveArray(Collections.emptyList(), Integer.class));
 156     }
 157
 158     @Test
 159     public void testGetWrappersArrayZeroLength() {
 160         assertArrayEquals(new Integer[0], (Integer[]) ConfigurationUtils.getWrappersArray(Collections.emptyList(), Integer.class));
 161         assertArrayEquals(new Byte[0], (Byte[]) ConfigurationUtils.getWrappersArray(Collections.emptyList(), Byte.class));
 162         assertArrayEquals(new Short[0], (Short[]) ConfigurationUtils.getWrappersArray(Collections.emptyList(), Short.class));
 163         assertArrayEquals(new Long[0], (Long[]) ConfigurationUtils.getWrappersArray(Collections.emptyList(), Long.class));
 164         assertArrayEquals(new Double[0], (Double[]) ConfigurationUtils.getWrappersArray(Collections.emptyList(), Double.class));
 165         assertArrayEquals(new Float[0], (Float[]) ConfigurationUtils.getWrappersArray(Collections.emptyList(), Float.class));
 166         assertArrayEquals(new Boolean[0], (Boolean[]) ConfigurationUtils.getWrappersArray(Collections.emptyList(), Boolean.class));
 167         assertArrayEquals(new Character[0], (Character[]) ConfigurationUtils.getWrappersArray(Collections.emptyList(), Character.class));
 168         assertNull(ConfigurationUtils.getWrappersArray(Collections.emptyList(), boolean.class));
 169     }
 170
 171     @Test
 172     public void testPrimitivesArrayNonZeroLength() {
 173         List<Integer> list = new ArrayList<>();
 174         list.add(1);
 175         list.add(2);
 176         list.add(3);
 177         list.add(4);
 178         list.add(5);
 179         assertArrayEquals(new int[]{1, 2, 3, 4, 5}, (int[]) ConfigurationUtils.getPrimitiveArray(list, int.class));
 180     }
 181
 182     @Test
 183     public void testWrappersArrayNonZeroLength() {
 184         List<Integer> list = new ArrayList<>();
 185         list.add(1);
 186         list.add(2);
 187         list.add(3);
 188         list.add(4);
 189         list.add(5);
 190         assertArrayEquals(new Integer[]{1, 2, 3, 4, 5}, (Integer[]) ConfigurationUtils.getWrappersArray(list, Integer.class));
 191     }
 192
 193     @Test
 194     public void testGetAllFilesRecursiveIncludeAll() throws IOException {
 195         Path tmpRoot = TestUtil.createTestDirsStructure(TMP_DIR_PREFIX);
 196         Collection<File> allFiles = ConfigurationUtils.getAllFiles(tmpRoot.toFile(), true, false);
 197         assertEquals(7, allFiles.size());
 198         TestUtil.deleteTestDirsStrucuture(tmpRoot);
 199     }
 200
 201     @Test
 202     public void testGetAllFilesRecursiveIncludeDirsOnly() throws IOException {
 203         Path tmpRoot = TestUtil.createTestDirsStructure(TMP_DIR_PREFIX);
 204         Collection<File> allFiles = ConfigurationUtils.getAllFiles(tmpRoot.toFile(), true, true);
 205         assertEquals(3, allFiles.size());
 206         TestUtil.deleteTestDirsStrucuture(tmpRoot);
 207     }
 208
 209     @Test
 210     public void testGetAllFilesNonRecursiveIncludeAll() throws IOException {
 211         Path tmpRoot = TestUtil.createTestDirsStructure(TMP_DIR_PREFIX);
 212         Collection<File> allFiles = ConfigurationUtils.getAllFiles(tmpRoot.toFile(), false, false);
 213         assertEquals(2, allFiles.size());
 214         TestUtil.deleteTestDirsStrucuture(tmpRoot);
 215     }
 216
 217     @Test
 218     public void testGetAllFilesNonRecursiveIncludeDirsOnly() throws IOException {
 219         Path tmpRoot = TestUtil.createTestDirsStructure(TMP_DIR_PREFIX);
 220         Collection<File> allFiles = ConfigurationUtils.getAllFiles(tmpRoot.toFile(), false, true);
 221         assertEquals(1, allFiles.size());
 222         TestUtil.deleteTestDirsStrucuture(tmpRoot);
 223     }
 224
 225     @Test
 226     public void testGetAllFilesEmptyDir() throws IOException {
 227         Path tmpRoot = TestUtil.createEmptyTmpDir(TMP_DIR_PREFIX);
 228         Collection<File> allFiles = ConfigurationUtils.getAllFiles(tmpRoot.toFile(), true, true);
 229         assertEquals(0, allFiles.size());
 230         TestUtil.deleteTestDirsStrucuture(tmpRoot);
 231     }
 232
 233     @Test
 234     public void testGetAllFilesNonExistentDir() throws IOException {
 235         Path nonExistentDir = Paths.get("/tmp/nonexistentdir");
 236         Collection<File> allFiles = ConfigurationUtils.getAllFiles(nonExistentDir.toFile(), false, true);
 237         assertEquals(0, allFiles.size());
 238     }
 239
 240     @Test
 241     public void testGetConfigPropertyBaseConfig() throws Exception {
 242         ConfigurationRepository repo = populateTestBaseConfig();
 243         Configuration config = repo.getConfigurationFor(Constants.DEFAULT_TENANT, TEST_NAME_SPACE);
 244         assertEquals(TEST_NAME_SPACE, ConfigurationUtils.getProperty(config, Constants.NAMESPACE_KEY, Hint.DEFAULT.value()));
 245     }
 246
 247     @Test
 248     public void testGetCompositeConfigPropertyDefaultHints() throws Exception {
 249         ConfigurationRepository repo = populateTestCompositeConfig();
 250         Configuration config = repo.getConfigurationFor(Constants.DEFAULT_TENANT, TEST_COMPOSITE_NAMESPACE);
 251         assertEquals(TEST_NAME_SPACE, ConfigurationUtils.getProperty(config, Constants.NAMESPACE_KEY, Hint.DEFAULT.value()));
 252     }
 253
 254     @Test
 255     public void testGetCompositeConfigPropertyNodeSpecificHints() throws Exception {
 256         ConfigurationRepository repo = populateTestCompositeConfig();
 257         Configuration config = repo.getConfigurationFor(Constants.DEFAULT_TENANT, TEST_COMPOSITE_NAMESPACE);
 258         assertEquals(TEST_NAME_SPACE, ConfigurationUtils.getProperty(config, Constants.NAMESPACE_KEY, Hint.NODE_SPECIFIC.value()));
 259     }
 260
 261     @Test
 262     public void testIsAMap() {
 263         assertTrue(ConfigurationUtils.isAMap(HashMap.class));
 264         assertFalse(ConfigurationUtils.isAMap(ArrayList.class));
 265     }
 266
 267     @Test
 268     public void testIsACollection() {
 269         assertTrue(ConfigurationUtils.isACollection(ArrayList.class));
 270         assertFalse(ConfigurationUtils.isACollection(HashMap.class));
 271     }
 272
 273     @Test
 274     public void testIsAPrimitiveOrWrapper() {
 275         assertTrue(ConfigurationUtils.isAPrimitiveOrWrapper(int.class));
 276         assertTrue(ConfigurationUtils.isAPrimitiveOrWrapper(Integer.class));
 277         assertFalse(ConfigurationUtils.isAPrimitiveOrWrapper(HashMap.class));
 278     }
 279
 280     @Test
 281     public void testIsAPrimitivesArray() {
 282         assertTrue(ConfigurationUtils.isAPrimitivesArray(int[].class));
 283         assertFalse(ConfigurationUtils.isAPrimitivesArray(Integer[].class));
 284         assertFalse(ConfigurationUtils.isAPrimitivesArray(HashMap[].class));
 285     }
 286
 287     @Test
 288     public void testIsAWrapperArray() {
 289         assertTrue(ConfigurationUtils.isAWrappersArray(Integer[].class));
 290         assertFalse(ConfigurationUtils.isAWrappersArray(int[].class));
 291         assertFalse(ConfigurationUtils.isAWrappersArray(HashMap[].class));
 292     }
 293
 294     @Test
 295     public void testIsAPrimitivesOrWrapperArray() {
 296         assertTrue(ConfigurationUtils.isAPrimitivesOrWrappersArray(int[].class));
 297         assertTrue(ConfigurationUtils.isAPrimitivesOrWrappersArray(Integer[].class));
 298         assertFalse(ConfigurationUtils.isAPrimitivesOrWrappersArray(HashMap[].class));
 299     }
 300
 301     private ConfigurationRepository populateTestBaseConfig() {
 302         BaseConfiguration inputConfig = new PropertiesConfiguration();
 303         inputConfig.setProperty(Constants.NAMESPACE_KEY, TEST_NAME_SPACE);
 304         ConfigurationRepository repo = ConfigurationRepository.lookup();
 305
 306         repo.populateConfiguration(
 307                 Constants.DEFAULT_TENANT + Constants.KEY_ELEMENTS_DELIMITER + TEST_NAME_SPACE, inputConfig);
 308
 309         return repo;
 310     }
 311
 312     private ConfigurationRepository populateTestCompositeConfig() {
 313         CompositeConfiguration inputCompositeConfig = new CompositeConfiguration();
 314         Configuration inputConfig1 = new BaseConfiguration();
 315         Configuration inputConfig2 = new BaseConfiguration();
 316         inputConfig1.setProperty(Constants.NAMESPACE_KEY, TEST_NAME_SPACE);
 317         inputCompositeConfig.addConfiguration(inputConfig1);
 318         inputCompositeConfig.addConfigurationFirst(inputConfig2);
 319
 320         ConfigurationRepository repo = ConfigurationRepository.lookup();
 321         repo.populateConfiguration(
 322                 Constants.DEFAULT_TENANT + Constants.KEY_ELEMENTS_DELIMITER + TEST_COMPOSITE_NAMESPACE,
 323                 inputCompositeConfig
 324         );
 325
 326         return repo;
 327     }
 328 }