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