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