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.HashMap;
  21 import java.util.List;
  22 import java.util.Map;
  23
  24 import org.junit.Assert;
  25 import org.junit.Test;
  26
  27 import org.onap.sdc.tosca.datatypes.model.RequirementAssignment;
  28
  29 @SuppressWarnings("Duplicates")
  30 public class EntityConsolidationDataTest {
  31
  32     private static final String NODE_TEMPLATE_ID_1 = "nodeTemplateId1";
  33     private static final String NODE_TEMPLATE_ID_2 = "nodeTemplateId2";
  34     private static final String REQUIREMENT_ID_1 = "requirementId1";
  35     private static final String REQUIREMENT_ID_2 = "requirementId2";
  36
  37     @Test
  38     public void testAddNodesConnectedIn_SameNodeTemplateIds() {
  39         EntityConsolidationData consolidationData = new EntityConsolidationData();
  40         Map<String, String[]> expectedNodesConnectedData = new HashMap<>();
  41
  42         addNodesConnectedIn(consolidationData,NODE_TEMPLATE_ID_1, REQUIREMENT_ID_1);
  43         expectedNodesConnectedData.put(NODE_TEMPLATE_ID_1, new String[]{REQUIREMENT_ID_1});
  44         checkNodesConnected(consolidationData.getNodesConnectedIn(), expectedNodesConnectedData);
  45
  46         addNodesConnectedIn(consolidationData,NODE_TEMPLATE_ID_1, REQUIREMENT_ID_2);
  47         expectedNodesConnectedData.put(NODE_TEMPLATE_ID_1, new String[]{REQUIREMENT_ID_1, REQUIREMENT_ID_2});
  48         checkNodesConnected(consolidationData.getNodesConnectedIn(), expectedNodesConnectedData);
  49     }
  50
  51     @Test
  52     public void testAddNodesConnectedIn_DiffNodeTemplateIds() {
  53         EntityConsolidationData consolidationData = new EntityConsolidationData();
  54         Map<String, String[]> expectedNodesConnectedData = new HashMap<>();
  55
  56         addNodesConnectedIn(consolidationData, NODE_TEMPLATE_ID_1, REQUIREMENT_ID_1);
  57         expectedNodesConnectedData.put(NODE_TEMPLATE_ID_1, new String[]{REQUIREMENT_ID_1});
  58         checkNodesConnected(consolidationData.getNodesConnectedIn(), expectedNodesConnectedData);
  59
  60         addNodesConnectedIn(consolidationData, NODE_TEMPLATE_ID_2, REQUIREMENT_ID_2);
  61         expectedNodesConnectedData.put(NODE_TEMPLATE_ID_2, new String[]{REQUIREMENT_ID_2});
  62         checkNodesConnected(consolidationData.getNodesConnectedIn(), expectedNodesConnectedData);
  63     }
  64
  65     @Test
  66     public void testAddNodesConnectedOut_SameNodeTemplateIds() {
  67         EntityConsolidationData consolidationData = new EntityConsolidationData();
  68         Map<String, String[]> expectedNodesConnectedData = new HashMap<>();
  69
  70         addNodesConnectedOut(consolidationData, NODE_TEMPLATE_ID_1, REQUIREMENT_ID_1);
  71         expectedNodesConnectedData.put(NODE_TEMPLATE_ID_1, new String[]{REQUIREMENT_ID_1});
  72         checkNodesConnected(consolidationData.getNodesConnectedOut(), expectedNodesConnectedData);
  73
  74         addNodesConnectedOut(consolidationData, NODE_TEMPLATE_ID_1, REQUIREMENT_ID_2);
  75         expectedNodesConnectedData.put(NODE_TEMPLATE_ID_1, new String[]{REQUIREMENT_ID_1, REQUIREMENT_ID_2});
  76         checkNodesConnected(consolidationData.getNodesConnectedOut(), expectedNodesConnectedData);
  77     }
  78
  79     @Test
  80     public void testAddNodesConnectedOut_DiffNodeTemplateIds() {
  81         EntityConsolidationData consolidationData = new EntityConsolidationData();
  82         Map<String, String[]> expectedNodesConnectedData = new HashMap<>();
  83
  84         addNodesConnectedOut(consolidationData, NODE_TEMPLATE_ID_1, REQUIREMENT_ID_1);
  85         expectedNodesConnectedData.put(NODE_TEMPLATE_ID_1, new String[]{REQUIREMENT_ID_1});
  86         checkNodesConnected(consolidationData.getNodesConnectedOut(), expectedNodesConnectedData);
  87
  88         addNodesConnectedOut(consolidationData, NODE_TEMPLATE_ID_2, REQUIREMENT_ID_2);
  89         expectedNodesConnectedData.put(NODE_TEMPLATE_ID_2, new String[]{REQUIREMENT_ID_2});
  90         checkNodesConnected(consolidationData.getNodesConnectedOut(), expectedNodesConnectedData);
  91     }
  92
  93     @Test
  94     public void testAddOutputParamGetAttrIn() {
  95         EntityConsolidationData consolidationData = new EntityConsolidationData();
  96         GetAttrFuncData getAttrFuncData1 = createGetAttrFuncData("field1");
  97
  98         consolidationData.addOutputParamGetAttrIn(getAttrFuncData1);
  99         List<GetAttrFuncData> outputParametersGetAttrIn = consolidationData.getOutputParametersGetAttrIn();
 100         Assert.assertEquals(1, outputParametersGetAttrIn.size());
 101         Assert.assertTrue(outputParametersGetAttrIn.contains(getAttrFuncData1));
 102
 103         GetAttrFuncData getAttrFuncData2 = createGetAttrFuncData("field2");
 104         consolidationData.addOutputParamGetAttrIn(getAttrFuncData2);
 105         Assert.assertEquals(2,outputParametersGetAttrIn.size());
 106         Assert.assertTrue(outputParametersGetAttrIn.contains(getAttrFuncData1));
 107         Assert.assertTrue(outputParametersGetAttrIn.contains(getAttrFuncData2));
 108     }
 109
 110     @Test
 111     public void testRemoveParamNameFromAttrFuncList() {
 112         EntityConsolidationData consolidationData = new EntityConsolidationData();
 113         GetAttrFuncData getAttrFuncData1 = createGetAttrFuncData("field1");
 114
 115         consolidationData.addOutputParamGetAttrIn(getAttrFuncData1);
 116         // verify that getAttrFuncData was added
 117         List<GetAttrFuncData> outputParametersGetAttrIn = consolidationData.getOutputParametersGetAttrIn();
 118         Assert.assertEquals(1, outputParametersGetAttrIn.size());
 119
 120         consolidationData.removeParamNameFromAttrFuncList("field2");
 121         //verify that not existing getAttrFuncData parameter wasn't removed and no Exception
 122         outputParametersGetAttrIn = consolidationData.getOutputParametersGetAttrIn();
 123         Assert.assertEquals(1, outputParametersGetAttrIn.size());
 124
 125         consolidationData.removeParamNameFromAttrFuncList("field1");
 126         //verify that existing getAttrFuncData parameter was removed
 127         outputParametersGetAttrIn = consolidationData.getOutputParametersGetAttrIn();
 128         Assert.assertEquals(0, outputParametersGetAttrIn.size());
 129     }
 130
 131     private GetAttrFuncData createGetAttrFuncData(String field) {
 132         GetAttrFuncData getAttrFuncData = new GetAttrFuncData();
 133         getAttrFuncData.setFieldName(field);
 134         getAttrFuncData.setAttributeName("attribute");
 135         return  getAttrFuncData;
 136     }
 137
 138     private void checkNodesConnected(Map<String, List<RequirementAssignmentData>> actualNodesConnected,
 139                                               Map<String, String[]> expectedNodesConnected) {
 140         Assert.assertNotNull(actualNodesConnected);
 141
 142         expectedNodesConnected.keySet().forEach(expectedNodeTemplateId -> {
 143             Assert.assertTrue(actualNodesConnected.containsKey(expectedNodeTemplateId));
 144             Assert.assertEquals(expectedNodesConnected.size(), actualNodesConnected.size());
 145
 146             List<RequirementAssignmentData> actualRequirementAssignmentData =
 147                     actualNodesConnected.get(expectedNodeTemplateId);
 148             List<String> expectedRequirementIdList =
 149                     Arrays.asList(expectedNodesConnected.get(expectedNodeTemplateId));
 150             Assert.assertEquals(expectedRequirementIdList.size(), actualRequirementAssignmentData.size());
 151
 152             actualRequirementAssignmentData.forEach(actualRequirementAssignment ->
 153                     Assert.assertTrue(expectedRequirementIdList
 154                             .contains(actualRequirementAssignment.getRequirementId())));
 155         });
 156
 157     }
 158
 159     private void addNodesConnectedIn(EntityConsolidationData consolidationData,
 160             String nodeTemplateId, String requirementId) {
 161         RequirementAssignment requirementAssignment = new RequirementAssignment();
 162         consolidationData.addNodesConnectedIn(nodeTemplateId, requirementId, requirementAssignment);
 163     }
 164
 165     private void addNodesConnectedOut(EntityConsolidationData consolidationData,
 166             String nodeTemplateId, String requirementId) {
 167         RequirementAssignment requirementAssignment = new RequirementAssignment();
 168         consolidationData.addNodesConnectedOut(nodeTemplateId, requirementId, requirementAssignment);
 169     }
 170 }