gerrit.onap Code Review - sdc.git/blob

   1 /*
   2  * Copyright © 2016-2018 European Support Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.openecomp.sdc.translator.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     @Ignore
 948     public void testThreeNovaOfSameTypePreConditionFalse() throws IOException {
 949         loadInputAndOutputData(BASE_DIRECTORY + "pattern1b/noConsolidation");
 950
 951         List<UnifiedCompositionData> unifiedCompositionDataList = new ArrayList<>();
 952         List<Pair<String, String>> portTypeToIdList1 = new ArrayList<>();
 953         portTypeToIdList1.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_1));
 954         portTypeToIdList1.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_2));
 955
 956         UnifiedCompositionData unifiedCompositionData1 =
 957                 createCompositionData(FSB1_template, portTypeToIdList1);
 958         addOutputGetAttrInForCompute1WithConsolidation(unifiedCompositionData1);
 959         addOutputGetAttrInForPortWithConsolidation1(unifiedCompositionData1);
 960         unifiedCompositionDataList.add(unifiedCompositionData1);
 961
 962         UnifiedCompositionData unifiedCompositionData2 =
 963                 createCompositionData(FSB2_template, portTypeToIdList1);
 964         addOutputGetAttrInForCompute1WithConsolidation(unifiedCompositionData2);
 965         addOutputGetAttrInForPortWithConsolidation1(unifiedCompositionData2);
 966         unifiedCompositionDataList.add(unifiedCompositionData2);
 967
 968         portTypeToIdList1.remove(1);
 969         UnifiedCompositionData unifiedCompositionData3 =
 970                 createCompositionData(FSB3_template, portTypeToIdList1);
 971         addOutputGetAttrInForCompute1WithConsolidation(unifiedCompositionData3);
 972         addOutputGetAttrInForPortWithConsolidation1(unifiedCompositionData3);
 973         unifiedCompositionDataList.add(unifiedCompositionData3);
 974
 975         UnifiedCompositionSingleSubstitution unifiedCompositionSingleSubstitution =
 976                 new UnifiedCompositionSingleSubstitution();
 977         unifiedCompositionSingleSubstitution
 978                 .createUnifiedComposition(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), null,
 979                         unifiedCompositionDataList, context);
 980
 981         checkSTResults(expectedOutserviceTemplates, null, null, inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML));
 982     }
 983
 984     @Test
 985     public void testUnifiedNestedCompositionOneComputeInNested() throws IOException {
 986         loadInputAndOutputData(BASE_DIRECTORY + "pattern4/oneNestedNode");
 987
 988         ConsolidationData consolidationData = new ConsolidationData();
 989         String nestedFileName = "nested-pcm_v0.1ServiceTemplate.yaml";
 990         TestUtils.updateNestedConsolidationData(MAIN_SERVICE_TEMPLATE_YAML, Collections.singletonList("server_pcm_001"),
 991                 consolidationData);
 992
 993         TestUtils.initComputeNodeTypeInConsolidationData(nestedFileName,
 994                 "org.openecomp.resource.vfc.nodes.heat.pcm_server", consolidationData);
 995         TestUtils.initComputeNodeTemplateIdInConsolidationData(nestedFileName,
 996                 "org.openecomp.resource.vfc.nodes.heat.pcm_server", "server_pcm", consolidationData);
 997
 998         context.setConsolidationData(consolidationData);
 999         context.getTranslatedServiceTemplates()
1000                 .put(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME,
1001                         inputServiceTemplates.get(GLOBAL_SUBSTITUTION_TYPES_SERVICE_TEMPLATE_YAML));
1002         context.getTranslatedServiceTemplates()
1003                 .put(nestedFileName, inputServiceTemplates.get(nestedFileName));
1004         context.getTranslatedServiceTemplates()
1005                 .put(MAIN_SERVICE_TEMPLATE_YAML, inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML));
1006
1007     UnifiedCompositionData unifiedComposition = createUnifiedCompositionOnlyNested("server_pcm_001");
1008     UnifiedCompositionTo unifiedCompositionTo = new UnifiedCompositionTo(
1009         inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), inputServiceTemplates.get(nestedFileName), null,
1010         context);
1011     unifiedCompositionService.handleUnifiedNestedDefinition(unifiedCompositionTo, unifiedComposition);
1012
1013         checkSTResults(expectedOutserviceTemplates, nestedFileName,
1014                 context.getTranslatedServiceTemplates().get(nestedFileName),
1015                 context.getTranslatedServiceTemplates()
1016                         .get(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME), null);
1017     }
1018
1019     @Test
1020     public void testTwoNestedWithOneCompute() throws IOException {
1021         loadInputAndOutputData(BASE_DIRECTORY + "pattern4/twoNestedWithOneCompute");
1022
1023         ConsolidationData consolidationData = new ConsolidationData();
1024         String nestedFileName1 = "nested-pcm_v0.1ServiceTemplate.yaml";
1025         String nestedFileName2 = "nested-oam_v0.1ServiceTemplate.yaml";
1026
1027         TestUtils.updateNestedConsolidationData(MAIN_SERVICE_TEMPLATE_YAML,
1028                 Arrays.asList("server_pcm_001", "server_oam_001"), consolidationData);
1029
1030         TestUtils.initComputeNodeTypeInConsolidationData(nestedFileName1,
1031                 "org.openecomp.resource.vfc.nodes.heat.pcm_server", consolidationData);
1032         TestUtils.initComputeNodeTemplateIdInConsolidationData(nestedFileName1,
1033                 "org.openecomp.resource.vfc.nodes.heat.pcm_server", "server_pcm", consolidationData);
1034         TestUtils.initComputeNodeTypeInConsolidationData(nestedFileName2,
1035                 "org.openecomp.resource.vfc.nodes.heat.oam_server", consolidationData);
1036         TestUtils.initComputeNodeTemplateIdInConsolidationData(nestedFileName2,
1037                 "org.openecomp.resource.vfc.nodes.heat.oam_server", "server_oam", consolidationData);
1038
1039         context.setConsolidationData(consolidationData);
1040         context.getTranslatedServiceTemplates()
1041                 .put(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME,
1042                         inputServiceTemplates.get(GLOBAL_SUBSTITUTION_TYPES_SERVICE_TEMPLATE_YAML));
1043         context.getTranslatedServiceTemplates()
1044                 .put(nestedFileName1, inputServiceTemplates.get(nestedFileName1));
1045         context.getTranslatedServiceTemplates()
1046                 .put(nestedFileName2, inputServiceTemplates.get(nestedFileName2));
1047         context.getTranslatedServiceTemplates()
1048                 .put(MAIN_SERVICE_TEMPLATE_YAML, inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML));
1049
1050     UnifiedCompositionData unifiedComposition =
1051         createUnifiedCompositionOnlyNested("server_pcm_001");
1052     UnifiedCompositionTo unifiedCompositionTo1 = new UnifiedCompositionTo(inputServiceTemplates
1053         .get(MAIN_SERVICE_TEMPLATE_YAML), inputServiceTemplates.get(nestedFileName1), null, context);
1054     unifiedCompositionService.handleUnifiedNestedDefinition(unifiedCompositionTo1, unifiedComposition);
1055     unifiedComposition = createUnifiedCompositionOnlyNested("server_oam_001");
1056     UnifiedCompositionTo unifiedCompositionTo2 = new UnifiedCompositionTo(inputServiceTemplates
1057         .get(MAIN_SERVICE_TEMPLATE_YAML), inputServiceTemplates.get(nestedFileName2), null, context);
1058     unifiedCompositionService.handleUnifiedNestedDefinition(unifiedCompositionTo2, unifiedComposition);
1059
1060         checkSTResults(expectedOutserviceTemplates, nestedFileName1,
1061                 context.getTranslatedServiceTemplates().get(nestedFileName1),
1062                 context.getTranslatedServiceTemplates()
1063                         .get(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME), null);
1064         checkSTResults(expectedOutserviceTemplates, nestedFileName2,
1065                 context.getTranslatedServiceTemplates().get(nestedFileName2),
1066                 null, null);
1067     }
1068
1069     @Test
1070     public void testNestedCompositionNodesConnectedIn() throws IOException {
1071         loadInputAndOutputData(BASE_DIRECTORY + "pattern4/nestedNodesConnectedIn");
1072         ConsolidationData consolidationData = new ConsolidationData();
1073         String nestedFileName = "nested-pcm_v0.1ServiceTemplate.yaml";
1074         TestUtils.updateNestedConsolidationData(MAIN_SERVICE_TEMPLATE_YAML, Collections.singletonList("server_pcm_001"),
1075                 consolidationData);
1076         context.getTranslatedServiceTemplates()
1077                 .put(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME,
1078                         inputServiceTemplates.get(GLOBAL_SUBSTITUTION_TYPES_SERVICE_TEMPLATE_YAML));
1079         context.getTranslatedServiceTemplates()
1080                 .put(nestedFileName, inputServiceTemplates.get(nestedFileName));
1081         context.getTranslatedServiceTemplates()
1082                 .put(MAIN_SERVICE_TEMPLATE_YAML, inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML));
1083         context.addUnifiedNestedNodeTemplateId(MAIN_SERVICE_TEMPLATE_YAML, "server_pcm_001", "abstract_pcm_server_0");
1084
1085         Map<String, List<RequirementAssignmentData>> nodeConnectedInList =
1086                 TestUtils.getNodeConnectedInList("server_pcm_001", inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
1087                         DEPENDENCY);
1088         UnifiedCompositionData unifiedComposition =
1089                 createUnifiedCompositionOnlyNested("server_pcm_001");
1090         unifiedComposition.getNestedTemplateConsolidationData()
1091                 .setNodesConnectedIn(nodeConnectedInList);
1092
1093         unifiedCompositionService.updNestedCompositionNodesConnectedInConnectivity
1094                 (inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), unifiedComposition, context);
1095         checkSTResults(expectedOutserviceTemplates, nestedFileName,
1096                 context.getTranslatedServiceTemplates().get(nestedFileName),
1097                 context.getTranslatedServiceTemplates()
1098                         .get(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME), context
1099                         .getTranslatedServiceTemplates().get(MAIN_SERVICE_TEMPLATE_YAML));
1100     }
1101
1102
1103     @Test
1104     public void testNestedCompositionNodesGetAttrIn() throws IOException {
1105         loadInputAndOutputData(BASE_DIRECTORY + "pattern4/nestedNodesGetAttrIn");
1106         ConsolidationData consolidationData = new ConsolidationData();
1107         String nestedFileName = "nested-pcm_v0.1ServiceTemplate.yaml";
1108         TestUtils.updateNestedConsolidationData(MAIN_SERVICE_TEMPLATE_YAML, Collections.singletonList("server_pcm_001"),
1109                 consolidationData);
1110         context.getTranslatedServiceTemplates()
1111                 .put(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME,
1112                         inputServiceTemplates.get(GLOBAL_SUBSTITUTION_TYPES_SERVICE_TEMPLATE_YAML));
1113         context.getTranslatedServiceTemplates()
1114                 .put(nestedFileName, inputServiceTemplates.get(nestedFileName));
1115         context.getTranslatedServiceTemplates()
1116                 .put(MAIN_SERVICE_TEMPLATE_YAML, inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML));
1117         context.addUnifiedNestedNodeTemplateId(MAIN_SERVICE_TEMPLATE_YAML, "server_pcm_001", "abstract_pcm_server_0");
1118
1119         Map<String, List<RequirementAssignmentData>> nodeConnectedInList =
1120                 TestUtils.getNodeConnectedInList("server_pcm_001", inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
1121                         DEPENDENCY);
1122         UnifiedCompositionData unifiedComposition =
1123                 createUnifiedCompositionOnlyNested("server_pcm_001");
1124         addGetAttInUnifiedCompositionData(unifiedComposition
1125                 .getNestedTemplateConsolidationData(), TENANT_ID, "oam_net_gw", "packet_mirror_network");
1126         addGetAttInUnifiedCompositionData(unifiedComposition
1127                         .getNestedTemplateConsolidationData(), USER_DATA_FORMAT, "oam_net_gw",
1128                 "server_compute_get_attr_test");
1129         addGetAttInUnifiedCompositionData(unifiedComposition
1130                         .getNestedTemplateConsolidationData(), "metadata", "server_pcm_id",
1131                 "server_compute_get_attr_test");
1132         unifiedCompositionService.updNestedCompositionNodesGetAttrInConnectivity
1133                 (inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), unifiedComposition, context);
1134         checkSTResults(expectedOutserviceTemplates, nestedFileName,
1135                 context.getTranslatedServiceTemplates().get(nestedFileName),
1136                 context.getTranslatedServiceTemplates()
1137                         .get(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME), context
1138                         .getTranslatedServiceTemplates().get(MAIN_SERVICE_TEMPLATE_YAML));
1139     }
1140
1141     @Test
1142     public void testNestedCompositionOutputParamGetAttrIn() throws IOException {
1143         loadInputAndOutputData(BASE_DIRECTORY + "pattern4/nestedOutputParamGetAttrIn");
1144         ConsolidationData consolidationData = new ConsolidationData();
1145         String nestedFileName = "nested-pcm_v0.1ServiceTemplate.yaml";
1146         TestUtils.updateNestedConsolidationData(MAIN_SERVICE_TEMPLATE_YAML, Collections.singletonList("server_pcm_001"),
1147                 consolidationData);
1148         context.getTranslatedServiceTemplates()
1149                 .put(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME,
1150                         inputServiceTemplates.get(GLOBAL_SUBSTITUTION_TYPES_SERVICE_TEMPLATE_YAML));
1151         context.getTranslatedServiceTemplates()
1152                 .put(nestedFileName, inputServiceTemplates.get(nestedFileName));
1153         context.getTranslatedServiceTemplates()
1154                 .put(MAIN_SERVICE_TEMPLATE_YAML, inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML));
1155         context.addUnifiedNestedNodeTemplateId(MAIN_SERVICE_TEMPLATE_YAML, "server_pcm_001", "abstract_pcm_server_0");
1156
1157         Map<String, List<RequirementAssignmentData>> nodeConnectedInList =
1158                 TestUtils.getNodeConnectedInList("server_pcm_001", inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
1159                         DEPENDENCY);
1160         UnifiedCompositionData unifiedComposition =
1161                 createUnifiedCompositionOnlyNested("server_pcm_001");
1162         addOutputGetAttInUnifiedCompositionData(unifiedComposition
1163                 .getNestedTemplateConsolidationData(), "output_attr_1", ACCESS_IPv4);
1164         addOutputGetAttInUnifiedCompositionData(unifiedComposition
1165                 .getNestedTemplateConsolidationData(), "output_attr_2", ACCESS_IPv6);
1166         unifiedCompositionService.updNestedCompositionOutputParamGetAttrInConnectivity
1167                 (inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), unifiedComposition, context);
1168         checkSTResults(expectedOutserviceTemplates, nestedFileName,
1169                 context.getTranslatedServiceTemplates().get(nestedFileName),
1170                 context.getTranslatedServiceTemplates()
1171                         .get(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME), context
1172                         .getTranslatedServiceTemplates().get(MAIN_SERVICE_TEMPLATE_YAML));
1173     }
1174
1175     @Test
1176     public void testInputOutputParameterType() throws IOException{
1177         loadInputAndOutputData(BASE_DIRECTORY + "inputoutputparamtype");
1178         ConsolidationData consolidationData = new ConsolidationData();
1179         List<Pair<String, String>> portTypeToIdList = new ArrayList<>();
1180         portTypeToIdList.add(new ImmutablePair<>("FSB1_Port", "FSB1_Port_1"));
1181         portTypeToIdList.add(new ImmutablePair<>("VMI", "VMI_1"));
1182
1183         UnifiedCompositionData unifiedCompositionData = createCompositionData(FSB1, portTypeToIdList);
1184
1185         Map<String, NodeTemplate> nodeTemplates =
1186                 inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML).getTopology_template().getNode_templates();
1187         for (Map.Entry<String, NodeTemplate> nodeTemplateEntry : nodeTemplates.entrySet() ) {
1188             String nodeTemplateId = nodeTemplateEntry.getKey();
1189             if (nodeTemplateId.equals("cmaui_volume_test_compute_properties")) {
1190                 Map<String, List<GetAttrFuncData>> nodesGetAttrIn =
1191                         TestUtils.getNodesGetAttrIn(nodeTemplateEntry.getValue(), nodeTemplateId);
1192                 unifiedCompositionData.getComputeTemplateConsolidationData()
1193                         .setNodesGetAttrIn(nodesGetAttrIn);
1194             }
1195
1196             if (nodeTemplateId.equals("cmaui_volume_test_neutron_port_properties")) {
1197                 Map<String, List<GetAttrFuncData>> nodesGetAttrIn =
1198                         TestUtils.getNodesGetAttrIn(nodeTemplateEntry.getValue(), nodeTemplateId);
1199                 unifiedCompositionData.getPortTemplateConsolidationDataList().get(0)
1200                         .setNodesGetAttrIn(nodesGetAttrIn);
1201             }
1202
1203             if (nodeTemplateId.equals("cmaui_volume_test_contrailv2_VMI_properties")) {
1204                 Map<String, List<GetAttrFuncData>> nodesGetAttrIn =
1205                         TestUtils.getNodesGetAttrIn(nodeTemplateEntry.getValue(), nodeTemplateId);
1206                 unifiedCompositionData.getPortTemplateConsolidationDataList().get(1)
1207                         .setNodesGetAttrIn(nodesGetAttrIn);
1208             }
1209         }
1210
1211         List<UnifiedCompositionData> unifiedCompositionDataList = new LinkedList<>();
1212         unifiedCompositionDataList.add(unifiedCompositionData);
1213
1214         UnifiedCompositionSingleSubstitution unifiedCompositionSingleSubstitution =
1215                 new UnifiedCompositionSingleSubstitution();
1216         unifiedCompositionSingleSubstitution
1217                 .createUnifiedComposition(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), null,
1218                         unifiedCompositionDataList, context);
1219         checkSTResults(expectedOutserviceTemplates, null, null, inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML));
1220         System.out.println();
1221
1222     }
1223
1224
1225     private UnifiedCompositionData createUnifiedCompositionOnlyNested(
1226             String nestedNodeTemplateId) {
1227         NestedTemplateConsolidationData nestedTemplateConsolidationData =
1228                 new NestedTemplateConsolidationData();
1229         nestedTemplateConsolidationData.setNodeTemplateId(nestedNodeTemplateId);
1230         UnifiedCompositionData unifiedCompositionData = new UnifiedCompositionData();
1231         unifiedCompositionData.setNestedTemplateConsolidationData(nestedTemplateConsolidationData);
1232         return unifiedCompositionData;
1233     }
1234
1235     private void setUnifiedCompositionData(List<String> nodeTemplateIds) {
1236         UnifiedSubstitutionData unifiedSubstitutionData =
1237                 context.getUnifiedSubstitutionData().get(MAIN_SERVICE_TEMPLATE_YAML) == null ? new UnifiedSubstitutionData()
1238                         : context.getUnifiedSubstitutionData().get(MAIN_SERVICE_TEMPLATE_YAML);
1239         Map<String, String> substitutionAbstractNodeIds = new HashMap<>();
1240         for (String id : nodeTemplateIds) {
1241             substitutionAbstractNodeIds.put(id, "FSB2");
1242         }
1243
1244         substitutionAbstractNodeIds.put("", FSB1);
1245
1246         unifiedSubstitutionData.setNodesRelatedAbstractNode(substitutionAbstractNodeIds);
1247     }
1248
1249     private void checkSTResults(
1250             Map<String, ServiceTemplate> expectedOutserviceTemplates,
1251             ServiceTemplate substitutionServiceTemplate,
1252             ServiceTemplate gloablSubstitutionServiceTemplate, ServiceTemplate mainServiceTemplate) {
1253         YamlUtil yamlUtil = new YamlUtil();
1254         if (Objects.nonNull(substitutionServiceTemplate)) {
1255             String substitutionST = "SubstitutionServiceTemplate.yaml";
1256             assertEquals("difference substitution service template: ",
1257                     yamlUtil.objectToYaml(expectedOutserviceTemplates.get(substitutionST)),
1258                     yamlUtil.objectToYaml(substitutionServiceTemplate));
1259         }
1260         if (Objects.nonNull(gloablSubstitutionServiceTemplate)) {
1261             assertEquals("difference global substitution service template: ",
1262                     yamlUtil.objectToYaml(expectedOutserviceTemplates.get(GLOBAL_SUBSTITUTION_TYPES_SERVICE_TEMPLATE_YAML)),
1263                     yamlUtil.objectToYaml(gloablSubstitutionServiceTemplate));
1264         }
1265         if (Objects.nonNull(mainServiceTemplate)) {
1266             assertEquals("difference main service template: ",
1267                     yamlUtil.objectToYaml(expectedOutserviceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML)),
1268                     yamlUtil.objectToYaml(mainServiceTemplate));
1269         }
1270     }
1271
1272     private void checkSTResults(
1273             Map<String, ServiceTemplate> expectedOutserviceTemplates,
1274             String nestedSTFileName, ServiceTemplate nestedServiceTemplate,
1275             ServiceTemplate gloablSubstitutionServiceTemplate, ServiceTemplate mainServiceTemplate) {
1276         YamlUtil yamlUtil = new YamlUtil();
1277
1278         if (Objects.nonNull(nestedServiceTemplate)) {
1279             assertEquals("difference nested service template: ",
1280                     yamlUtil.objectToYaml(expectedOutserviceTemplates.get(nestedSTFileName)),
1281                     yamlUtil.objectToYaml(nestedServiceTemplate));
1282         }
1283         checkSTResults(expectedOutserviceTemplates, null, gloablSubstitutionServiceTemplate,
1284                 mainServiceTemplate);
1285     }
1286
1287
1288     private void loadInputAndOutputData(String path) throws IOException {
1289         inputServiceTemplates = new HashMap<>();
1290         TestUtils.loadServiceTemplates(path + IN_PREFIX, new ToscaExtensionYamlUtil(),
1291                 inputServiceTemplates);
1292         expectedOutserviceTemplates = new HashMap<>();
1293         TestUtils.loadServiceTemplates(path + OUT_PREFIX, new ToscaExtensionYamlUtil(),
1294                 expectedOutserviceTemplates);
1295     }
1296
1297
1298     private void addGetAttInUnifiedCompositionData(EntityConsolidationData entityConsolidationData,
1299                                                    String propertyName, String attributeName,
1300                                                    String nodeTemplateId) {
1301         GetAttrFuncData getAttrFuncData = new GetAttrFuncData();
1302         getAttrFuncData.setAttributeName(attributeName);
1303         getAttrFuncData.setFieldName(propertyName);
1304         entityConsolidationData.addNodesGetAttrIn(nodeTemplateId, getAttrFuncData);
1305     }
1306
1307     private void addOutputGetAttInUnifiedCompositionData(
1308             EntityConsolidationData entityConsolidationData,
1309             String outParamName, String attributeName) {
1310         GetAttrFuncData getAttrFuncData = new GetAttrFuncData();
1311         getAttrFuncData.setAttributeName(attributeName);
1312         getAttrFuncData.setFieldName(outParamName);
1313         entityConsolidationData.addOutputParamGetAttrIn(getAttrFuncData);
1314     }
1315
1316     private ConsolidationData createConsolidationData(List<String> computeNodeIds,
1317                                                       List<Pair<String, String>> portTypeToIdList) {
1318
1319         ConsolidationData consolidationData = new ConsolidationData();
1320         String computeNodeTypeName = "org.openecomp.resource.vfc.nodes.heat.FSB2";
1321
1322         TestUtils
1323                 .initComputeNodeTypeInConsolidationData(MAIN_SERVICE_TEMPLATE_YAML, computeNodeTypeName, consolidationData);
1324         TestUtils.initPortConsolidationData(MAIN_SERVICE_TEMPLATE_YAML, consolidationData);
1325
1326         for (String computeId : computeNodeIds) {
1327             ComputeTemplateConsolidationData computeTemplateConsolidationData =
1328                     new ComputeTemplateConsolidationData();
1329             TestUtils.updatePortsInComputeTemplateConsolidationData(portTypeToIdList,
1330                     computeTemplateConsolidationData);
1331             consolidationData.getComputeConsolidationData().getFileComputeConsolidationData(MAIN_SERVICE_TEMPLATE_YAML)
1332                     .getTypeComputeConsolidationData(computeNodeTypeName)
1333                     .setComputeTemplateConsolidationData(computeId,
1334                             computeTemplateConsolidationData);
1335         }
1336
1337         for (Pair<String, String> portTypeToId : portTypeToIdList) {
1338             consolidationData.getPortConsolidationData().getFilePortConsolidationData(MAIN_SERVICE_TEMPLATE_YAML)
1339                     .setPortTemplateConsolidationData(portTypeToId.getRight(),
1340                             new PortTemplateConsolidationData());
1341         }
1342
1343         return consolidationData;
1344     }
1345
1346     private UnifiedCompositionData createCompositionData(String computeNodeTemplateId,
1347                                                          List<Pair<String, String>> portTypeToIdList) {
1348
1349         UnifiedCompositionData unifiedCompositionData = new UnifiedCompositionData();
1350         NodeTemplate computeNodeTemplate =
1351                 DataModelUtil.getNodeTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), computeNodeTemplateId);
1352         Optional<List<RequirementAssignmentData>> requirementAssignmentDataList =
1353                 TestUtils.getRequirementAssignmentDataList(computeNodeTemplate, "local_storage");
1354         List<RequirementAssignmentData> requirementAssignmentList =
1355                 (requirementAssignmentDataList.isPresent()) ? requirementAssignmentDataList.get() : null;
1356         Map<String, List<RequirementAssignmentData>> volume = null;
1357         if (requirementAssignmentList != null) {
1358             volume = getVolume(requirementAssignmentList);
1359         }
1360         unifiedCompositionData.setComputeTemplateConsolidationData(
1361                 TestUtils.createComputeTemplateConsolidationData(computeNodeTemplateId, portTypeToIdList,
1362                         volume));
1363         if (portTypeToIdList != null) {
1364             for (Pair<String, String> port : portTypeToIdList) {
1365                 NodeTemplate portNodeTemplate =
1366                         DataModelUtil.getNodeTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), port.getRight());
1367
1368                 Map<String, List<RequirementAssignmentData>> nodeConnectedOut =
1369                         TestUtils.getNodeConnectedOutList(portNodeTemplate, "link");
1370                 PortTemplateConsolidationData portTemplateConsolidationData =
1371                         TestUtils.createPortTemplateConsolidationData(port.getRight());
1372                 portTemplateConsolidationData.setNodesConnectedOut(nodeConnectedOut);
1373                 unifiedCompositionData.addPortTemplateConsolidationData(portTemplateConsolidationData);
1374             }
1375         }
1376         return unifiedCompositionData;
1377     }
1378
1379     private List<UnifiedCompositionData> createAbstractSubstituteCompositionDataComputeAndPort() {
1380         List<UnifiedCompositionData> unifiedCompositionDataList = new ArrayList<>();
1381         UnifiedCompositionData data1 = createComputeUnifiedCompositionData(FSB1_template);
1382         UnifiedCompositionData data2 = createComputeUnifiedCompositionData(FSB2_template);
1383
1384         List<Pair<String, String>> portTypeToIdList = new ArrayList<>();
1385         ImmutablePair<String, String> portTypePair1 = new ImmutablePair<>(FSB1_INTERNAL,
1386                 FSB1_INTERNAL_1);
1387         ImmutablePair<String, String> portTypePair2 = new ImmutablePair<>(FSB2_INTERNAL,
1388                 FSB2_INTERNAL_1);
1389         portTypeToIdList.add(portTypePair1);
1390         portTypeToIdList.add(portTypePair2);
1391         addPortDataToCompositionData(portTypeToIdList, data1);
1392         portTypeToIdList.remove(portTypePair1);
1393         portTypeToIdList.remove(portTypePair2);
1394         portTypeToIdList.add(new ImmutablePair<>(FSB1_INTERNAL, FSB1_INTERNAL_2));
1395         portTypeToIdList.add(new ImmutablePair<>(FSB2_INTERNAL, FSB2_INTERNAL_2));
1396         addPortDataToCompositionData(portTypeToIdList, data2);
1397
1398         unifiedCompositionDataList.add(data1);
1399         unifiedCompositionDataList.add(data2);
1400         return unifiedCompositionDataList;
1401     }
1402
1403
1404     private UnifiedCompositionData createComputeUnifiedCompositionData(String computeNodeTemplateId) {
1405         NodeTemplate computeNodeTemplate =
1406                 DataModelUtil.getNodeTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), computeNodeTemplateId);
1407         Optional<List<RequirementAssignmentData>> requirementAssignmentDataList =
1408                 TestUtils.getRequirementAssignmentDataList(computeNodeTemplate, "local_storage");
1409         Map<String, List<RequirementAssignmentData>> volume = null;
1410         if (requirementAssignmentDataList.isPresent()) {
1411             volume = getVolume(requirementAssignmentDataList.get());
1412         }
1413         UnifiedCompositionData data = new UnifiedCompositionData();
1414         Map<String, List<RequirementAssignmentData>> computeNodeConnectedOut =
1415                 TestUtils.getNodeConnectedOutList(computeNodeTemplate, DEPENDENCY);
1416         Map<String, List<RequirementAssignmentData>> computeNodeConnectedIn =
1417                 TestUtils
1418                         .getNodeConnectedInList(computeNodeTemplateId, inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
1419                                 DEPENDENCY);
1420         ComputeTemplateConsolidationData computeTemplateConsolidationData = TestUtils
1421                 .createComputeTemplateConsolidationData(computeNodeTemplateId, null, volume);
1422         List<String> computeNodeGroups =
1423                 TestUtils.getGroupsForNode(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
1424                         computeNodeTemplateId);
1425         if (!computeNodeGroups.isEmpty()) {
1426             computeTemplateConsolidationData.setGroupIds(computeNodeGroups);
1427         }
1428         computeTemplateConsolidationData.setNodesConnectedOut(computeNodeConnectedOut);
1429         computeTemplateConsolidationData.setNodesConnectedIn(computeNodeConnectedIn);
1430         data.setComputeTemplateConsolidationData(computeTemplateConsolidationData);
1431         return data;
1432     }
1433
1434     private void addPortDataToCompositionData(List<Pair<String, String>> portTypeToIdList,
1435                                               UnifiedCompositionData data) {
1436         ComputeTemplateConsolidationData computeTemplateConsolidationData = data
1437                 .getComputeTemplateConsolidationData();
1438
1439         for (Pair<String, String> port : portTypeToIdList) {
1440             NodeTemplate portNodeTemplate =
1441                     DataModelUtil.getNodeTemplate(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), port.getRight());
1442
1443             Optional<List<RequirementAssignmentData>> bindingReqList =
1444                     TestUtils.getRequirementAssignmentDataList(portNodeTemplate, "binding");
1445
1446             if (bindingReqList.isPresent()) {
1447                 for (RequirementAssignmentData reqData : bindingReqList.get()) {
1448                     String nodeId = reqData.getRequirementAssignment().getNode();
1449                     if (nodeId.equals(computeTemplateConsolidationData.getNodeTemplateId())) {
1450                         computeTemplateConsolidationData.addPort(port.getLeft(), port.getRight());
1451                     }
1452                 }
1453             }
1454             Map<String, List<RequirementAssignmentData>> portNodeConnectedOut =
1455                     TestUtils.getNodeConnectedOutList(portNodeTemplate, "link");
1456             PortTemplateConsolidationData portTemplateConsolidationData = TestUtils
1457                     .createPortTemplateConsolidationData(port.getRight());
1458             portTemplateConsolidationData.setNodesConnectedOut(portNodeConnectedOut);
1459
1460             //Add node connected in info to test data
1461             Map<String, List<RequirementAssignmentData>> portNodeConnectedIn =
1462                     TestUtils.getNodeConnectedInList(port.getRight(), inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML),
1463                             PORT);
1464             portTemplateConsolidationData.setNodesConnectedIn(portNodeConnectedIn);
1465
1466             //Add group infromation for ports
1467             List<String> portGroups =
1468                     TestUtils.getGroupsForNode(inputServiceTemplates.get(MAIN_SERVICE_TEMPLATE_YAML), port.getRight());
1469             portTemplateConsolidationData.setGroupIds(portGroups);
1470             data.addPortTemplateConsolidationData(portTemplateConsolidationData);
1471
1472         }
1473         addGetAttrForCompute(data);
1474         addGetAttrForPort(data);
1475     }
1476
1477     private Map<String, List<RequirementAssignmentData>> getVolume(
1478             List<RequirementAssignmentData> requirementAssignmentList) {
1479         Map<String, List<RequirementAssignmentData>> volume = new HashMap<>();
1480         for (RequirementAssignmentData requirementAssignmentData : requirementAssignmentList) {
1481             String volumeNodeTemplateId = requirementAssignmentData.getRequirementAssignment().getNode();
1482             volume.computeIfAbsent(volumeNodeTemplateId, k -> new ArrayList<>());
1483             volume.get(volumeNodeTemplateId).add(requirementAssignmentData);
1484         }
1485         return volume;
1486     }
1487
1488     private void addGetAttrForPort(UnifiedCompositionData unifiedCompositionData) {
1489         for (PortTemplateConsolidationData portTemplateConsolidationData : unifiedCompositionData
1490                 .getPortTemplateConsolidationDataList()) {
1491             if (portTemplateConsolidationData.getNodeTemplateId().equals(FSB1_INTERNAL_1)) {
1492                 addGetAttInUnifiedCompositionData(portTemplateConsolidationData, "network_name",
1493                         NETWORK_ID, JSA_NET1);
1494                 addGetAttInUnifiedCompositionData(portTemplateConsolidationData, SIZE,
1495                         DEVICE_OWNER, CMAUI_VOLUME1);
1496             } else if (portTemplateConsolidationData.getNodeTemplateId().equals(FSB2_INTERNAL_2)) {
1497                 addGetAttInUnifiedCompositionData(portTemplateConsolidationData, TENANT_ID,
1498                         NETWORK_ID, JSA_NET1);
1499                 addGetAttInUnifiedCompositionData(portTemplateConsolidationData, "qos_policy",
1500                         NETWORK_ID, JSA_NET1);
1501                 addGetAttInUnifiedCompositionData(portTemplateConsolidationData, VOLUME_TYPE,
1502                         TENANT_ID, CMAUI_VOLUME1);
1503             } else if (portTemplateConsolidationData.getNodeTemplateId().equals(FSB1_OAM)) {
1504                 addGetAttInUnifiedCompositionData(portTemplateConsolidationData, SIZE,
1505                         STATUS, CMAUI_VOLUME1);
1506             }
1507         }
1508     }
1509
1510     private void addGetAttrForPort2(UnifiedCompositionData unifiedCompositionData) {
1511         for (PortTemplateConsolidationData portTemplateConsolidationData : unifiedCompositionData
1512                 .getPortTemplateConsolidationDataList()) {
1513             if (portTemplateConsolidationData.getNodeTemplateId().equals(FSB2_INTERNAL_1)) {
1514                 addGetAttInUnifiedCompositionData(portTemplateConsolidationData, VOLUME_TYPE,
1515                         TENANT_ID, CMAUI_VOLUME3);
1516             } else if (portTemplateConsolidationData.getNodeTemplateId().equals(FSB1_INTERNAL_2)) {
1517                 addGetAttInUnifiedCompositionData(portTemplateConsolidationData, SIZE,
1518                         DEVICE_OWNER, CMAUI_VOLUME3);
1519                 addGetAttInUnifiedCompositionData(portTemplateConsolidationData, SIZE,
1520                         STATUS, CMAUI_VOLUME1);
1521             }
1522         }
1523     }
1524
1525     private void addGetAttrForPortInnerUC(UnifiedCompositionData unifiedCompositionData) {
1526         for (PortTemplateConsolidationData portTemplateConsolidationData : unifiedCompositionData
1527                 .getPortTemplateConsolidationDataList()) {
1528             if (portTemplateConsolidationData.getNodeTemplateId().equals(FSB1_INTERNAL_1)) {
1529                 addGetAttInUnifiedCompositionData(portTemplateConsolidationData, AVAILABILITY_ZONE,
1530                         MYATTR, FSB1_template);
1531                 addGetAttInUnifiedCompositionData(portTemplateConsolidationData, "metadata",
1532                         MYATTR, FSB1_template);
1533                 addGetAttInUnifiedCompositionData(portTemplateConsolidationData, "name",
1534                         MYATTR, FSB1_template);
1535                 addGetAttInUnifiedCompositionData(portTemplateConsolidationData, AVAILABILITY_ZONE,
1536                         TENANT_ID, FSB1_template);
1537             }
1538         }
1539     }
1540
1541     private void addGetAttrForCompute(UnifiedCompositionData unifiedCompositionData) {
1542         addGetAttInUnifiedCompositionData(unifiedCompositionData.getComputeTemplateConsolidationData(),
1543                 "dhcp_agent_ids", ADDRESSES, JSA_NET1);
1544         addGetAttInUnifiedCompositionData(unifiedCompositionData.getComputeTemplateConsolidationData(),
1545                 VOLUME_TYPE, ADDRESSES, CMAUI_VOLUME1);
1546         addGetAttInUnifiedCompositionData(unifiedCompositionData.getComputeTemplateConsolidationData(),
1547                 SIZE, ACCESS_IPv6, CMAUI_VOLUME2);
1548     }
1549
1550     private void addGetAttrForCompute2(UnifiedCompositionData unifiedCompositionData) {
1551         addGetAttInUnifiedCompositionData(unifiedCompositionData.getComputeTemplateConsolidationData(),
1552                 VOLUME_TYPE, ADDRESSES, CMAUI_VOLUME3);
1553         addGetAttInUnifiedCompositionData(unifiedCompositionData.getComputeTemplateConsolidationData(),
1554                 SIZE, USER_DATA_FORMAT, CMAUI_VOLUME3);
1555     }
1556
1557     private void addOutputGetAttrInForComputeNoConsolidation(
1558             UnifiedCompositionData unifiedCompositionData) {
1559         addOutputGetAttInUnifiedCompositionData(unifiedCompositionData
1560                 .getComputeTemplateConsolidationData(), SIMPLE_OUTPUT1, ACCESS_IPv4);
1561         addOutputGetAttInUnifiedCompositionData(unifiedCompositionData
1562                 .getComputeTemplateConsolidationData(), SIMPLE_OUTPUT2, ADDRESSES);
1563         addOutputGetAttInUnifiedCompositionData(unifiedCompositionData
1564                 .getComputeTemplateConsolidationData(), COMPLEX_OUTPUT1, ADDRESSES);
1565         addOutputGetAttInUnifiedCompositionData(unifiedCompositionData
1566                 .getComputeTemplateConsolidationData(), COMPLEX_OUTPUT3, ACCESS_IPv6);
1567
1568     }
1569
1570     private void addOutputGetAttrInForCompute1WithConsolidation(
1571             UnifiedCompositionData unifiedCompositionData) {
1572         addOutputGetAttInUnifiedCompositionData(unifiedCompositionData
1573                 .getComputeTemplateConsolidationData(), SIMPLE_OUTPUT1, ACCESS_IPv4);
1574         addOutputGetAttInUnifiedCompositionData(unifiedCompositionData
1575                 .getComputeTemplateConsolidationData(), COMPLEX_OUTPUT1, ADDRESSES);
1576
1577     }
1578
1579     private void addOutputGetAttrInForCompute2WithConsolidation(
1580             UnifiedCompositionData unifiedCompositionData) {
1581         addOutputGetAttInUnifiedCompositionData(unifiedCompositionData
1582                 .getComputeTemplateConsolidationData(), SIMPLE_OUTPUT2, ADDRESSES);
1583     }
1584
1585     private void addOutputGetAttrInForPortNoConsolidation(
1586             UnifiedCompositionData unifiedCompositionData) {
1587         for (PortTemplateConsolidationData portTemplateConsolidationData : unifiedCompositionData
1588                 .getPortTemplateConsolidationDataList()) {
1589             if (portTemplateConsolidationData.getNodeTemplateId().equals(FSB1_INTERNAL_1)) {
1590                 addOutputGetAttInUnifiedCompositionData(portTemplateConsolidationData, COMPLEX_OUTPUT2,
1591                         DEVICE_OWNER);
1592                 addOutputGetAttInUnifiedCompositionData(portTemplateConsolidationData, COMPLEX_OUTPUT3,
1593                         DEVICE_OWNER);
1594             } else if (portTemplateConsolidationData.getNodeTemplateId().equals(FSB2_INTERNAL_2)) {
1595                 addOutputGetAttInUnifiedCompositionData(portTemplateConsolidationData, COMPLEX_OUTPUT1,
1596                         TENANT_ID);
1597             } else if (portTemplateConsolidationData.getNodeTemplateId().equals(FSB1_OAM)) {
1598                 addOutputGetAttInUnifiedCompositionData(portTemplateConsolidationData, COMPLEX_OUTPUT2,
1599                         USER_DATA_FORMAT);
1600             }
1601         }
1602     }
1603
1604     private void addOutputGetAttrInForPortWithConsolidation1(
1605             UnifiedCompositionData unifiedCompositionData) {
1606         for (PortTemplateConsolidationData portTemplateConsolidationData : unifiedCompositionData
1607                 .getPortTemplateConsolidationDataList()) {
1608             if (portTemplateConsolidationData.getNodeTemplateId().equals(FSB2_INTERNAL_2)) {
1609                 addOutputGetAttInUnifiedCompositionData(portTemplateConsolidationData, COMPLEX_OUTPUT1,
1610                         TENANT_ID);
1611             } else if (portTemplateConsolidationData.getNodeTemplateId().equals(FSB1_INTERNAL_1)) {
1612                 addOutputGetAttInUnifiedCompositionData(portTemplateConsolidationData, COMPLEX_OUTPUT3,
1613                         "admin_state_up");
1614             }
1615         }
1616     }
1617
1618     private void addOutputGetAttrInForPortWithConsolidation2(
1619             UnifiedCompositionData unifiedCompositionData) {
1620         for (PortTemplateConsolidationData portTemplateConsolidationData : unifiedCompositionData
1621                 .getPortTemplateConsolidationDataList()) {
1622             if (portTemplateConsolidationData.getNodeTemplateId().equals(FSB2_INTERNAL_1)) {
1623                 addOutputGetAttInUnifiedCompositionData(portTemplateConsolidationData, COMPLEX_OUTPUT2,
1624                         USER_DATA_FORMAT);
1625             } else if (portTemplateConsolidationData.getNodeTemplateId().equals(FSB1_INTERNAL_2)) {
1626                 addOutputGetAttInUnifiedCompositionData(portTemplateConsolidationData, COMPLEX_OUTPUT2,
1627                         DEVICE_OWNER);
1628             }
1629         }
1630     }
1631
1632     private NodeTemplate getMockNode(String path) throws IOException {
1633         URL resource = this.getClass().getResource(path);
1634         YamlUtil yamlUtil = new YamlUtil();
1635         return yamlUtil.yamlToObject(resource.openStream(), NodeTemplate.class);
1636     }
1637
1638 }