openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/test/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/consolidation/ComputeConsolidationDataHandlerTest.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.HashMap;
  20 import java.util.Map;
  21
  22 import org.junit.Before;
  23 import org.junit.Test;
  24 import org.mockito.Mock;
  25 import org.mockito.Mockito;
  26 import org.mockito.MockitoAnnotations;
  27
  28 import org.onap.sdc.tosca.datatypes.model.NodeTemplate;
  29 import org.onap.sdc.tosca.datatypes.model.RequirementAssignment;
  30 import org.onap.sdc.tosca.datatypes.model.ServiceTemplate;
  31 import org.onap.sdc.tosca.datatypes.model.TopologyTemplate;
  32 import org.openecomp.sdc.heat.datatypes.model.HeatOrchestrationTemplate;
  33 import org.openecomp.sdc.tosca.services.ToscaConstants;
  34 import org.openecomp.sdc.translator.datatypes.heattotosca.to.TranslateTo;
  35
  36
  37 public class ComputeConsolidationDataHandlerTest {
  38
  39     private static final String COMPUTE_NODE_TEMPLATE_ID_1 = "computeNodeTemplateId";
  40     private static final String COMPUTE_NODE_TEMPLATE_ID_2 = "computeNodeTemplateId2";
  41     private static final String COMPUTE_NODE_TYPE_1 = "computeNodeType1";
  42
  43     private static final String PORT_NODE_TYPE_1 = "portType1";
  44     private static final String PORT_NODE_TEMPLATE_ID_1 = "portNodeTemplateId1";
  45
  46     private static final String GROUP_ID = "groupId";
  47     private static final String REQUIREMENT_ID = "requirementId";
  48     private static final String SERVICE_FILE_NAME_PREFIX = "Main";
  49     private static final String SERVICE_FILE_NAME = SERVICE_FILE_NAME_PREFIX + "ServiceTemplate.yaml";
  50     private static final String MAIN_SERVICE_TEMPLATE = "MainServiceTemplate.yaml";
  51
  52     @Before
  53     public void setUp() {
  54         MockitoAnnotations.openMocks(this);
  55         consolidationDataHandler = new ComputeConsolidationDataHandler(computeConsolidationData);
  56     }
  57
  58     @Mock
  59     private static ComputeConsolidationData computeConsolidationData;
  60     @Mock
  61     private static TranslateTo translateTo;
  62     @Mock
  63     private static ServiceTemplate serviceTemplate;
  64     @Mock
  65     private static ComputeTemplateConsolidationData consolidationData;
  66     @Mock
  67     private static HeatOrchestrationTemplate heatOrchestrationTemplate;
  68
  69     private static ComputeConsolidationDataHandler consolidationDataHandler;
  70     private static final RequirementAssignment requirementAssignment = new RequirementAssignment();
  71
  72     @Test
  73     public void testAddNodesConnectedOut() {
  74         mockEntities(COMPUTE_NODE_TEMPLATE_ID_1);
  75         consolidationDataHandler
  76                 .addNodesConnectedOut(translateTo, COMPUTE_NODE_TEMPLATE_ID_1, REQUIREMENT_ID, requirementAssignment);
  77         Mockito.verify(computeConsolidationData)
  78                .addComputeTemplateConsolidationData(SERVICE_FILE_NAME, COMPUTE_NODE_TYPE_1, COMPUTE_NODE_TEMPLATE_ID_1);
  79         Mockito.verify(consolidationData)
  80                .addNodesConnectedOut(COMPUTE_NODE_TEMPLATE_ID_1, REQUIREMENT_ID, requirementAssignment);
  81     }
  82
  83     @Test
  84     public void testAddNodesConnectedOut_consolidationDataNotExist() {
  85         mockEntities_NullConsolidationData(COMPUTE_NODE_TEMPLATE_ID_1);
  86         consolidationDataHandler
  87                 .addNodesConnectedOut(translateTo, COMPUTE_NODE_TEMPLATE_ID_1, REQUIREMENT_ID, requirementAssignment);
  88         Mockito.verify(computeConsolidationData)
  89                .addComputeTemplateConsolidationData(SERVICE_FILE_NAME, COMPUTE_NODE_TYPE_1, COMPUTE_NODE_TEMPLATE_ID_1);
  90         Mockito.verify(consolidationData, Mockito.times(0))
  91                .addNodesConnectedOut(Mockito.any(), Mockito.any(), Mockito.any());
  92     }
  93
  94     @Test
  95     public void testAddNodesConnectedIn() {
  96         String sourceNodeTemplateId = COMPUTE_NODE_TEMPLATE_ID_1;
  97         String dependentNodeTemplateId = COMPUTE_NODE_TEMPLATE_ID_2;
  98         mockEntities(dependentNodeTemplateId);
  99         consolidationDataHandler
 100                 .addNodesConnectedIn(translateTo, sourceNodeTemplateId, dependentNodeTemplateId, "targetResourceId",
 101                         REQUIREMENT_ID, requirementAssignment);
 102         Mockito.verify(computeConsolidationData)
 103                .addComputeTemplateConsolidationData(SERVICE_FILE_NAME, COMPUTE_NODE_TYPE_1, dependentNodeTemplateId);
 104         Mockito.verify(consolidationData)
 105                .addNodesConnectedIn(sourceNodeTemplateId, REQUIREMENT_ID, requirementAssignment);
 106     }
 107
 108     @Test
 109     public void testAddNodesConnectedIn_consolidationDataNotExist() {
 110         String dependentNodeTemplateId = COMPUTE_NODE_TEMPLATE_ID_2;
 111         mockEntities_NullConsolidationData(dependentNodeTemplateId);
 112         consolidationDataHandler.addNodesConnectedIn(translateTo, COMPUTE_NODE_TEMPLATE_ID_1, dependentNodeTemplateId,
 113                 "targetResourceId", REQUIREMENT_ID, requirementAssignment);
 114         Mockito.verify(computeConsolidationData)
 115                .addComputeTemplateConsolidationData(SERVICE_FILE_NAME, COMPUTE_NODE_TYPE_1, dependentNodeTemplateId);
 116         Mockito.verify(consolidationData, Mockito.times(0))
 117                .addNodesConnectedIn(Mockito.any(), Mockito.any(), Mockito.any());
 118     }
 119
 120     @Test
 121     public void testRemoveParamNameFromAttrFuncList() {
 122         mockEntities(COMPUTE_NODE_TEMPLATE_ID_2);
 123         consolidationDataHandler
 124                 .removeParamNameFromAttrFuncList(serviceTemplate, heatOrchestrationTemplate, "paramName",
 125                         COMPUTE_NODE_TEMPLATE_ID_1, COMPUTE_NODE_TEMPLATE_ID_2);
 126         Mockito.verify(computeConsolidationData)
 127                .addComputeTemplateConsolidationData(SERVICE_FILE_NAME, COMPUTE_NODE_TYPE_1, COMPUTE_NODE_TEMPLATE_ID_2);
 128         Mockito.verify(consolidationData).removeParamNameFromAttrFuncList("paramName");
 129     }
 130
 131     @Test
 132     public void testRemoveParamNameFromAttrFuncList_consolidationDataNotExist() {
 133         mockEntities_NullConsolidationData(COMPUTE_NODE_TEMPLATE_ID_2);
 134         consolidationDataHandler
 135                 .removeParamNameFromAttrFuncList(serviceTemplate, heatOrchestrationTemplate, "paramName",
 136                         COMPUTE_NODE_TEMPLATE_ID_1, COMPUTE_NODE_TEMPLATE_ID_2);
 137         Mockito.verify(computeConsolidationData)
 138                .addComputeTemplateConsolidationData(SERVICE_FILE_NAME, COMPUTE_NODE_TYPE_1, COMPUTE_NODE_TEMPLATE_ID_2);
 139         Mockito.verify(consolidationData, Mockito.times(0)).removeParamNameFromAttrFuncList(Mockito.any());
 140     }
 141
 142     @Test
 143     public void testAddConsolidationData() {
 144         consolidationDataHandler
 145                 .addConsolidationData(SERVICE_FILE_NAME, COMPUTE_NODE_TYPE_1, COMPUTE_NODE_TEMPLATE_ID_1);
 146         Mockito.verify(computeConsolidationData)
 147                .addComputeTemplateConsolidationData(SERVICE_FILE_NAME, COMPUTE_NODE_TYPE_1, COMPUTE_NODE_TEMPLATE_ID_1);
 148     }
 149
 150     @Test
 151     public void testAddPortToConsolidationData() {
 152         mockEntities(COMPUTE_NODE_TEMPLATE_ID_1);
 153         consolidationDataHandler
 154                 .addPortToConsolidationData(translateTo, COMPUTE_NODE_TYPE_1, COMPUTE_NODE_TEMPLATE_ID_1,
 155                         PORT_NODE_TYPE_1, PORT_NODE_TEMPLATE_ID_1);
 156         Mockito.verify(computeConsolidationData)
 157                .addComputeTemplateConsolidationData(SERVICE_FILE_NAME, COMPUTE_NODE_TYPE_1, COMPUTE_NODE_TEMPLATE_ID_1);
 158         Mockito.verify(consolidationData).addPort(PORT_NODE_TYPE_1, PORT_NODE_TEMPLATE_ID_1);
 159     }
 160
 161     @Test
 162     public void testAddVolumeToConsolidationData() {
 163         mockEntities(COMPUTE_NODE_TEMPLATE_ID_1);
 164         consolidationDataHandler
 165                 .addVolumeToConsolidationData(translateTo, COMPUTE_NODE_TYPE_1, COMPUTE_NODE_TEMPLATE_ID_1,
 166                         REQUIREMENT_ID, requirementAssignment);
 167         Mockito.verify(computeConsolidationData)
 168                .addComputeTemplateConsolidationData(SERVICE_FILE_NAME, COMPUTE_NODE_TYPE_1, COMPUTE_NODE_TEMPLATE_ID_1);
 169         Mockito.verify(consolidationData).addVolume(REQUIREMENT_ID, requirementAssignment);
 170     }
 171
 172
 173     @Test
 174     public void testAddGroupIdToConsolidationData() {
 175         mockEntities(COMPUTE_NODE_TEMPLATE_ID_1);
 176         consolidationDataHandler
 177                 .addGroupIdToConsolidationData(translateTo, COMPUTE_NODE_TYPE_1, COMPUTE_NODE_TEMPLATE_ID_1, GROUP_ID);
 178         Mockito.verify(computeConsolidationData)
 179                .addComputeTemplateConsolidationData(SERVICE_FILE_NAME, COMPUTE_NODE_TYPE_1, COMPUTE_NODE_TEMPLATE_ID_1);
 180         Mockito.verify(consolidationData).addGroupId(GROUP_ID);
 181     }
 182
 183     private void mockEntities(String nodeTemplateId) {
 184         mockServiceTemplate(nodeTemplateId);
 185         mockTranslateTo(nodeTemplateId);
 186         mockComputeConsolidationData();
 187     }
 188
 189     private void mockEntities_NullConsolidationData(String nodeTemplateId) {
 190         mockServiceTemplate(nodeTemplateId);
 191         mockTranslateTo(nodeTemplateId);
 192         mockNullConsolidationData();
 193     }
 194
 195     private void mockServiceTemplate(String nodeTemplateId) {
 196         TopologyTemplate topologyTemplate = createTopologyTemplate(nodeTemplateId);
 197         Mockito.when(serviceTemplate.getTopology_template()).thenReturn(topologyTemplate);
 198
 199         Map<String, String> metadata = new HashMap<>();
 200         metadata.put(ToscaConstants.ST_METADATA_TEMPLATE_NAME, SERVICE_FILE_NAME_PREFIX);
 201         Mockito.when(serviceTemplate.getMetadata()).thenReturn(metadata);
 202     }
 203
 204     private void mockTranslateTo(String nodeTemplateId) {
 205         Mockito.when(translateTo.getTranslatedId()).thenReturn(nodeTemplateId);
 206         Mockito.when(translateTo.getServiceTemplate()).thenReturn(serviceTemplate);
 207     }
 208
 209     private void mockComputeConsolidationData() {
 210         Mockito.when(computeConsolidationData
 211                              .addComputeTemplateConsolidationData(Mockito.anyString(), Mockito.anyString(),
 212                                      Mockito.anyString())).thenReturn(consolidationData);
 213     }
 214
 215     private void mockNullConsolidationData() {
 216         Mockito.when(computeConsolidationData
 217                              .addComputeTemplateConsolidationData(Mockito.anyString(), Mockito.anyString(),
 218                                      Mockito.anyString())).thenReturn(null);
 219     }
 220
 221     private TopologyTemplate createTopologyTemplate(String nodeTemplateId) {
 222         TopologyTemplate topologyTemplate = new TopologyTemplate();
 223         Map<String, NodeTemplate> nodeTemplates = new HashMap<>();
 224         NodeTemplate nodeTemplate = new NodeTemplate();
 225         nodeTemplate.setType(COMPUTE_NODE_TYPE_1);
 226         nodeTemplates.put(nodeTemplateId, nodeTemplate);
 227         topologyTemplate.setNode_templates(nodeTemplates);
 228         return topologyTemplate;
 229     }
 230
 231     @Test
 232     public void isNumberOfComputeTypesLegalPositive() {
 233         ComputeConsolidationDataHandler computeConsolidationDataHandler =
 234                 new ComputeConsolidationDataHandler(computeConsolidationData);
 235
 236         computeConsolidationDataHandler.isNumberOfComputeTypesLegal(MAIN_SERVICE_TEMPLATE);
 237
 238         Mockito.verify(computeConsolidationData).isNumberOfComputeTypesLegal(MAIN_SERVICE_TEMPLATE);
 239     }
 240 }