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.lang.reflect.Array;
  30 import java.lang.reflect.Field;
  31 import java.util.ArrayDeque;
  32 import java.util.ArrayList;
  33 import java.util.Arrays;
  34 import java.util.Collection;
  35 import java.util.Deque;
  36 import java.util.HashSet;
  37 import java.util.List;
  38 import java.util.Map;
  39 import java.util.Queue;
  40 import java.util.Set;
  41 import java.util.SortedSet;
  42 import java.util.TreeSet;
  43 import java.util.concurrent.BlockingQueue;
  44 import java.util.concurrent.ConcurrentLinkedQueue;
  45 import java.util.concurrent.LinkedBlockingQueue;
  46 import java.util.concurrent.LinkedTransferQueue;
  47 import java.util.concurrent.TransferQueue;
  48 import java.util.stream.Collectors;
  49 import java.util.stream.IntStream;
  50 import java.util.stream.Stream;
  51
  52 import org.apache.commons.configuration2.BaseConfiguration;
  53 import org.apache.commons.configuration2.CompositeConfiguration;
  54 import org.apache.commons.configuration2.Configuration;
  55 import org.apache.commons.configuration2.PropertiesConfiguration;
  56 import org.junit.Test;
  57 import org.onap.config.api.Hint;
  58 import org.onap.config.impl.ConfigurationRepository;
  59
  60 public class ConfigurationUtilsTest {
  61
  62     private static final String TEST_NAME_SPACE = "testNameSpaceOne";
  63     private static final String TEST_COMPOSITE_NAMESPACE = "testCOmpositeConfig";
  64
  65     @Test
  66     public void testCommaList() {
  67         List<?> list = Arrays.asList("1", "2", 3);
  68         String commaSeparatedList = ConfigurationUtils.getCommaSeparatedList(list);
  69         list.forEach(o -> assertTrue(commaSeparatedList.contains(o.toString())));
  70     }
  71
  72     @Test
  73     public void testCommaListWithNullAndEmptyStrings() {
  74         List list = Arrays.asList(null, "", " ");
  75         String commaSeparatedList = ConfigurationUtils.getCommaSeparatedList(list);
  76         assertTrue(commaSeparatedList.isEmpty());
  77     }
  78
  79     @Test
  80     public void testGetArrayClassFunction() {
  81         assertEquals(String[].class, ConfigurationUtils.getArrayClass(String.class));
  82         assertNull(ConfigurationUtils.getArrayClass(ConfigurationUtilsTest.class));
  83     }
  84
  85     @Test
  86     public void testGetCollectionGenericType() throws NoSuchFieldException {
  87
  88         class DummyClass {
  89             public Map<String, String> testParameterizedTypeField;
  90         }
  91         Field field = DummyClass.class.getField("testParameterizedTypeField");
  92         assertEquals(String.class, ConfigurationUtils.getCollectionGenericType(field));
  93     }
  94
  95     @Test
  96     public void testCastingArray() {
  97         int arraySize = 2;
  98         final Class[] primitiveType = new Class[]{boolean.class, byte.class,
  99                 double.class, float.class, int.class, long.class, short.class};
 100
 101         for (Class clazz: primitiveType) {
 102             Class expectedResultClass = Array.newInstance(clazz, 0).getClass();
 103             List defaultCollection = IntStream.range(0, arraySize).mapToObj(i ->
 104                     ConfigurationUtils.getDefaultFor(clazz)).collect(toList());
 105
 106             Object resultArray = ConfigurationUtils.getPrimitiveArray(defaultCollection, clazz);
 107
 108             assertNotNull(resultArray);
 109             assertFalse(ConfigurationUtils.isZeroLengthArray(expectedResultClass, resultArray));
 110             assertNotNull(expectedResultClass.cast(resultArray));
 111         }
 112     }
 113
 114     @Test(expected = IllegalArgumentException.class)
 115     public void testGetCompatibleCollection() {
 116         final Map<Class, Class> testClasses = Stream.of(new Class[][] {
 117                 {BlockingQueue.class, LinkedBlockingQueue.class},
 118                 {TransferQueue.class, LinkedTransferQueue.class},
 119                 {Deque.class, ArrayDeque.class},
 120                 {Queue.class, ConcurrentLinkedQueue.class},
 121                 {SortedSet.class, TreeSet.class},
 122                 {Set.class, HashSet.class},
 123                 {List.class, ArrayList.class}
 124         }).collect(Collectors.toMap(data -> data[0], data -> data[1]));
 125
 126         testClasses.forEach((entryClass, expResultClass) -> {
 127                 Class resultClass = ConfigurationUtils.getCompatibleCollectionForAbstractDef(entryClass).getClass();
 128                 assertEquals(expResultClass, resultClass);
 129             }
 130         );
 131
 132         ConfigurationUtils.getCompatibleCollectionForAbstractDef(Collection.class);
 133
 134     }
 135
 136     @Test
 137     public void testGetConfigPropertyBaseConfig() throws Exception {
 138         ConfigurationRepository repo = populateTestBaseConfig();
 139         Configuration config = repo.getConfigurationFor(Constants.DEFAULT_TENANT, TEST_NAME_SPACE);
 140         assertEquals(TEST_NAME_SPACE, ConfigurationUtils.getProperty(config, Constants.NAMESPACE_KEY, Hint.DEFAULT.value()));
 141     }
 142
 143     @Test
 144     public void testGetCompositeConfigPropertyDefaultHints() throws Exception {
 145         ConfigurationRepository repo = populateTestCompositeConfig();
 146         Configuration config = repo.getConfigurationFor(Constants.DEFAULT_TENANT, TEST_COMPOSITE_NAMESPACE);
 147         assertEquals(TEST_NAME_SPACE, ConfigurationUtils.getProperty(config, Constants.NAMESPACE_KEY, Hint.DEFAULT.value()));
 148     }
 149
 150     @Test
 151     public void testGetCompositeConfigPropertyNodeSpecificHints() throws Exception {
 152         ConfigurationRepository repo = populateTestCompositeConfig();
 153         Configuration config = repo.getConfigurationFor(Constants.DEFAULT_TENANT, TEST_COMPOSITE_NAMESPACE);
 154         assertEquals(TEST_NAME_SPACE, ConfigurationUtils.getProperty(config, Constants.NAMESPACE_KEY, Hint.NODE_SPECIFIC.value()));
 155     }
 156
 157     private ConfigurationRepository populateTestBaseConfig() {
 158         BaseConfiguration inputConfig = new PropertiesConfiguration();
 159         inputConfig.setProperty(Constants.NAMESPACE_KEY, TEST_NAME_SPACE);
 160         ConfigurationRepository repo = ConfigurationRepository.lookup();
 161
 162         repo.populateConfiguration(
 163                 Constants.DEFAULT_TENANT + Constants.KEY_ELEMENTS_DELIMITER + TEST_NAME_SPACE, inputConfig);
 164
 165         return repo;
 166     }
 167
 168     private ConfigurationRepository populateTestCompositeConfig() {
 169         CompositeConfiguration inputCompositeConfig = new CompositeConfiguration();
 170         Configuration inputConfig1= new BaseConfiguration();
 171         Configuration inputConfig2= new BaseConfiguration();
 172         inputConfig1.setProperty(Constants.NAMESPACE_KEY, TEST_NAME_SPACE);
 173         inputCompositeConfig.addConfiguration(inputConfig1);
 174         inputCompositeConfig.addConfigurationFirst(inputConfig2);
 175
 176         ConfigurationRepository repo = ConfigurationRepository.lookup();
 177         repo.populateConfiguration(
 178                 Constants.DEFAULT_TENANT + Constants.KEY_ELEMENTS_DELIMITER + TEST_COMPOSITE_NAMESPACE,
 179                 inputCompositeConfig
 180         );
 181
 182         return repo;
 183     }
 184 }