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

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