openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/test/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/consolidation/TypeComputeConsolidationDataTest.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
  17 package org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation;
  18
  19 import java.util.Arrays;
  20 import java.util.Collection;
  21 import java.util.Collections;
  22 import java.util.HashMap;
  23 import java.util.HashSet;
  24 import java.util.List;
  25 import java.util.Map;
  26 import java.util.Objects;
  27 import java.util.Set;
  28
  29 import org.apache.commons.collections4.MapUtils;
  30 import org.junit.Assert;
  31 import org.junit.Before;
  32 import org.junit.Test;
  33 import org.mockito.Mock;
  34 import org.mockito.Mockito;
  35 import org.mockito.MockitoAnnotations;
  36
  37 public class TypeComputeConsolidationDataTest {
  38
  39     private static final String COMPUTE_NODE_TEMPLATE_ID_1 = "computeNodeTemplateId1";
  40     private static final String COMPUTE_NODE_TEMPLATE_ID_2 = "computeNodeTemplateId2";
  41     private static final String SERVER_NETWORK_ROLE_1_PORT = "server_networkrole_1_port";
  42     private static final String SERVER_NETWORK_ROLE_2_PORT = "server_networkrole_2_port";
  43     private static final String SERVER_NETWORK_ROLE_1_PORT1 = "server_networkrole_1_port";
  44     private static final String SERVER_OAM = "server_oam";
  45     private static final String SERVER_CMAUI = "server_cmaui";
  46     private static final String SERVER_0_NETWORK_ROLE_1_PORT = "server_0_networkrole_1_port";
  47     private static final String SERVER_1_NETWORK_ROLE_1_PORT = "server_1_networkrole_1_port";
  48     private static final String SERVER_TYPE = "server_type";
  49
  50     @Mock
  51     private ComputeTemplateConsolidationData computeTemplateConsolidationDataMock;
  52
  53     @Before
  54     public void setUp() {
  55         MockitoAnnotations.openMocks(this);
  56     }
  57
  58     private Map<String, List<String>> multipleNumberOfPortInEachTypeTypeMap = new HashMap<String, List<String>>() {
  59         {
  60             put("oam_untr_port", Arrays.asList("oam_1_untr_port_1", "oam_1_untr_port_2"));
  61             put("cmaui_untr_port", Arrays.asList("cmaui_1_untr_port_1", "cmaui_1_untr_port_2"));
  62         }
  63     };
  64
  65     private Map<String, List<String>> singleNumberOfPortTypeMap = new HashMap<String, List<String>>() {
  66         {
  67             put("oam_untr_port", Collections.singletonList("oam_1_untr_port_1"));
  68         }
  69     };
  70
  71     private final TypeComputeConsolidationData consolidationData = new TypeComputeConsolidationData();
  72
  73     @Test
  74     public void testCollectAllPortsOfEachTypeFromComputesNoPorts() {
  75         ComputeTemplateConsolidationData computeTemplateConsolidationData = new ComputeTemplateConsolidationData();
  76         consolidationData.setComputeTemplateConsolidationData(SERVER_TYPE,
  77                 computeTemplateConsolidationData);
  78
  79         Map<String, List<String>> stringListMap = consolidationData.collectAllPortsOfEachTypeFromComputes();
  80         Assert.assertTrue(Objects.nonNull(stringListMap) && MapUtils.isEmpty(stringListMap));
  81     }
  82
  83     @Test
  84     public void testCollectAllPortsOfEachTypeFromComputes() {
  85         Map<String, List<String>> ports = new HashMap<>();
  86         ports.put(SERVER_NETWORK_ROLE_1_PORT,
  87                 Arrays.asList(SERVER_0_NETWORK_ROLE_1_PORT, SERVER_1_NETWORK_ROLE_1_PORT));
  88
  89         ComputeTemplateConsolidationData computeTemplateConsolidationData = new ComputeTemplateConsolidationData();
  90         computeTemplateConsolidationData.setPorts(ports);
  91
  92         consolidationData.setComputeTemplateConsolidationData(SERVER_TYPE,
  93                 computeTemplateConsolidationData);
  94
  95         Map<String, List<String>> stringListMap = consolidationData.collectAllPortsOfEachTypeFromComputes();
  96         Assert.assertTrue(stringListMap.containsKey(SERVER_NETWORK_ROLE_1_PORT)
  97                                   && stringListMap.get(SERVER_NETWORK_ROLE_1_PORT).size() == 2);
  98     }
  99
 100     @Test
 101     public void testCollectAllPortsOfEachTypeFromComputesWithMultipleCompute() {
 102         Map<String, List<String>> ports = new HashMap<>();
 103         ports.put(SERVER_NETWORK_ROLE_1_PORT,
 104                 Arrays.asList("server_0_network_role_1_port_1", "server_1_network_role_1_port_2"));
 105
 106         Map<String, List<String>> ports1 = new HashMap<>();
 107         ports1.put(SERVER_NETWORK_ROLE_2_PORT,
 108                 Arrays.asList("server_0_network_role_2_port_1", "server_1_network_role_2_port_2"));
 109
 110         ComputeTemplateConsolidationData computeTemplateConsolidationData = new ComputeTemplateConsolidationData();
 111         computeTemplateConsolidationData.setPorts(ports);
 112
 113         ComputeTemplateConsolidationData computeTemplateConsolidationData1 = new ComputeTemplateConsolidationData();
 114         computeTemplateConsolidationData1.setPorts(ports1);
 115
 116         consolidationData.setComputeTemplateConsolidationData(SERVER_TYPE,
 117                 computeTemplateConsolidationData);
 118
 119         consolidationData.setComputeTemplateConsolidationData("server_type1",
 120                 computeTemplateConsolidationData1);
 121
 122         Map<String, List<String>> stringListMap = consolidationData.collectAllPortsOfEachTypeFromComputes();
 123         Assert.assertEquals(2, stringListMap.size());
 124         Assert.assertEquals(2, stringListMap.get(SERVER_NETWORK_ROLE_1_PORT).size());
 125         Assert.assertTrue(stringListMap.get(SERVER_NETWORK_ROLE_1_PORT).contains("server_0_network_role_1_port_1")
 126                 && stringListMap.get(SERVER_NETWORK_ROLE_1_PORT).contains("server_1_network_role_1_port_2"));
 127
 128         Assert.assertEquals(2, stringListMap.get(SERVER_NETWORK_ROLE_2_PORT).size());
 129         Assert.assertTrue(stringListMap.get(SERVER_NETWORK_ROLE_2_PORT).contains("server_0_network_role_2_port_1")
 130                 && stringListMap.get(SERVER_NETWORK_ROLE_2_PORT).contains("server_1_network_role_2_port_2"));
 131     }
 132
 133     @Test
 134     public void testAddComputeTemplateConsolidationData() {
 135         consolidationData.addComputeTemplateConsolidationData(COMPUTE_NODE_TEMPLATE_ID_1);
 136
 137         Set<String> expectedNodeTemplateIds =  new HashSet<>();
 138         expectedNodeTemplateIds.add(COMPUTE_NODE_TEMPLATE_ID_1);
 139         verifyComputeTemplateConsolidationData(consolidationData, COMPUTE_NODE_TEMPLATE_ID_1, expectedNodeTemplateIds);
 140     }
 141
 142     @Test
 143     public void testAddSameConsolidationDataTwice_noNewCreated() {
 144         consolidationData.addComputeTemplateConsolidationData(COMPUTE_NODE_TEMPLATE_ID_1);
 145         ComputeTemplateConsolidationData firstComputeTemplateConsolidationData =
 146                 consolidationData.getComputeTemplateConsolidationData(COMPUTE_NODE_TEMPLATE_ID_1);
 147
 148         consolidationData.addComputeTemplateConsolidationData(COMPUTE_NODE_TEMPLATE_ID_1);
 149         ComputeTemplateConsolidationData secondComputeTemplateConsolidationData =
 150                 consolidationData.getComputeTemplateConsolidationData(COMPUTE_NODE_TEMPLATE_ID_1);
 151         Assert.assertEquals(firstComputeTemplateConsolidationData, secondComputeTemplateConsolidationData);
 152     }
 153
 154     @Test
 155     public void testAddDiffConsolidationData_DiffNodeTemplateId() {
 156         final ComputeTemplateConsolidationData firstComputeTemplateConsolidationData = consolidationData
 157                 .addComputeTemplateConsolidationData(COMPUTE_NODE_TEMPLATE_ID_1);
 158         Set<String> expectedNodeTemplateIds1 =  new HashSet<>();
 159         expectedNodeTemplateIds1.add(COMPUTE_NODE_TEMPLATE_ID_1);
 160         verifyComputeTemplateConsolidationData(consolidationData, COMPUTE_NODE_TEMPLATE_ID_1, expectedNodeTemplateIds1);
 161
 162         final ComputeTemplateConsolidationData secondComputeTemplateConsolidationData = consolidationData
 163                 .addComputeTemplateConsolidationData(COMPUTE_NODE_TEMPLATE_ID_2);
 164         Set<String> expectedNodeTemplateIds2 =  new HashSet<>();
 165         expectedNodeTemplateIds2.add(COMPUTE_NODE_TEMPLATE_ID_2);
 166         verifyComputeTemplateConsolidationData(consolidationData, COMPUTE_NODE_TEMPLATE_ID_2, expectedNodeTemplateIds2);
 167
 168         Assert.assertNotEquals(firstComputeTemplateConsolidationData, secondComputeTemplateConsolidationData);
 169     }
 170
 171     @Test
 172     public void isThereMoreThanOneComputeTypeInstancePositive() {
 173         TypeComputeConsolidationData typeComputeConsolidationData = new TypeComputeConsolidationData();
 174         typeComputeConsolidationData.setComputeTemplateConsolidationData(
 175                 SERVER_OAM, new ComputeTemplateConsolidationData());
 176         typeComputeConsolidationData.setComputeTemplateConsolidationData(
 177                 "server_mao", new ComputeTemplateConsolidationData());
 178
 179         Assert.assertTrue(typeComputeConsolidationData.isThereMoreThanOneComputeTypeInstance());
 180     }
 181
 182     @Test
 183     public void isThereMoreThanOneComputeTypeInstanceNegative() {
 184         TypeComputeConsolidationData typeComputeConsolidationData = new TypeComputeConsolidationData();
 185         typeComputeConsolidationData.setComputeTemplateConsolidationData(
 186                 "server_mao", new ComputeTemplateConsolidationData());
 187
 188         Assert.assertFalse(typeComputeConsolidationData.isThereMoreThanOneComputeTypeInstance());
 189     }
 190
 191     @Test
 192     public void isThereMoreThanOneComputeTypeInstanceEmpty() {
 193         TypeComputeConsolidationData typeComputeConsolidationData = new TypeComputeConsolidationData();
 194         Assert.assertFalse(typeComputeConsolidationData.isThereMoreThanOneComputeTypeInstance());
 195     }
 196
 197     @Test
 198     public void isNumberOfPortFromEachTypeLegal() {
 199         TypeComputeConsolidationData typeComputeConsolidationData = new TypeComputeConsolidationData();
 200         typeComputeConsolidationData.setComputeTemplateConsolidationData(
 201                 SERVER_OAM, computeTemplateConsolidationDataMock);
 202
 203         typeComputeConsolidationData.isNumberOfPortFromEachTypeLegal();
 204
 205         Mockito.verify(computeTemplateConsolidationDataMock).isNumberOfPortFromEachTypeLegal();
 206     }
 207
 208     @Test
 209     public void isPortTypesAndNumberOfPortEqualsBetweenComputeNodesPositive() {
 210         TypeComputeConsolidationData typeComputeConsolidationData = new TypeComputeConsolidationData();
 211
 212         ComputeTemplateConsolidationData firstComputeTemplate = new ComputeTemplateConsolidationData();
 213         firstComputeTemplate.setPorts(singleNumberOfPortTypeMap);
 214
 215         ComputeTemplateConsolidationData secondComputeTemplate = new ComputeTemplateConsolidationData();
 216         secondComputeTemplate.setPorts(singleNumberOfPortTypeMap);
 217
 218         typeComputeConsolidationData.setComputeTemplateConsolidationData(SERVER_OAM, firstComputeTemplate);
 219         typeComputeConsolidationData.setComputeTemplateConsolidationData(SERVER_CMAUI, secondComputeTemplate);
 220
 221         Assert.assertTrue(typeComputeConsolidationData.isPortTypesEqualsBetweenComputeNodes());
 222         Assert.assertTrue(typeComputeConsolidationData.isNumberOfPortsEqualsBetweenComputeNodes());
 223     }
 224
 225     @Test
 226     public void isPortTypesAndNumberOfPortEqualsBetweenComputeNodesNegative() {
 227         TypeComputeConsolidationData typeComputeConsolidationData = new TypeComputeConsolidationData();
 228
 229         ComputeTemplateConsolidationData firstComputeTemplate = new ComputeTemplateConsolidationData();
 230         firstComputeTemplate.setPorts(multipleNumberOfPortInEachTypeTypeMap);
 231         typeComputeConsolidationData.setComputeTemplateConsolidationData(SERVER_OAM, firstComputeTemplate);
 232
 233         ComputeTemplateConsolidationData secondComputeTemplate = new ComputeTemplateConsolidationData();
 234         secondComputeTemplate.setPorts(singleNumberOfPortTypeMap);
 235         typeComputeConsolidationData.setComputeTemplateConsolidationData(SERVER_CMAUI, secondComputeTemplate);
 236
 237         Assert.assertFalse(typeComputeConsolidationData.isPortTypesEqualsBetweenComputeNodes());
 238         Assert.assertFalse(typeComputeConsolidationData.isNumberOfPortsEqualsBetweenComputeNodes());
 239     }
 240
 241     @Test
 242     public void isNumberOfComputeConsolidationDataPerTypeLegalPositive() {
 243         TypeComputeConsolidationData typeComputeConsolidationData = new TypeComputeConsolidationData();
 244         typeComputeConsolidationData.setComputeTemplateConsolidationData(
 245                 SERVER_CMAUI, new ComputeTemplateConsolidationData());
 246
 247         Assert.assertTrue(typeComputeConsolidationData.isNumberOfComputeConsolidationDataPerTypeLegal());
 248     }
 249
 250     @Test
 251     public void isNumberOfComputeConsolidationDataPerTypeLegalNegative() {
 252         TypeComputeConsolidationData typeComputeConsolidationData = new TypeComputeConsolidationData();
 253         typeComputeConsolidationData.setComputeTemplateConsolidationData(
 254                 SERVER_CMAUI, new ComputeTemplateConsolidationData());
 255         typeComputeConsolidationData.setComputeTemplateConsolidationData(
 256                 SERVER_OAM, new ComputeTemplateConsolidationData());
 257
 258         Assert.assertFalse(typeComputeConsolidationData.isNumberOfComputeConsolidationDataPerTypeLegal());
 259     }
 260
 261     @Test
 262     public void isGetAttrOutFromEntityLegal() {
 263         Map<String, List<String>> ports = new HashMap<>();
 264         ports.put(SERVER_NETWORK_ROLE_1_PORT1,
 265                 Arrays.asList(SERVER_0_NETWORK_ROLE_1_PORT, SERVER_1_NETWORK_ROLE_1_PORT));
 266
 267         Mockito.when(computeTemplateConsolidationDataMock.isGetAttrOutFromEntityLegal(Mockito.any(), Mockito.any()))
 268                 .thenReturn(true);
 269
 270         TypeComputeConsolidationData typeComputeConsolidationData = new TypeComputeConsolidationData();
 271         typeComputeConsolidationData.setComputeTemplateConsolidationData("server_oam_1", computeTemplateConsolidationDataMock);
 272
 273         Assert.assertTrue(typeComputeConsolidationData.isGetAttrOutFromEntityLegal(ports));
 274         Mockito.verify(computeTemplateConsolidationDataMock, Mockito.times(1))
 275                 .isGetAttrOutFromEntityLegal(Mockito.any(), Mockito.any());
 276     }
 277
 278     @Test
 279     public void testIsGetAttrOutFromEntityLegalNegative() {
 280         Map<String, List<String>> ports = new HashMap<>();
 281         ports.put(SERVER_NETWORK_ROLE_1_PORT1,
 282                 Arrays.asList(SERVER_0_NETWORK_ROLE_1_PORT, SERVER_1_NETWORK_ROLE_1_PORT));
 283
 284         TypeComputeConsolidationData typeComputeConsolidationData = new TypeComputeConsolidationData();
 285         typeComputeConsolidationData.setComputeTemplateConsolidationData("server_oam_1",
 286                 computeTemplateConsolidationDataMock);
 287
 288         Mockito.when(computeTemplateConsolidationDataMock.isGetAttrOutFromEntityLegal(Mockito.any(), Mockito.any()))
 289                 .thenReturn(false);
 290
 291         Assert.assertFalse(typeComputeConsolidationData.isGetAttrOutFromEntityLegal(ports));
 292
 293         Mockito.verify(computeTemplateConsolidationDataMock, Mockito.times(1))
 294                 .isGetAttrOutFromEntityLegal(Mockito.any(), Mockito.any());
 295
 296     }
 297
 298     private void verifyComputeTemplateConsolidationData(TypeComputeConsolidationData typeComputeConsolidationData,
 299             String computeNodeTemplateId, Set<String> expectedComputeNodeTemplateIds) {
 300         ComputeTemplateConsolidationData computeTemplateConsolidationData =
 301                 typeComputeConsolidationData.getComputeTemplateConsolidationData(computeNodeTemplateId);
 302         Assert.assertNotNull(computeTemplateConsolidationData);
 303         Assert.assertEquals(computeTemplateConsolidationData.getNodeTemplateId(), computeNodeTemplateId);
 304
 305         verifyGetAllComputeNodeTemplateId(typeComputeConsolidationData, expectedComputeNodeTemplateIds);
 306     }
 307
 308     private void verifyGetAllComputeNodeTemplateId(TypeComputeConsolidationData typeComputeConsolidationData,
 309             Set<String> expectedComputeNodeTemplateIds) {
 310         Collection<String> allComputeNodeTemplateIds  = typeComputeConsolidationData.getAllComputeNodeTemplateIds();
 311         Assert.assertNotNull(allComputeNodeTemplateIds);
 312         Assert.assertTrue(allComputeNodeTemplateIds.containsAll(expectedComputeNodeTemplateIds));
 313     }
 314 }