catalog-be/src/test/java/org/openecomp/sdc/be/tosca/CapabilityRequirementConverterTest.java

   1 /*
   2  * Copyright © 2016-2019 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.be.tosca;
  18
  19 import java.util.Iterator;
  20
  21 import org.junit.Assert;
  22 import org.junit.Before;
  23 import org.junit.Test;
  24 import org.mockito.InjectMocks;
  25 import org.mockito.Mock;
  26 import org.mockito.Mockito;
  27 import org.mockito.MockitoAnnotations;
  28 import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition;
  29 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  30 import org.openecomp.sdc.be.model.CapabilityDefinition;
  31 import org.openecomp.sdc.be.model.Component;
  32 import org.openecomp.sdc.be.model.ComponentInstance;
  33 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
  34 import org.openecomp.sdc.be.model.ComponentParametersView;
  35 import org.openecomp.sdc.be.model.DataTypeDefinition;
  36 import org.openecomp.sdc.be.model.RequirementDefinition;
  37 import org.openecomp.sdc.be.model.Resource;
  38 import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
  39 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  40 import org.openecomp.sdc.be.tosca.model.SubstitutionMapping;
  41 import org.openecomp.sdc.be.tosca.model.ToscaNodeTemplate;
  42
  43
  44 import fj.data.Either;
  45 import mockit.Deencapsulation;
  46 import org.openecomp.sdc.be.tosca.model.ToscaRequirement;
  47
  48 import java.util.*;
  49 import java.util.stream.Collectors;
  50
  51 import static java.util.Arrays.asList;
  52 import static org.assertj.core.api.Assertions.assertThat;
  53 import static org.mockito.Mockito.doReturn;
  54
  55 public class CapabilityRequirementConverterTest {
  56
  57         @InjectMocks
  58         CapabilityRequirementConverter testSubject;
  59
  60         @Mock
  61         ToscaOperationFacade toscaOperationFacade;
  62
  63         CapabilityRequirementConverter capabiltyRequirementConvertor = Mockito.spy(new CapabilityRequirementConverter());
  64         ComponentInstance instanceProxy = Mockito.spy(new ComponentInstance());
  65         ComponentInstance vfInstance = Mockito.spy(new ComponentInstance());
  66         Component vfComponent = Mockito.spy(new Resource());
  67         ComponentInstance vfcInstance = Mockito.spy(new ComponentInstance());
  68         Component vfcComponent = Mockito.spy(new Resource());
  69
  70         @Before
  71         public void setUpMock() throws Exception {
  72                 MockitoAnnotations.initMocks(this);
  73         }
  74
  75         @Test
  76         public void testGetInstance() {
  77                 CapabilityRequirementConverter.getInstance();
  78         }
  79
  80         @Test
  81         public void testConvertComponentInstanceCapabilties() {
  82                 Map<String, List<CapabilityDefinition>> capabilities = newCapabilities("port");
  83                 vfInstance.setCapabilities(capabilities);
  84                 ToscaNodeTemplate nodeTemplate = new ToscaNodeTemplate();
  85                 Map<String, DataTypeDefinition> testDataTypes = new HashMap<String, DataTypeDefinition>();
  86
  87                 capabilities.get("att.Node").clear();
  88                 testSubject.convertComponentInstanceCapabilities(vfInstance, testDataTypes, nodeTemplate);
  89
  90                 capabilities = newCapabilities("port");
  91                 vfInstance.setCapabilities(capabilities);
  92                 vfInstance.setComponentUid("uid");
  93
  94                 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
  95                                 Mockito.any(ComponentParametersView.class)))
  96                                 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
  97
  98                 testSubject.convertComponentInstanceCapabilities(vfInstance, testDataTypes, nodeTemplate);
  99
 100         }
 101
 102         @Test
 103         public void testConvertComponentInstanceCapabilties_1() {
 104                 Map<String, List<CapabilityDefinition>> capabilities = newCapabilities("port");
 105                 ToscaNodeTemplate nodeTemplate = new ToscaNodeTemplate();
 106                 Map<String, DataTypeDefinition> testDataTypes = new HashMap<String, DataTypeDefinition>();
 107
 108                 vfInstance.setComponentUid("uid");
 109
 110                 vfInstance.setCapabilities(capabilities);
 111
 112                 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
 113                                 Mockito.any(ComponentParametersView.class)))
 114                                 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
 115
 116                 testSubject.convertComponentInstanceCapabilities(vfInstance, testDataTypes, nodeTemplate);
 117
 118         }
 119
 120
 121
 122         @Test
 123         public void testConvertSubstitutionMappingRequirements() {
 124                 Map<String, Component> componentsCache = new HashMap<>();
 125                 SubstitutionMapping substitution = new SubstitutionMapping();
 126                 Map<String, List<RequirementDefinition>> requirementsMap = new HashMap<String, List<RequirementDefinition>>();
 127                 List<RequirementDefinition> requirementsArray = new ArrayList<RequirementDefinition>();
 128                 RequirementDefinition definition = new RequirementDefinition();
 129                 definition.setOwnerId("id");
 130                 definition.setName("name");
 131                 definition.setParentName("parentName");
 132                 List<String> path = new ArrayList<>();
 133                 path.add("path1");
 134                 path.add("path2");
 135                 definition.setPath(path);
 136                 requirementsArray.add(definition);
 137                 requirementsMap.put("key", requirementsArray);
 138                 List<ComponentInstance> instances = new ArrayList<>();
 139                 ComponentInstance instance = new ComponentInstance();
 140                 instance.setUniqueId("uid");
 141                 instances.add(instance);
 142                 vfComponent.setRequirements(requirementsMap);
 143                 vfComponent.setComponentInstances(instances);
 144
 145                 testSubject.convertSubstitutionMappingRequirements(componentsCache, vfComponent, substitution);
 146         }
 147
 148         @Test
 149         public void testConvertSubstitutionMappingRequirements_1() {
 150                 Map<String, Component> componentsCache = new HashMap<>();
 151                 SubstitutionMapping substitution = new SubstitutionMapping();
 152                 Map<String, List<RequirementDefinition>> requirementsMap = new HashMap<String, List<RequirementDefinition>>();
 153                 List<RequirementDefinition> requirementsArray = new ArrayList<RequirementDefinition>();
 154                 RequirementDefinition definition = new RequirementDefinition();
 155                 definition.setName("name");
 156                 definition.setParentName("parentName");
 157                 List<String> path = new ArrayList<>();
 158                 path.add("path1.");
 159                 path.add("id");
 160                 definition.setPath(path);
 161                 requirementsArray.add(definition);
 162                 requirementsMap.put("key", requirementsArray);
 163                 List<ComponentInstance> instances = new ArrayList<>();
 164                 ComponentInstance instance = new ComponentInstance();
 165                 instance.setUniqueId("id");
 166                 instance.setComponentUid("id");
 167                 instances.add(instance);
 168                 vfComponent.setRequirements(requirementsMap);
 169                 vfComponent.setComponentInstances(instances);
 170
 171                 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
 172                                 Mockito.any(ComponentParametersView.class))).thenReturn(Either.left(vfcComponent));
 173
 174                 testSubject.convertSubstitutionMappingRequirements(componentsCache, vfComponent, substitution);
 175         }
 176
 177         @Test
 178         public void testConvertSubstitutionMappingRequirementsAsMap() {
 179                 Map<String, Component> componentsCache = new HashMap<>();
 180                 vfComponent.setRequirements(null);
 181
 182                 Deencapsulation.invoke(testSubject, "convertSubstitutionMappingRequirementsAsMap", componentsCache,
 183                                 vfComponent);
 184         }
 185
 186         @Test
 187         public void testBuildAddSubstitutionMappingsRequirements() {
 188                 Map<String, Component> componentsCache = new HashMap<>();
 189                 Map<String, List<RequirementDefinition>> requirementsMap = new HashMap<String, List<RequirementDefinition>>();
 190                 List<RequirementDefinition> requirementsArray = new ArrayList<RequirementDefinition>();
 191                 RequirementDefinition definition = new RequirementDefinition();
 192                 definition.setOwnerId("id");
 193                 definition.setName("name");
 194                 definition.setParentName("parentName");
 195                 List<String> path = new ArrayList<>();
 196                 path.add("path1");
 197                 path.add("path2");
 198                 definition.setPath(path);
 199                 requirementsArray.add(definition);
 200                 requirementsMap.put("key", requirementsArray);
 201                 vfComponent.setRequirements(requirementsMap);
 202                 List<ComponentInstance> componentInstances = new ArrayList<>();
 203                 ComponentInstance instance = new ComponentInstance();
 204                 instance.setUniqueId("id");
 205                 componentInstances.add(instance);
 206
 207                 vfComponent.setComponentInstances(componentInstances);
 208
 209                 Deencapsulation.invoke(testSubject, "buildAddSubstitutionMappingsRequirements", componentsCache, vfComponent,
 210                                 requirementsMap);
 211         }
 212
 213         @Test
 214         public void testBuildAddSubstitutionMappingsCapabilities() {
 215                 Map<String, Component> componentsCache = new HashMap<>();
 216                 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
 217
 218                 Deencapsulation.invoke(testSubject, "buildAddSubstitutionMappingsCapabilities", componentsCache, vfComponent,
 219                                 capabilities);
 220         }
 221
 222         @Test
 223         public void testBuildAddSubstitutionMappingsCapabilities_1() {
 224                 Map<String, Component> componentsCache = new HashMap<>();
 225                 Map<String, List<CapabilityDefinition>> capabilitiesMap = new HashMap<String, List<CapabilityDefinition>>();
 226                 List<CapabilityDefinition> capabilitiesArray = new ArrayList<CapabilityDefinition>();
 227                 CapabilityDefinition definition = new CapabilityDefinition();
 228                 definition.setOwnerId("id");
 229                 definition.setName("name");
 230                 definition.setParentName("parentName");
 231                 List<String> path = new ArrayList<>();
 232                 path.add("path1");
 233                 path.add("path2");
 234                 definition.setPath(path);
 235                 capabilitiesArray.add(definition);
 236                 capabilitiesMap.put("key", capabilitiesArray);
 237                 vfComponent.setCapabilities(capabilitiesMap);
 238                 List<ComponentInstance> componentInstances = new ArrayList<>();
 239                 ComponentInstance instance = new ComponentInstance();
 240                 instance.setUniqueId("id");
 241                 componentInstances.add(instance);
 242
 243                 vfComponent.setComponentInstances(componentInstances);
 244
 245                 Deencapsulation.invoke(testSubject, "buildAddSubstitutionMappingsCapabilities", componentsCache, vfComponent,
 246                                 capabilitiesMap);
 247         }
 248
 249         @Test
 250         public void testConvertProxyCapabilities() {
 251                 Map<String, Component> componentsCache = new HashMap<>();
 252                 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 253
 254                 List<ComponentInstance> componentInstances = new ArrayList<>();
 255                 ComponentInstance instance = new ComponentInstance();
 256                 instance.setUniqueId("id");
 257                 componentInstances.add(instance);
 258
 259                 vfComponent.setComponentInstances(componentInstances);
 260
 261                 testSubject.convertProxyCapabilities(componentsCache, instance, dataTypes);
 262         }
 263
 264         @Test
 265         public void testConvertProxyRequirementsNoRequirements() {
 266                 Map<String, Component> componentsCache = new HashMap<>();
 267
 268                 List<ComponentInstance> componentInstances = new ArrayList<>();
 269                 ComponentInstance instance = new ComponentInstance();
 270                 instance.setUniqueId("id");
 271                 instance.setComponentUid("componentUid");
 272                 componentInstances.add(instance);
 273
 274                 vfComponent.setComponentInstances(componentInstances);
 275
 276                 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
 277                                 Mockito.any(ComponentParametersView.class)))
 278                                 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
 279
 280                 List<Map<String, ToscaRequirement>> proxyRequirements =
 281                                 testSubject.convertProxyRequirements(componentsCache, instance);
 282                 Assert.assertEquals(0, proxyRequirements.size());
 283         }
 284
 285         @Test
 286         public void testConvertProxyRequirementsNotSubstitutedName() {
 287                 Map<String, Component> componentsCache = new HashMap<>();
 288                 RequirementDefinition r = new RequirementDefinition();
 289                 r.setName("port0.dependency");
 290                 r.setPreviousName("dependency");
 291                 r.setCapability("tosca.capabilities.Node");
 292                 r.setNode("tosca.nodes.Root");
 293                 r.setRelationship("tosca.relationships.DependsOn");
 294                 r.setMinOccurrences(RequirementDataDefinition.MIN_OCCURRENCES);
 295                 r.setMaxOccurrences(RequirementDataDefinition.MAX_OCCURRENCES);
 296                 r.setOwnerId("id");
 297                 r.setParentName("parentName");
 298
 299                 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
 300                 List<RequirementDefinition> requirementDefinitions = new ArrayList<>();
 301                 requirementDefinitions.add(r);
 302                 requirements.put("dependency", requirementDefinitions);
 303
 304                 List<ComponentInstance> componentInstances = new ArrayList<>();
 305                 ComponentInstance instance = new ComponentInstance();
 306                 instance.setUniqueId("id");
 307                 instance.setComponentUid("componentUid");
 308                 instance.setRequirements(requirements);
 309                 instance.setNormalizedName("port0");
 310                 componentInstances.add(instance);
 311
 312                 vfComponent.setComponentInstances(componentInstances);
 313
 314                 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
 315                                 Mockito.any(ComponentParametersView.class)))
 316                                 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
 317
 318                 List<Map<String, ToscaRequirement>> proxyRequirements =
 319                                 testSubject.convertProxyRequirements(componentsCache, instance);
 320                 Map<String, ToscaRequirement> proxyRequirement = proxyRequirements.get(0);
 321                 Assert.assertEquals("dependency", proxyRequirement.keySet().iterator().next());
 322         }
 323
 324         @Test
 325         public void testConvertProxyRequirementsSubstitutedName() {
 326                 Map<String, Component> componentsCache = new HashMap<>();
 327                 RequirementDefinition r = new RequirementDefinition();
 328                 r.setName("dependency");
 329                 r.setPreviousName("dependency");
 330                 r.setCapability("tosca.capabilities.Node");
 331                 r.setNode("tosca.nodes.Root");
 332                 r.setRelationship("tosca.relationships.DependsOn");
 333                 r.setMinOccurrences(RequirementDataDefinition.MIN_OCCURRENCES);
 334                 r.setMaxOccurrences(RequirementDataDefinition.MAX_OCCURRENCES);
 335                 r.setOwnerId("id");
 336                 r.setParentName("parentName");
 337
 338                 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
 339                 List<RequirementDefinition> requirementDefinitions = new ArrayList<>();
 340                 requirementDefinitions.add(r);
 341                 requirements.put("dependency", requirementDefinitions);
 342
 343                 List<ComponentInstance> componentInstances = new ArrayList<>();
 344                 ComponentInstance instance = new ComponentInstance();
 345                 instance.setUniqueId("id");
 346                 instance.setComponentUid("componentUid");
 347                 instance.setRequirements(requirements);
 348                 instance.setNormalizedName("port0");
 349                 componentInstances.add(instance);
 350
 351                 vfComponent.setComponentInstances(componentInstances);
 352
 353                 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
 354                                 Mockito.any(ComponentParametersView.class)))
 355                                 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
 356
 357                 testSubject.convertProxyRequirements(componentsCache, instance);
 358         }
 359
 360         @Test
 361         public void testConvertProxyCapabilitiesWhenCapabilitiesNotNull() {
 362                 Map<String, Component> componentsCache = new HashMap<>();
 363                 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 364
 365                 List<ComponentInstance> componentInstances = new ArrayList<>();
 366                 ComponentInstance instance = new ComponentInstance();
 367                 instance.setUniqueId("id");
 368                 componentInstances.add(instance);
 369
 370                 vfComponent.setComponentInstances(componentInstances);
 371
 372                 Map<String, List<CapabilityDefinition>> capabilitiesMap = new HashMap<String, List<CapabilityDefinition>>();
 373                 List<CapabilityDefinition> capabilitiesArray = new ArrayList<CapabilityDefinition>();
 374                 CapabilityDefinition definition = new CapabilityDefinition();
 375                 definition.setOwnerId("id");
 376                 capabilitiesArray.add(definition);
 377                 capabilitiesMap.put("key", capabilitiesArray);
 378                 vfComponent.setUniqueId("id");
 379
 380                 instance.setCapabilities(capabilitiesMap);
 381                 instance.setComponentUid("uid");
 382
 383                 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
 384                                 Mockito.any(ComponentParametersView.class)))
 385                                 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
 386
 387                 testSubject.convertProxyCapabilities(componentsCache, instance, dataTypes);
 388         }
 389
 390         @Test
 391         public void testConvertSubstitutionMappingCapabilities() {
 392                 Map<String, Component> componentsCache = new HashMap<>();
 393
 394                 testSubject.convertSubstitutionMappingCapabilities(componentsCache, vfComponent);
 395
 396                 Map<String, List<CapabilityDefinition>> capabilitiesMap = new HashMap<String, List<CapabilityDefinition>>();
 397                 List<CapabilityDefinition> capabilitiesArray = new ArrayList<CapabilityDefinition>();
 398                 CapabilityDefinition definition = new CapabilityDefinition();
 399                 definition.setOwnerId("id");
 400                 definition.setName("name");
 401                 definition.setParentName("parentName");
 402                 List<String> path = new ArrayList<>();
 403                 path.add("path1");
 404                 path.add("id");
 405                 definition.setPath(path);
 406                 capabilitiesArray.add(definition);
 407                 capabilitiesMap.put("key", capabilitiesArray);
 408                 vfComponent.setCapabilities(capabilitiesMap);
 409
 410                 List<ComponentInstance> instances = new ArrayList<>();
 411                 ComponentInstance instance = new ComponentInstance();
 412                 instance.setUniqueId("uid");
 413                 instances.add(instance);
 414                 vfComponent.setComponentInstances(instances);
 415
 416                 testSubject.convertSubstitutionMappingCapabilities(componentsCache, vfComponent);
 417         }
 418
 419
 420         @Test
 421         public void testAppendNameRecursively() {
 422                 Map<String, Component> componentsCache = new HashMap<>();
 423                 StringBuilder builder = new StringBuilder();
 424                 List<String> path = new ArrayList<>();
 425
 426                 path.add("id");
 427                 Iterator<String> iter = path.iterator();
 428                 List<ComponentInstance> resourceInstances = new ArrayList<>();
 429                 ComponentInstance instance = new ComponentInstance();
 430                 instance.setUniqueId("id");
 431                 instance.setComponentUid("uid");
 432                 resourceInstances.add(instance);
 433                 vfComponent.setComponentInstances(resourceInstances);
 434
 435                 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
 436                                 Mockito.any(ComponentParametersView.class)))
 437                                 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
 438
 439                 Deencapsulation.invoke(testSubject, "appendNameRecursively", componentsCache, vfComponent, iter, builder);
 440
 441         }
 442
 443         @Test
 444         public void testGetFilter() {
 445                 ComponentInstance instance = new ComponentInstance();
 446                 instance.setIsProxy(true);
 447
 448                 Deencapsulation.invoke(testSubject, "getFilter", instance);
 449         }
 450
 451         @Test
 452         public void testGetReducedPathByOwner() throws Exception {
 453                 List<String> pathList = new ArrayList<>();
 454                 String uniqueId = "41d3a665-1313-4b5e-9bf0-e901ecf4b806.a77df84e-83eb-4edc-9823-d1f9f6549693.lb_2";
 455
 456                 String exerpt = "41d3a665-1313-4b5e-9bf0-e901ecf4b806.a77df84e-83eb-4edc-9823-d1f9f6549693.lb_1";
 457                 String duplicate = "a77df84e-83eb-4edc-9823-d1f9f6549693.c79e9a4a-b172-4323-a2e2-1c48d6603241.lb_swu_direct_4_rvmi";
 458                 pathList.add(exerpt);
 459                 pathList.add(duplicate);
 460                 pathList.add(duplicate);
 461                 pathList.add(uniqueId);
 462
 463                 pathList.add("5f172af9-1588-443e-8897-1432b19aad8c.2cb7514a-1e50-4280-8457-baacb97b50bf.vepdgtp4837vf0");
 464                 pathList.add("86ae128e-3d0a-41f7-a957-db1df9fe598c.9cc8f8ac-6869-4dd6-a6e1-74ecb9570dc4.vepdgtp4837svc_proxy0");
 465
 466         List<String> reducedMap = new CapabilityRequirementConverter().getReducedPathByOwner( pathList , uniqueId );
 467
 468                 assertThat(reducedMap).isNotNull().doesNotContain(exerpt).containsOnlyOnce(duplicate).hasSize(4);
 469
 470                 List<String> path = new ArrayList<String>();
 471
 472                 capabiltyRequirementConvertor.getReducedPathByOwner(path, uniqueId);
 473
 474                 path.add("");
 475                 capabiltyRequirementConvertor.getReducedPathByOwner(path, uniqueId);
 476                 capabiltyRequirementConvertor.getReducedPathByOwner(path, "");
 477         }
 478
 479         // generate stub capability
 480         private Map<String, List<CapabilityDefinition>> newCapabilities(String capabilityName) {
 481                 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
 482                 List<CapabilityDefinition> list = new ArrayList<>();
 483                 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
 484                 capabilityDefinition.setName(capabilityName);
 485                 capabilityDefinition.setType("att.Node");
 486                 List<ComponentInstanceProperty> properties = new ArrayList<>();
 487                 ComponentInstanceProperty prop = new ComponentInstanceProperty();
 488                 prop.setValue("value");
 489                 properties.add(prop);
 490                 capabilityDefinition.setProperties(properties);
 491                 List<String> pathList = new ArrayList<>();
 492
 493                 capabilityDefinition.setOwnerId("41d3a665-1313-4b5e-9bf0-e901ecf4b806.a77df84e-83eb-4edc-9823-d1f9f6549693");
 494                 pathList.add("41d3a665-1313-4b5e-9bf0-e901ecf4b806.a77df84e-83eb-4edc-9823-d1f9f6549693.lb_1");
 495                 // pathList.add("a77df84e-83eb-4edc-9823-d1f9f6549693.c79e9a4a-b172-4323-a2e2-1c48d6603241.lb_swu_direct_4_rvmi");
 496                 pathList.add("5f172af9-1588-443e-8897-1432b19aad8c.2cb7514a-1e50-4280-8457-baacb97b50bf.vepdgtp4837vf0");
 497                 pathList.add("86ae128e-3d0a-41f7-a957-db1df9fe598c.9cc8f8ac-6869-4dd6-a6e1-74ecb9570dc4.vepdgtp4837svc_proxy0");
 498
 499                 capabilityDefinition.setPath(pathList);
 500                 list.add(capabilityDefinition);
 501                 capabilities.put(capabilityDefinition.getType(), list);
 502
 503                 return capabilities;
 504         }
 505
 506         @Test
 507         public void testBuildName() {
 508                 doReturn("1").when(instanceProxy).getActualComponentUid();
 509                 doReturn("2").when(vfInstance).getActualComponentUid();
 510                 doReturn("3").when(vfcInstance).getActualComponentUid();
 511                 // region proxy
 512                 Component proxyOrigin = new Resource();
 513
 514                 proxyOrigin.setName("vepdgtp4837svc_proxy0");
 515                 proxyOrigin.setComponentType(ComponentTypeEnum.RESOURCE);
 516                 proxyOrigin.setComponentInstances(asList(vfInstance));
 517
 518                 // endregion
 519                 // region vf+vfc
 520                 vfInstance.setName("vepdgtp4837vf0");
 521                 vfInstance.setNormalizedName("vepdgtp4837vf0");
 522                 vfInstance.setUniqueId(
 523                                 "5f172af9-1588-443e-8897-1432b19aad8c.2cb7514a-1e50-4280-8457-baacb97b50bf.vepdgtp4837vf0");
 524                 vfComponent.setName("vepdgtp4837vf0"); // origin
 525                 vfComponent.setComponentInstances(Arrays.asList(vfcInstance));
 526                 vfcInstance.setUniqueId("41d3a665-1313-4b5e-9bf0-e901ecf4b806.a77df84e-83eb-4edc-9823-d1f9f6549693.lb_1");
 527                 vfcInstance.setName("lb_1");
 528                 vfcInstance.setNormalizedName("lb_1");
 529                 vfcInstance.setName("41d3a665-1313-4b5e-9bf0-e901ecf4b806.a77df84e-83eb-4edc-9823-d1f9f6549693.lb_1");
 530                 vfcComponent.setName("lb_1");
 531                 // endregion
 532                 Map<String, List<CapabilityDefinition>> capabilities = newCapabilities("port");
 533                 vfcComponent.setCapabilities(capabilities);
 534                 Map<Component, ComponentInstance> map = Collections
 535                                 .unmodifiableMap(new HashMap<Component, ComponentInstance>() {
 536                                         {
 537                                                 put(proxyOrigin, null);
 538                                                 put(vfComponent, vfInstance);
 539                                                 put(vfcComponent, vfcInstance);
 540                                         }
 541                                 });
 542                 Map<String, Component> cache = Collections.unmodifiableMap(new HashMap<String, Component>() {
 543                         {
 544                                 put("1", proxyOrigin);
 545                                 put("2", vfComponent);
 546                                 put("3", vfcComponent);
 547                         }
 548                 });
 549                 instanceProxy.setCapabilities(capabilities);
 550                 proxyOrigin.setCapabilities(capabilities);
 551                 List<CapabilityDefinition> flatList = capabilities.values().stream().flatMap(List::stream)
 552                                 .collect(Collectors.toList());
 553                 flatList.stream().forEach((CapabilityDefinition capabilityDefinition) -> {
 554                         String name = capabiltyRequirementConvertor.buildCapabilityNameForComponentInstance(cache, instanceProxy,
 555                                         capabilityDefinition);
 556                         System.out.println("built name -> " + name);
 557                         assertThat(name).isEqualTo("vepdgtp4837vf0.lb_1." + capabilityDefinition.getName());
 558                 });
 559         }
 560 }