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.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
  51     @Before
  52     public void setUp() {
  53         MockitoAnnotations.initMocks(this);
  54         consolidationDataHandler = new ComputeConsolidationDataHandler(computeConsolidationData);
  55     }
  56
  57     @Mock
  58     private static ComputeConsolidationData computeConsolidationData;
  59     @Mock
  60     private static TranslateTo translateTo;
  61     @Mock
  62     private static ServiceTemplate serviceTemplate;
  63     @Mock
  64     private static ComputeTemplateConsolidationData consolidationData;
  65     @Mock
  66     private static HeatOrchestrationTemplate heatOrchestrationTemplate;
  67
  68     private static ComputeConsolidationDataHandler consolidationDataHandler;
  69     private static final RequirementAssignment requirementAssignment = new RequirementAssignment();
  70
  71     @Test
  72     public void testAddNodesConnectedOut() {
  73         mockEntities(COMPUTE_NODE_TEMPLATE_ID_1);
  74         consolidationDataHandler.addNodesConnectedOut(
  75                 translateTo, COMPUTE_NODE_TEMPLATE_ID_1, REQUIREMENT_ID, requirementAssignment);
  76         Mockito.verify(computeConsolidationData).addComputeTemplateConsolidationData(
  77                 SERVICE_FILE_NAME, COMPUTE_NODE_TYPE_1, COMPUTE_NODE_TEMPLATE_ID_1);
  78         Mockito.verify(consolidationData).addNodesConnectedOut(
  79                 COMPUTE_NODE_TEMPLATE_ID_1, REQUIREMENT_ID, requirementAssignment);
  80     }
  81
  82     @Test
  83     public void testAddNodesConnectedOut_consolidationDataNotExist() {
  84         mockEntities_NullConsolidationData(COMPUTE_NODE_TEMPLATE_ID_1);
  85         consolidationDataHandler.addNodesConnectedOut(
  86                 translateTo, COMPUTE_NODE_TEMPLATE_ID_1, REQUIREMENT_ID, requirementAssignment);
  87         Mockito.verify(computeConsolidationData).addComputeTemplateConsolidationData(
  88                 SERVICE_FILE_NAME, COMPUTE_NODE_TYPE_1, COMPUTE_NODE_TEMPLATE_ID_1);
  89         Mockito.verify(consolidationData, Mockito.times(0)).addNodesConnectedOut(
  90                 Mockito.any(),  Mockito.any(),  Mockito.any());
  91     }
  92
  93     @Test
  94     public void testAddNodesConnectedIn() {
  95         String sourceNodeTemplateId = COMPUTE_NODE_TEMPLATE_ID_1;
  96         String dependentNodeTemplateId = COMPUTE_NODE_TEMPLATE_ID_2;
  97         mockEntities(dependentNodeTemplateId);
  98         consolidationDataHandler.addNodesConnectedIn(translateTo, sourceNodeTemplateId,
  99                 dependentNodeTemplateId, "targetResourceId", REQUIREMENT_ID, requirementAssignment);
 100         Mockito.verify(computeConsolidationData).addComputeTemplateConsolidationData(
 101                 SERVICE_FILE_NAME, COMPUTE_NODE_TYPE_1, dependentNodeTemplateId);
 102         Mockito.verify(consolidationData).addNodesConnectedIn(
 103                 sourceNodeTemplateId, REQUIREMENT_ID, requirementAssignment);
 104     }
 105
 106     @Test
 107     public void testAddNodesConnectedIn_consolidationDataNotExist() {
 108         String dependentNodeTemplateId = COMPUTE_NODE_TEMPLATE_ID_2;
 109         mockEntities_NullConsolidationData(dependentNodeTemplateId);
 110         consolidationDataHandler.addNodesConnectedIn(translateTo, COMPUTE_NODE_TEMPLATE_ID_1,
 111                 dependentNodeTemplateId, "targetResourceId", REQUIREMENT_ID, requirementAssignment);
 112         Mockito.verify(computeConsolidationData).addComputeTemplateConsolidationData(
 113                 SERVICE_FILE_NAME, COMPUTE_NODE_TYPE_1, dependentNodeTemplateId);
 114         Mockito.verify(consolidationData, Mockito.times(0)).addNodesConnectedIn(
 115                 Mockito.any(), Mockito.any(), Mockito.any());
 116     }
 117
 118     @Test
 119     public void testRemoveParamNameFromAttrFuncList() {
 120         mockEntities(COMPUTE_NODE_TEMPLATE_ID_2);
 121         consolidationDataHandler.removeParamNameFromAttrFuncList(serviceTemplate, heatOrchestrationTemplate,
 122                         "paramName", COMPUTE_NODE_TEMPLATE_ID_1, COMPUTE_NODE_TEMPLATE_ID_2);
 123         Mockito.verify(computeConsolidationData).addComputeTemplateConsolidationData(
 124                 SERVICE_FILE_NAME, COMPUTE_NODE_TYPE_1, COMPUTE_NODE_TEMPLATE_ID_2);
 125         Mockito.verify(consolidationData).removeParamNameFromAttrFuncList("paramName");
 126     }
 127
 128     @Test
 129     public void testRemoveParamNameFromAttrFuncList_consolidationDataNotExist() {
 130         mockEntities_NullConsolidationData(COMPUTE_NODE_TEMPLATE_ID_2);
 131         consolidationDataHandler.removeParamNameFromAttrFuncList(serviceTemplate, heatOrchestrationTemplate,
 132                 "paramName", COMPUTE_NODE_TEMPLATE_ID_1, COMPUTE_NODE_TEMPLATE_ID_2);
 133         Mockito.verify(computeConsolidationData).addComputeTemplateConsolidationData(
 134                 SERVICE_FILE_NAME, COMPUTE_NODE_TYPE_1, COMPUTE_NODE_TEMPLATE_ID_2);
 135         Mockito.verify(consolidationData, Mockito.times(0))
 136                 .removeParamNameFromAttrFuncList(Mockito.any());
 137     }
 138
 139     @Test
 140     public void testAddConsolidationData() {
 141         consolidationDataHandler.addConsolidationData(SERVICE_FILE_NAME,
 142                 COMPUTE_NODE_TYPE_1, COMPUTE_NODE_TEMPLATE_ID_1);
 143         Mockito.verify(computeConsolidationData).addComputeTemplateConsolidationData(
 144                 SERVICE_FILE_NAME, COMPUTE_NODE_TYPE_1, COMPUTE_NODE_TEMPLATE_ID_1);
 145     }
 146
 147     @Test
 148     public void testAddPortToConsolidationData() {
 149         mockEntities(COMPUTE_NODE_TEMPLATE_ID_1);
 150         consolidationDataHandler.addPortToConsolidationData(translateTo, COMPUTE_NODE_TYPE_1,
 151                 COMPUTE_NODE_TEMPLATE_ID_1, PORT_NODE_TYPE_1, PORT_NODE_TEMPLATE_ID_1);
 152         Mockito.verify(computeConsolidationData).addComputeTemplateConsolidationData(
 153                 SERVICE_FILE_NAME, COMPUTE_NODE_TYPE_1, COMPUTE_NODE_TEMPLATE_ID_1);
 154         Mockito.verify(consolidationData).addPort(PORT_NODE_TYPE_1, PORT_NODE_TEMPLATE_ID_1);
 155     }
 156
 157     @Test
 158     public void testAddVolumeToConsolidationData() {
 159         mockEntities(COMPUTE_NODE_TEMPLATE_ID_1);
 160         consolidationDataHandler.addVolumeToConsolidationData(
 161                 translateTo, COMPUTE_NODE_TYPE_1, COMPUTE_NODE_TEMPLATE_ID_1,
 162                         REQUIREMENT_ID, requirementAssignment);
 163         Mockito.verify(computeConsolidationData).addComputeTemplateConsolidationData(
 164                 SERVICE_FILE_NAME, COMPUTE_NODE_TYPE_1, COMPUTE_NODE_TEMPLATE_ID_1);
 165         Mockito.verify(consolidationData).addVolume(REQUIREMENT_ID, requirementAssignment);
 166     }
 167
 168
 169     @Test
 170     public void testAddGroupIdToConsolidationData() {
 171         mockEntities(COMPUTE_NODE_TEMPLATE_ID_1);
 172         consolidationDataHandler.addGroupIdToConsolidationData(
 173                 translateTo, COMPUTE_NODE_TYPE_1, COMPUTE_NODE_TEMPLATE_ID_1, GROUP_ID);
 174         Mockito.verify(computeConsolidationData).addComputeTemplateConsolidationData(
 175                 SERVICE_FILE_NAME, COMPUTE_NODE_TYPE_1, COMPUTE_NODE_TEMPLATE_ID_1);
 176         Mockito.verify(consolidationData).addGroupId(GROUP_ID);
 177     }
 178
 179     private void mockEntities(String nodeTemplateId) {
 180         mockServiceTemplate(nodeTemplateId);
 181         mockTranslateTo(nodeTemplateId);
 182         mockComputeConsolidationData();
 183     }
 184
 185     private void mockEntities_NullConsolidationData(String nodeTemplateId) {
 186         mockServiceTemplate(nodeTemplateId);
 187         mockTranslateTo(nodeTemplateId);
 188         mockNullConsolidationData();
 189     }
 190
 191     private void mockServiceTemplate(String nodeTemplateId) {
 192         TopologyTemplate topologyTemplate = createTopologyTemplate(nodeTemplateId);
 193         Mockito.when(serviceTemplate.getTopology_template()).thenReturn(topologyTemplate);
 194
 195         Map<String, String> metadata = new HashMap<>();
 196         metadata.put(ToscaConstants.ST_METADATA_TEMPLATE_NAME, SERVICE_FILE_NAME_PREFIX);
 197         Mockito.when(serviceTemplate.getMetadata()).thenReturn(metadata);
 198     }
 199
 200     private void mockTranslateTo(String nodeTemplateId) {
 201         Mockito.when(translateTo.getTranslatedId()).thenReturn(nodeTemplateId);
 202         Mockito.when(translateTo.getServiceTemplate()).thenReturn(serviceTemplate);
 203     }
 204
 205     private void mockComputeConsolidationData() {
 206         Mockito.when(computeConsolidationData
 207             .addComputeTemplateConsolidationData(Mockito.anyString(), Mockito.anyString(),
 208                 Mockito.anyString())).thenReturn(consolidationData);
 209     }
 210
 211     private void mockNullConsolidationData() {
 212         Mockito.when(computeConsolidationData
 213                              .addComputeTemplateConsolidationData(Mockito.anyString(), Mockito.anyString(),
 214                                      Mockito.anyString())).thenReturn(null);
 215     }
 216
 217     private  TopologyTemplate createTopologyTemplate(String nodeTemplateId) {
 218         TopologyTemplate topologyTemplate = new TopologyTemplate();
 219         Map<String, NodeTemplate> nodeTemplates = new HashMap<>();
 220         NodeTemplate nodeTemplate = new NodeTemplate();
 221         nodeTemplate.setType(COMPUTE_NODE_TYPE_1);
 222         nodeTemplates.put(nodeTemplateId, nodeTemplate);
 223         topologyTemplate.setNode_templates(nodeTemplates);
 224         return topologyTemplate;
 225     }
 226
 227 }