gerrit.onap Code Review - sdc.git/blob

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