openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/test/java/org/openecomp/sdc/translator/services/heattotosca/UnifiedCompositionServiceTest.java

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