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