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