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

   1 /*
   2  * Copyright © 2016-2018 European Support Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.openecomp.sdc.translator.services.heattotosca;
  18
  19 import static org.junit.Assert.assertEquals;
  20 import static org.mockito.Matchers.anyObject;
  21 import static org.mockito.Matchers.anyString;
  22
  23 import org.apache.commons.lang3.tuple.ImmutablePair;
  24 import org.apache.commons.lang3.tuple.Pair;
  25 import org.junit.Before;
  26 import org.junit.Ignore;
  27 import org.junit.Test;
  28 import org.mockito.InjectMocks;
  29 import org.mockito.Mockito;
  30 import org.mockito.MockitoAnnotations;
  31 import org.mockito.Spy;
  32 import org.openecomp.sdc.tosca.datatypes.model.NodeTemplate;
  33 import org.openecomp.sdc.tosca.datatypes.model.ServiceTemplate;
  34 import org.openecomp.sdc.tosca.services.DataModelUtil;
  35 import org.openecomp.sdc.tosca.services.ToscaExtensionYamlUtil;
  36 import org.openecomp.sdc.tosca.services.YamlUtil;
  37 import org.openecomp.sdc.translator.TestUtils;
  38 import org.openecomp.sdc.translator.datatypes.heattotosca.TranslationContext;
  39 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedCompositionData;
  40 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedCompositionEntity;
  41 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedSubstitutionData;
  42 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.to.UnifiedCompositionTo;
  43 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ComputeTemplateConsolidationData;
  44 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ConsolidationData;
  45 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.EntityConsolidationData;
  46 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.GetAttrFuncData;
  47 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.NestedTemplateConsolidationData;
  48 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.PortTemplateConsolidationData;
  49 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.RequirementAssignmentData;
  50 import org.openecomp.sdc.translator.services.heattotosca.impl.unifiedcomposition.UnifiedCompositionSingleSubstitution;
  51
  52 import java.io.IOException;
  53 import java.net.URL;
  54 import java.util.ArrayList;
  55 import java.util.Arrays;
  56 import java.util.Collections;
  57 import java.util.HashMap;
  58 import java.util.LinkedList;
  59 import java.util.List;
  60 import java.util.Map;
  61 import java.util.Objects;
  62 import java.util.Optional;
  63
  64 public class UnifiedCompositionServiceTest {
  65     private static final String BASE_DIRECTORY = "/mock/services/heattotosca/unifiedComposition/";
  66     @InjectMocks
  67     @Spy
  68     UnifiedCompositionService unifiedCompositionService;
  69     @Spy
  70     TranslationContext context;
  71
  72     private static final String IN_PREFIX = "/in";
  73     private static final String OUT_PREFIX = "/out";
  74     private static final String FSB1_template = "FSB1_template";
  75     private static final String FSB2_template = "FSB2_template";
  76     private static final String FSB3_template = "FSB3_template";
  77     private static final String FSB1_INTERNAL = "FSB1_Internal";
  78     private static final String FSB2_INTERNAL = "FSB2_Internal";
  79     private static final String FSB1_INTERNAL_1 = "FSB1_Internal_1";
  80     private static final String FSB1_INTERNAL_2 = "FSB1_Internal_2";
  81     private static final String FSB2_INTERNAL_1 = "FSB2_Internal_1";
  82     private static final String FSB2_INTERNAL_2 = "FSB2_Internal_2";
  83     private static final String PORT = "port";
  84     private static final String PORT_1 = "port_1";
  85     private static final String PORT_2 = "port_2";
  86     private static final String FSB1_OAM = "FSB1_OAM";
  87     private static final String ORG_OPENECOMP_RESOURCE_ABSTRACT_NODES_FSB1 = "org.openecomp.resource.abstract.nodes.FSB1";
  88     private static final String ORG_OPENECOMP_RESOURCE_VFC_NODES_HEAT_FSB = "org.openecomp.resource.vfc.nodes.heat.FSB";
  89     private static final String DEVICE_OWNER = "device_owner";
  90     private static final String COMPLEX_OUTPUT1 = "complexOutput1";
  91     private static final String COMPLEX_OUTPUT2 = "complexOutput2";
  92     private static final String COMPLEX_OUTPUT3 = "complexOutput3";
  93     private static final String USER_DATA_FORMAT = "user_data_format";
  94     private static final String TENANT_ID = "tenant_id";
  95     private static final String SIMPLE_OUTPUT1 = "simpleOutput1";
  96     private static final String SIMPLE_OUTPUT2 = "simpleOutput2";
  97     private static final String ADDRESSES = "addresses";
  98     private static final String CMAUI_VOLUME1 = "cmaui_volume1";
  99     private static final String CMAUI_VOLUME2 = "cmaui_volume2";
 100     private static final String CMAUI_VOLUME3 = "cmaui_volume3";
 101     private static final String ACCESS_IPv4 = "accessIPv4";
 102     private static final String ACCESS_IPv6 = "accessIPv6";
 103     private static final String FSB1 = "FSB1";
 104     private static final String MYATTR = "myAttr";
 105     private static final String VOLUME_TYPE = "volume_type";
 106     private static final String SIZE = "size";
 107     private static final String NETWORK_ID = "network_id";
 108     private static final String JSA_NET1 = "jsa_net1";
 109     private static final String STATUS = "status";
 110     private static final String AVAILABILITY_ZONE = "availability_zone";
 111     private static final String DEPENDENCY = "dependency";
 112
 113     Map<String, ServiceTemplate> inputServiceTemplates;
 114     Map<String, ServiceTemplate> expectedOutserviceTemplates;
 115
 116     private static final String MAIN_SERVICE_TEMPLATE_YAML = "MainServiceTemplate.yaml";
 117     private static final String GLOBAL_SUBSTITUTION_TYPES_SERVICE_TEMPLATE_YAML =
 118             "GlobalSubstitutionTypesServiceTemplate.yaml";
 119
 120     @Before
 121     public void setUp() {
 122         MockitoAnnotations.initMocks(this);
 123     }
 124
 125     //todo
 126     @Test
 127     public void createUnifiedComposition() throws Exception {
 128
 129     }
 130
 131     @Test
 132     public void createSubstitutionStNoConsolidationData() throws Exception {
 133         String path = BASE_DIRECTORY + "creSubstitutionServiceTemplate/NoOutParamDuplicatePortType";
 134         loadInputAndOutputData(path);
 135         ServiceTemplate expectedServiceTemplate =
 136                 TestUtils.loadServiceTemplate(BASE_DIRECTORY +
 137                         "creSubstitutionServiceTemplate/NoOutParamDuplicatePortType" + OUT_PREFIX);
 138
 139         List<UnifiedCompositionData> unifiedCompositionDataList = new ArrayList<>();
 140         Optional<ServiceTemplate> substitutionServiceTemplate = unifiedCompositionService
 141                 .createUnifiedSubstitutionServiceTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 142                         unifiedCompositionDataList,
 143                         context, "org.openecomp.resource.vfc.nodes.heat.FSB1", null);
 144         assertEquals(false, substitutionServiceTemplate.isPresent());
 145     }
 146
 147     @Test
 148     public void createSubstitutionStNoOutputParamAndDuplicatePortType() throws Exception {
 149         List<Pair<String, String>> portTypeToIdList = new ArrayList<>();
 150         portTypeToIdList.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_1));
 151         portTypeToIdList.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_2));
 152         portTypeToIdList.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_1));
 153         portTypeToIdList.add(new ImmutablePair<>(FSB1_OAM, FSB1_OAM));
 154
 155         loadInputAndOutputData(BASE_DIRECTORY + "creSubstitutionServiceTemplate/NoOutParamDuplicatePortType");
 156         UnifiedCompositionData unifiedCompositionData =
 157                 createCompositionData(FSB1_template, portTypeToIdList);
 158         List<UnifiedCompositionData> unifiedCompositionDataList = new ArrayList<>();
 159         unifiedCompositionDataList.add(unifiedCompositionData);
 160
 161         Optional<ServiceTemplate> substitutionServiceTemplate = unifiedCompositionService
 162                 .createUnifiedSubstitutionServiceTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 163                         unifiedCompositionDataList,
 164                         context, ORG_OPENECOMP_RESOURCE_ABSTRACT_NODES_FSB1, null);
 165         assertEquals(true, substitutionServiceTemplate.isPresent());
 166         substitutionServiceTemplate
 167                 .ifPresent(
 168                         subServiceTemplate -> checkSTResults(expectedOutserviceTemplates,
 169                                 subServiceTemplate, context.getGlobalSubstitutionServiceTemplate(), null));
 170     }
 171
 172     @Test
 173     public void createSubstitutionStWithOutputParamNoConsolidation() throws Exception {
 174         List<Pair<String, String>> portTypeToIdList = new ArrayList<>();
 175         portTypeToIdList.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_1));
 176         portTypeToIdList.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_2));
 177         portTypeToIdList.add(new ImmutablePair<>(FSB1_OAM, FSB1_OAM));
 178
 179         loadInputAndOutputData(BASE_DIRECTORY + "creSubstitutionServiceTemplate/WithOutputParameters/noConsolidation");
 180         UnifiedCompositionData unifiedCompositionData =
 181                 createCompositionData(FSB1_template, portTypeToIdList);
 182         addGetAttrForCompute(unifiedCompositionData);
 183         addGetAttrForPort(unifiedCompositionData);
 184         List<UnifiedCompositionData> unifiedCompositionDataList = new ArrayList<>();
 185         unifiedCompositionDataList.add(unifiedCompositionData);
 186
 187         Optional<ServiceTemplate> substitutionServiceTemplate = unifiedCompositionService
 188                 .createUnifiedSubstitutionServiceTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 189                         unifiedCompositionDataList,
 190                         context, ORG_OPENECOMP_RESOURCE_ABSTRACT_NODES_FSB1, null);
 191         assertEquals(true, substitutionServiceTemplate.isPresent());
 192         substitutionServiceTemplate
 193                 .ifPresent(
 194                         subServiceTemplate -> checkSTResults(expectedOutserviceTemplates,
 195                                 subServiceTemplate, context.getGlobalSubstitutionServiceTemplate(), null));
 196     }
 197
 198     @Test
 199     public void createSubstitutionStWithOutputParamWithConsolidation() throws Exception {
 200         List<UnifiedCompositionData> unifiedCompositionDataList = new ArrayList<>();
 201         List<Pair<String, String>> portTypeToIdList1 = new ArrayList<>();
 202         portTypeToIdList1.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_1));
 203         portTypeToIdList1.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_2));
 204
 205         loadInputAndOutputData(BASE_DIRECTORY + "creSubstitutionServiceTemplate/WithOutputParameters/consolidation");
 206         UnifiedCompositionData unifiedCompositionData1 =
 207                 createCompositionData(FSB1_template, portTypeToIdList1);
 208         addGetAttrForCompute(unifiedCompositionData1);
 209         addGetAttrForPort(unifiedCompositionData1);
 210         unifiedCompositionDataList.add(unifiedCompositionData1);
 211
 212         List<Pair<String, String>> portTypeToIdList2 = new ArrayList<>();
 213         portTypeToIdList2.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_2));
 214         portTypeToIdList2.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_1));
 215
 216         UnifiedCompositionData unifiedCompositionData2 =
 217                 createCompositionData(FSB2_template, portTypeToIdList2);
 218         addGetAttrForCompute2(unifiedCompositionData2);
 219         addGetAttrForPort2(unifiedCompositionData2);
 220         unifiedCompositionDataList.add(unifiedCompositionData2);
 221
 222         Optional<ServiceTemplate> substitutionServiceTemplate = unifiedCompositionService
 223                 .createUnifiedSubstitutionServiceTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 224                         unifiedCompositionDataList,
 225                         context, ORG_OPENECOMP_RESOURCE_ABSTRACT_NODES_FSB1, null);
 226         assertEquals(true, substitutionServiceTemplate.isPresent());
 227         substitutionServiceTemplate
 228                 .ifPresent(
 229                         subServiceTemplate -> checkSTResults(expectedOutserviceTemplates,
 230                                 subServiceTemplate, context.getGlobalSubstitutionServiceTemplate(), null));
 231     }
 232
 233     @Test
 234     public void createSubstitutionStNoPorts() throws Exception {
 235         loadInputAndOutputData(BASE_DIRECTORY + "creSubstitutionServiceTemplate/NoPorts");
 236
 237         UnifiedCompositionData unifiedCompositionData = new UnifiedCompositionData();
 238         unifiedCompositionData.setComputeTemplateConsolidationData(
 239                 TestUtils.createComputeTemplateConsolidationData(FSB1_template, null, null));
 240         List<UnifiedCompositionData> unifiedCompositionDataList = new ArrayList<>();
 241         unifiedCompositionDataList.add(unifiedCompositionData);
 242
 243         Optional<ServiceTemplate> substitutionServiceTemplate = unifiedCompositionService
 244                 .createUnifiedSubstitutionServiceTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 245                         unifiedCompositionDataList,
 246                         context, ORG_OPENECOMP_RESOURCE_ABSTRACT_NODES_FSB1, null);
 247         assertEquals(true, substitutionServiceTemplate.isPresent());
 248         substitutionServiceTemplate
 249                 .ifPresent(
 250                         subServiceTemplate -> checkSTResults(expectedOutserviceTemplates,
 251                                 subServiceTemplate, context.getGlobalSubstitutionServiceTemplate(), null));
 252     }
 253
 254
 255     @Test
 256     public void createSubstitutionStWithIndex() throws Exception {
 257         List<Pair<String, String>> portTypeToIdList = new ArrayList<>();
 258         portTypeToIdList.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_1));
 259         portTypeToIdList.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_2));
 260         portTypeToIdList.add(new ImmutablePair<>(FSB1_OAM, FSB1_OAM));
 261
 262         loadInputAndOutputData(BASE_DIRECTORY + "creSubstitutionServiceTemplate/WithIndex");
 263         UnifiedCompositionData unifiedCompositionData =
 264                 createCompositionData(FSB1_template, portTypeToIdList);
 265         List<UnifiedCompositionData> unifiedCompositionDataList = new ArrayList<>();
 266         unifiedCompositionDataList.add(unifiedCompositionData);
 267
 268         Optional<ServiceTemplate> substitutionServiceTemplate = unifiedCompositionService
 269                 .createUnifiedSubstitutionServiceTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 270                         unifiedCompositionDataList,
 271                         context,ORG_OPENECOMP_RESOURCE_ABSTRACT_NODES_FSB1, 2);
 272         assertEquals(true, substitutionServiceTemplate.isPresent());
 273         substitutionServiceTemplate
 274                 .ifPresent(
 275                         subServiceTemplate -> checkSTResults(expectedOutserviceTemplates,
 276                                 subServiceTemplate, context.getGlobalSubstitutionServiceTemplate(), null));
 277     }
 278
 279
 280     @Test
 281     public void createAbstractSubstituteOneComputeMultiplePortsDifferentTypesTest() throws Exception {
 282         loadInputAndOutputData(BASE_DIRECTORY + "createAbstractSubstitute/oneComputeMultiplePortsDiffType");
 283
 284         UnifiedCompositionData data = createComputeUnifiedCompositionData(FSB1_template);
 285         List<Pair<String, String>> portTypeToIdList = new ArrayList<>();
 286         portTypeToIdList.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_1));
 287         portTypeToIdList.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_2));
 288         portTypeToIdList.add(new ImmutablePair<>(FSB1_OAM, FSB1_OAM));
 289         addPortDataToCompositionData(portTypeToIdList, data);
 290
 291         List<UnifiedCompositionData> unifiedCompositionDataList = new LinkedList<>();
 292         unifiedCompositionDataList.add(data);
 293         Optional<ServiceTemplate> substitutionServiceTemplate = unifiedCompositionService
 294                 .createUnifiedSubstitutionServiceTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 295                         unifiedCompositionDataList,
 296                         context, ORG_OPENECOMP_RESOURCE_VFC_NODES_HEAT_FSB, null);
 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 createAbstractSubstituteOneComputeMultiplePortsSameTypesTest() throws Exception {
 313         loadInputAndOutputData(BASE_DIRECTORY + "createAbstractSubstitute/oneComputeMultiplePortsSameType");
 314
 315         UnifiedCompositionData data = createComputeUnifiedCompositionData(FSB1_template);
 316         List<Pair<String, String>> portTypeToIdList = new ArrayList<>();
 317         portTypeToIdList.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_1));
 318         portTypeToIdList.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_2));
 319         addPortDataToCompositionData(portTypeToIdList, data);
 320
 321         List<UnifiedCompositionData> unifiedCompositionDataList = new LinkedList<>();
 322         unifiedCompositionDataList.add(data);
 323         Optional<ServiceTemplate> substitutionServiceTemplate = unifiedCompositionService
 324                 .createUnifiedSubstitutionServiceTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 325                         unifiedCompositionDataList
 326                         , context, ORG_OPENECOMP_RESOURCE_VFC_NODES_HEAT_FSB, null);
 327
 328         assertEquals(true, substitutionServiceTemplate.isPresent());
 329         if (substitutionServiceTemplate.isPresent()) {
 330             String substitutionNodeTypeId =
 331                     unifiedCompositionService.getSubstitutionNodeTypeId(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 332                             unifiedCompositionDataList.get(0), null, context);
 333             String nodeTemplateId = unifiedCompositionService.createAbstractSubstituteNodeTemplate(
 334                     inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), substitutionServiceTemplate.get(),
 335                     unifiedCompositionDataList, substitutionNodeTypeId,
 336                     context, null);
 337             validateAbstractSubstitute();
 338         }
 339     }
 340
 341
 342     @Test
 343     public void createAbstractSubstituteTwoComputesMultiplePorts() throws Exception {
 344         loadInputAndOutputData(BASE_DIRECTORY + "createAbstractSubstitute/twoComputesMultiplePorts");
 345         List<UnifiedCompositionData> unifiedCompositionDataList =
 346                 createAbstractSubstituteCompositionDataComputeAndPort();
 347         Optional<ServiceTemplate> substitutionServiceTemplate = unifiedCompositionService
 348                 .createUnifiedSubstitutionServiceTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 349                         unifiedCompositionDataList
 350                         , context, ORG_OPENECOMP_RESOURCE_VFC_NODES_HEAT_FSB, null);
 351         assertEquals(true, substitutionServiceTemplate.isPresent());
 352         if (substitutionServiceTemplate.isPresent()) {
 353             String substitutionNodeTypeId =
 354                     unifiedCompositionService.getSubstitutionNodeTypeId(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 355                             unifiedCompositionDataList.get(0), null, context);
 356             String nodeTemplateId = unifiedCompositionService.createAbstractSubstituteNodeTemplate(
 357                     inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), substitutionServiceTemplate.get(),
 358                     unifiedCompositionDataList, substitutionNodeTypeId,
 359                     context, null);
 360             validateAbstractSubstitute();
 361         }
 362     }
 363
 364
 365     @Test
 366     public void updNodesConnectedOutWithConsolidationTest() throws Exception {
 367         loadInputAndOutputData(BASE_DIRECTORY + "updNodesConnectedOut/consolidation");
 368         List<UnifiedCompositionData> unifiedCompositionDataList =
 369                 createAbstractSubstituteCompositionDataComputeAndPort();
 370         Optional<ServiceTemplate> substitutionServiceTemplate = unifiedCompositionService
 371                 .createUnifiedSubstitutionServiceTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 372                         unifiedCompositionDataList
 373                         , context, ORG_OPENECOMP_RESOURCE_VFC_NODES_HEAT_FSB, null);
 374         assertEquals(true, substitutionServiceTemplate.isPresent());
 375         if (substitutionServiceTemplate.isPresent()) {
 376             String substitutionNodeTypeId =
 377                     unifiedCompositionService.getSubstitutionNodeTypeId(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 378                             unifiedCompositionDataList.get(0), null, context);
 379             String nodeTemplateId = unifiedCompositionService.createAbstractSubstituteNodeTemplate(
 380                     inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), substitutionServiceTemplate.get(),
 381                     unifiedCompositionDataList, substitutionNodeTypeId,
 382                     context, null);
 383
 384             unifiedCompositionService
 385                     .updateCompositionConnectivity(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 386                             unifiedCompositionDataList, context);
 387             validateAbstractSubstitute();
 388         }
 389     }
 390
 391     private void validateAbstractSubstitute() {
 392         YamlUtil yamlUtil = new YamlUtil();
 393         assertEquals(yamlUtil.objectToYaml(expectedOutserviceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML)), yamlUtil
 394                 .objectToYaml(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML)));
 395     }
 396
 397
 398     @Test
 399     public void updNodesConnectedOutNoConsolidationTest() throws Exception {
 400         loadInputAndOutputData(BASE_DIRECTORY + "updNodesConnectedOut/noConsolidation");
 401
 402         UnifiedCompositionData data = createComputeUnifiedCompositionData(FSB1_template);
 403         List<Pair<String, String>> portTypeToIdList = new ArrayList<>();
 404         portTypeToIdList.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_1));
 405         portTypeToIdList.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_2));
 406         portTypeToIdList.add(new ImmutablePair<>(FSB1_OAM, FSB1_OAM));
 407         addPortDataToCompositionData(portTypeToIdList, data);
 408
 409         List<UnifiedCompositionData> unifiedCompositionDataList = new LinkedList<>();
 410         unifiedCompositionDataList.add(data);
 411
 412         Optional<ServiceTemplate> substitutionServiceTemplate = unifiedCompositionService
 413                 .createUnifiedSubstitutionServiceTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 414                         unifiedCompositionDataList
 415                         , context, ORG_OPENECOMP_RESOURCE_VFC_NODES_HEAT_FSB, null);
 416         assertEquals(true, substitutionServiceTemplate.isPresent());
 417         if (substitutionServiceTemplate.isPresent()) {
 418             String substitutionNodeTypeId =
 419                     unifiedCompositionService.getSubstitutionNodeTypeId(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 420                             unifiedCompositionDataList.get(0), null, context);
 421             String nodeTemplateId = unifiedCompositionService.createAbstractSubstituteNodeTemplate(
 422                     inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), substitutionServiceTemplate.get(),
 423                     unifiedCompositionDataList, substitutionNodeTypeId,
 424                     context, null);
 425
 426             unifiedCompositionService
 427                     .updateCompositionConnectivity(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 428                             unifiedCompositionDataList, context);
 429             validateAbstractSubstitute();
 430         }
 431     }
 432
 433
 434     @Test
 435     public void updNodesConnectedInNoConsolidationTest() throws Exception {
 436         loadInputAndOutputData(BASE_DIRECTORY + "updNodesConnectedIn/noConsolidation");
 437
 438         UnifiedCompositionData data = createComputeUnifiedCompositionData("QRouter");
 439         List<Pair<String, String>> portTypeToIdList = new ArrayList<>();
 440         portTypeToIdList.add(new ImmutablePair<>("cdr_network_port", "cdr_network_port"));
 441         portTypeToIdList
 442                 .add(new ImmutablePair<>("oam_private_net_network_port", "oam_private_net_network_port"));
 443         addPortDataToCompositionData(portTypeToIdList, data);
 444
 445         List<UnifiedCompositionData> unifiedCompositionDataList = new LinkedList<>();
 446         unifiedCompositionDataList.add(data);
 447
 448         Optional<ServiceTemplate> substitutionServiceTemplate = unifiedCompositionService
 449                 .createUnifiedSubstitutionServiceTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 450                         unifiedCompositionDataList
 451                         , context, "org.openecomp.resource.abstract.nodes.QRouter", null);
 452
 453         String substitutionNodeTypeId =
 454                 unifiedCompositionService.getSubstitutionNodeTypeId(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 455                         unifiedCompositionDataList.get(0), null, context);
 456         String nodeTemplateId = unifiedCompositionService.createAbstractSubstituteNodeTemplate(
 457                 inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), substitutionServiceTemplate.get(),
 458                 unifiedCompositionDataList, substitutionNodeTypeId,
 459                 context, null);
 460
 461         unifiedCompositionService
 462                 .updateCompositionConnectivity(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 463                         unifiedCompositionDataList, context);
 464         validateAbstractSubstitute();
 465     }
 466
 467
 468     @Test
 469     public void updNodesConnectedInWithConsolidationTest() throws Exception {
 470         loadInputAndOutputData(BASE_DIRECTORY + "updNodesConnectedIn/consolidation");
 471
 472         List<UnifiedCompositionData> unifiedCompositionDataList =
 473                 createAbstractSubstituteCompositionDataComputeAndPort();
 474
 475         Optional<ServiceTemplate> substitutionServiceTemplate = unifiedCompositionService
 476                 .createUnifiedSubstitutionServiceTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 477                         unifiedCompositionDataList
 478                         , context, "org.openecomp.resource.abstract.nodes.FSB", null);
 479
 480         String substitutionNodeTypeId =
 481                 unifiedCompositionService.getSubstitutionNodeTypeId(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 482                         unifiedCompositionDataList.get(0), null, context);
 483         String nodeTemplateId = unifiedCompositionService.createAbstractSubstituteNodeTemplate(
 484                 inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), substitutionServiceTemplate.get(),
 485                 unifiedCompositionDataList, substitutionNodeTypeId,
 486                 context, null);
 487
 488         unifiedCompositionService
 489                 .updateCompositionConnectivity(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 490                         unifiedCompositionDataList, context);
 491         validateAbstractSubstitute();
 492     }
 493
 494
 495     @Test
 496     public void updVolumesNoConsolidationTest() throws Exception {
 497         loadInputAndOutputData(BASE_DIRECTORY + "updVolumes/noConsolidation");
 498
 499         UnifiedCompositionData data = createComputeUnifiedCompositionData(FSB1_template);
 500         List<Pair<String, String>> portTypeToIdList = new ArrayList<>();
 501         portTypeToIdList.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_1));
 502         portTypeToIdList.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_2));
 503         portTypeToIdList.add(new ImmutablePair<>(FSB1_OAM, FSB1_OAM));
 504         addPortDataToCompositionData(portTypeToIdList, data);
 505
 506         List<UnifiedCompositionData> unifiedCompositionDataList = new LinkedList<>();
 507         unifiedCompositionDataList.add(data);
 508
 509         Optional<ServiceTemplate> substitutionServiceTemplate = unifiedCompositionService
 510                 .createUnifiedSubstitutionServiceTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 511                         unifiedCompositionDataList
 512                         , context, ORG_OPENECOMP_RESOURCE_VFC_NODES_HEAT_FSB, null);
 513
 514         String substitutionNodeTypeId =
 515                 unifiedCompositionService.getSubstitutionNodeTypeId(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 516                         unifiedCompositionDataList.get(0), null, context);
 517         String nodeTemplateId = unifiedCompositionService.createAbstractSubstituteNodeTemplate(
 518                 inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), substitutionServiceTemplate.get(),
 519                 unifiedCompositionDataList, substitutionNodeTypeId,
 520                 context, null);
 521
 522         unifiedCompositionService
 523                 .updateCompositionConnectivity(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 524                         unifiedCompositionDataList, context);
 525         validateAbstractSubstitute();
 526     }
 527
 528
 529     @Test
 530     public void updVolumesWithConsolidationTest() throws Exception {
 531         loadInputAndOutputData(BASE_DIRECTORY + "updVolumes/consolidation");
 532         List<UnifiedCompositionData> unifiedCompositionDataList =
 533                 createAbstractSubstituteCompositionDataComputeAndPort();
 534         Optional<ServiceTemplate> substitutionServiceTemplate = unifiedCompositionService
 535                 .createUnifiedSubstitutionServiceTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 536                         unifiedCompositionDataList
 537                         , context, ORG_OPENECOMP_RESOURCE_VFC_NODES_HEAT_FSB, null);
 538
 539         String substitutionNodeTypeId =
 540                 unifiedCompositionService.getSubstitutionNodeTypeId(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 541                         unifiedCompositionDataList.get(0), null, context);
 542         String nodeTemplateId = unifiedCompositionService.createAbstractSubstituteNodeTemplate(
 543                 inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), substitutionServiceTemplate.get(),
 544                 unifiedCompositionDataList, substitutionNodeTypeId,
 545                 context, null);
 546
 547         unifiedCompositionService
 548                 .updateCompositionConnectivity(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 549                         unifiedCompositionDataList, context);
 550         validateAbstractSubstitute();
 551     }
 552
 553
 554     @Test
 555     public void updGroupsNoConsolidationTest() throws Exception {
 556         loadInputAndOutputData(BASE_DIRECTORY + "updGroupsConnectivity/noConsolidation");
 557         UnifiedCompositionData data = createComputeUnifiedCompositionData("server_smp1");
 558         List<Pair<String, String>> portTypeToIdList = new ArrayList<>();
 559         portTypeToIdList.add(new ImmutablePair<>(PORT, PORT_1));
 560         portTypeToIdList.add(new ImmutablePair<>(PORT, PORT_2));
 561         addPortDataToCompositionData(portTypeToIdList, data);
 562
 563         //Add groups
 564         List<String> computeGroupIdList =
 565                 TestUtils.getGroupsForNode(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), "server_smp1");
 566         data.getComputeTemplateConsolidationData().setGroupIds(computeGroupIdList);
 567
 568         List<UnifiedCompositionData> unifiedCompositionDataList = new LinkedList<>();
 569         unifiedCompositionDataList.add(data);
 570
 571         Optional<ServiceTemplate> substitutionServiceTemplate = unifiedCompositionService
 572                 .createUnifiedSubstitutionServiceTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 573                         unifiedCompositionDataList
 574                         , context, "org.openecomp.resource.abstract.nodes.smp", null);
 575
 576         String substitutionNodeTypeId =
 577                 unifiedCompositionService.getSubstitutionNodeTypeId(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 578                         unifiedCompositionDataList.get(0), null, context);
 579         String nodeTemplateId = unifiedCompositionService.createAbstractSubstituteNodeTemplate(
 580                 inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), substitutionServiceTemplate.get(),
 581                 unifiedCompositionDataList, substitutionNodeTypeId,
 582                 context, null);
 583
 584         unifiedCompositionService
 585                 .updateCompositionConnectivity(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 586                         unifiedCompositionDataList, context);
 587         validateAbstractSubstitute();
 588     }
 589
 590
 591     @Test
 592     public void updGroupsWithConsolidationTest() throws Exception {
 593         loadInputAndOutputData(BASE_DIRECTORY + "updGroupsConnectivity/consolidation");
 594
 595         List<UnifiedCompositionData> unifiedCompositionDataList =
 596                 createAbstractSubstituteCompositionDataComputeAndPort();
 597
 598         Optional<ServiceTemplate> substitutionServiceTemplate = unifiedCompositionService
 599                 .createUnifiedSubstitutionServiceTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 600                         unifiedCompositionDataList
 601                         , context, ORG_OPENECOMP_RESOURCE_VFC_NODES_HEAT_FSB, null);
 602
 603         String substitutionNodeTypeId =
 604                 unifiedCompositionService.getSubstitutionNodeTypeId(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 605                         unifiedCompositionDataList.get(0), null, context);
 606         String nodeTemplateId = unifiedCompositionService.createAbstractSubstituteNodeTemplate(
 607                 inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), substitutionServiceTemplate.get(),
 608                 unifiedCompositionDataList, substitutionNodeTypeId,
 609                 context, null);
 610
 611         unifiedCompositionService
 612                 .updateCompositionConnectivity(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 613                         unifiedCompositionDataList, context);
 614         validateAbstractSubstitute();
 615     }
 616
 617     @Test
 618     public void updOutParamGetAttrInNoConsolidationTest() throws Exception {
 619         List<Pair<String, String>> portTypeToIdList = new ArrayList<>();
 620         portTypeToIdList.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_1));
 621         portTypeToIdList.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_2));
 622         portTypeToIdList.add(new ImmutablePair<>(FSB1_OAM, FSB1_OAM));
 623
 624         loadInputAndOutputData(BASE_DIRECTORY + "updOutputGetAttrIn/noConsolidation");
 625         UnifiedCompositionData unifiedCompositionData =
 626                 createCompositionData(FSB1_template, portTypeToIdList);
 627         addOutputGetAttrInForComputeNoConsolidation(unifiedCompositionData);
 628         addOutputGetAttrInForPortNoConsolidation(unifiedCompositionData);
 629
 630         List<UnifiedCompositionData> unifiedCompositionDataList = new ArrayList<>();
 631         unifiedCompositionDataList.add(unifiedCompositionData);
 632         Mockito.doNothing().when(unifiedCompositionService).updNodesConnectedOutConnectivity
 633                 (inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), unifiedCompositionDataList, context);
 634         Mockito.doReturn(FSB1).when(context).getUnifiedAbstractNodeTemplateId(anyObject(),
 635                 anyString());
 636         unifiedCompositionService
 637                 .updateCompositionConnectivity(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 638                         unifiedCompositionDataList, context);
 639
 640         checkSTResults(expectedOutserviceTemplates, null, null, inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML));
 641     }
 642
 643     @Test
 644     public void updOutParamGetAttrInWithConsolidationTest() throws Exception {
 645         List<UnifiedCompositionData> unifiedCompositionDataList = new ArrayList<>();
 646         List<Pair<String, String>> portTypeToIdList1 = new ArrayList<>();
 647         portTypeToIdList1.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_1));
 648         portTypeToIdList1.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_2));
 649
 650         loadInputAndOutputData(BASE_DIRECTORY + "updOutputGetAttrIn/consolidation");
 651         UnifiedCompositionData unifiedCompositionData1 =
 652                 createCompositionData(FSB1_template, portTypeToIdList1);
 653         addOutputGetAttrInForCompute1WithConsolidation(unifiedCompositionData1);
 654         addOutputGetAttrInForPortWithConsolidation1(unifiedCompositionData1);
 655         unifiedCompositionDataList.add(unifiedCompositionData1);
 656
 657         List<Pair<String, String>> portTypeToIdList2 = new ArrayList<>();
 658         portTypeToIdList2.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_2));
 659         portTypeToIdList2.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_1));
 660
 661         UnifiedCompositionData unifiedCompositionData2 =
 662                 createCompositionData(FSB2_template, portTypeToIdList2);
 663         unifiedCompositionDataList.add(unifiedCompositionData2);
 664         addOutputGetAttrInForCompute2WithConsolidation(unifiedCompositionData2);
 665         addOutputGetAttrInForPortWithConsolidation2(unifiedCompositionData2);
 666
 667         Mockito.doNothing().when(unifiedCompositionService).updNodesConnectedOutConnectivity
 668                 (inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), unifiedCompositionDataList, context);
 669         Mockito.doReturn(FSB1).when(context).getUnifiedAbstractNodeTemplateId(anyObject(),
 670                 anyString());
 671
 672         unifiedCompositionService
 673                 .updateCompositionConnectivity(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 674                         unifiedCompositionDataList, context);
 675
 676         checkSTResults(expectedOutserviceTemplates, null, null, inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML));
 677     }
 678
 679     @Test
 680     public void updNodeGetAttrInNoConsolidationTest() throws Exception {
 681         List<Pair<String, String>> portTypeToIdList = new ArrayList<>();
 682         portTypeToIdList.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_1));
 683         portTypeToIdList.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_2));
 684         portTypeToIdList.add(new ImmutablePair<>(FSB1_OAM, FSB1_OAM));
 685
 686         loadInputAndOutputData(BASE_DIRECTORY + "updNodesGetAttrIn/noConsolidation");
 687         UnifiedCompositionData unifiedCompositionData =
 688                 createCompositionData(FSB1_template, portTypeToIdList);
 689         addGetAttrForCompute(unifiedCompositionData);
 690         addGetAttrForPort(unifiedCompositionData);
 691         addGetAttrForPortInnerUC(unifiedCompositionData);
 692
 693         List<UnifiedCompositionData> unifiedCompositionDataList = new ArrayList<>();
 694         unifiedCompositionDataList.add(unifiedCompositionData);
 695         Mockito.doNothing().when(unifiedCompositionService).updNodesConnectedOutConnectivity
 696                 (inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), unifiedCompositionDataList, context);
 697         Mockito.doReturn(FSB1).when(context).getUnifiedAbstractNodeTemplateId(anyObject(),
 698                 anyString());
 699         unifiedCompositionService
 700                 .updateCompositionConnectivity(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 701                         unifiedCompositionDataList, context);
 702
 703         checkSTResults(expectedOutserviceTemplates, null, null, inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML));
 704     }
 705
 706     @Test
 707     public void updNodeGetAttrInWithConsolidationTest() throws Exception {
 708         List<UnifiedCompositionData> unifiedCompositionDataList = new ArrayList<>();
 709         List<Pair<String, String>> portTypeToIdList1 = new ArrayList<>();
 710         portTypeToIdList1.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_1));
 711         portTypeToIdList1.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_2));
 712
 713         loadInputAndOutputData(BASE_DIRECTORY + "updNodesGetAttrIn/consolidation");
 714         UnifiedCompositionData unifiedCompositionData1 =
 715                 createCompositionData(FSB1_template, portTypeToIdList1);
 716         addGetAttrForCompute(unifiedCompositionData1);
 717         addGetAttrForPort(unifiedCompositionData1);
 718         unifiedCompositionDataList.add(unifiedCompositionData1);
 719
 720         List<Pair<String, String>> portTypeToIdList2 = new ArrayList<>();
 721         portTypeToIdList2.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_2));
 722         portTypeToIdList2.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_1));
 723
 724         UnifiedCompositionData unifiedCompositionData2 =
 725                 createCompositionData(FSB2_template, portTypeToIdList2);
 726         addGetAttrForCompute2(unifiedCompositionData2);
 727         addGetAttrForPort2(unifiedCompositionData2);
 728         unifiedCompositionDataList.add(unifiedCompositionData2);
 729
 730
 731         Mockito.doNothing().when(unifiedCompositionService).updNodesConnectedOutConnectivity
 732                 (inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), unifiedCompositionDataList, context);
 733         Mockito.doReturn(FSB1).when(context).getUnifiedAbstractNodeTemplateId(anyObject(),
 734                 anyString());
 735
 736         unifiedCompositionService
 737                 .updateCompositionConnectivity(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 738                         unifiedCompositionDataList, context);
 739
 740         checkSTResults(expectedOutserviceTemplates, null, null, inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML));
 741     }
 742
 743
 744     @Test
 745     public void updNodesGetAttrFromInnerNodesTest() throws Exception {
 746         List<Pair<String, String>> portTypeToIdList = new ArrayList<>();
 747         portTypeToIdList.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_1));
 748         portTypeToIdList.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_2));
 749         portTypeToIdList.add(new ImmutablePair<>(FSB1_OAM, FSB1_OAM));
 750
 751         loadInputAndOutputData(BASE_DIRECTORY +
 752                 "creSubstitutionServiceTemplate/updNodesGetAttrInFromInnerNodes/noConsolidation");
 753         UnifiedCompositionData unifiedCompositionData =
 754                 createCompositionData(FSB1_template, portTypeToIdList);
 755         addGetAttrForCompute(unifiedCompositionData);
 756         addGetAttrForPort(unifiedCompositionData);
 757         addGetAttrForPortInnerUC(unifiedCompositionData);
 758         List<UnifiedCompositionData> unifiedCompositionDataList = new ArrayList<>();
 759         unifiedCompositionDataList.add(unifiedCompositionData);
 760
 761         Mockito.doReturn(FSB1).when(context).getUnifiedAbstractNodeTemplateId(anyObject(),
 762                 anyString());
 763
 764         Optional<ServiceTemplate> substitutionServiceTemplate = unifiedCompositionService
 765                 .createUnifiedSubstitutionServiceTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 766                         unifiedCompositionDataList,
 767                         context, ORG_OPENECOMP_RESOURCE_ABSTRACT_NODES_FSB1, null);
 768         assertEquals(true, substitutionServiceTemplate.isPresent());
 769         substitutionServiceTemplate
 770                 .ifPresent(
 771                         subServiceTemplate -> checkSTResults(expectedOutserviceTemplates,
 772                                 subServiceTemplate, context.getGlobalSubstitutionServiceTemplate(), null));
 773     }
 774
 775
 776     @Test
 777     public void updNodesGetAttrFromConsolidationNodesTest() throws Exception {
 778         List<UnifiedCompositionData> unifiedCompositionDataList = new ArrayList<>();
 779         List<Pair<String, String>> portTypeToIdList1 = new ArrayList<>();
 780         portTypeToIdList1.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_1));
 781         portTypeToIdList1.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_2));
 782
 783         loadInputAndOutputData(BASE_DIRECTORY +
 784                 "creSubstitutionServiceTemplate/updNodesGetAttrInFromInnerNodes/consolidation");
 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_INTERNAL_2));
 793         portTypeToIdList2.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_1));
 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(MAIN_SERVICE_TEMPLATE_YAML),
 803                         unifiedCompositionDataList,
 804                         context, ORG_OPENECOMP_RESOURCE_ABSTRACT_NODES_FSB1, 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         List<Pair<String, String>> portTypeToIdList = new ArrayList<>();
 815         portTypeToIdList.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_1));
 816         portTypeToIdList.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_2));
 817         portTypeToIdList.add(new ImmutablePair<>("FSB_OAM", FSB1_OAM));
 818
 819         loadInputAndOutputData(BASE_DIRECTORY + "cleanMainSt/noConsolidation");
 820         UnifiedCompositionData unifiedCompositionData =
 821                 createCompositionData(FSB1_template, portTypeToIdList);
 822         addGetAttrForCompute(unifiedCompositionData);
 823         addGetAttrForPort(unifiedCompositionData);
 824
 825         List<UnifiedCompositionData> unifiedCompositionDataList = new ArrayList<>();
 826         unifiedCompositionDataList.add(unifiedCompositionData);
 827
 828         NodeTemplate abstractNodeTemplate = getMockNode(
 829                 BASE_DIRECTORY + "cleanMainSt/mockAbstractNodeTemplate.yaml");
 830         inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML).getTopology_template().getNode_templates()
 831                 .put(FSB1, abstractNodeTemplate);
 832
 833         Mockito.doReturn(FSB1).when(context).getUnifiedAbstractNodeTemplateId(anyObject(),
 834                 anyString());
 835
 836         unifiedCompositionService.
 837                 cleanUnifiedCompositionEntities(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 838                         unifiedCompositionDataList, context);
 839
 840         checkSTResults(expectedOutserviceTemplates, null, null, inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML));
 841     }
 842
 843     @Test
 844     public void cleanMainServiceTemplateTestWithConsolidation() throws IOException {
 845         loadInputAndOutputData(BASE_DIRECTORY + "cleanMainSt/consolidation");
 846
 847         List<UnifiedCompositionData> unifiedCompositionDataList = new ArrayList<>();
 848         List<Pair<String, String>> portTypeToIdList1 = new ArrayList<>();
 849         portTypeToIdList1.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_1));
 850         portTypeToIdList1.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_2));
 851
 852         UnifiedCompositionData unifiedCompositionData1 =
 853                 createCompositionData(FSB1_template, portTypeToIdList1);
 854         addOutputGetAttrInForCompute1WithConsolidation(unifiedCompositionData1);
 855         addOutputGetAttrInForPortWithConsolidation1(unifiedCompositionData1);
 856         unifiedCompositionDataList.add(unifiedCompositionData1);
 857
 858         List<Pair<String, String>> portTypeToIdList2 = new ArrayList<>();
 859         portTypeToIdList2.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_2));
 860         portTypeToIdList2.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_1));
 861
 862         UnifiedCompositionData unifiedCompositionData2 =
 863                 createCompositionData(FSB2_template, portTypeToIdList2);
 864         addOutputGetAttrInForCompute2WithConsolidation(unifiedCompositionData2);
 865         addOutputGetAttrInForPortWithConsolidation2(unifiedCompositionData2);
 866         unifiedCompositionDataList.add(unifiedCompositionData2);
 867
 868         NodeTemplate abstractNodeTemplate = getMockNode(
 869                 BASE_DIRECTORY + "cleanMainSt/mockAbstractNodeTemplate.yaml");
 870         inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML).getTopology_template().getNode_templates()
 871                 .put(FSB1, abstractNodeTemplate);
 872
 873         Mockito.doReturn(FSB1).when(context).getUnifiedAbstractNodeTemplateId(anyObject(),
 874                 anyString());
 875
 876         unifiedCompositionService.
 877                 cleanUnifiedCompositionEntities(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
 878                         unifiedCompositionDataList, context);
 879
 880         checkSTResults(expectedOutserviceTemplates, null, null, inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML));
 881     }
 882
 883     @Test
 884     public void updateNewAbstractNodeTemplateNoConsolidation() throws IOException {
 885         loadInputAndOutputData(BASE_DIRECTORY + "fixNewAbstractNodeTemplate/noConsolidation");
 886
 887         List<Pair<String, String>> portTypeToIdList = new ArrayList<>();
 888         portTypeToIdList.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_1));
 889         portTypeToIdList.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_2));
 890
 891         NodeTemplate cleanedComputeNodeTemplate =
 892                 getMockNode(
 893                         BASE_DIRECTORY + "fixNewAbstractNodeTemplate/mockComputeNodeTemplate.yaml");
 894
 895
 896         context.setConsolidationData(
 897                 createConsolidationData(Collections.singletonList(FSB1_template), portTypeToIdList));
 898         context.addCleanedNodeTemplate(MAIN_SERVICE_TEMPLATE_YAML, FSB1_template,
 899                 UnifiedCompositionEntity.COMPUTE, cleanedComputeNodeTemplate);
 900         context.addCleanedNodeTemplate(MAIN_SERVICE_TEMPLATE_YAML, FSB1_INTERNAL_1,
 901                 UnifiedCompositionEntity.PORT, cleanedComputeNodeTemplate);
 902         context.addCleanedNodeTemplate(MAIN_SERVICE_TEMPLATE_YAML, FSB1_INTERNAL_2,
 903                 UnifiedCompositionEntity.PORT, cleanedComputeNodeTemplate);
 904
 905         setUnifiedCompositionData(Arrays.asList(FSB1_template, FSB1_INTERNAL_1, FSB1_INTERNAL_2));
 906
 907         unifiedCompositionService
 908                 .updateUnifiedAbstractNodesConnectivity(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), context);
 909
 910         checkSTResults(expectedOutserviceTemplates, null, null, inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML));
 911     }
 912
 913     @Test
 914     public void updateNewAbstractNodeTemplateWithConsolidation() throws IOException {
 915         loadInputAndOutputData(BASE_DIRECTORY + "fixNewAbstractNodeTemplate/consolidation");
 916
 917         List<Pair<String, String>> portTypeToIdList = new ArrayList<>();
 918         portTypeToIdList.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_1));
 919         portTypeToIdList.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_1));
 920
 921         NodeTemplate cleanedComputeNodeTemplate =
 922                 getMockNode(
 923                         BASE_DIRECTORY + "fixNewAbstractNodeTemplate/mockComputeNodeTemplate.yaml");
 924
 925
 926         context.setConsolidationData(
 927                 createConsolidationData(Arrays.asList("FSB1_template_1", "FSB1_template_2"),
 928                         portTypeToIdList));
 929         context.addCleanedNodeTemplate(MAIN_SERVICE_TEMPLATE_YAML, "FSB1_template_1",
 930                 UnifiedCompositionEntity.COMPUTE, cleanedComputeNodeTemplate);
 931         context.addCleanedNodeTemplate(MAIN_SERVICE_TEMPLATE_YAML, "FSB1_template_2",
 932                 UnifiedCompositionEntity.COMPUTE, cleanedComputeNodeTemplate);
 933         context.addCleanedNodeTemplate(MAIN_SERVICE_TEMPLATE_YAML, FSB1_INTERNAL_1,
 934                 UnifiedCompositionEntity.PORT, cleanedComputeNodeTemplate);
 935         context.addCleanedNodeTemplate(MAIN_SERVICE_TEMPLATE_YAML, FSB2_INTERNAL_1,
 936                 UnifiedCompositionEntity.PORT, cleanedComputeNodeTemplate);
 937
 938         setUnifiedCompositionData(
 939                 Arrays.asList("FSB1_template_1", "FSB1_template_2", FSB1_INTERNAL_1, FSB2_INTERNAL_1));
 940
 941         unifiedCompositionService
 942                 .updateUnifiedAbstractNodesConnectivity(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), context);
 943
 944         checkSTResults(expectedOutserviceTemplates, null, null, inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML));
 945     }
 946
 947     @Test
 948     public void testUnifiedNestedCompositionOneComputeInNested() throws IOException {
 949         loadInputAndOutputData(BASE_DIRECTORY + "pattern4/oneNestedNode");
 950
 951         ConsolidationData consolidationData = new ConsolidationData();
 952         String nestedFileName = "nested-pcm_v0.1ServiceTemplate.yaml";
 953         TestUtils.updateNestedConsolidationData(MAIN_SERVICE_TEMPLATE_YAML, Collections.singletonList("server_pcm_001"),
 954                 consolidationData);
 955
 956         TestUtils.initComputeNodeTypeInConsolidationData(nestedFileName,
 957                 "org.openecomp.resource.vfc.nodes.heat.pcm_server", consolidationData);
 958         TestUtils.initComputeNodeTemplateIdInConsolidationData(nestedFileName,
 959                 "org.openecomp.resource.vfc.nodes.heat.pcm_server", "server_pcm", consolidationData);
 960
 961         context.setConsolidationData(consolidationData);
 962         context.getTranslatedServiceTemplates()
 963                 .put(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME,
 964                         inputServiceTemplates.get(GLOBAL_SUBSTITUTION_TYPES_SERVICE_TEMPLATE_YAML));
 965         context.getTranslatedServiceTemplates()
 966                 .put(nestedFileName, inputServiceTemplates.get(nestedFileName));
 967         context.getTranslatedServiceTemplates()
 968                 .put(MAIN_SERVICE_TEMPLATE_YAML, inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML));
 969
 970     UnifiedCompositionData unifiedComposition = createUnifiedCompositionOnlyNested("server_pcm_001");
 971     UnifiedCompositionTo unifiedCompositionTo = new UnifiedCompositionTo(
 972         inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), inputServiceTemplates.get(nestedFileName), null,
 973         context, null);
 974     unifiedCompositionService.handleUnifiedNestedDefinition(unifiedCompositionTo, unifiedComposition);
 975
 976         checkSTResults(expectedOutserviceTemplates, nestedFileName,
 977                 context.getTranslatedServiceTemplates().get(nestedFileName),
 978                 context.getTranslatedServiceTemplates()
 979                         .get(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME), null);
 980     }
 981
 982     @Test
 983     public void testTwoNestedWithOneCompute() throws IOException {
 984         loadInputAndOutputData(BASE_DIRECTORY + "pattern4/twoNestedWithOneCompute");
 985
 986         ConsolidationData consolidationData = new ConsolidationData();
 987         String nestedFileName1 = "nested-pcm_v0.1ServiceTemplate.yaml";
 988         String nestedFileName2 = "nested-oam_v0.1ServiceTemplate.yaml";
 989
 990         TestUtils.updateNestedConsolidationData(MAIN_SERVICE_TEMPLATE_YAML,
 991                 Arrays.asList("server_pcm_001", "server_oam_001"), consolidationData);
 992
 993         TestUtils.initComputeNodeTypeInConsolidationData(nestedFileName1,
 994                 "org.openecomp.resource.vfc.nodes.heat.pcm_server", consolidationData);
 995         TestUtils.initComputeNodeTemplateIdInConsolidationData(nestedFileName1,
 996                 "org.openecomp.resource.vfc.nodes.heat.pcm_server", "server_pcm", consolidationData);
 997         TestUtils.initComputeNodeTypeInConsolidationData(nestedFileName2,
 998                 "org.openecomp.resource.vfc.nodes.heat.oam_server", consolidationData);
 999         TestUtils.initComputeNodeTemplateIdInConsolidationData(nestedFileName2,
1000                 "org.openecomp.resource.vfc.nodes.heat.oam_server", "server_oam", consolidationData);
1001
1002         context.setConsolidationData(consolidationData);
1003         context.getTranslatedServiceTemplates()
1004                 .put(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME,
1005                         inputServiceTemplates.get(GLOBAL_SUBSTITUTION_TYPES_SERVICE_TEMPLATE_YAML));
1006         context.getTranslatedServiceTemplates()
1007                 .put(nestedFileName1, inputServiceTemplates.get(nestedFileName1));
1008         context.getTranslatedServiceTemplates()
1009                 .put(nestedFileName2, inputServiceTemplates.get(nestedFileName2));
1010         context.getTranslatedServiceTemplates()
1011                 .put(MAIN_SERVICE_TEMPLATE_YAML, inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML));
1012
1013     UnifiedCompositionData unifiedComposition =
1014         createUnifiedCompositionOnlyNested("server_pcm_001");
1015     UnifiedCompositionTo unifiedCompositionTo1 = new UnifiedCompositionTo(inputServiceTemplates
1016         .get(MAIN_SERVICE_TEMPLATE_YAML), inputServiceTemplates.get(nestedFileName1), null,
1017         context, null);
1018     unifiedCompositionService.handleUnifiedNestedDefinition(unifiedCompositionTo1, unifiedComposition);
1019     unifiedComposition = createUnifiedCompositionOnlyNested("server_oam_001");
1020     UnifiedCompositionTo unifiedCompositionTo2 = new UnifiedCompositionTo(inputServiceTemplates
1021         .get(MAIN_SERVICE_TEMPLATE_YAML), inputServiceTemplates.get(nestedFileName2), null,
1022         context, null);
1023     unifiedCompositionService.handleUnifiedNestedDefinition(unifiedCompositionTo2, unifiedComposition);
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_Port_1"));
1146         portTypeToIdList.add(new ImmutablePair<>("VMI", "VMI_1"));
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_INTERNAL_1);
1352         ImmutablePair<String, String> portTypePair2 = new ImmutablePair<>(FSB2_INTERNAL,
1353                 FSB2_INTERNAL_1);
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_INTERNAL_2));
1360         portTypeToIdList.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_2));
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_INTERNAL_1)) {
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_INTERNAL_2)) {
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_INTERNAL_1)) {
1479                 addGetAttInUnifiedCompositionData(portTemplateConsolidationData, VOLUME_TYPE,
1480                         TENANT_ID, CMAUI_VOLUME3);
1481             } else if (portTemplateConsolidationData.getNodeTemplateId().equals(FSB1_INTERNAL_2)) {
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_INTERNAL_1)) {
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_INTERNAL_1)) {
1555                 addOutputGetAttInUnifiedCompositionData(portTemplateConsolidationData, COMPLEX_OUTPUT2,
1556                         DEVICE_OWNER);
1557                 addOutputGetAttInUnifiedCompositionData(portTemplateConsolidationData, COMPLEX_OUTPUT3,
1558                         DEVICE_OWNER);
1559             } else if (portTemplateConsolidationData.getNodeTemplateId().equals(FSB2_INTERNAL_2)) {
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_INTERNAL_2)) {
1574                 addOutputGetAttInUnifiedCompositionData(portTemplateConsolidationData, COMPLEX_OUTPUT1,
1575                         TENANT_ID);
1576             } else if (portTemplateConsolidationData.getNodeTemplateId().equals(FSB1_INTERNAL_1)) {
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_INTERNAL_1)) {
1588                 addOutputGetAttInUnifiedCompositionData(portTemplateConsolidationData, COMPLEX_OUTPUT2,
1589                         USER_DATA_FORMAT);
1590             } else if (portTemplateConsolidationData.getNodeTemplateId().equals(FSB1_INTERNAL_2)) {
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 }