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.assertEquals;
  24 import static org.junit.Assert.assertNull;
  25 import static org.junit.Assert.assertNotNull;
  26 import static org.junit.Assert.assertTrue;
  27 import static org.junit.Assert.assertFalse;
  28
  29 import java.io.File;
  30 import java.io.IOException;
  31 import java.lang.reflect.Array;
  32 import java.lang.reflect.Field;
  33 import java.nio.file.Path;
  34 import java.nio.file.Paths;
  35 import java.util.ArrayDeque;
  36 import java.util.ArrayList;
  37 import java.util.Arrays;
  38 import java.util.Collection;
  39 import java.util.Deque;
  40 import java.util.HashSet;
  41 import java.util.List;
  42 import java.util.Map;
  43 import java.util.Queue;
  44 import java.util.Set;
  45 import java.util.SortedSet;
  46 import java.util.TreeSet;
  47 import java.util.concurrent.BlockingQueue;
  48 import java.util.concurrent.ConcurrentLinkedQueue;
  49 import java.util.concurrent.LinkedBlockingQueue;
  50 import java.util.concurrent.LinkedTransferQueue;
  51 import java.util.concurrent.TransferQueue;
  52 import java.util.stream.Collectors;
  53 import java.util.stream.IntStream;
  54 import java.util.stream.Stream;
  55
  56 import org.apache.commons.configuration2.BaseConfiguration;
  57 import org.apache.commons.configuration2.CompositeConfiguration;
  58 import org.apache.commons.configuration2.Configuration;
  59 import org.apache.commons.configuration2.PropertiesConfiguration;
  60 import org.junit.Test;
  61 import org.onap.config.util.TestUtil;
  62 import org.onap.config.api.Hint;
  63 import org.onap.config.impl.ConfigurationRepository;
  64
  65 public class ConfigurationUtilsTest {
  66
  67     public static final String TMP_DIR_PREFIX = "sdc-testing-";
  68     private static final String TEST_NAME_SPACE = "testNameSpaceOne";
  69     private static final String TEST_COMPOSITE_NAMESPACE = "testCOmpositeConfig";
  70
  71     @Test
  72     public void testCommaList() {
  73         List<?> list = Arrays.asList("1", "2", 3);
  74         String commaSeparatedList = ConfigurationUtils.getCommaSeparatedList(list);
  75         list.forEach(o -> assertTrue(commaSeparatedList.contains(o.toString())));
  76     }
  77
  78     @Test
  79     public void testCommaListWithNullAndEmptyStrings() {
  80         List list = Arrays.asList(null, "", " ");
  81         String commaSeparatedList = ConfigurationUtils.getCommaSeparatedList(list);
  82         assertTrue(commaSeparatedList.isEmpty());
  83     }
  84
  85     @Test
  86     public void testGetArrayClassFunction() {
  87         assertEquals(String[].class, ConfigurationUtils.getArrayClass(String.class));
  88         assertNull(ConfigurationUtils.getArrayClass(ConfigurationUtilsTest.class));
  89     }
  90
  91     @Test
  92     public void testGetCollectionGenericType() throws NoSuchFieldException {
  93
  94         class DummyClass {
  95             public Map<String, String> testParameterizedTypeField;
  96         }
  97         Field field = DummyClass.class.getField("testParameterizedTypeField");
  98         assertEquals(String.class, ConfigurationUtils.getCollectionGenericType(field));
  99     }
 100
 101     @Test
 102     public void testCastingArray() {
 103         int arraySize = 2;
 104         final Class[] primitiveType = new Class[]{boolean.class, byte.class,
 105                 double.class, float.class, int.class, long.class, short.class};
 106
 107         for (Class clazz: primitiveType) {
 108             Class expectedResultClass = Array.newInstance(clazz, 0).getClass();
 109             List defaultCollection = IntStream.range(0, arraySize).mapToObj(i ->
 110                     ConfigurationUtils.getDefaultFor(clazz)).collect(toList());
 111
 112             Object resultArray = ConfigurationUtils.getPrimitiveArray(defaultCollection, clazz);
 113
 114             assertNotNull(resultArray);
 115             assertFalse(ConfigurationUtils.isZeroLengthArray(expectedResultClass, resultArray));
 116             assertNotNull(expectedResultClass.cast(resultArray));
 117         }
 118     }
 119
 120     @Test(expected = IllegalArgumentException.class)
 121     public void testGetCompatibleCollection() {
 122         final Map<Class, Class> testClasses = Stream.of(new Class[][] {
 123                 {BlockingQueue.class, LinkedBlockingQueue.class},
 124                 {TransferQueue.class, LinkedTransferQueue.class},
 125                 {Deque.class, ArrayDeque.class},
 126                 {Queue.class, ConcurrentLinkedQueue.class},
 127                 {SortedSet.class, TreeSet.class},
 128                 {Set.class, HashSet.class},
 129                 {List.class, ArrayList.class}
 130         }).collect(Collectors.toMap(data -> data[0], data -> data[1]));
 131
 132         testClasses.forEach((entryClass, expResultClass) -> {
 133                 Class resultClass = ConfigurationUtils.getCompatibleCollectionForAbstractDef(entryClass).getClass();
 134                 assertEquals(expResultClass, resultClass);
 135             }
 136         );
 137
 138         ConfigurationUtils.getCompatibleCollectionForAbstractDef(Collection.class);
 139
 140     }
 141
 142     @Test
 143     public void testGetAllFilesRecursiveIncludeAll() throws IOException {
 144         Path tmpRoot = TestUtil.createTestDirsStructure(TMP_DIR_PREFIX);
 145         Collection<File> allFiles = ConfigurationUtils.getAllFiles(tmpRoot.toFile(), true, false);
 146         assertEquals(7, allFiles.size());
 147         TestUtil.deleteTestDirsStrucuture(tmpRoot);
 148     }
 149
 150     @Test
 151     public void testGetAllFilesRecursiveIncludeDirsOnly() throws IOException {
 152         Path tmpRoot = TestUtil.createTestDirsStructure(TMP_DIR_PREFIX);
 153         Collection<File> allFiles = ConfigurationUtils.getAllFiles(tmpRoot.toFile(), true, true);
 154         assertEquals(3, allFiles.size());
 155         TestUtil.deleteTestDirsStrucuture(tmpRoot);
 156     }
 157
 158     @Test
 159     public void testGetAllFilesNonRecursiveIncludeAll() throws IOException {
 160         Path tmpRoot = TestUtil.createTestDirsStructure(TMP_DIR_PREFIX);
 161         Collection<File> allFiles = ConfigurationUtils.getAllFiles(tmpRoot.toFile(), false, false);
 162         assertEquals(2, allFiles.size());
 163         TestUtil.deleteTestDirsStrucuture(tmpRoot);
 164     }
 165
 166     @Test
 167     public void testGetAllFilesNonRecursiveIncludeDirsOnly() throws IOException {
 168         Path tmpRoot = TestUtil.createTestDirsStructure(TMP_DIR_PREFIX);
 169         Collection<File> allFiles = ConfigurationUtils.getAllFiles(tmpRoot.toFile(), false, true);
 170         assertEquals(1, allFiles.size());
 171         TestUtil.deleteTestDirsStrucuture(tmpRoot);
 172     }
 173
 174     @Test
 175     public void testGetAllFilesEmptyDir() throws IOException {
 176         Path tmpRoot = TestUtil.createEmptyTmpDir(TMP_DIR_PREFIX);
 177         Collection<File> allFiles = ConfigurationUtils.getAllFiles(tmpRoot.toFile(), true, true);
 178         assertEquals(0, allFiles.size());
 179         TestUtil.deleteTestDirsStrucuture(tmpRoot);
 180     }
 181
 182     @Test
 183     public void testGetAllFilesNonExistentDir() throws IOException {
 184         Path nonExistentDir = Paths.get("/tmp/nonexistentdir");
 185         Collection<File> allFiles = ConfigurationUtils.getAllFiles(nonExistentDir.toFile(), false, true);
 186         assertEquals(0, allFiles.size());
 187     }
 188
 189     @Test
 190     public void testGetConfigPropertyBaseConfig() throws Exception {
 191         ConfigurationRepository repo = populateTestBaseConfig();
 192         Configuration config = repo.getConfigurationFor(Constants.DEFAULT_TENANT, TEST_NAME_SPACE);
 193         assertEquals(TEST_NAME_SPACE, ConfigurationUtils.getProperty(config, Constants.NAMESPACE_KEY, Hint.DEFAULT.value()));
 194     }
 195
 196     @Test
 197     public void testGetCompositeConfigPropertyDefaultHints() throws Exception {
 198         ConfigurationRepository repo = populateTestCompositeConfig();
 199         Configuration config = repo.getConfigurationFor(Constants.DEFAULT_TENANT, TEST_COMPOSITE_NAMESPACE);
 200         assertEquals(TEST_NAME_SPACE, ConfigurationUtils.getProperty(config, Constants.NAMESPACE_KEY, Hint.DEFAULT.value()));
 201     }
 202
 203     @Test
 204     public void testGetCompositeConfigPropertyNodeSpecificHints() throws Exception {
 205         ConfigurationRepository repo = populateTestCompositeConfig();
 206         Configuration config = repo.getConfigurationFor(Constants.DEFAULT_TENANT, TEST_COMPOSITE_NAMESPACE);
 207         assertEquals(TEST_NAME_SPACE, ConfigurationUtils.getProperty(config, Constants.NAMESPACE_KEY, Hint.NODE_SPECIFIC.value()));
 208     }
 209
 210     private ConfigurationRepository populateTestBaseConfig() {
 211         BaseConfiguration inputConfig = new PropertiesConfiguration();
 212         inputConfig.setProperty(Constants.NAMESPACE_KEY, TEST_NAME_SPACE);
 213         ConfigurationRepository repo = ConfigurationRepository.lookup();
 214
 215         repo.populateConfiguration(
 216                 Constants.DEFAULT_TENANT + Constants.KEY_ELEMENTS_DELIMITER + TEST_NAME_SPACE, inputConfig);
 217
 218         return repo;
 219     }
 220
 221     private ConfigurationRepository populateTestCompositeConfig() {
 222         CompositeConfiguration inputCompositeConfig = new CompositeConfiguration();
 223         Configuration inputConfig1= new BaseConfiguration();
 224         Configuration inputConfig2= new BaseConfiguration();
 225         inputConfig1.setProperty(Constants.NAMESPACE_KEY, TEST_NAME_SPACE);
 226         inputCompositeConfig.addConfiguration(inputConfig1);
 227         inputCompositeConfig.addConfigurationFirst(inputConfig2);
 228
 229         ConfigurationRepository repo = ConfigurationRepository.lookup();
 230         repo.populateConfiguration(
 231                 Constants.DEFAULT_TENANT + Constants.KEY_ELEMENTS_DELIMITER + TEST_COMPOSITE_NAMESPACE,
 232                 inputCompositeConfig
 233         );
 234
 235         return repo;
 236     }
 237 }