openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/test/java/org/openecomp/sdc/translator/services/heattotosca/UnifiedCompositionServiceTest.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.services.heattotosca;
  18
  19 import static org.junit.Assert.assertEquals;
  20 import static org.mockito.Matchers.anyObject;
  21 import static org.mockito.Matchers.anyString;
  22
  23 import org.apache.commons.lang3.tuple.ImmutablePair;
  24 import org.apache.commons.lang3.tuple.Pair;
  25 import org.junit.Before;
  26 import org.junit.Test;
  27 import org.mockito.InjectMocks;
  28 import org.mockito.Mockito;
  29 import org.mockito.MockitoAnnotations;
  30 import org.mockito.Spy;
  31 import org.onap.sdc.tosca.datatypes.model.NodeTemplate;
  32 import org.onap.sdc.tosca.datatypes.model.ServiceTemplate;
  33 import org.openecomp.sdc.tosca.services.DataModelUtil;
  34 import org.onap.sdc.tosca.services.ToscaExtensionYamlUtil;
  35 import org.onap.sdc.tosca.services.YamlUtil;
  36 import org.openecomp.sdc.translator.TestUtils;
  37 import org.openecomp.sdc.translator.datatypes.heattotosca.TranslationContext;
  38 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedCompositionData;
  39 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedCompositionEntity;
  40 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedSubstitutionData;
  41 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.to.UnifiedCompositionTo;
  42 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ComputeTemplateConsolidationData;
  43 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ConsolidationData;
  44 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.EntityConsolidationData;
  45 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.GetAttrFuncData;
  46 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.NestedTemplateConsolidationData;
  47 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.PortTemplateConsolidationData;
  48 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.RequirementAssignmentData;
  49 import org.openecomp.sdc.translator.services.heattotosca.impl.unifiedcomposition.UnifiedCompositionSingleSubstitution;
  50
  51 import java.io.IOException;
  52 import java.net.URL;
  53 import java.util.ArrayList;
  54 import java.util.Arrays;
  55 import java.util.Collections;
  56 import java.util.HashMap;
  57 import java.util.LinkedList;
  58 import java.util.List;
  59 import java.util.Map;
  60 import java.util.Objects;
  61 import java.util.Optional;
  62
  63 public class UnifiedCompositionServiceTest {
  64     private static final String BASE_DIRECTORY = "/mock/services/heattotosca/unifiedComposition/";
  65     @InjectMocks
  66     @Spy
  67     UnifiedCompositionService unifiedCompositionService;
  68     @Spy
  69     TranslationContext context;
  70
  71     private static final String IN_PREFIX = "/in";
  72     private static final String OUT_PREFIX = "/out";
  73     private static final String FSB1_template = "FSB1_template";
  74     private static final String FSB2_template = "FSB2_template";
  75     private static final String FSB3_template = "FSB3_template";
  76     private static final String FSB1_INTERNAL = "FSB1_Internal";
  77     private static final String FSB2_INTERNAL = "FSB2_Internal";
  78     private static final String FSB1_INTERNAL_1 = "FSB1_Internal_1";
  79     private static final String FSB1_INTERNAL_2 = "FSB1_Internal_2";
  80     private static final String FSB2_INTERNAL_1 = "FSB2_Internal_1";
  81     private static final String FSB2_INTERNAL_2 = "FSB2_Internal_2";
  82     private static final String PORT = "port";
  83     private static final String PORT_1 = "port_1";
  84     private static final String PORT_2 = "port_2";
  85     private static final String FSB1_OAM = "FSB1_OAM";
  86     private static final String ORG_OPENECOMP_RESOURCE_ABSTRACT_NODES_FSB1 = "org.openecomp.resource.abstract.nodes.FSB1";
  87     private static final String ORG_OPENECOMP_RESOURCE_VFC_NODES_HEAT_FSB = "org.openecomp.resource.vfc.nodes.heat.FSB";
  88     private static final String DEVICE_OWNER = "device_owner";
  89     private static final String COMPLEX_OUTPUT1 = "complexOutput1";
  90     private static final String COMPLEX_OUTPUT2 = "complexOutput2";
  91     private static final String COMPLEX_OUTPUT3 = "complexOutput3";
  92     private static final String USER_DATA_FORMAT = "user_data_format";
  93     private static final String TENANT_ID = "tenant_id";
  94     private static final String SIMPLE_OUTPUT1 = "simpleOutput1";
  95     private static final String SIMPLE_OUTPUT2 = "simpleOutput2";
  96     private static final String ADDRESSES = "addresses";
  97     private static final String CMAUI_VOLUME1 = "cmaui_volume1";
  98     private static final String CMAUI_VOLUME2 = "cmaui_volume2";
  99     private static final String CMAUI_VOLUME3 = "cmaui_volume3";
 100     private static final String ACCESS_IPv4 = "accessIPv4";
 101     private static final String ACCESS_IPv6 = "accessIPv6";
 102     private static final String FSB1 = "FSB1";
 103     private static final String MYATTR = "myAttr";
 104     private static final String VOLUME_TYPE = "volume_type";
 105     private static final String SIZE = "size";
 106     private static final String NETWORK_ID = "network_id";
 107     private static final String JSA_NET1 = "jsa_net1";
 108     private static final String STATUS = "status";
 109     private static final String AVAILABILITY_ZONE = "availability_zone";
 110     private static final String DEPENDENCY = "dependency";
 111
 112     Map<String, ServiceTemplate> inputServiceTemplates;
 113     Map<String, ServiceTemplate> expectedOutserviceTemplates;
 114
 115     private static final String MAIN_SERVICE_TEMPLATE_YAML = "MainServiceTemplate.yaml";
 116     private static final String GLOBAL_SUBSTITUTION_TYPES_SERVICE_TEMPLATE_YAML =
 117             "GlobalSubstitutionTypesServiceTemplate.yaml";
 118
 119     @Before
 120     public void setUp() {
 121         MockitoAnnotations.initMocks(this);
 122     }
 123
 124     //todo
 125     @Test
 126     public void createUnifiedComposition() throws Exception {
 127
 128     }
 129
 130     @Test
 131     public void createSubstitutionStNoConsolidationData() throws Exception {
 132         String path = BASE_DIRECTORY + "creSubstitutionServiceTemplate/NoOutParamDuplicatePortType";
 133         loadInputAndOutputData(path);
 134         ServiceTemplate expectedServiceTemplate =
 135                 TestUtils.loadServiceTemplate(BASE_DIRECTORY +
 136                         "creSubstitutionServiceTemplate/NoOutParamDuplicatePortType" + OUT_PREFIX);
 137
 138         List<UnifiedCompositionData> unifiedCompositionDataList = new ArrayList<>();
 139         Optional<ServiceTemplate> substitutionServiceTemplate = unifiedCompositionService
 140                 .createUnifiedSubstitutionServiceTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 141                         unifiedCompositionDataList,
 142                         context, "org.openecomp.resource.vfc.nodes.heat.FSB1", null);
 143         assertEquals(false, substitutionServiceTemplate.isPresent());
 144     }
 145
 146     @Test
 147     public void createSubstitutionStNoOutputParamAndDuplicatePortType() throws Exception {
 148         List<Pair<String, String>> portTypeToIdList = new ArrayList<>();
 149         portTypeToIdList.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_1));
 150         portTypeToIdList.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_2));
 151         portTypeToIdList.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_1));
 152         portTypeToIdList.add(new ImmutablePair<>(FSB1_OAM, FSB1_OAM));
 153
 154         loadInputAndOutputData(BASE_DIRECTORY + "creSubstitutionServiceTemplate/NoOutParamDuplicatePortType");
 155         UnifiedCompositionData unifiedCompositionData =
 156                 createCompositionData(FSB1_template, portTypeToIdList);
 157         List<UnifiedCompositionData> unifiedCompositionDataList = new ArrayList<>();
 158         unifiedCompositionDataList.add(unifiedCompositionData);
 159
 160         Optional<ServiceTemplate> substitutionServiceTemplate = unifiedCompositionService
 161                 .createUnifiedSubstitutionServiceTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 162                         unifiedCompositionDataList,
 163                         context, ORG_OPENECOMP_RESOURCE_ABSTRACT_NODES_FSB1, null);
 164         assertEquals(true, substitutionServiceTemplate.isPresent());
 165         substitutionServiceTemplate
 166                 .ifPresent(
 167                         subServiceTemplate -> checkSTResults(expectedOutserviceTemplates,
 168                                 subServiceTemplate, context.getGlobalSubstitutionServiceTemplate(), null));
 169     }
 170
 171     @Test
 172     public void createSubstitutionStWithOutputParamNoConsolidation() throws Exception {
 173         List<Pair<String, String>> portTypeToIdList = new ArrayList<>();
 174         portTypeToIdList.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_1));
 175         portTypeToIdList.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_2));
 176         portTypeToIdList.add(new ImmutablePair<>(FSB1_OAM, FSB1_OAM));
 177
 178         loadInputAndOutputData(BASE_DIRECTORY + "creSubstitutionServiceTemplate/WithOutputParameters/noConsolidation");
 179         UnifiedCompositionData unifiedCompositionData =
 180                 createCompositionData(FSB1_template, portTypeToIdList);
 181         addGetAttrForCompute(unifiedCompositionData);
 182         addGetAttrForPort(unifiedCompositionData);
 183         List<UnifiedCompositionData> unifiedCompositionDataList = new ArrayList<>();
 184         unifiedCompositionDataList.add(unifiedCompositionData);
 185
 186         Optional<ServiceTemplate> substitutionServiceTemplate = unifiedCompositionService
 187                 .createUnifiedSubstitutionServiceTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 188                         unifiedCompositionDataList,
 189                         context, ORG_OPENECOMP_RESOURCE_ABSTRACT_NODES_FSB1, null);
 190         assertEquals(true, substitutionServiceTemplate.isPresent());
 191         substitutionServiceTemplate
 192                 .ifPresent(
 193                         subServiceTemplate -> checkSTResults(expectedOutserviceTemplates,
 194                                 subServiceTemplate, context.getGlobalSubstitutionServiceTemplate(), null));
 195     }
 196
 197     @Test
 198     public void createSubstitutionStWithOutputParamWithConsolidation() throws Exception {
 199         List<UnifiedCompositionData> unifiedCompositionDataList = new ArrayList<>();
 200         List<Pair<String, String>> portTypeToIdList1 = new ArrayList<>();
 201         portTypeToIdList1.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_1));
 202         portTypeToIdList1.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_2));
 203
 204         loadInputAndOutputData(BASE_DIRECTORY + "creSubstitutionServiceTemplate/WithOutputParameters/consolidation");
 205         UnifiedCompositionData unifiedCompositionData1 =
 206                 createCompositionData(FSB1_template, portTypeToIdList1);
 207         addGetAttrForCompute(unifiedCompositionData1);
 208         addGetAttrForPort(unifiedCompositionData1);
 209         unifiedCompositionDataList.add(unifiedCompositionData1);
 210
 211         List<Pair<String, String>> portTypeToIdList2 = new ArrayList<>();
 212         portTypeToIdList2.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_2));
 213         portTypeToIdList2.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_1));
 214
 215         UnifiedCompositionData unifiedCompositionData2 =
 216                 createCompositionData(FSB2_template, portTypeToIdList2);
 217         addGetAttrForCompute2(unifiedCompositionData2);
 218         addGetAttrForPort2(unifiedCompositionData2);
 219         unifiedCompositionDataList.add(unifiedCompositionData2);
 220
 221         Optional<ServiceTemplate> substitutionServiceTemplate = unifiedCompositionService
 222                 .createUnifiedSubstitutionServiceTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 223                         unifiedCompositionDataList,
 224                         context, ORG_OPENECOMP_RESOURCE_ABSTRACT_NODES_FSB1, null);
 225         assertEquals(true, substitutionServiceTemplate.isPresent());
 226         substitutionServiceTemplate
 227                 .ifPresent(
 228                         subServiceTemplate -> checkSTResults(expectedOutserviceTemplates,
 229                                 subServiceTemplate, context.getGlobalSubstitutionServiceTemplate(), null));
 230     }
 231
 232     @Test
 233     public void createSubstitutionStNoPorts() throws Exception {
 234         loadInputAndOutputData(BASE_DIRECTORY + "creSubstitutionServiceTemplate/NoPorts");
 235
 236         UnifiedCompositionData unifiedCompositionData = new UnifiedCompositionData();
 237         unifiedCompositionData.setComputeTemplateConsolidationData(
 238                 TestUtils.createComputeTemplateConsolidationData(FSB1_template, null, null));
 239         List<UnifiedCompositionData> unifiedCompositionDataList = new ArrayList<>();
 240         unifiedCompositionDataList.add(unifiedCompositionData);
 241
 242         Optional<ServiceTemplate> substitutionServiceTemplate = unifiedCompositionService
 243                 .createUnifiedSubstitutionServiceTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 244                         unifiedCompositionDataList,
 245                         context, ORG_OPENECOMP_RESOURCE_ABSTRACT_NODES_FSB1, null);
 246         assertEquals(true, substitutionServiceTemplate.isPresent());
 247         substitutionServiceTemplate
 248                 .ifPresent(
 249                         subServiceTemplate -> checkSTResults(expectedOutserviceTemplates,
 250                                 subServiceTemplate, context.getGlobalSubstitutionServiceTemplate(), null));
 251     }
 252
 253
 254     @Test
 255     public void createSubstitutionStWithIndex() throws Exception {
 256         List<Pair<String, String>> portTypeToIdList = new ArrayList<>();
 257         portTypeToIdList.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_1));
 258         portTypeToIdList.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_2));
 259         portTypeToIdList.add(new ImmutablePair<>(FSB1_OAM, FSB1_OAM));
 260
 261         loadInputAndOutputData(BASE_DIRECTORY + "creSubstitutionServiceTemplate/WithIndex");
 262         UnifiedCompositionData unifiedCompositionData =
 263                 createCompositionData(FSB1_template, portTypeToIdList);
 264         List<UnifiedCompositionData> unifiedCompositionDataList = new ArrayList<>();
 265         unifiedCompositionDataList.add(unifiedCompositionData);
 266
 267         Optional<ServiceTemplate> substitutionServiceTemplate = unifiedCompositionService
 268                 .createUnifiedSubstitutionServiceTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 269                         unifiedCompositionDataList,
 270                         context,ORG_OPENECOMP_RESOURCE_ABSTRACT_NODES_FSB1, 2);
 271         assertEquals(true, substitutionServiceTemplate.isPresent());
 272         substitutionServiceTemplate
 273                 .ifPresent(
 274                         subServiceTemplate -> checkSTResults(expectedOutserviceTemplates,
 275                                 subServiceTemplate, context.getGlobalSubstitutionServiceTemplate(), null));
 276     }
 277
 278
 279     @Test
 280     public void createAbstractSubstituteOneComputeMultiplePortsDifferentTypesTest() throws Exception {
 281         loadInputAndOutputData(BASE_DIRECTORY + "createAbstractSubstitute/oneComputeMultiplePortsDiffType");
 282
 283         UnifiedCompositionData data = createComputeUnifiedCompositionData(FSB1_template);
 284         List<Pair<String, String>> portTypeToIdList = new ArrayList<>();
 285         portTypeToIdList.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_1));
 286         portTypeToIdList.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_2));
 287         portTypeToIdList.add(new ImmutablePair<>(FSB1_OAM, FSB1_OAM));
 288         addPortDataToCompositionData(portTypeToIdList, data);
 289
 290         List<UnifiedCompositionData> unifiedCompositionDataList = new LinkedList<>();
 291         unifiedCompositionDataList.add(data);
 292         Optional<ServiceTemplate> substitutionServiceTemplate = unifiedCompositionService
 293                 .createUnifiedSubstitutionServiceTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 294                         unifiedCompositionDataList,
 295                         context, ORG_OPENECOMP_RESOURCE_VFC_NODES_HEAT_FSB, null);
 296         assertEquals(true, substitutionServiceTemplate.isPresent());
 297         if (substitutionServiceTemplate.isPresent()) {
 298             String substitutionNodeTypeId =
 299                     unifiedCompositionService.getSubstitutionNodeTypeId(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 300                             unifiedCompositionDataList.get(0), null, context);
 301             String nodeTemplateId = unifiedCompositionService.createAbstractSubstituteNodeTemplate(
 302                     inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), substitutionServiceTemplate.get(),
 303                     unifiedCompositionDataList, substitutionNodeTypeId,
 304                     context, null);
 305             validateAbstractSubstitute();
 306         }
 307     }
 308
 309
 310     @Test
 311     public void createAbstractSubstituteOneComputeMultiplePortsSameTypesTest() throws Exception {
 312         loadInputAndOutputData(BASE_DIRECTORY + "createAbstractSubstitute/oneComputeMultiplePortsSameType");
 313
 314         UnifiedCompositionData data = createComputeUnifiedCompositionData(FSB1_template);
 315         List<Pair<String, String>> portTypeToIdList = new ArrayList<>();
 316         portTypeToIdList.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_1));
 317         portTypeToIdList.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_2));
 318         addPortDataToCompositionData(portTypeToIdList, data);
 319
 320         List<UnifiedCompositionData> unifiedCompositionDataList = new LinkedList<>();
 321         unifiedCompositionDataList.add(data);
 322         Optional<ServiceTemplate> substitutionServiceTemplate = unifiedCompositionService
 323                 .createUnifiedSubstitutionServiceTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 324                         unifiedCompositionDataList
 325                         , context, ORG_OPENECOMP_RESOURCE_VFC_NODES_HEAT_FSB, null);
 326
 327         assertEquals(true, substitutionServiceTemplate.isPresent());
 328         if (substitutionServiceTemplate.isPresent()) {
 329             String substitutionNodeTypeId =
 330                     unifiedCompositionService.getSubstitutionNodeTypeId(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 331                             unifiedCompositionDataList.get(0), null, context);
 332             String nodeTemplateId = unifiedCompositionService.createAbstractSubstituteNodeTemplate(
 333                     inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), substitutionServiceTemplate.get(),
 334                     unifiedCompositionDataList, substitutionNodeTypeId,
 335                     context, null);
 336             validateAbstractSubstitute();
 337         }
 338     }
 339
 340
 341     @Test
 342     public void createAbstractSubstituteTwoComputesMultiplePorts() throws Exception {
 343         loadInputAndOutputData(BASE_DIRECTORY + "createAbstractSubstitute/twoComputesMultiplePorts");
 344         List<UnifiedCompositionData> unifiedCompositionDataList =
 345                 createAbstractSubstituteCompositionDataComputeAndPort();
 346         Optional<ServiceTemplate> substitutionServiceTemplate = unifiedCompositionService
 347                 .createUnifiedSubstitutionServiceTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 348                         unifiedCompositionDataList
 349                         , context, ORG_OPENECOMP_RESOURCE_VFC_NODES_HEAT_FSB, null);
 350         assertEquals(true, substitutionServiceTemplate.isPresent());
 351         if (substitutionServiceTemplate.isPresent()) {
 352             String substitutionNodeTypeId =
 353                     unifiedCompositionService.getSubstitutionNodeTypeId(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 354                             unifiedCompositionDataList.get(0), null, context);
 355             String nodeTemplateId = unifiedCompositionService.createAbstractSubstituteNodeTemplate(
 356                     inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), substitutionServiceTemplate.get(),
 357                     unifiedCompositionDataList, substitutionNodeTypeId,
 358                     context, null);
 359             validateAbstractSubstitute();
 360         }
 361     }
 362
 363
 364     @Test
 365     public void updNodesConnectedOutWithConsolidationTest() throws Exception {
 366         loadInputAndOutputData(BASE_DIRECTORY + "updNodesConnectedOut/consolidation");
 367         List<UnifiedCompositionData> unifiedCompositionDataList =
 368                 createAbstractSubstituteCompositionDataComputeAndPort();
 369         Optional<ServiceTemplate> substitutionServiceTemplate = unifiedCompositionService
 370                 .createUnifiedSubstitutionServiceTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 371                         unifiedCompositionDataList
 372                         , context, ORG_OPENECOMP_RESOURCE_VFC_NODES_HEAT_FSB, null);
 373         assertEquals(true, substitutionServiceTemplate.isPresent());
 374         if (substitutionServiceTemplate.isPresent()) {
 375             String substitutionNodeTypeId =
 376                     unifiedCompositionService.getSubstitutionNodeTypeId(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 377                             unifiedCompositionDataList.get(0), null, context);
 378             String nodeTemplateId = unifiedCompositionService.createAbstractSubstituteNodeTemplate(
 379                     inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), substitutionServiceTemplate.get(),
 380                     unifiedCompositionDataList, substitutionNodeTypeId,
 381                     context, null);
 382
 383             unifiedCompositionService
 384                     .updateCompositionConnectivity(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 385                             unifiedCompositionDataList, context);
 386             validateAbstractSubstitute();
 387         }
 388     }
 389
 390     private void validateAbstractSubstitute() {
 391         YamlUtil yamlUtil = new YamlUtil();
 392         assertEquals(yamlUtil.objectToYaml(expectedOutserviceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML)), yamlUtil
 393                 .objectToYaml(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML)));
 394     }
 395
 396
 397     @Test
 398     public void updNodesConnectedOutNoConsolidationTest() throws Exception {
 399         loadInputAndOutputData(BASE_DIRECTORY + "updNodesConnectedOut/noConsolidation");
 400
 401         UnifiedCompositionData data = createComputeUnifiedCompositionData(FSB1_template);
 402         List<Pair<String, String>> portTypeToIdList = new ArrayList<>();
 403         portTypeToIdList.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_1));
 404         portTypeToIdList.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_2));
 405         portTypeToIdList.add(new ImmutablePair<>(FSB1_OAM, FSB1_OAM));
 406         addPortDataToCompositionData(portTypeToIdList, data);
 407
 408         List<UnifiedCompositionData> unifiedCompositionDataList = new LinkedList<>();
 409         unifiedCompositionDataList.add(data);
 410
 411         Optional<ServiceTemplate> substitutionServiceTemplate = unifiedCompositionService
 412                 .createUnifiedSubstitutionServiceTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 413                         unifiedCompositionDataList
 414                         , context, ORG_OPENECOMP_RESOURCE_VFC_NODES_HEAT_FSB, null);
 415         assertEquals(true, substitutionServiceTemplate.isPresent());
 416         if (substitutionServiceTemplate.isPresent()) {
 417             String substitutionNodeTypeId =
 418                     unifiedCompositionService.getSubstitutionNodeTypeId(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 419                             unifiedCompositionDataList.get(0), null, context);
 420             String nodeTemplateId = unifiedCompositionService.createAbstractSubstituteNodeTemplate(
 421                     inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), substitutionServiceTemplate.get(),
 422                     unifiedCompositionDataList, substitutionNodeTypeId,
 423                     context, null);
 424
 425             unifiedCompositionService
 426                     .updateCompositionConnectivity(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 427                             unifiedCompositionDataList, context);
 428             validateAbstractSubstitute();
 429         }
 430     }
 431
 432
 433     @Test
 434     public void updNodesConnectedInNoConsolidationTest() throws Exception {
 435         loadInputAndOutputData(BASE_DIRECTORY + "updNodesConnectedIn/noConsolidation");
 436
 437         UnifiedCompositionData data = createComputeUnifiedCompositionData("QRouter");
 438         List<Pair<String, String>> portTypeToIdList = new ArrayList<>();
 439         portTypeToIdList.add(new ImmutablePair<>("cdr_network_port", "cdr_network_port"));
 440         portTypeToIdList
 441                 .add(new ImmutablePair<>("oam_private_net_network_port", "oam_private_net_network_port"));
 442         addPortDataToCompositionData(portTypeToIdList, data);
 443
 444         List<UnifiedCompositionData> unifiedCompositionDataList = new LinkedList<>();
 445         unifiedCompositionDataList.add(data);
 446
 447         Optional<ServiceTemplate> substitutionServiceTemplate = unifiedCompositionService
 448                 .createUnifiedSubstitutionServiceTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 449                         unifiedCompositionDataList
 450                         , context, "org.openecomp.resource.abstract.nodes.QRouter", null);
 451
 452         String substitutionNodeTypeId =
 453                 unifiedCompositionService.getSubstitutionNodeTypeId(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 454                         unifiedCompositionDataList.get(0), null, context);
 455         String nodeTemplateId = unifiedCompositionService.createAbstractSubstituteNodeTemplate(
 456                 inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), substitutionServiceTemplate.get(),
 457                 unifiedCompositionDataList, substitutionNodeTypeId,
 458                 context, null);
 459
 460         unifiedCompositionService
 461                 .updateCompositionConnectivity(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 462                         unifiedCompositionDataList, context);
 463         validateAbstractSubstitute();
 464     }
 465
 466
 467     @Test
 468     public void updNodesConnectedInWithConsolidationTest() throws Exception {
 469         loadInputAndOutputData(BASE_DIRECTORY + "updNodesConnectedIn/consolidation");
 470
 471         List<UnifiedCompositionData> unifiedCompositionDataList =
 472                 createAbstractSubstituteCompositionDataComputeAndPort();
 473
 474         Optional<ServiceTemplate> substitutionServiceTemplate = unifiedCompositionService
 475                 .createUnifiedSubstitutionServiceTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 476                         unifiedCompositionDataList
 477                         , context, "org.openecomp.resource.abstract.nodes.FSB", null);
 478
 479         String substitutionNodeTypeId =
 480                 unifiedCompositionService.getSubstitutionNodeTypeId(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 481                         unifiedCompositionDataList.get(0), null, context);
 482         String nodeTemplateId = unifiedCompositionService.createAbstractSubstituteNodeTemplate(
 483                 inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), substitutionServiceTemplate.get(),
 484                 unifiedCompositionDataList, substitutionNodeTypeId,
 485                 context, null);
 486
 487         unifiedCompositionService
 488                 .updateCompositionConnectivity(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 489                         unifiedCompositionDataList, context);
 490         validateAbstractSubstitute();
 491     }
 492
 493
 494     @Test
 495     public void updVolumesNoConsolidationTest() throws Exception {
 496         loadInputAndOutputData(BASE_DIRECTORY + "updVolumes/noConsolidation");
 497
 498         UnifiedCompositionData data = createComputeUnifiedCompositionData(FSB1_template);
 499         List<Pair<String, String>> portTypeToIdList = new ArrayList<>();
 500         portTypeToIdList.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_1));
 501         portTypeToIdList.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_2));
 502         portTypeToIdList.add(new ImmutablePair<>(FSB1_OAM, FSB1_OAM));
 503         addPortDataToCompositionData(portTypeToIdList, data);
 504
 505         List<UnifiedCompositionData> unifiedCompositionDataList = new LinkedList<>();
 506         unifiedCompositionDataList.add(data);
 507
 508         Optional<ServiceTemplate> substitutionServiceTemplate = unifiedCompositionService
 509                 .createUnifiedSubstitutionServiceTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 510                         unifiedCompositionDataList
 511                         , context, ORG_OPENECOMP_RESOURCE_VFC_NODES_HEAT_FSB, null);
 512
 513         String substitutionNodeTypeId =
 514                 unifiedCompositionService.getSubstitutionNodeTypeId(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 515                         unifiedCompositionDataList.get(0), null, context);
 516         String nodeTemplateId = unifiedCompositionService.createAbstractSubstituteNodeTemplate(
 517                 inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), substitutionServiceTemplate.get(),
 518                 unifiedCompositionDataList, substitutionNodeTypeId,
 519                 context, null);
 520
 521         unifiedCompositionService
 522                 .updateCompositionConnectivity(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 523                         unifiedCompositionDataList, context);
 524         validateAbstractSubstitute();
 525     }
 526
 527
 528     @Test
 529     public void updVolumesWithConsolidationTest() throws Exception {
 530         loadInputAndOutputData(BASE_DIRECTORY + "updVolumes/consolidation");
 531         List<UnifiedCompositionData> unifiedCompositionDataList =
 532                 createAbstractSubstituteCompositionDataComputeAndPort();
 533         Optional<ServiceTemplate> substitutionServiceTemplate = unifiedCompositionService
 534                 .createUnifiedSubstitutionServiceTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 535                         unifiedCompositionDataList
 536                         , context, ORG_OPENECOMP_RESOURCE_VFC_NODES_HEAT_FSB, null);
 537
 538         String substitutionNodeTypeId =
 539                 unifiedCompositionService.getSubstitutionNodeTypeId(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 540                         unifiedCompositionDataList.get(0), null, context);
 541         String nodeTemplateId = unifiedCompositionService.createAbstractSubstituteNodeTemplate(
 542                 inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), substitutionServiceTemplate.get(),
 543                 unifiedCompositionDataList, substitutionNodeTypeId,
 544                 context, null);
 545
 546         unifiedCompositionService
 547                 .updateCompositionConnectivity(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 548                         unifiedCompositionDataList, context);
 549         validateAbstractSubstitute();
 550     }
 551
 552
 553     @Test
 554     public void updGroupsNoConsolidationTest() throws Exception {
 555         loadInputAndOutputData(BASE_DIRECTORY + "updGroupsConnectivity/noConsolidation");
 556         UnifiedCompositionData data = createComputeUnifiedCompositionData("server_smp1");
 557         List<Pair<String, String>> portTypeToIdList = new ArrayList<>();
 558         portTypeToIdList.add(new ImmutablePair<>(PORT, PORT_1));
 559         portTypeToIdList.add(new ImmutablePair<>(PORT, PORT_2));
 560         addPortDataToCompositionData(portTypeToIdList, data);
 561
 562         //Add groups
 563         List<String> computeGroupIdList =
 564                 TestUtils.getGroupsForNode(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), "server_smp1");
 565         data.getComputeTemplateConsolidationData().setGroupIds(computeGroupIdList);
 566
 567         List<UnifiedCompositionData> unifiedCompositionDataList = new LinkedList<>();
 568         unifiedCompositionDataList.add(data);
 569
 570         Optional<ServiceTemplate> substitutionServiceTemplate = unifiedCompositionService
 571                 .createUnifiedSubstitutionServiceTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 572                         unifiedCompositionDataList
 573                         , context, "org.openecomp.resource.abstract.nodes.smp", null);
 574
 575         String substitutionNodeTypeId =
 576                 unifiedCompositionService.getSubstitutionNodeTypeId(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 577                         unifiedCompositionDataList.get(0), null, context);
 578         String nodeTemplateId = unifiedCompositionService.createAbstractSubstituteNodeTemplate(
 579                 inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), substitutionServiceTemplate.get(),
 580                 unifiedCompositionDataList, substitutionNodeTypeId,
 581                 context, null);
 582
 583         unifiedCompositionService
 584                 .updateCompositionConnectivity(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 585                         unifiedCompositionDataList, context);
 586         validateAbstractSubstitute();
 587     }
 588
 589
 590     @Test
 591     public void updGroupsWithConsolidationTest() throws Exception {
 592         loadInputAndOutputData(BASE_DIRECTORY + "updGroupsConnectivity/consolidation");
 593
 594         List<UnifiedCompositionData> unifiedCompositionDataList =
 595                 createAbstractSubstituteCompositionDataComputeAndPort();
 596
 597         Optional<ServiceTemplate> substitutionServiceTemplate = unifiedCompositionService
 598                 .createUnifiedSubstitutionServiceTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 599                         unifiedCompositionDataList
 600                         , context, ORG_OPENECOMP_RESOURCE_VFC_NODES_HEAT_FSB, null);
 601
 602         String substitutionNodeTypeId =
 603                 unifiedCompositionService.getSubstitutionNodeTypeId(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 604                         unifiedCompositionDataList.get(0), null, context);
 605         String nodeTemplateId = unifiedCompositionService.createAbstractSubstituteNodeTemplate(
 606                 inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), substitutionServiceTemplate.get(),
 607                 unifiedCompositionDataList, substitutionNodeTypeId,
 608                 context, null);
 609
 610         unifiedCompositionService
 611                 .updateCompositionConnectivity(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 612                         unifiedCompositionDataList, context);
 613         validateAbstractSubstitute();
 614     }
 615
 616     @Test
 617     public void updOutParamGetAttrInNoConsolidationTest() throws Exception {
 618         List<Pair<String, String>> portTypeToIdList = new ArrayList<>();
 619         portTypeToIdList.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_1));
 620         portTypeToIdList.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_2));
 621         portTypeToIdList.add(new ImmutablePair<>(FSB1_OAM, FSB1_OAM));
 622
 623         loadInputAndOutputData(BASE_DIRECTORY + "updOutputGetAttrIn/noConsolidation");
 624         UnifiedCompositionData unifiedCompositionData =
 625                 createCompositionData(FSB1_template, portTypeToIdList);
 626         addOutputGetAttrInForComputeNoConsolidation(unifiedCompositionData);
 627         addOutputGetAttrInForPortNoConsolidation(unifiedCompositionData);
 628
 629         List<UnifiedCompositionData> unifiedCompositionDataList = new ArrayList<>();
 630         unifiedCompositionDataList.add(unifiedCompositionData);
 631         Mockito.doNothing().when(unifiedCompositionService).updNodesConnectedOutConnectivity
 632                 (inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), unifiedCompositionDataList, context);
 633         Mockito.doReturn(FSB1).when(context).getUnifiedAbstractNodeTemplateId(anyObject(),
 634                 anyString());
 635         unifiedCompositionService
 636                 .updateCompositionConnectivity(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 637                         unifiedCompositionDataList, context);
 638
 639         checkSTResults(expectedOutserviceTemplates, null, null, inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML));
 640     }
 641
 642     @Test
 643     public void updOutParamGetAttrInWithConsolidationTest() throws Exception {
 644         List<UnifiedCompositionData> unifiedCompositionDataList = new ArrayList<>();
 645         List<Pair<String, String>> portTypeToIdList1 = new ArrayList<>();
 646         portTypeToIdList1.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_1));
 647         portTypeToIdList1.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_2));
 648
 649         loadInputAndOutputData(BASE_DIRECTORY + "updOutputGetAttrIn/consolidation");
 650         UnifiedCompositionData unifiedCompositionData1 =
 651                 createCompositionData(FSB1_template, portTypeToIdList1);
 652         addOutputGetAttrInForCompute1WithConsolidation(unifiedCompositionData1);
 653         addOutputGetAttrInForPortWithConsolidation1(unifiedCompositionData1);
 654         unifiedCompositionDataList.add(unifiedCompositionData1);
 655
 656         List<Pair<String, String>> portTypeToIdList2 = new ArrayList<>();
 657         portTypeToIdList2.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_2));
 658         portTypeToIdList2.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_1));
 659
 660         UnifiedCompositionData unifiedCompositionData2 =
 661                 createCompositionData(FSB2_template, portTypeToIdList2);
 662         unifiedCompositionDataList.add(unifiedCompositionData2);
 663         addOutputGetAttrInForCompute2WithConsolidation(unifiedCompositionData2);
 664         addOutputGetAttrInForPortWithConsolidation2(unifiedCompositionData2);
 665
 666         Mockito.doNothing().when(unifiedCompositionService).updNodesConnectedOutConnectivity
 667                 (inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), unifiedCompositionDataList, context);
 668         Mockito.doReturn(FSB1).when(context).getUnifiedAbstractNodeTemplateId(anyObject(),
 669                 anyString());
 670
 671         unifiedCompositionService
 672                 .updateCompositionConnectivity(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 673                         unifiedCompositionDataList, context);
 674
 675         checkSTResults(expectedOutserviceTemplates, null, null, inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML));
 676     }
 677
 678     @Test
 679     public void updNodeGetAttrInNoConsolidationTest() throws Exception {
 680         List<Pair<String, String>> portTypeToIdList = new ArrayList<>();
 681         portTypeToIdList.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_1));
 682         portTypeToIdList.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_2));
 683         portTypeToIdList.add(new ImmutablePair<>(FSB1_OAM, FSB1_OAM));
 684
 685         loadInputAndOutputData(BASE_DIRECTORY + "updNodesGetAttrIn/noConsolidation");
 686         UnifiedCompositionData unifiedCompositionData =
 687                 createCompositionData(FSB1_template, portTypeToIdList);
 688         addGetAttrForCompute(unifiedCompositionData);
 689         addGetAttrForPort(unifiedCompositionData);
 690         addGetAttrForPortInnerUC(unifiedCompositionData);
 691
 692         List<UnifiedCompositionData> unifiedCompositionDataList = new ArrayList<>();
 693         unifiedCompositionDataList.add(unifiedCompositionData);
 694         Mockito.doNothing().when(unifiedCompositionService).updNodesConnectedOutConnectivity
 695                 (inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), unifiedCompositionDataList, context);
 696         Mockito.doReturn(FSB1).when(context).getUnifiedAbstractNodeTemplateId(anyObject(),
 697                 anyString());
 698         unifiedCompositionService
 699                 .updateCompositionConnectivity(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 700                         unifiedCompositionDataList, context);
 701
 702         checkSTResults(expectedOutserviceTemplates, null, null, inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML));
 703     }
 704
 705     @Test
 706     public void updNodeGetAttrInWithConsolidationTest() throws Exception {
 707         List<UnifiedCompositionData> unifiedCompositionDataList = new ArrayList<>();
 708         List<Pair<String, String>> portTypeToIdList1 = new ArrayList<>();
 709         portTypeToIdList1.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_1));
 710         portTypeToIdList1.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_2));
 711
 712         loadInputAndOutputData(BASE_DIRECTORY + "updNodesGetAttrIn/consolidation");
 713         UnifiedCompositionData unifiedCompositionData1 =
 714                 createCompositionData(FSB1_template, portTypeToIdList1);
 715         addGetAttrForCompute(unifiedCompositionData1);
 716         addGetAttrForPort(unifiedCompositionData1);
 717         unifiedCompositionDataList.add(unifiedCompositionData1);
 718
 719         List<Pair<String, String>> portTypeToIdList2 = new ArrayList<>();
 720         portTypeToIdList2.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_2));
 721         portTypeToIdList2.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_1));
 722
 723         UnifiedCompositionData unifiedCompositionData2 =
 724                 createCompositionData(FSB2_template, portTypeToIdList2);
 725         addGetAttrForCompute2(unifiedCompositionData2);
 726         addGetAttrForPort2(unifiedCompositionData2);
 727         unifiedCompositionDataList.add(unifiedCompositionData2);
 728
 729
 730         Mockito.doNothing().when(unifiedCompositionService).updNodesConnectedOutConnectivity
 731                 (inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), unifiedCompositionDataList, context);
 732         Mockito.doReturn(FSB1).when(context).getUnifiedAbstractNodeTemplateId(anyObject(),
 733                 anyString());
 734
 735         unifiedCompositionService
 736                 .updateCompositionConnectivity(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 737                         unifiedCompositionDataList, context);
 738
 739         checkSTResults(expectedOutserviceTemplates, null, null, inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML));
 740     }
 741
 742
 743     @Test
 744     public void updNodesGetAttrFromInnerNodesTest() throws Exception {
 745         List<Pair<String, String>> portTypeToIdList = new ArrayList<>();
 746         portTypeToIdList.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_1));
 747         portTypeToIdList.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_2));
 748         portTypeToIdList.add(new ImmutablePair<>(FSB1_OAM, FSB1_OAM));
 749
 750         loadInputAndOutputData(BASE_DIRECTORY +
 751                 "creSubstitutionServiceTemplate/updNodesGetAttrInFromInnerNodes/noConsolidation");
 752         UnifiedCompositionData unifiedCompositionData =
 753                 createCompositionData(FSB1_template, portTypeToIdList);
 754         addGetAttrForCompute(unifiedCompositionData);
 755         addGetAttrForPort(unifiedCompositionData);
 756         addGetAttrForPortInnerUC(unifiedCompositionData);
 757         List<UnifiedCompositionData> unifiedCompositionDataList = new ArrayList<>();
 758         unifiedCompositionDataList.add(unifiedCompositionData);
 759
 760         Mockito.doReturn(FSB1).when(context).getUnifiedAbstractNodeTemplateId(anyObject(),
 761                 anyString());
 762
 763         Optional<ServiceTemplate> substitutionServiceTemplate = unifiedCompositionService
 764                 .createUnifiedSubstitutionServiceTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 765                         unifiedCompositionDataList,
 766                         context, ORG_OPENECOMP_RESOURCE_ABSTRACT_NODES_FSB1, null);
 767         assertEquals(true, substitutionServiceTemplate.isPresent());
 768         substitutionServiceTemplate
 769                 .ifPresent(
 770                         subServiceTemplate -> checkSTResults(expectedOutserviceTemplates,
 771                                 subServiceTemplate, context.getGlobalSubstitutionServiceTemplate(), null));
 772     }
 773
 774
 775     @Test
 776     public void updNodesGetAttrFromConsolidationNodesTest() throws Exception {
 777         List<UnifiedCompositionData> unifiedCompositionDataList = new ArrayList<>();
 778         List<Pair<String, String>> portTypeToIdList1 = new ArrayList<>();
 779         portTypeToIdList1.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_1));
 780         portTypeToIdList1.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_2));
 781
 782         loadInputAndOutputData(BASE_DIRECTORY +
 783                 "creSubstitutionServiceTemplate/updNodesGetAttrInFromInnerNodes/consolidation");
 784         UnifiedCompositionData unifiedCompositionData1 =
 785                 createCompositionData(FSB1_template, portTypeToIdList1);
 786         addGetAttrForCompute(unifiedCompositionData1);
 787         addGetAttrForPort(unifiedCompositionData1);
 788         unifiedCompositionDataList.add(unifiedCompositionData1);
 789
 790         List<Pair<String, String>> portTypeToIdList2 = new ArrayList<>();
 791         portTypeToIdList2.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_2));
 792         portTypeToIdList2.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_1));
 793
 794         UnifiedCompositionData unifiedCompositionData2 =
 795                 createCompositionData(FSB2_template, portTypeToIdList2);
 796         addGetAttrForCompute2(unifiedCompositionData2);
 797         addGetAttrForPort2(unifiedCompositionData2);
 798         unifiedCompositionDataList.add(unifiedCompositionData2);
 799
 800         Optional<ServiceTemplate> substitutionServiceTemplate = unifiedCompositionService
 801                 .createUnifiedSubstitutionServiceTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 802                         unifiedCompositionDataList,
 803                         context, ORG_OPENECOMP_RESOURCE_ABSTRACT_NODES_FSB1, null);
 804         assertEquals(true, substitutionServiceTemplate.isPresent());
 805         substitutionServiceTemplate
 806                 .ifPresent(
 807                         subServiceTemplate -> checkSTResults(expectedOutserviceTemplates,
 808                                 subServiceTemplate, context.getGlobalSubstitutionServiceTemplate(), null));
 809     }
 810
 811     @Test
 812     public void cleanMainServiceTemplateTestNoConsolidation() throws IOException {
 813         List<Pair<String, String>> portTypeToIdList = new ArrayList<>();
 814         portTypeToIdList.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_1));
 815         portTypeToIdList.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_2));
 816         portTypeToIdList.add(new ImmutablePair<>("FSB_OAM", FSB1_OAM));
 817
 818         loadInputAndOutputData(BASE_DIRECTORY + "cleanMainSt/noConsolidation");
 819         UnifiedCompositionData unifiedCompositionData =
 820                 createCompositionData(FSB1_template, portTypeToIdList);
 821         addGetAttrForCompute(unifiedCompositionData);
 822         addGetAttrForPort(unifiedCompositionData);
 823
 824         List<UnifiedCompositionData> unifiedCompositionDataList = new ArrayList<>();
 825         unifiedCompositionDataList.add(unifiedCompositionData);
 826
 827         NodeTemplate abstractNodeTemplate = getMockNode(
 828                 BASE_DIRECTORY + "cleanMainSt/mockAbstractNodeTemplate.yaml");
 829         inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML).getTopology_template().getNode_templates()
 830                 .put(FSB1, abstractNodeTemplate);
 831
 832         Mockito.doReturn(FSB1).when(context).getUnifiedAbstractNodeTemplateId(anyObject(),
 833                 anyString());
 834
 835         unifiedCompositionService.
 836                 cleanUnifiedCompositionEntities(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 837                         unifiedCompositionDataList, context);
 838
 839         checkSTResults(expectedOutserviceTemplates, null, null, inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML));
 840     }
 841
 842     @Test
 843     public void cleanMainServiceTemplateTestWithConsolidation() throws IOException {
 844         loadInputAndOutputData(BASE_DIRECTORY + "cleanMainSt/consolidation");
 845
 846         List<UnifiedCompositionData> unifiedCompositionDataList = new ArrayList<>();
 847         List<Pair<String, String>> portTypeToIdList1 = new ArrayList<>();
 848         portTypeToIdList1.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_1));
 849         portTypeToIdList1.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_2));
 850
 851         UnifiedCompositionData unifiedCompositionData1 =
 852                 createCompositionData(FSB1_template, portTypeToIdList1);
 853         addOutputGetAttrInForCompute1WithConsolidation(unifiedCompositionData1);
 854         addOutputGetAttrInForPortWithConsolidation1(unifiedCompositionData1);
 855         unifiedCompositionDataList.add(unifiedCompositionData1);
 856
 857         List<Pair<String, String>> portTypeToIdList2 = new ArrayList<>();
 858         portTypeToIdList2.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_2));
 859         portTypeToIdList2.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_1));
 860
 861         UnifiedCompositionData unifiedCompositionData2 =
 862                 createCompositionData(FSB2_template, portTypeToIdList2);
 863         addOutputGetAttrInForCompute2WithConsolidation(unifiedCompositionData2);
 864         addOutputGetAttrInForPortWithConsolidation2(unifiedCompositionData2);
 865         unifiedCompositionDataList.add(unifiedCompositionData2);
 866
 867         NodeTemplate abstractNodeTemplate = getMockNode(
 868                 BASE_DIRECTORY + "cleanMainSt/mockAbstractNodeTemplate.yaml");
 869         inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML).getTopology_template().getNode_templates()
 870                 .put(FSB1, abstractNodeTemplate);
 871
 872         Mockito.doReturn(FSB1).when(context).getUnifiedAbstractNodeTemplateId(anyObject(),
 873                 anyString());
 874
 875         unifiedCompositionService.
 876                 cleanUnifiedCompositionEntities(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 877                         unifiedCompositionDataList, context);
 878
 879         checkSTResults(expectedOutserviceTemplates, null, null, inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML));
 880     }
 881
 882     @Test
 883     public void updateNewAbstractNodeTemplateNoConsolidation() throws IOException {
 884         loadInputAndOutputData(BASE_DIRECTORY + "fixNewAbstractNodeTemplate/noConsolidation");
 885
 886         List<Pair<String, String>> portTypeToIdList = new ArrayList<>();
 887         portTypeToIdList.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_1));
 888         portTypeToIdList.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_2));
 889
 890         NodeTemplate cleanedComputeNodeTemplate =
 891                 getMockNode(
 892                         BASE_DIRECTORY + "fixNewAbstractNodeTemplate/mockComputeNodeTemplate.yaml");
 893
 894
 895         context.setConsolidationData(
 896                 createConsolidationData(Collections.singletonList(FSB1_template), portTypeToIdList));
 897         context.addCleanedNodeTemplate(MAIN_SERVICE_TEMPLATE_YAML, FSB1_template,
 898                 UnifiedCompositionEntity.COMPUTE, cleanedComputeNodeTemplate);
 899         context.addCleanedNodeTemplate(MAIN_SERVICE_TEMPLATE_YAML, FSB1_INTERNAL_1,
 900                 UnifiedCompositionEntity.PORT, cleanedComputeNodeTemplate);
 901         context.addCleanedNodeTemplate(MAIN_SERVICE_TEMPLATE_YAML, FSB1_INTERNAL_2,
 902                 UnifiedCompositionEntity.PORT, cleanedComputeNodeTemplate);
 903
 904         setUnifiedCompositionData(Arrays.asList(FSB1_template, FSB1_INTERNAL_1, FSB1_INTERNAL_2));
 905
 906         unifiedCompositionService
 907                 .updateUnifiedAbstractNodesConnectivity(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), context);
 908
 909         checkSTResults(expectedOutserviceTemplates, null, null, inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML));
 910     }
 911
 912     @Test
 913     public void updateNewAbstractNodeTemplateWithConsolidation() throws IOException {
 914         loadInputAndOutputData(BASE_DIRECTORY + "fixNewAbstractNodeTemplate/consolidation");
 915
 916         List<Pair<String, String>> portTypeToIdList = new ArrayList<>();
 917         portTypeToIdList.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_1));
 918         portTypeToIdList.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_1));
 919
 920         NodeTemplate cleanedComputeNodeTemplate =
 921                 getMockNode(
 922                         BASE_DIRECTORY + "fixNewAbstractNodeTemplate/mockComputeNodeTemplate.yaml");
 923
 924
 925         context.setConsolidationData(
 926                 createConsolidationData(Arrays.asList("FSB1_template_1", "FSB1_template_2"),
 927                         portTypeToIdList));
 928         context.addCleanedNodeTemplate(MAIN_SERVICE_TEMPLATE_YAML, "FSB1_template_1",
 929                 UnifiedCompositionEntity.COMPUTE, cleanedComputeNodeTemplate);
 930         context.addCleanedNodeTemplate(MAIN_SERVICE_TEMPLATE_YAML, "FSB1_template_2",
 931                 UnifiedCompositionEntity.COMPUTE, cleanedComputeNodeTemplate);
 932         context.addCleanedNodeTemplate(MAIN_SERVICE_TEMPLATE_YAML, FSB1_INTERNAL_1,
 933                 UnifiedCompositionEntity.PORT, cleanedComputeNodeTemplate);
 934         context.addCleanedNodeTemplate(MAIN_SERVICE_TEMPLATE_YAML, FSB2_INTERNAL_1,
 935                 UnifiedCompositionEntity.PORT, cleanedComputeNodeTemplate);
 936
 937         setUnifiedCompositionData(
 938                 Arrays.asList("FSB1_template_1", "FSB1_template_2", FSB1_INTERNAL_1, FSB2_INTERNAL_1));
 939
 940         unifiedCompositionService
 941                 .updateUnifiedAbstractNodesConnectivity(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), context);
 942
 943         checkSTResults(expectedOutserviceTemplates, null, null, inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML));
 944     }
 945
 946     @Test
 947     public void testUnifiedNestedCompositionOneComputeInNested() throws IOException {
 948         loadInputAndOutputData(BASE_DIRECTORY + "pattern4/oneNestedNode");
 949
 950         ConsolidationData consolidationData = new ConsolidationData();
 951         String nestedFileName = "nested-pcm_v0.1ServiceTemplate.yaml";
 952         TestUtils.updateNestedConsolidationData(MAIN_SERVICE_TEMPLATE_YAML, Collections.singletonList("server_pcm_001"),
 953                 consolidationData);
 954
 955         TestUtils.initComputeNodeTypeInConsolidationData(nestedFileName,
 956                 "org.openecomp.resource.vfc.nodes.heat.pcm_server", consolidationData);
 957         TestUtils.initComputeNodeTemplateIdInConsolidationData(nestedFileName,
 958                 "org.openecomp.resource.vfc.nodes.heat.pcm_server", "server_pcm", consolidationData);
 959
 960         context.setConsolidationData(consolidationData);
 961         context.getTranslatedServiceTemplates()
 962                 .put(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME,
 963                         inputServiceTemplates.get(GLOBAL_SUBSTITUTION_TYPES_SERVICE_TEMPLATE_YAML));
 964         context.getTranslatedServiceTemplates()
 965                 .put(nestedFileName, inputServiceTemplates.get(nestedFileName));
 966         context.getTranslatedServiceTemplates()
 967                 .put(MAIN_SERVICE_TEMPLATE_YAML, inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML));
 968
 969     UnifiedCompositionData unifiedComposition = createUnifiedCompositionOnlyNested("server_pcm_001");
 970     UnifiedCompositionTo unifiedCompositionTo = new UnifiedCompositionTo(
 971         inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), inputServiceTemplates.get(nestedFileName), null,
 972         context, null);
 973     unifiedCompositionService.handleUnifiedNestedDefinition(unifiedCompositionTo, unifiedComposition);
 974
 975         checkSTResults(expectedOutserviceTemplates, nestedFileName,
 976                 context.getTranslatedServiceTemplates().get(nestedFileName),
 977                 context.getTranslatedServiceTemplates()
 978                         .get(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME), null);
 979     }
 980
 981     @Test
 982     public void testTwoNestedWithOneCompute() throws IOException {
 983         loadInputAndOutputData(BASE_DIRECTORY + "pattern4/twoNestedWithOneCompute");
 984
 985         ConsolidationData consolidationData = new ConsolidationData();
 986         String nestedFileName1 = "nested-pcm_v0.1ServiceTemplate.yaml";
 987         String nestedFileName2 = "nested-oam_v0.1ServiceTemplate.yaml";
 988
 989         TestUtils.updateNestedConsolidationData(MAIN_SERVICE_TEMPLATE_YAML,
 990                 Arrays.asList("server_pcm_001", "server_oam_001"), consolidationData);
 991
 992         TestUtils.initComputeNodeTypeInConsolidationData(nestedFileName1,
 993                 "org.openecomp.resource.vfc.nodes.heat.pcm_server", consolidationData);
 994         TestUtils.initComputeNodeTemplateIdInConsolidationData(nestedFileName1,
 995                 "org.openecomp.resource.vfc.nodes.heat.pcm_server", "server_pcm", consolidationData);
 996         TestUtils.initComputeNodeTypeInConsolidationData(nestedFileName2,
 997                 "org.openecomp.resource.vfc.nodes.heat.oam_server", consolidationData);
 998         TestUtils.initComputeNodeTemplateIdInConsolidationData(nestedFileName2,
 999                 "org.openecomp.resource.vfc.nodes.heat.oam_server", "server_oam", consolidationData);
1000
1001         context.setConsolidationData(consolidationData);
1002         context.getTranslatedServiceTemplates()
1003                 .put(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME,
1004                         inputServiceTemplates.get(GLOBAL_SUBSTITUTION_TYPES_SERVICE_TEMPLATE_YAML));
1005         context.getTranslatedServiceTemplates()
1006                 .put(nestedFileName1, inputServiceTemplates.get(nestedFileName1));
1007         context.getTranslatedServiceTemplates()
1008                 .put(nestedFileName2, inputServiceTemplates.get(nestedFileName2));
1009         context.getTranslatedServiceTemplates()
1010                 .put(MAIN_SERVICE_TEMPLATE_YAML, inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML));
1011
1012     UnifiedCompositionData unifiedComposition =
1013         createUnifiedCompositionOnlyNested("server_pcm_001");
1014     UnifiedCompositionTo unifiedCompositionTo1 = new UnifiedCompositionTo(inputServiceTemplates
1015         .get(MAIN_SERVICE_TEMPLATE_YAML), inputServiceTemplates.get(nestedFileName1), null,
1016         context, null);
1017     unifiedCompositionService.handleUnifiedNestedDefinition(unifiedCompositionTo1, unifiedComposition);
1018     unifiedComposition = createUnifiedCompositionOnlyNested("server_oam_001");
1019     UnifiedCompositionTo unifiedCompositionTo2 = new UnifiedCompositionTo(inputServiceTemplates
1020         .get(MAIN_SERVICE_TEMPLATE_YAML), inputServiceTemplates.get(nestedFileName2), null,
1021         context, null);
1022     unifiedCompositionService.handleUnifiedNestedDefinition(unifiedCompositionTo2, unifiedComposition);
1023
1024         checkSTResults(expectedOutserviceTemplates, nestedFileName1,
1025                 context.getTranslatedServiceTemplates().get(nestedFileName1),
1026                 context.getTranslatedServiceTemplates()
1027                         .get(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME), null);
1028         checkSTResults(expectedOutserviceTemplates, nestedFileName2,
1029                 context.getTranslatedServiceTemplates().get(nestedFileName2),
1030                 null, null);
1031     }
1032
1033     @Test
1034     public void testNestedCompositionNodesConnectedIn() throws IOException {
1035         loadInputAndOutputData(BASE_DIRECTORY + "pattern4/nestedNodesConnectedIn");
1036         ConsolidationData consolidationData = new ConsolidationData();
1037         String nestedFileName = "nested-pcm_v0.1ServiceTemplate.yaml";
1038         TestUtils.updateNestedConsolidationData(MAIN_SERVICE_TEMPLATE_YAML, Collections.singletonList("server_pcm_001"),
1039                 consolidationData);
1040         context.getTranslatedServiceTemplates()
1041                 .put(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME,
1042                         inputServiceTemplates.get(GLOBAL_SUBSTITUTION_TYPES_SERVICE_TEMPLATE_YAML));
1043         context.getTranslatedServiceTemplates()
1044                 .put(nestedFileName, inputServiceTemplates.get(nestedFileName));
1045         context.getTranslatedServiceTemplates()
1046                 .put(MAIN_SERVICE_TEMPLATE_YAML, inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML));
1047         context.addUnifiedNestedNodeTemplateId(MAIN_SERVICE_TEMPLATE_YAML, "server_pcm_001", "abstract_pcm_server_0");
1048
1049         Map<String, List<RequirementAssignmentData>> nodeConnectedInList =
1050                 TestUtils.getNodeConnectedInList("server_pcm_001", inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
1051                         DEPENDENCY);
1052         UnifiedCompositionData unifiedComposition =
1053                 createUnifiedCompositionOnlyNested("server_pcm_001");
1054         unifiedComposition.getNestedTemplateConsolidationData()
1055                 .setNodesConnectedIn(nodeConnectedInList);
1056
1057         unifiedCompositionService.updNestedCompositionNodesConnectedInConnectivity
1058                 (inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), unifiedComposition, context);
1059         checkSTResults(expectedOutserviceTemplates, nestedFileName,
1060                 context.getTranslatedServiceTemplates().get(nestedFileName),
1061                 context.getTranslatedServiceTemplates()
1062                         .get(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME), context
1063                         .getTranslatedServiceTemplates().get(MAIN_SERVICE_TEMPLATE_YAML));
1064     }
1065
1066
1067     @Test
1068     public void testNestedCompositionNodesGetAttrIn() throws IOException {
1069         loadInputAndOutputData(BASE_DIRECTORY + "pattern4/nestedNodesGetAttrIn");
1070         ConsolidationData consolidationData = new ConsolidationData();
1071         String nestedFileName = "nested-pcm_v0.1ServiceTemplate.yaml";
1072         TestUtils.updateNestedConsolidationData(MAIN_SERVICE_TEMPLATE_YAML, Collections.singletonList("server_pcm_001"),
1073                 consolidationData);
1074         context.getTranslatedServiceTemplates()
1075                 .put(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME,
1076                         inputServiceTemplates.get(GLOBAL_SUBSTITUTION_TYPES_SERVICE_TEMPLATE_YAML));
1077         context.getTranslatedServiceTemplates()
1078                 .put(nestedFileName, inputServiceTemplates.get(nestedFileName));
1079         context.getTranslatedServiceTemplates()
1080                 .put(MAIN_SERVICE_TEMPLATE_YAML, inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML));
1081         context.addUnifiedNestedNodeTemplateId(MAIN_SERVICE_TEMPLATE_YAML, "server_pcm_001", "abstract_pcm_server_0");
1082
1083         Map<String, List<RequirementAssignmentData>> nodeConnectedInList =
1084                 TestUtils.getNodeConnectedInList("server_pcm_001", inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
1085                         DEPENDENCY);
1086         UnifiedCompositionData unifiedComposition =
1087                 createUnifiedCompositionOnlyNested("server_pcm_001");
1088         addGetAttInUnifiedCompositionData(unifiedComposition
1089                 .getNestedTemplateConsolidationData(), TENANT_ID, "oam_net_gw", "packet_mirror_network");
1090         addGetAttInUnifiedCompositionData(unifiedComposition
1091                         .getNestedTemplateConsolidationData(), USER_DATA_FORMAT, "oam_net_gw",
1092                 "server_compute_get_attr_test");
1093         addGetAttInUnifiedCompositionData(unifiedComposition
1094                         .getNestedTemplateConsolidationData(), "metadata", "server_pcm_id",
1095                 "server_compute_get_attr_test");
1096         unifiedCompositionService.updNestedCompositionNodesGetAttrInConnectivity
1097                 (inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), unifiedComposition, context);
1098         checkSTResults(expectedOutserviceTemplates, nestedFileName,
1099                 context.getTranslatedServiceTemplates().get(nestedFileName),
1100                 context.getTranslatedServiceTemplates()
1101                         .get(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME), context
1102                         .getTranslatedServiceTemplates().get(MAIN_SERVICE_TEMPLATE_YAML));
1103     }
1104
1105     @Test
1106     public void testNestedCompositionOutputParamGetAttrIn() throws IOException {
1107         loadInputAndOutputData(BASE_DIRECTORY + "pattern4/nestedOutputParamGetAttrIn");
1108         ConsolidationData consolidationData = new ConsolidationData();
1109         String nestedFileName = "nested-pcm_v0.1ServiceTemplate.yaml";
1110         TestUtils.updateNestedConsolidationData(MAIN_SERVICE_TEMPLATE_YAML, Collections.singletonList("server_pcm_001"),
1111                 consolidationData);
1112         context.getTranslatedServiceTemplates()
1113                 .put(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME,
1114                         inputServiceTemplates.get(GLOBAL_SUBSTITUTION_TYPES_SERVICE_TEMPLATE_YAML));
1115         context.getTranslatedServiceTemplates()
1116                 .put(nestedFileName, inputServiceTemplates.get(nestedFileName));
1117         context.getTranslatedServiceTemplates()
1118                 .put(MAIN_SERVICE_TEMPLATE_YAML, inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML));
1119         context.addUnifiedNestedNodeTemplateId(MAIN_SERVICE_TEMPLATE_YAML, "server_pcm_001", "abstract_pcm_server_0");
1120
1121         Map<String, List<RequirementAssignmentData>> nodeConnectedInList =
1122                 TestUtils.getNodeConnectedInList("server_pcm_001", inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
1123                         DEPENDENCY);
1124         UnifiedCompositionData unifiedComposition =
1125                 createUnifiedCompositionOnlyNested("server_pcm_001");
1126         addOutputGetAttInUnifiedCompositionData(unifiedComposition
1127                 .getNestedTemplateConsolidationData(), "output_attr_1", ACCESS_IPv4);
1128         addOutputGetAttInUnifiedCompositionData(unifiedComposition
1129                 .getNestedTemplateConsolidationData(), "output_attr_2", ACCESS_IPv6);
1130         unifiedCompositionService.updNestedCompositionOutputParamGetAttrInConnectivity
1131                 (inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), unifiedComposition, context);
1132         checkSTResults(expectedOutserviceTemplates, nestedFileName,
1133                 context.getTranslatedServiceTemplates().get(nestedFileName),
1134                 context.getTranslatedServiceTemplates()
1135                         .get(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME), context
1136                         .getTranslatedServiceTemplates().get(MAIN_SERVICE_TEMPLATE_YAML));
1137     }
1138
1139     @Test
1140     public void testInputOutputParameterType() throws IOException{
1141         loadInputAndOutputData(BASE_DIRECTORY + "inputoutputparamtype");
1142         ConsolidationData consolidationData = new ConsolidationData();
1143         List<Pair<String, String>> portTypeToIdList = new ArrayList<>();
1144         portTypeToIdList.add(new ImmutablePair<>("FSB1_Port", "FSB1_Port_1"));
1145         portTypeToIdList.add(new ImmutablePair<>("VMI", "VMI_1"));
1146
1147         UnifiedCompositionData unifiedCompositionData = createCompositionData(FSB1, portTypeToIdList);
1148
1149         Map<String, NodeTemplate> nodeTemplates =
1150                 inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML).getTopology_template().getNode_templates();
1151         for (Map.Entry<String, NodeTemplate> nodeTemplateEntry : nodeTemplates.entrySet() ) {
1152             String nodeTemplateId = nodeTemplateEntry.getKey();
1153             if (nodeTemplateId.equals("cmaui_volume_test_compute_properties")) {
1154                 Map<String, List<GetAttrFuncData>> nodesGetAttrIn =
1155                         TestUtils.getNodesGetAttrIn(nodeTemplateEntry.getValue(), nodeTemplateId);
1156                 unifiedCompositionData.getComputeTemplateConsolidationData()
1157                         .setNodesGetAttrIn(nodesGetAttrIn);
1158             }
1159
1160             if (nodeTemplateId.equals("cmaui_volume_test_neutron_port_properties")) {
1161                 Map<String, List<GetAttrFuncData>> nodesGetAttrIn =
1162                         TestUtils.getNodesGetAttrIn(nodeTemplateEntry.getValue(), nodeTemplateId);
1163                 unifiedCompositionData.getPortTemplateConsolidationDataList().get(0)
1164                         .setNodesGetAttrIn(nodesGetAttrIn);
1165             }
1166
1167             if (nodeTemplateId.equals("cmaui_volume_test_contrailv2_VMI_properties")) {
1168                 Map<String, List<GetAttrFuncData>> nodesGetAttrIn =
1169                         TestUtils.getNodesGetAttrIn(nodeTemplateEntry.getValue(), nodeTemplateId);
1170                 unifiedCompositionData.getPortTemplateConsolidationDataList().get(1)
1171                         .setNodesGetAttrIn(nodesGetAttrIn);
1172             }
1173         }
1174
1175         List<UnifiedCompositionData> unifiedCompositionDataList = new LinkedList<>();
1176         unifiedCompositionDataList.add(unifiedCompositionData);
1177
1178         UnifiedCompositionSingleSubstitution unifiedCompositionSingleSubstitution =
1179                 new UnifiedCompositionSingleSubstitution();
1180         unifiedCompositionSingleSubstitution
1181                 .createUnifiedComposition(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), null,
1182                         unifiedCompositionDataList, context);
1183         checkSTResults(expectedOutserviceTemplates, null, null, inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML));
1184         System.out.println();
1185
1186     }
1187
1188
1189     private UnifiedCompositionData createUnifiedCompositionOnlyNested(
1190             String nestedNodeTemplateId) {
1191         NestedTemplateConsolidationData nestedTemplateConsolidationData =
1192                 new NestedTemplateConsolidationData();
1193         nestedTemplateConsolidationData.setNodeTemplateId(nestedNodeTemplateId);
1194         UnifiedCompositionData unifiedCompositionData = new UnifiedCompositionData();
1195         unifiedCompositionData.setNestedTemplateConsolidationData(nestedTemplateConsolidationData);
1196         return unifiedCompositionData;
1197     }
1198
1199     private void setUnifiedCompositionData(List<String> nodeTemplateIds) {
1200         UnifiedSubstitutionData unifiedSubstitutionData =
1201                 context.getUnifiedSubstitutionData().get(MAIN_SERVICE_TEMPLATE_YAML) == null ? new UnifiedSubstitutionData()
1202                         : context.getUnifiedSubstitutionData().get(MAIN_SERVICE_TEMPLATE_YAML);
1203         Map<String, String> substitutionAbstractNodeIds = new HashMap<>();
1204         for (String id : nodeTemplateIds) {
1205             substitutionAbstractNodeIds.put(id, "FSB2");
1206         }
1207
1208         substitutionAbstractNodeIds.put("", FSB1);
1209
1210         unifiedSubstitutionData.setNodesRelatedAbstractNode(substitutionAbstractNodeIds);
1211     }
1212
1213     private void checkSTResults(
1214             Map<String, ServiceTemplate> expectedOutserviceTemplates,
1215             ServiceTemplate substitutionServiceTemplate,
1216             ServiceTemplate gloablSubstitutionServiceTemplate, ServiceTemplate mainServiceTemplate) {
1217         YamlUtil yamlUtil = new YamlUtil();
1218         if (Objects.nonNull(substitutionServiceTemplate)) {
1219             String substitutionST = "SubstitutionServiceTemplate.yaml";
1220             assertEquals("difference substitution service template: ",
1221                     yamlUtil.objectToYaml(expectedOutserviceTemplates.get(substitutionST)),
1222                     yamlUtil.objectToYaml(substitutionServiceTemplate));
1223         }
1224         if (Objects.nonNull(gloablSubstitutionServiceTemplate)) {
1225             assertEquals("difference global substitution service template: ",
1226                     yamlUtil.objectToYaml(expectedOutserviceTemplates.get(GLOBAL_SUBSTITUTION_TYPES_SERVICE_TEMPLATE_YAML)),
1227                     yamlUtil.objectToYaml(gloablSubstitutionServiceTemplate));
1228         }
1229         if (Objects.nonNull(mainServiceTemplate)) {
1230             assertEquals("difference main service template: ",
1231                     yamlUtil.objectToYaml(expectedOutserviceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML)),
1232                     yamlUtil.objectToYaml(mainServiceTemplate));
1233         }
1234     }
1235
1236     private void checkSTResults(
1237             Map<String, ServiceTemplate> expectedOutserviceTemplates,
1238             String nestedSTFileName, ServiceTemplate nestedServiceTemplate,
1239             ServiceTemplate gloablSubstitutionServiceTemplate, ServiceTemplate mainServiceTemplate) {
1240         YamlUtil yamlUtil = new YamlUtil();
1241
1242         if (Objects.nonNull(nestedServiceTemplate)) {
1243             assertEquals("difference nested service template: ",
1244                     yamlUtil.objectToYaml(expectedOutserviceTemplates.get(nestedSTFileName)),
1245                     yamlUtil.objectToYaml(nestedServiceTemplate));
1246         }
1247         checkSTResults(expectedOutserviceTemplates, null, gloablSubstitutionServiceTemplate,
1248                 mainServiceTemplate);
1249     }
1250
1251
1252     private void loadInputAndOutputData(String path) throws IOException {
1253         inputServiceTemplates = new HashMap<>();
1254         TestUtils.loadServiceTemplates(path + IN_PREFIX, new ToscaExtensionYamlUtil(),
1255                 inputServiceTemplates);
1256         expectedOutserviceTemplates = new HashMap<>();
1257         TestUtils.loadServiceTemplates(path + OUT_PREFIX, new ToscaExtensionYamlUtil(),
1258                 expectedOutserviceTemplates);
1259     }
1260
1261
1262     private void addGetAttInUnifiedCompositionData(EntityConsolidationData entityConsolidationData,
1263                                                    String propertyName, String attributeName,
1264                                                    String nodeTemplateId) {
1265         GetAttrFuncData getAttrFuncData = new GetAttrFuncData();
1266         getAttrFuncData.setAttributeName(attributeName);
1267         getAttrFuncData.setFieldName(propertyName);
1268         entityConsolidationData.addNodesGetAttrIn(nodeTemplateId, getAttrFuncData);
1269     }
1270
1271     private void addOutputGetAttInUnifiedCompositionData(
1272             EntityConsolidationData entityConsolidationData,
1273             String outParamName, String attributeName) {
1274         GetAttrFuncData getAttrFuncData = new GetAttrFuncData();
1275         getAttrFuncData.setAttributeName(attributeName);
1276         getAttrFuncData.setFieldName(outParamName);
1277         entityConsolidationData.addOutputParamGetAttrIn(getAttrFuncData);
1278     }
1279
1280     private ConsolidationData createConsolidationData(List<String> computeNodeIds,
1281                                                       List<Pair<String, String>> portTypeToIdList) {
1282
1283         ConsolidationData consolidationData = new ConsolidationData();
1284         String computeNodeTypeName = "org.openecomp.resource.vfc.nodes.heat.FSB2";
1285
1286         TestUtils
1287                 .initComputeNodeTypeInConsolidationData(MAIN_SERVICE_TEMPLATE_YAML, computeNodeTypeName, consolidationData);
1288         TestUtils.initPortConsolidationData(MAIN_SERVICE_TEMPLATE_YAML, consolidationData);
1289
1290         for (String computeId : computeNodeIds) {
1291             ComputeTemplateConsolidationData computeTemplateConsolidationData =
1292                     new ComputeTemplateConsolidationData();
1293             TestUtils.updatePortsInComputeTemplateConsolidationData(portTypeToIdList,
1294                     computeTemplateConsolidationData);
1295             consolidationData.getComputeConsolidationData().getFileComputeConsolidationData(MAIN_SERVICE_TEMPLATE_YAML)
1296                     .getTypeComputeConsolidationData(computeNodeTypeName)
1297                     .setComputeTemplateConsolidationData(computeId,
1298                             computeTemplateConsolidationData);
1299         }
1300
1301         for (Pair<String, String> portTypeToId : portTypeToIdList) {
1302             consolidationData.getPortConsolidationData().getFilePortConsolidationData(MAIN_SERVICE_TEMPLATE_YAML)
1303                     .setPortTemplateConsolidationData(portTypeToId.getRight(),
1304                             new PortTemplateConsolidationData());
1305         }
1306
1307         return consolidationData;
1308     }
1309
1310     private UnifiedCompositionData createCompositionData(String computeNodeTemplateId,
1311                                                          List<Pair<String, String>> portTypeToIdList) {
1312
1313         UnifiedCompositionData unifiedCompositionData = new UnifiedCompositionData();
1314         NodeTemplate computeNodeTemplate =
1315                 DataModelUtil.getNodeTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), computeNodeTemplateId);
1316         Optional<List<RequirementAssignmentData>> requirementAssignmentDataList =
1317                 TestUtils.getRequirementAssignmentDataList(computeNodeTemplate, "local_storage");
1318         List<RequirementAssignmentData> requirementAssignmentList =
1319                 (requirementAssignmentDataList.isPresent()) ? requirementAssignmentDataList.get() : null;
1320         Map<String, List<RequirementAssignmentData>> volume = null;
1321         if (requirementAssignmentList != null) {
1322             volume = getVolume(requirementAssignmentList);
1323         }
1324         unifiedCompositionData.setComputeTemplateConsolidationData(
1325                 TestUtils.createComputeTemplateConsolidationData(computeNodeTemplateId, portTypeToIdList,
1326                         volume));
1327         if (portTypeToIdList != null) {
1328             for (Pair<String, String> port : portTypeToIdList) {
1329                 NodeTemplate portNodeTemplate =
1330                         DataModelUtil.getNodeTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), port.getRight());
1331
1332                 Map<String, List<RequirementAssignmentData>> nodeConnectedOut =
1333                         TestUtils.getNodeConnectedOutList(portNodeTemplate, "link");
1334                 PortTemplateConsolidationData portTemplateConsolidationData =
1335                         TestUtils.createPortTemplateConsolidationData(port.getRight());
1336                 portTemplateConsolidationData.setNodesConnectedOut(nodeConnectedOut);
1337                 unifiedCompositionData.addPortTemplateConsolidationData(portTemplateConsolidationData);
1338             }
1339         }
1340         return unifiedCompositionData;
1341     }
1342
1343     private List<UnifiedCompositionData> createAbstractSubstituteCompositionDataComputeAndPort() {
1344         List<UnifiedCompositionData> unifiedCompositionDataList = new ArrayList<>();
1345         UnifiedCompositionData data1 = createComputeUnifiedCompositionData(FSB1_template);
1346         UnifiedCompositionData data2 = createComputeUnifiedCompositionData(FSB2_template);
1347
1348         List<Pair<String, String>> portTypeToIdList = new ArrayList<>();
1349         ImmutablePair<String, String> portTypePair1 = new ImmutablePair<>(FSB1_INTERNAL,
1350                 FSB1_INTERNAL_1);
1351         ImmutablePair<String, String> portTypePair2 = new ImmutablePair<>(FSB2_INTERNAL,
1352                 FSB2_INTERNAL_1);
1353         portTypeToIdList.add(portTypePair1);
1354         portTypeToIdList.add(portTypePair2);
1355         addPortDataToCompositionData(portTypeToIdList, data1);
1356         portTypeToIdList.remove(portTypePair1);
1357         portTypeToIdList.remove(portTypePair2);
1358         portTypeToIdList.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_2));
1359         portTypeToIdList.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_2));
1360         addPortDataToCompositionData(portTypeToIdList, data2);
1361
1362         unifiedCompositionDataList.add(data1);
1363         unifiedCompositionDataList.add(data2);
1364         return unifiedCompositionDataList;
1365     }
1366
1367
1368     private UnifiedCompositionData createComputeUnifiedCompositionData(String computeNodeTemplateId) {
1369         NodeTemplate computeNodeTemplate =
1370                 DataModelUtil.getNodeTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), computeNodeTemplateId);
1371         Optional<List<RequirementAssignmentData>> requirementAssignmentDataList =
1372                 TestUtils.getRequirementAssignmentDataList(computeNodeTemplate, "local_storage");
1373         Map<String, List<RequirementAssignmentData>> volume = null;
1374         if (requirementAssignmentDataList.isPresent()) {
1375             volume = getVolume(requirementAssignmentDataList.get());
1376         }
1377         UnifiedCompositionData data = new UnifiedCompositionData();
1378         Map<String, List<RequirementAssignmentData>> computeNodeConnectedOut =
1379                 TestUtils.getNodeConnectedOutList(computeNodeTemplate, DEPENDENCY);
1380         Map<String, List<RequirementAssignmentData>> computeNodeConnectedIn =
1381                 TestUtils
1382                         .getNodeConnectedInList(computeNodeTemplateId, inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
1383                                 DEPENDENCY);
1384         ComputeTemplateConsolidationData computeTemplateConsolidationData = TestUtils
1385                 .createComputeTemplateConsolidationData(computeNodeTemplateId, null, volume);
1386         List<String> computeNodeGroups =
1387                 TestUtils.getGroupsForNode(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
1388                         computeNodeTemplateId);
1389         if (!computeNodeGroups.isEmpty()) {
1390             computeTemplateConsolidationData.setGroupIds(computeNodeGroups);
1391         }
1392         computeTemplateConsolidationData.setNodesConnectedOut(computeNodeConnectedOut);
1393         computeTemplateConsolidationData.setNodesConnectedIn(computeNodeConnectedIn);
1394         data.setComputeTemplateConsolidationData(computeTemplateConsolidationData);
1395         return data;
1396     }
1397
1398     private void addPortDataToCompositionData(List<Pair<String, String>> portTypeToIdList,
1399                                               UnifiedCompositionData data) {
1400         ComputeTemplateConsolidationData computeTemplateConsolidationData = data
1401                 .getComputeTemplateConsolidationData();
1402
1403         for (Pair<String, String> port : portTypeToIdList) {
1404             NodeTemplate portNodeTemplate =
1405                     DataModelUtil.getNodeTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), port.getRight());
1406
1407             Optional<List<RequirementAssignmentData>> bindingReqList =
1408                     TestUtils.getRequirementAssignmentDataList(portNodeTemplate, "binding");
1409
1410             if (bindingReqList.isPresent()) {
1411                 for (RequirementAssignmentData reqData : bindingReqList.get()) {
1412                     String nodeId = reqData.getRequirementAssignment().getNode();
1413                     if (nodeId.equals(computeTemplateConsolidationData.getNodeTemplateId())) {
1414                         computeTemplateConsolidationData.addPort(port.getLeft(), port.getRight());
1415                     }
1416                 }
1417             }
1418             Map<String, List<RequirementAssignmentData>> portNodeConnectedOut =
1419                     TestUtils.getNodeConnectedOutList(portNodeTemplate, "link");
1420             PortTemplateConsolidationData portTemplateConsolidationData = TestUtils
1421                     .createPortTemplateConsolidationData(port.getRight());
1422             portTemplateConsolidationData.setNodesConnectedOut(portNodeConnectedOut);
1423
1424             //Add node connected in info to test data
1425             Map<String, List<RequirementAssignmentData>> portNodeConnectedIn =
1426                     TestUtils.getNodeConnectedInList(port.getRight(), inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
1427                             PORT);
1428             portTemplateConsolidationData.setNodesConnectedIn(portNodeConnectedIn);
1429
1430             //Add group infromation for ports
1431             List<String> portGroups =
1432                     TestUtils.getGroupsForNode(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), port.getRight());
1433             portTemplateConsolidationData.setGroupIds(portGroups);
1434             data.addPortTemplateConsolidationData(portTemplateConsolidationData);
1435
1436         }
1437         addGetAttrForCompute(data);
1438         addGetAttrForPort(data);
1439     }
1440
1441     private Map<String, List<RequirementAssignmentData>> getVolume(
1442             List<RequirementAssignmentData> requirementAssignmentList) {
1443         Map<String, List<RequirementAssignmentData>> volume = new HashMap<>();
1444         for (RequirementAssignmentData requirementAssignmentData : requirementAssignmentList) {
1445             String volumeNodeTemplateId = requirementAssignmentData.getRequirementAssignment().getNode();
1446             volume.computeIfAbsent(volumeNodeTemplateId, k -> new ArrayList<>());
1447             volume.get(volumeNodeTemplateId).add(requirementAssignmentData);
1448         }
1449         return volume;
1450     }
1451
1452     private void addGetAttrForPort(UnifiedCompositionData unifiedCompositionData) {
1453         for (PortTemplateConsolidationData portTemplateConsolidationData : unifiedCompositionData
1454                 .getPortTemplateConsolidationDataList()) {
1455             if (portTemplateConsolidationData.getNodeTemplateId().equals(FSB1_INTERNAL_1)) {
1456                 addGetAttInUnifiedCompositionData(portTemplateConsolidationData, "network_name",
1457                         NETWORK_ID, JSA_NET1);
1458                 addGetAttInUnifiedCompositionData(portTemplateConsolidationData, SIZE,
1459                         DEVICE_OWNER, CMAUI_VOLUME1);
1460             } else if (portTemplateConsolidationData.getNodeTemplateId().equals(FSB2_INTERNAL_2)) {
1461                 addGetAttInUnifiedCompositionData(portTemplateConsolidationData, TENANT_ID,
1462                         NETWORK_ID, JSA_NET1);
1463                 addGetAttInUnifiedCompositionData(portTemplateConsolidationData, "qos_policy",
1464                         NETWORK_ID, JSA_NET1);
1465                 addGetAttInUnifiedCompositionData(portTemplateConsolidationData, VOLUME_TYPE,
1466                         TENANT_ID, CMAUI_VOLUME1);
1467             } else if (portTemplateConsolidationData.getNodeTemplateId().equals(FSB1_OAM)) {
1468                 addGetAttInUnifiedCompositionData(portTemplateConsolidationData, SIZE,
1469                         STATUS, CMAUI_VOLUME1);
1470             }
1471         }
1472     }
1473
1474     private void addGetAttrForPort2(UnifiedCompositionData unifiedCompositionData) {
1475         for (PortTemplateConsolidationData portTemplateConsolidationData : unifiedCompositionData
1476                 .getPortTemplateConsolidationDataList()) {
1477             if (portTemplateConsolidationData.getNodeTemplateId().equals(FSB2_INTERNAL_1)) {
1478                 addGetAttInUnifiedCompositionData(portTemplateConsolidationData, VOLUME_TYPE,
1479                         TENANT_ID, CMAUI_VOLUME3);
1480             } else if (portTemplateConsolidationData.getNodeTemplateId().equals(FSB1_INTERNAL_2)) {
1481                 addGetAttInUnifiedCompositionData(portTemplateConsolidationData, SIZE,
1482                         DEVICE_OWNER, CMAUI_VOLUME3);
1483                 addGetAttInUnifiedCompositionData(portTemplateConsolidationData, SIZE,
1484                         STATUS, CMAUI_VOLUME1);
1485             }
1486         }
1487     }
1488
1489     private void addGetAttrForPortInnerUC(UnifiedCompositionData unifiedCompositionData) {
1490         for (PortTemplateConsolidationData portTemplateConsolidationData : unifiedCompositionData
1491                 .getPortTemplateConsolidationDataList()) {
1492             if (portTemplateConsolidationData.getNodeTemplateId().equals(FSB1_INTERNAL_1)) {
1493                 addGetAttInUnifiedCompositionData(portTemplateConsolidationData, AVAILABILITY_ZONE,
1494                         MYATTR, FSB1_template);
1495                 addGetAttInUnifiedCompositionData(portTemplateConsolidationData, "metadata",
1496                         MYATTR, FSB1_template);
1497                 addGetAttInUnifiedCompositionData(portTemplateConsolidationData, "name",
1498                         MYATTR, FSB1_template);
1499                 addGetAttInUnifiedCompositionData(portTemplateConsolidationData, AVAILABILITY_ZONE,
1500                         TENANT_ID, FSB1_template);
1501             }
1502         }
1503     }
1504
1505     private void addGetAttrForCompute(UnifiedCompositionData unifiedCompositionData) {
1506         addGetAttInUnifiedCompositionData(unifiedCompositionData.getComputeTemplateConsolidationData(),
1507                 "dhcp_agent_ids", ADDRESSES, JSA_NET1);
1508         addGetAttInUnifiedCompositionData(unifiedCompositionData.getComputeTemplateConsolidationData(),
1509                 VOLUME_TYPE, ADDRESSES, CMAUI_VOLUME1);
1510         addGetAttInUnifiedCompositionData(unifiedCompositionData.getComputeTemplateConsolidationData(),
1511                 SIZE, ACCESS_IPv6, CMAUI_VOLUME2);
1512     }
1513
1514     private void addGetAttrForCompute2(UnifiedCompositionData unifiedCompositionData) {
1515         addGetAttInUnifiedCompositionData(unifiedCompositionData.getComputeTemplateConsolidationData(),
1516                 VOLUME_TYPE, ADDRESSES, CMAUI_VOLUME3);
1517         addGetAttInUnifiedCompositionData(unifiedCompositionData.getComputeTemplateConsolidationData(),
1518                 SIZE, USER_DATA_FORMAT, CMAUI_VOLUME3);
1519     }
1520
1521     private void addOutputGetAttrInForComputeNoConsolidation(
1522             UnifiedCompositionData unifiedCompositionData) {
1523         addOutputGetAttInUnifiedCompositionData(unifiedCompositionData
1524                 .getComputeTemplateConsolidationData(), SIMPLE_OUTPUT1, ACCESS_IPv4);
1525         addOutputGetAttInUnifiedCompositionData(unifiedCompositionData
1526                 .getComputeTemplateConsolidationData(), SIMPLE_OUTPUT2, ADDRESSES);
1527         addOutputGetAttInUnifiedCompositionData(unifiedCompositionData
1528                 .getComputeTemplateConsolidationData(), COMPLEX_OUTPUT1, ADDRESSES);
1529         addOutputGetAttInUnifiedCompositionData(unifiedCompositionData
1530                 .getComputeTemplateConsolidationData(), COMPLEX_OUTPUT3, ACCESS_IPv6);
1531
1532     }
1533
1534     private void addOutputGetAttrInForCompute1WithConsolidation(
1535             UnifiedCompositionData unifiedCompositionData) {
1536         addOutputGetAttInUnifiedCompositionData(unifiedCompositionData
1537                 .getComputeTemplateConsolidationData(), SIMPLE_OUTPUT1, ACCESS_IPv4);
1538         addOutputGetAttInUnifiedCompositionData(unifiedCompositionData
1539                 .getComputeTemplateConsolidationData(), COMPLEX_OUTPUT1, ADDRESSES);
1540
1541     }
1542
1543     private void addOutputGetAttrInForCompute2WithConsolidation(
1544             UnifiedCompositionData unifiedCompositionData) {
1545         addOutputGetAttInUnifiedCompositionData(unifiedCompositionData
1546                 .getComputeTemplateConsolidationData(), SIMPLE_OUTPUT2, ADDRESSES);
1547     }
1548
1549     private void addOutputGetAttrInForPortNoConsolidation(
1550             UnifiedCompositionData unifiedCompositionData) {
1551         for (PortTemplateConsolidationData portTemplateConsolidationData : unifiedCompositionData
1552                 .getPortTemplateConsolidationDataList()) {
1553             if (portTemplateConsolidationData.getNodeTemplateId().equals(FSB1_INTERNAL_1)) {
1554                 addOutputGetAttInUnifiedCompositionData(portTemplateConsolidationData, COMPLEX_OUTPUT2,
1555                         DEVICE_OWNER);
1556                 addOutputGetAttInUnifiedCompositionData(portTemplateConsolidationData, COMPLEX_OUTPUT3,
1557                         DEVICE_OWNER);
1558             } else if (portTemplateConsolidationData.getNodeTemplateId().equals(FSB2_INTERNAL_2)) {
1559                 addOutputGetAttInUnifiedCompositionData(portTemplateConsolidationData, COMPLEX_OUTPUT1,
1560                         TENANT_ID);
1561             } else if (portTemplateConsolidationData.getNodeTemplateId().equals(FSB1_OAM)) {
1562                 addOutputGetAttInUnifiedCompositionData(portTemplateConsolidationData, COMPLEX_OUTPUT2,
1563                         USER_DATA_FORMAT);
1564             }
1565         }
1566     }
1567
1568     private void addOutputGetAttrInForPortWithConsolidation1(
1569             UnifiedCompositionData unifiedCompositionData) {
1570         for (PortTemplateConsolidationData portTemplateConsolidationData : unifiedCompositionData
1571                 .getPortTemplateConsolidationDataList()) {
1572             if (portTemplateConsolidationData.getNodeTemplateId().equals(FSB2_INTERNAL_2)) {
1573                 addOutputGetAttInUnifiedCompositionData(portTemplateConsolidationData, COMPLEX_OUTPUT1,
1574                         TENANT_ID);
1575             } else if (portTemplateConsolidationData.getNodeTemplateId().equals(FSB1_INTERNAL_1)) {
1576                 addOutputGetAttInUnifiedCompositionData(portTemplateConsolidationData, COMPLEX_OUTPUT3,
1577                         "admin_state_up");
1578             }
1579         }
1580     }
1581
1582     private void addOutputGetAttrInForPortWithConsolidation2(
1583             UnifiedCompositionData unifiedCompositionData) {
1584         for (PortTemplateConsolidationData portTemplateConsolidationData : unifiedCompositionData
1585                 .getPortTemplateConsolidationDataList()) {
1586             if (portTemplateConsolidationData.getNodeTemplateId().equals(FSB2_INTERNAL_1)) {
1587                 addOutputGetAttInUnifiedCompositionData(portTemplateConsolidationData, COMPLEX_OUTPUT2,
1588                         USER_DATA_FORMAT);
1589             } else if (portTemplateConsolidationData.getNodeTemplateId().equals(FSB1_INTERNAL_2)) {
1590                 addOutputGetAttInUnifiedCompositionData(portTemplateConsolidationData, COMPLEX_OUTPUT2,
1591                         DEVICE_OWNER);
1592             }
1593         }
1594     }
1595
1596     private NodeTemplate getMockNode(String path) throws IOException {
1597         URL resource = this.getClass().getResource(path);
1598         YamlUtil yamlUtil = new YamlUtil();
1599         return yamlUtil.yamlToObject(resource.openStream(), NodeTemplate.class);
1600     }
1601
1602 }