gerrit.onap Code Review - sdc.git/blob

   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.Collections;
  21 import java.util.HashMap;
  22 import java.util.List;
  23 import java.util.Map;
  24
  25 import org.junit.Assert;
  26 import org.junit.Test;
  27
  28 import org.onap.sdc.tosca.datatypes.model.RequirementAssignment;
  29
  30 @SuppressWarnings("Duplicates")
  31 public class EntityConsolidationDataTest {
  32
  33     private static final String NODE_TEMPLATE_ID_1 = "nodeTemplateId1";
  34     private static final String NODE_TEMPLATE_ID_2 = "nodeTemplateId2";
  35     private static final String REQUIREMENT_ID_1 = "requirementId1";
  36     private static final String REQUIREMENT_ID_2 = "requirementId2";
  37     private static final String GROUP_ID_1 = "groupId1";
  38     private static final String GROUP_ID_2 = "groupId2";
  39     private static final String FIELD_1 = "field1";
  40     private static final String FIELD_2 = "field2";
  41
  42
  43     private final EntityConsolidationData consolidationData = new EntityConsolidationData();
  44
  45     @Test
  46     public void testIsGetAttrOutFromEntityLegal() {
  47         Map<String, List<String>> ports = new HashMap<>();
  48         ports.put("server_networkrole_1_port",
  49                 Arrays.asList("server_0_networkrole_1_port", "server_1_networkrole_1_port"));
  50
  51         GetAttrFuncData getAttrFuncData = new GetAttrFuncData("vmac_address", "accessIPv4");
  52         Map<String, List<GetAttrFuncData>> getAttOutMap = new HashMap<>();
  53         getAttOutMap.put("server_0_networkrole_1_port", Collections.singletonList(getAttrFuncData));
  54
  55         GetAttrFuncData getAttrFuncData1 = new GetAttrFuncData("vmac_address", "accessIPv4");
  56         Map<String, List<GetAttrFuncData>> getAttOutMap1 = new HashMap<>();
  57         getAttOutMap1.put("server_1_networkrole_1_port", Collections.singletonList(getAttrFuncData1));
  58
  59
  60         EntityConsolidationData entityConsolidationData = new EntityConsolidationData();
  61         entityConsolidationData.setNodesGetAttrOut(getAttOutMap);
  62
  63         EntityConsolidationData entityConsolidationData1 = new EntityConsolidationData();
  64         entityConsolidationData1.setNodesGetAttrOut(getAttOutMap1);
  65
  66         List<EntityConsolidationData> entityConsolidationDataList =
  67                 Arrays.asList(entityConsolidationData, entityConsolidationData1);
  68
  69         Assert.assertTrue(entityConsolidationData
  70                                   .isGetAttrOutFromEntityLegal(entityConsolidationDataList, ports));
  71     }
  72
  73     @Test
  74     public void testIsGetAttrOutFromEntityLegalNegative() {
  75         Map<String, List<String>> ports = new HashMap<>();
  76         ports.put("server_networkrole_1_port",
  77                 Arrays.asList("server_0_networkrole_1_port", "server_0_networkrole_2_port"));
  78
  79         GetAttrFuncData getAttrFuncData = new GetAttrFuncData("vmac_address", "accessIPv4");
  80         Map<String, List<GetAttrFuncData>> getAttOutMap = new HashMap<>();
  81         getAttOutMap.put("server_0_networkrole_1_port", Collections.singletonList(getAttrFuncData));
  82
  83         GetAttrFuncData getAttrFuncData1 = new GetAttrFuncData("vmac_address", "accessIPv4");
  84         getAttOutMap.put("server_0_networkrole_2_port", Collections.singletonList(getAttrFuncData1));
  85
  86
  87         EntityConsolidationData entityConsolidationData = new EntityConsolidationData();
  88         entityConsolidationData.setNodesGetAttrOut(getAttOutMap);
  89
  90         EntityConsolidationData entityConsolidationData1 = new EntityConsolidationData();
  91
  92         List<EntityConsolidationData> entityConsolidationDataList =
  93                 Arrays.asList(entityConsolidationData, entityConsolidationData1);
  94
  95         Assert.assertFalse(entityConsolidationData
  96                                    .isGetAttrOutFromEntityLegal(entityConsolidationDataList, ports));
  97     }
  98
  99     @Test
 100     public void testIsGetAttrOutFromEntityLegalMultiplePortWithDiffAttr() {
 101         Map<String, List<String>> ports = new HashMap<>();
 102         ports.put("server_networkrole_1_port",
 103                 Arrays.asList("server_0_networkrole_1_port", "server_1_networkrole_1_port"));
 104
 105         ports.put("server_networkrole_2_port",
 106                 Arrays.asList("server_0_networkrole_2_port", "server_0_networkrole_2_port"));
 107
 108         GetAttrFuncData getAttrFuncData = new GetAttrFuncData("vmac_address", "accessIPv4");
 109         Map<String, List<GetAttrFuncData>> getAttOutMap = new HashMap<>();
 110         getAttOutMap.put("server_0_networkrole_1_port", Collections.singletonList(getAttrFuncData));
 111         getAttOutMap.put("server_0_networkrole_2_port", Collections.singletonList(getAttrFuncData));
 112
 113         GetAttrFuncData getAttrFuncData1 = new GetAttrFuncData("vmac_address", "accessIPv4");
 114         Map<String, List<GetAttrFuncData>> getAttOutMap1 = new HashMap<>();
 115         getAttOutMap.put("server_0_networkrole_1_port", Collections.singletonList(getAttrFuncData1));
 116
 117
 118         EntityConsolidationData entityConsolidationData = new EntityConsolidationData();
 119         entityConsolidationData.setNodesGetAttrOut(getAttOutMap);
 120
 121         EntityConsolidationData entityConsolidationData1 = new EntityConsolidationData();
 122         entityConsolidationData1.setNodesGetAttrOut(getAttOutMap1);
 123
 124         List<EntityConsolidationData> entityConsolidationDataList =
 125                 Arrays.asList(entityConsolidationData, entityConsolidationData1);
 126
 127         Assert.assertFalse(entityConsolidationData
 128                                    .isGetAttrOutFromEntityLegal(entityConsolidationDataList, ports));
 129     }
 130
 131     @Test
 132     public void testAddNodesConnectedIn_SameNodeTemplateIds() {
 133         Map<String, String[]> expectedNodesConnectedData = new HashMap<>();
 134         addNodesConnectedIn(consolidationData,NODE_TEMPLATE_ID_1, REQUIREMENT_ID_1);
 135         expectedNodesConnectedData.put(NODE_TEMPLATE_ID_1, new String[]{REQUIREMENT_ID_1});
 136         checkNodesConnected(consolidationData.getNodesConnectedIn(), expectedNodesConnectedData);
 137
 138         addNodesConnectedIn(consolidationData,NODE_TEMPLATE_ID_1, REQUIREMENT_ID_2);
 139         expectedNodesConnectedData.put(NODE_TEMPLATE_ID_1, new String[]{REQUIREMENT_ID_1, REQUIREMENT_ID_2});
 140         checkNodesConnected(consolidationData.getNodesConnectedIn(), expectedNodesConnectedData);
 141     }
 142
 143     @Test
 144     public void testAddNodesConnectedIn_DiffNodeTemplateIds() {
 145         Map<String, String[]> expectedNodesConnectedData = new HashMap<>();
 146         addNodesConnectedIn(consolidationData, NODE_TEMPLATE_ID_1, REQUIREMENT_ID_1);
 147         expectedNodesConnectedData.put(NODE_TEMPLATE_ID_1, new String[]{REQUIREMENT_ID_1});
 148         checkNodesConnected(consolidationData.getNodesConnectedIn(), expectedNodesConnectedData);
 149
 150         addNodesConnectedIn(consolidationData, NODE_TEMPLATE_ID_2, REQUIREMENT_ID_2);
 151         expectedNodesConnectedData.put(NODE_TEMPLATE_ID_2, new String[]{REQUIREMENT_ID_2});
 152         checkNodesConnected(consolidationData.getNodesConnectedIn(), expectedNodesConnectedData);
 153     }
 154
 155     @Test
 156     public void testAddNodesConnectedOut_SameNodeTemplateIds() {
 157         Map<String, String[]> expectedNodesConnectedData = new HashMap<>();
 158         addNodesConnectedOut(consolidationData, NODE_TEMPLATE_ID_1, REQUIREMENT_ID_1);
 159         expectedNodesConnectedData.put(NODE_TEMPLATE_ID_1, new String[]{REQUIREMENT_ID_1});
 160         checkNodesConnected(consolidationData.getNodesConnectedOut(), expectedNodesConnectedData);
 161
 162         addNodesConnectedOut(consolidationData, NODE_TEMPLATE_ID_1, REQUIREMENT_ID_2);
 163         expectedNodesConnectedData.put(NODE_TEMPLATE_ID_1, new String[]{REQUIREMENT_ID_1, REQUIREMENT_ID_2});
 164         checkNodesConnected(consolidationData.getNodesConnectedOut(), expectedNodesConnectedData);
 165     }
 166
 167     @Test
 168     public void testAddNodesConnectedOut_DiffNodeTemplateIds() {
 169         Map<String, String[]> expectedNodesConnectedData = new HashMap<>();
 170         addNodesConnectedOut(consolidationData, NODE_TEMPLATE_ID_1, REQUIREMENT_ID_1);
 171         expectedNodesConnectedData.put(NODE_TEMPLATE_ID_1, new String[]{REQUIREMENT_ID_1});
 172         checkNodesConnected(consolidationData.getNodesConnectedOut(), expectedNodesConnectedData);
 173
 174         addNodesConnectedOut(consolidationData, NODE_TEMPLATE_ID_2, REQUIREMENT_ID_2);
 175         expectedNodesConnectedData.put(NODE_TEMPLATE_ID_2, new String[]{REQUIREMENT_ID_2});
 176         checkNodesConnected(consolidationData.getNodesConnectedOut(), expectedNodesConnectedData);
 177     }
 178
 179     @Test
 180     public void testAddOutputParamGetAttrIn() {
 181         GetAttrFuncData getAttrFuncData1 = createGetAttrFuncData(FIELD_1);
 182         consolidationData.addOutputParamGetAttrIn(getAttrFuncData1);
 183         List<GetAttrFuncData> outputParametersGetAttrIn = consolidationData.getOutputParametersGetAttrIn();
 184         Assert.assertEquals(1, outputParametersGetAttrIn.size());
 185         Assert.assertTrue(outputParametersGetAttrIn.contains(getAttrFuncData1));
 186
 187         GetAttrFuncData getAttrFuncData2 = createGetAttrFuncData(FIELD_2);
 188         consolidationData.addOutputParamGetAttrIn(getAttrFuncData2);
 189         Assert.assertEquals(2,outputParametersGetAttrIn.size());
 190         Assert.assertTrue(outputParametersGetAttrIn.contains(getAttrFuncData1));
 191         Assert.assertTrue(outputParametersGetAttrIn.contains(getAttrFuncData2));
 192     }
 193
 194     @Test
 195     public void testRemoveParamNameFromAttrFuncList() {
 196         GetAttrFuncData getAttrFuncData1 = createGetAttrFuncData(FIELD_1);
 197         consolidationData.addOutputParamGetAttrIn(getAttrFuncData1);
 198         // verify that getAttrFuncData was added
 199         List<GetAttrFuncData> outputParametersGetAttrIn = consolidationData.getOutputParametersGetAttrIn();
 200         Assert.assertEquals(1, outputParametersGetAttrIn.size());
 201
 202         consolidationData.removeParamNameFromAttrFuncList(FIELD_2);
 203         //verify that not existing getAttrFuncData parameter wasn't removed and no Exception
 204         outputParametersGetAttrIn = consolidationData.getOutputParametersGetAttrIn();
 205         Assert.assertEquals(1, outputParametersGetAttrIn.size());
 206
 207         consolidationData.removeParamNameFromAttrFuncList("field1");
 208         //verify that existing getAttrFuncData parameter was removed
 209         outputParametersGetAttrIn = consolidationData.getOutputParametersGetAttrIn();
 210         Assert.assertEquals(0, outputParametersGetAttrIn.size());
 211     }
 212
 213     @Test
 214     public void testAddGroupId() {
 215         consolidationData.addGroupId(GROUP_ID_1);
 216         List<String> groupIds = consolidationData.getGroupIds();
 217         Assert.assertNotNull(groupIds);
 218         Assert.assertTrue(groupIds.contains(GROUP_ID_1));
 219         Assert.assertEquals(1, consolidationData.getGroupIds().size());
 220
 221         consolidationData.addGroupId(GROUP_ID_2);
 222         Assert.assertEquals(2, consolidationData.getGroupIds().size());
 223         Assert.assertTrue(groupIds.contains(GROUP_ID_2));
 224     }
 225
 226     private GetAttrFuncData createGetAttrFuncData(String field) {
 227         GetAttrFuncData getAttrFuncData = new GetAttrFuncData();
 228         getAttrFuncData.setFieldName(field);
 229         getAttrFuncData.setAttributeName("attribute");
 230         return  getAttrFuncData;
 231     }
 232
 233     private void checkNodesConnected(Map<String, List<RequirementAssignmentData>> actualNodesConnected,
 234                                               Map<String, String[]> expectedNodesConnected) {
 235         Assert.assertNotNull(actualNodesConnected);
 236
 237         expectedNodesConnected.keySet().forEach(expectedNodeTemplateId -> {
 238             Assert.assertTrue(actualNodesConnected.containsKey(expectedNodeTemplateId));
 239             Assert.assertEquals(expectedNodesConnected.size(), actualNodesConnected.size());
 240
 241             List<RequirementAssignmentData> actualRequirementAssignmentData =
 242                     actualNodesConnected.get(expectedNodeTemplateId);
 243             List<String> expectedRequirementIdList =
 244                     Arrays.asList(expectedNodesConnected.get(expectedNodeTemplateId));
 245             Assert.assertEquals(expectedRequirementIdList.size(), actualRequirementAssignmentData.size());
 246
 247             actualRequirementAssignmentData.forEach(actualRequirementAssignment ->
 248                     Assert.assertTrue(expectedRequirementIdList
 249                             .contains(actualRequirementAssignment.getRequirementId())));
 250         });
 251
 252     }
 253
 254     private void addNodesConnectedIn(EntityConsolidationData consolidationData,
 255             String nodeTemplateId, String requirementId) {
 256         RequirementAssignment requirementAssignment = new RequirementAssignment();
 257         consolidationData.addNodesConnectedIn(nodeTemplateId, requirementId, requirementAssignment);
 258     }
 259
 260     private void addNodesConnectedOut(EntityConsolidationData consolidationData,
 261             String nodeTemplateId, String requirementId) {
 262         RequirementAssignment requirementAssignment = new RequirementAssignment();
 263         consolidationData.addNodesConnectedOut(nodeTemplateId, requirementId, requirementAssignment);
 264     }
 265 }