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

   1 package org.openecomp.sdc.be.tosca;
   2
   3 import static java.util.Arrays.asList;
   4 import static org.assertj.core.api.Assertions.assertThat;
   5 import static org.mockito.Mockito.doReturn;
   6
   7 import java.util.ArrayList;
   8 import java.util.Arrays;
   9 import java.util.Collections;
  10 import java.util.HashMap;
  11 import java.util.Iterator;
  12 import java.util.List;
  13 import java.util.Map;
  14 import java.util.stream.Collectors;
  15
  16 import org.junit.Before;
  17 import org.junit.Test;
  18 import org.mockito.InjectMocks;
  19 import org.mockito.Mock;
  20 import org.mockito.Mockito;
  21 import org.mockito.MockitoAnnotations;
  22 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
  23 import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition;
  24 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  25 import org.openecomp.sdc.be.model.CapabilityDefinition;
  26 import org.openecomp.sdc.be.model.Component;
  27 import org.openecomp.sdc.be.model.ComponentInstance;
  28 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
  29 import org.openecomp.sdc.be.model.ComponentParametersView;
  30 import org.openecomp.sdc.be.model.DataTypeDefinition;
  31 import org.openecomp.sdc.be.model.RequirementDefinition;
  32 import org.openecomp.sdc.be.model.Resource;
  33 import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
  34 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  35 import org.openecomp.sdc.be.tosca.ToscaUtils.SubstituitionEntry;
  36 import org.openecomp.sdc.be.tosca.model.SubstitutionMapping;
  37 import org.openecomp.sdc.be.tosca.model.ToscaNodeTemplate;
  38 import org.openecomp.sdc.be.tosca.model.ToscaNodeType;
  39 import org.openecomp.sdc.be.tosca.model.ToscaTemplateCapability;
  40
  41 import fj.data.Either;
  42 import mockit.Deencapsulation;
  43
  44 public class CapabiltyRequirementConvertorTest {
  45
  46         @InjectMocks
  47         CapabiltyRequirementConvertor testSubject;
  48
  49         @Mock
  50         ToscaOperationFacade toscaOperationFacade;
  51
  52         CapabiltyRequirementConvertor capabiltyRequirementConvertor = Mockito.spy(new CapabiltyRequirementConvertor());
  53         ComponentInstance instanceProxy = Mockito.spy(new ComponentInstance());
  54         ComponentInstance vfInstance = Mockito.spy(new ComponentInstance());
  55         Component vfComponent = Mockito.spy(new Resource());
  56         ComponentInstance vfcInstance = Mockito.spy(new ComponentInstance());
  57         Component vfcComponent = Mockito.spy(new Resource());
  58
  59         @Before
  60         public void setUpMock() throws Exception {
  61                 MockitoAnnotations.initMocks(this);
  62         }
  63
  64         @Test
  65         public void testGetInstance() {
  66                 CapabiltyRequirementConvertor.getInstance();
  67         }
  68
  69         @Test
  70         public void testConvertComponentInstanceCapabilties() {
  71                 Map<String, List<CapabilityDefinition>> capabilities = newCapabilities("port");
  72                 vfInstance.setCapabilities(capabilities);
  73                 ToscaNodeTemplate nodeTemplate = new ToscaNodeTemplate();
  74                 Map<String, DataTypeDefinition> testDataTypes = new HashMap<String, DataTypeDefinition>();
  75
  76                 capabilities.get("att.Node").clear();
  77                 testSubject.convertComponentInstanceCapabilties(vfInstance, testDataTypes, nodeTemplate);
  78
  79                 capabilities = newCapabilities("port");
  80                 vfInstance.setCapabilities(capabilities);
  81                 vfInstance.setComponentUid("uid");
  82
  83                 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
  84                                 Mockito.any(ComponentParametersView.class)))
  85                                 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
  86
  87                 testSubject.convertComponentInstanceCapabilties(vfInstance, testDataTypes, nodeTemplate);
  88
  89         }
  90
  91         @Test
  92         public void testConvertComponentInstanceCapabilties_1() {
  93                 Map<String, List<CapabilityDefinition>> capabilities = newCapabilities("port");
  94                 ToscaNodeTemplate nodeTemplate = new ToscaNodeTemplate();
  95                 Map<String, DataTypeDefinition> testDataTypes = new HashMap<String, DataTypeDefinition>();
  96
  97                 vfInstance.setComponentUid("uid");
  98
  99                 vfInstance.setCapabilities(capabilities);
 100
 101                 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
 102                                 Mockito.any(ComponentParametersView.class)))
 103                                 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
 104
 105                 testSubject.convertComponentInstanceCapabilties(vfInstance, testDataTypes, nodeTemplate);
 106
 107         }
 108
 109         @Test
 110         public void testConvertOverridenProperty() {
 111                 ComponentInstance instance = new ComponentInstance();
 112                 Map<String, DataTypeDefinition> testDataTypes = new HashMap<String, DataTypeDefinition>();
 113                 Map<String, ToscaTemplateCapability> capabilities = new HashMap<>();
 114                 ComponentInstanceProperty p = new ComponentInstanceProperty();
 115                 SchemaDefinition entrySchema = new SchemaDefinition();
 116                 entrySchema.setProperty(new PropertyDataDefinition());
 117                 p.setSchema(entrySchema);
 118
 119                 Deencapsulation.invoke(testSubject, "convertOverridenProperty", instance, testDataTypes, capabilities, p,
 120                                 "port");
 121         }
 122
 123         @Test
 124         public void testConvertRequirements() {
 125                 ToscaNodeType nodeType = new ToscaNodeType();
 126
 127                 testSubject.convertRequirements(vfComponent, nodeType);
 128
 129         }
 130
 131         @Test
 132         public void testConvertRequirements_1() {
 133                 ToscaNodeType nodeType = new ToscaNodeType();
 134                 Map<String, List<RequirementDefinition>> requirementsMap = new HashMap<String, List<RequirementDefinition>>();
 135
 136                 List<RequirementDefinition> requirementsArray = new ArrayList<RequirementDefinition>();
 137                 RequirementDefinition definition = new RequirementDefinition();
 138                 definition.setOwnerId("id");
 139                 requirementsArray.add(definition);
 140                 requirementsMap.put("key", requirementsArray);
 141                 vfComponent.setRequirements(requirementsMap);
 142                 vfComponent.setUniqueId("id");
 143
 144                 testSubject.convertRequirements(vfComponent, nodeType);
 145
 146         }
 147
 148         @Test
 149         public void testConvertSubstitutionMappingRequirements() {
 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.setOwnerId("id");
 156                 definition.setName("name");
 157                 definition.setParentName("parentName");
 158                 List<String> path = new ArrayList<>();
 159                 path.add("path1");
 160                 path.add("path2");
 161                 definition.setPath(path);
 162                 requirementsArray.add(definition);
 163                 requirementsMap.put("key", requirementsArray);
 164                 List<ComponentInstance> instances = new ArrayList<>();
 165                 ComponentInstance instance = new ComponentInstance();
 166                 instance.setUniqueId("uid");
 167                 instances.add(instance);
 168                 vfComponent.setRequirements(requirementsMap);
 169                 vfComponent.setComponentInstances(instances);
 170
 171                 testSubject.convertSubstitutionMappingRequirements(componentsCache, vfComponent, substitution);
 172         }
 173
 174         @Test
 175         public void testConvertSubstitutionMappingRequirements_1() {
 176                 Map<String, Component> componentsCache = new HashMap<>();
 177                 SubstitutionMapping substitution = new SubstitutionMapping();
 178                 Map<String, List<RequirementDefinition>> requirementsMap = new HashMap<String, List<RequirementDefinition>>();
 179                 List<RequirementDefinition> requirementsArray = new ArrayList<RequirementDefinition>();
 180                 RequirementDefinition definition = new RequirementDefinition();
 181                 definition.setName("name");
 182                 definition.setParentName("parentName");
 183                 List<String> path = new ArrayList<>();
 184                 path.add("path1.");
 185                 path.add("id");
 186                 definition.setPath(path);
 187                 requirementsArray.add(definition);
 188                 requirementsMap.put("key", requirementsArray);
 189                 List<ComponentInstance> instances = new ArrayList<>();
 190                 ComponentInstance instance = new ComponentInstance();
 191                 instance.setUniqueId("id");
 192                 instance.setComponentUid("id");
 193                 instances.add(instance);
 194                 vfComponent.setRequirements(requirementsMap);
 195                 vfComponent.setComponentInstances(instances);
 196
 197                 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
 198                                 Mockito.any(ComponentParametersView.class))).thenReturn(Either.left(vfcComponent));
 199
 200                 testSubject.convertSubstitutionMappingRequirements(componentsCache, vfComponent, substitution);
 201         }
 202
 203         @Test
 204         public void testConvertSubstitutionMappingRequirementsAsMap() {
 205                 Map<String, Component> componentsCache = new HashMap<>();
 206                 vfComponent.setRequirements(null);
 207
 208                 Deencapsulation.invoke(testSubject, "convertSubstitutionMappingRequirementsAsMap", componentsCache,
 209                                 vfComponent);
 210         }
 211
 212         @Test
 213         public void testBuildAddSubstitutionMappingsRequirements() {
 214                 Map<String, Component> componentsCache = new HashMap<>();
 215                 Map<String, List<RequirementDefinition>> requirementsMap = new HashMap<String, List<RequirementDefinition>>();
 216                 List<RequirementDefinition> requirementsArray = new ArrayList<RequirementDefinition>();
 217                 RequirementDefinition definition = new RequirementDefinition();
 218                 definition.setOwnerId("id");
 219                 definition.setName("name");
 220                 definition.setParentName("parentName");
 221                 List<String> path = new ArrayList<>();
 222                 path.add("path1");
 223                 path.add("path2");
 224                 definition.setPath(path);
 225                 requirementsArray.add(definition);
 226                 requirementsMap.put("key", requirementsArray);
 227                 vfComponent.setRequirements(requirementsMap);
 228                 List<ComponentInstance> componentInstances = new ArrayList<>();
 229                 ComponentInstance instance = new ComponentInstance();
 230                 instance.setUniqueId("id");
 231                 componentInstances.add(instance);
 232
 233                 vfComponent.setComponentInstances(componentInstances);
 234
 235                 Deencapsulation.invoke(testSubject, "buildAddSubstitutionMappingsRequirements", componentsCache, vfComponent,
 236                                 requirementsMap);
 237         }
 238
 239         @Test
 240         public void testBuildAddSubstitutionMappingsCapabilities() {
 241                 Map<String, Component> componentsCache = new HashMap<>();
 242                 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
 243
 244                 Deencapsulation.invoke(testSubject, "buildAddSubstitutionMappingsCapabilities", componentsCache, vfComponent,
 245                                 capabilities);
 246         }
 247
 248         @Test
 249         public void testBuildAddSubstitutionMappingsCapabilities_1() {
 250                 Map<String, Component> componentsCache = new HashMap<>();
 251                 Map<String, List<CapabilityDefinition>> capabilitiesMap = new HashMap<String, List<CapabilityDefinition>>();
 252                 List<CapabilityDefinition> capabilitiesArray = new ArrayList<CapabilityDefinition>();
 253                 CapabilityDefinition definition = new CapabilityDefinition();
 254                 definition.setOwnerId("id");
 255                 definition.setName("name");
 256                 definition.setParentName("parentName");
 257                 List<String> path = new ArrayList<>();
 258                 path.add("path1");
 259                 path.add("path2");
 260                 definition.setPath(path);
 261                 capabilitiesArray.add(definition);
 262                 capabilitiesMap.put("key", capabilitiesArray);
 263                 vfComponent.setCapabilities(capabilitiesMap);
 264                 List<ComponentInstance> componentInstances = new ArrayList<>();
 265                 ComponentInstance instance = new ComponentInstance();
 266                 instance.setUniqueId("id");
 267                 componentInstances.add(instance);
 268
 269                 vfComponent.setComponentInstances(componentInstances);
 270
 271                 Deencapsulation.invoke(testSubject, "buildAddSubstitutionMappingsCapabilities", componentsCache, vfComponent,
 272                                 capabilitiesMap);
 273         }
 274
 275         @Test
 276         public void testBuildSubstitutedNamePerInstance() {
 277                 Map<String, Component> componentsCache = new HashMap<>();
 278                 String name = "name";
 279                 String ownerId = "id";
 280                 List<String> path = new ArrayList<>();
 281                 path.add("id");
 282                 SubstituitionEntry entry = new SubstituitionEntry();
 283
 284                 List<ComponentInstance> componentInstances = new ArrayList<>();
 285                 ComponentInstance instance = new ComponentInstance();
 286                 instance.setUniqueId("id");
 287                 instance.setComponentUid("uid");
 288                 componentInstances.add(instance);
 289
 290                 vfComponent.setComponentInstances(componentInstances);
 291
 292                 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
 293                                 Mockito.any(ComponentParametersView.class)))
 294                                 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
 295
 296                 Deencapsulation.invoke(testSubject, "buildSubstitutedNamePerInstance", componentsCache, vfComponent, name, path,
 297                                 ownerId, entry);
 298         }
 299
 300         @Test
 301         public void testConvertRequirement() {
 302                 RequirementDefinition definition = new RequirementDefinition();
 303                 List<String> path = new ArrayList<>();
 304                 path.add("value");
 305                 path.add("id");
 306                 definition.setName("name");
 307                 definition.setPath(path);
 308
 309                 List<ComponentInstance> componentInstances = new ArrayList<>();
 310                 ComponentInstance instance = new ComponentInstance();
 311                 instance.setUniqueId("id");
 312                 componentInstances.add(instance);
 313
 314                 vfComponent.setComponentInstances(componentInstances);
 315
 316                 Deencapsulation.invoke(testSubject, "convertRequirement", vfComponent, false, definition);
 317         }
 318
 319         @Test
 320         public void testConvertRequirement_1() {
 321                 RequirementDefinition definition = new RequirementDefinition();
 322                 List<String> path = new ArrayList<>();
 323                 path.add("id");
 324                 definition.setName("name");
 325                 definition.setPath(path);
 326
 327                 List<ComponentInstance> componentInstances = new ArrayList<>();
 328                 ComponentInstance instance = new ComponentInstance();
 329                 instance.setUniqueId("id");
 330                 componentInstances.add(instance);
 331
 332                 vfComponent.setComponentInstances(componentInstances);
 333
 334                 Deencapsulation.invoke(testSubject, "convertRequirement", vfComponent, false, definition);
 335         }
 336
 337         @Test
 338         public void testConvertRequirement_2() {
 339                 RequirementDefinition definition = new RequirementDefinition();
 340                 List<String> path = new ArrayList<>();
 341                 path.add("id");
 342                 definition.setName("name");
 343                 definition.setPath(path);
 344
 345                 List<ComponentInstance> componentInstances = new ArrayList<>();
 346                 ComponentInstance instance = new ComponentInstance();
 347                 instance.setUniqueId("id");
 348                 componentInstances.add(instance);
 349
 350                 vfComponent.setComponentInstances(componentInstances);
 351
 352                 path.add("value");
 353                 definition.setPath(path);
 354                 definition.setMaxOccurrences("1000");
 355
 356                 Deencapsulation.invoke(testSubject, "convertRequirement", vfComponent, false, definition);
 357         }
 358
 359         @Test
 360         public void testConvertCapabilities() {
 361                 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 362
 363                 testSubject.convertCapabilities(vfComponent, dataTypes);
 364
 365                 Map<String, List<CapabilityDefinition>> capabilitiesMap = new HashMap<String, List<CapabilityDefinition>>();
 366                 List<CapabilityDefinition> capabilitiesArray = new ArrayList<CapabilityDefinition>();
 367                 CapabilityDefinition definition = new CapabilityDefinition();
 368                 definition.setOwnerId("id");
 369                 capabilitiesArray.add(definition);
 370                 capabilitiesMap.put("key", capabilitiesArray);
 371                 vfComponent.setUniqueId("id");
 372                 vfComponent.setCapabilities(capabilitiesMap);
 373
 374                 testSubject.convertCapabilities(vfComponent, dataTypes);
 375         }
 376
 377         @Test
 378         public void testConvertProxyCapabilities() {
 379                 Map<String, Component> componentsCache = new HashMap<>();
 380                 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 381
 382                 List<ComponentInstance> componentInstances = new ArrayList<>();
 383                 ComponentInstance instance = new ComponentInstance();
 384                 instance.setUniqueId("id");
 385                 componentInstances.add(instance);
 386
 387                 vfComponent.setComponentInstances(componentInstances);
 388
 389                 testSubject.convertProxyCapabilities(componentsCache, vfComponent, vfComponent, instance, dataTypes);
 390         }
 391
 392         @Test
 393         public void testConvertProxyCapabilitiesWhenCapabilitiesNotNull() {
 394                 Map<String, Component> componentsCache = new HashMap<>();
 395                 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 396
 397                 List<ComponentInstance> componentInstances = new ArrayList<>();
 398                 ComponentInstance instance = new ComponentInstance();
 399                 instance.setUniqueId("id");
 400                 componentInstances.add(instance);
 401
 402                 vfComponent.setComponentInstances(componentInstances);
 403
 404                 Map<String, List<CapabilityDefinition>> capabilitiesMap = new HashMap<String, List<CapabilityDefinition>>();
 405                 List<CapabilityDefinition> capabilitiesArray = new ArrayList<CapabilityDefinition>();
 406                 CapabilityDefinition definition = new CapabilityDefinition();
 407                 definition.setOwnerId("id");
 408                 capabilitiesArray.add(definition);
 409                 capabilitiesMap.put("key", capabilitiesArray);
 410                 vfComponent.setUniqueId("id");
 411
 412                 instance.setCapabilities(capabilitiesMap);
 413                 instance.setComponentUid("uid");
 414
 415                 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
 416                                 Mockito.any(ComponentParametersView.class)))
 417                                 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
 418
 419                 testSubject.convertProxyCapabilities(componentsCache, vfComponent, vfComponent, instance, dataTypes);
 420         }
 421
 422         @Test
 423         public void testConvertSubstitutionMappingCapabilities() {
 424                 Map<String, Component> componentsCache = new HashMap<>();
 425
 426                 testSubject.convertSubstitutionMappingCapabilities(componentsCache, vfComponent);
 427
 428                 Map<String, List<CapabilityDefinition>> capabilitiesMap = new HashMap<String, List<CapabilityDefinition>>();
 429                 List<CapabilityDefinition> capabilitiesArray = new ArrayList<CapabilityDefinition>();
 430                 CapabilityDefinition definition = new CapabilityDefinition();
 431                 definition.setOwnerId("id");
 432                 definition.setName("name");
 433                 definition.setParentName("parentName");
 434                 List<String> path = new ArrayList<>();
 435                 path.add("path1");
 436                 path.add("id");
 437                 definition.setPath(path);
 438                 capabilitiesArray.add(definition);
 439                 capabilitiesMap.put("key", capabilitiesArray);
 440                 vfComponent.setCapabilities(capabilitiesMap);
 441
 442                 List<ComponentInstance> instances = new ArrayList<>();
 443                 ComponentInstance instance = new ComponentInstance();
 444                 instance.setUniqueId("uid");
 445                 instances.add(instance);
 446                 vfComponent.setComponentInstances(instances);
 447
 448                 testSubject.convertSubstitutionMappingCapabilities(componentsCache, vfComponent);
 449         }
 450
 451         @Test
 452         public void testGetCapabilityPath() {
 453                 CapabilityDefinition definition = new CapabilityDefinition();
 454                 List<String> path = new ArrayList<>();
 455                 path.add("value");
 456                 path.add("id");
 457                 definition.setName("name");
 458                 definition.setPath(path);
 459
 460                 List<ComponentInstance> componentInstances = new ArrayList<>();
 461                 ComponentInstance instance = new ComponentInstance();
 462                 instance.setUniqueId("id");
 463                 componentInstances.add(instance);
 464
 465                 vfComponent.setComponentInstances(componentInstances);
 466
 467                 Deencapsulation.invoke(testSubject, "getCapabilityPath", definition, vfComponent);
 468         }
 469
 470         @Test
 471         public void testGetCapabilityPath_1() {
 472                 CapabilityDefinition definition = new CapabilityDefinition();
 473                 List<String> path = new ArrayList<>();
 474                 path.add("id");
 475                 definition.setName("name");
 476                 definition.setPath(path);
 477
 478                 List<ComponentInstance> componentInstances = new ArrayList<>();
 479                 ComponentInstance instance = new ComponentInstance();
 480                 instance.setUniqueId("id");
 481                 componentInstances.add(instance);
 482
 483                 vfComponent.setComponentInstances(componentInstances);
 484
 485                 Deencapsulation.invoke(testSubject, "getCapabilityPath", definition, vfComponent);
 486         }
 487
 488         @Test
 489         public void testGetCapabilityPath_2() {
 490                 CapabilityDefinition definition = new CapabilityDefinition();
 491                 List<String> path = new ArrayList<>();
 492                 path.add("id");
 493                 definition.setName("name");
 494                 definition.setPath(path);
 495
 496                 List<ComponentInstance> componentInstances = new ArrayList<>();
 497                 ComponentInstance instance = new ComponentInstance();
 498                 instance.setUniqueId("id");
 499                 componentInstances.add(instance);
 500
 501                 vfComponent.setComponentInstances(componentInstances);
 502
 503                 path.add("value");
 504                 definition.setPath(path);
 505
 506                 Deencapsulation.invoke(testSubject, "getCapabilityPath", definition, vfComponent);
 507         }
 508
 509         @Test
 510         public void testConvertCapability_1() {
 511                 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 512
 513                 Map<String, List<CapabilityDefinition>> capabilitiesMap = new HashMap<String, List<CapabilityDefinition>>();
 514                 List<CapabilityDefinition> capabilitiesArray = new ArrayList<CapabilityDefinition>();
 515                 CapabilityDefinition definition = new CapabilityDefinition();
 516                 List<ComponentInstanceProperty> properties = new ArrayList<>();
 517                 properties.add(new ComponentInstanceProperty());
 518                 definition.setOwnerId("id");
 519                 definition.setName("name");
 520                 definition.setProperties(properties);
 521                 definition.setMaxOccurrences("1000");
 522                 List<String> path = new ArrayList<>();
 523                 path.add("value");
 524                 path.add("id");
 525                 definition.setPath(path);
 526                 capabilitiesArray.add(definition);
 527                 capabilitiesMap.put("key", capabilitiesArray);
 528                 vfComponent.setUniqueId("id");
 529                 vfComponent.setCapabilities(capabilitiesMap);
 530
 531                 List<ComponentInstance> componentInstances = new ArrayList<>();
 532                 ComponentInstance instance = new ComponentInstance();
 533                 instance.setUniqueId("id");
 534                 componentInstances.add(instance);
 535
 536                 vfComponent.setComponentInstances(componentInstances);
 537
 538                 Deencapsulation.invoke(testSubject, "convertCapabilty", vfComponent, new HashMap<>(), false, definition,
 539                                 dataTypes, "name");
 540         }
 541
 542         @Test
 543         public void testBuildSubstitutedName() {
 544                 ComponentInstance instance = new ComponentInstance();
 545                 instance.setUniqueId("id");
 546                 List<ComponentInstance> resourceInstances = new ArrayList<>();
 547                 resourceInstances.add(instance);
 548                 vfComponent.setComponentInstances(resourceInstances);
 549
 550                 List<String> path = new ArrayList<>();
 551                 path.add("notId");
 552
 553                 Deencapsulation.invoke(testSubject, "buildSubstitutedName", new HashMap<>(), vfComponent, path, "name");
 554         }
 555
 556         @Test
 557         public void testAppendNameRecursively() {
 558                 Map<String, Component> componentsCache = new HashMap<>();
 559                 StringBuilder builder = new StringBuilder();
 560                 List<String> path = new ArrayList<>();
 561
 562                 path.add("id");
 563                 Iterator<String> iter = path.iterator();
 564                 List<ComponentInstance> resourceInstances = new ArrayList<>();
 565                 ComponentInstance instance = new ComponentInstance();
 566                 instance.setUniqueId("id");
 567                 instance.setComponentUid("uid");
 568                 resourceInstances.add(instance);
 569                 vfComponent.setComponentInstances(resourceInstances);
 570
 571                 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
 572                                 Mockito.any(ComponentParametersView.class)))
 573                                 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
 574
 575                 Deencapsulation.invoke(testSubject, "appendNameRecursively", componentsCache, vfComponent, iter, builder);
 576
 577         }
 578
 579         @Test
 580         public void testGetFilter() {
 581                 ComponentInstance instance = new ComponentInstance();
 582                 instance.setIsProxy(true);
 583
 584                 Deencapsulation.invoke(testSubject, "getFilter", instance);
 585         }
 586
 587         @Test
 588         public void testGetReducedPathByOwner() throws Exception {
 589                 List<String> pathList = new ArrayList<>();
 590                 String uniqueId = "41d3a665-1313-4b5e-9bf0-e901ecf4b806.a77df84e-83eb-4edc-9823-d1f9f6549693.lb_2";
 591
 592                 String exerpt = "41d3a665-1313-4b5e-9bf0-e901ecf4b806.a77df84e-83eb-4edc-9823-d1f9f6549693.lb_1";
 593                 String duplicate = "a77df84e-83eb-4edc-9823-d1f9f6549693.c79e9a4a-b172-4323-a2e2-1c48d6603241.lb_swu_direct_4_rvmi";
 594                 pathList.add(exerpt);
 595                 pathList.add(duplicate);
 596                 pathList.add(duplicate);
 597                 pathList.add(uniqueId);
 598
 599                 pathList.add("5f172af9-1588-443e-8897-1432b19aad8c.2cb7514a-1e50-4280-8457-baacb97b50bf.vepdgtp4837vf0");
 600                 pathList.add("86ae128e-3d0a-41f7-a957-db1df9fe598c.9cc8f8ac-6869-4dd6-a6e1-74ecb9570dc4.vepdgtp4837svc_proxy0");
 601
 602                 List<String> reducedMap = new CapabiltyRequirementConvertor().getReducedPathByOwner(pathList, uniqueId);
 603
 604                 assertThat(reducedMap).isNotNull().doesNotContain(exerpt).containsOnlyOnce(duplicate).hasSize(4);
 605
 606                 List<String> path = new ArrayList<String>();
 607
 608                 capabiltyRequirementConvertor.getReducedPathByOwner(path, uniqueId);
 609
 610                 path.add("");
 611                 capabiltyRequirementConvertor.getReducedPathByOwner(path, uniqueId);
 612                 capabiltyRequirementConvertor.getReducedPathByOwner(path, "");
 613         }
 614
 615         // generate stub capability
 616         private Map<String, List<CapabilityDefinition>> newCapabilities(String capabilityName) {
 617                 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
 618                 List<CapabilityDefinition> list = new ArrayList<>();
 619                 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
 620                 capabilityDefinition.setName(capabilityName);
 621                 capabilityDefinition.setType("att.Node");
 622                 List<ComponentInstanceProperty> properties = new ArrayList<>();
 623                 ComponentInstanceProperty prop = new ComponentInstanceProperty();
 624                 prop.setValue("value");
 625                 properties.add(prop);
 626                 capabilityDefinition.setProperties(properties);
 627                 List<String> pathList = new ArrayList<>();
 628
 629                 capabilityDefinition.setOwnerId("41d3a665-1313-4b5e-9bf0-e901ecf4b806.a77df84e-83eb-4edc-9823-d1f9f6549693");
 630                 pathList.add("41d3a665-1313-4b5e-9bf0-e901ecf4b806.a77df84e-83eb-4edc-9823-d1f9f6549693.lb_1");
 631                 // pathList.add("a77df84e-83eb-4edc-9823-d1f9f6549693.c79e9a4a-b172-4323-a2e2-1c48d6603241.lb_swu_direct_4_rvmi");
 632                 pathList.add("5f172af9-1588-443e-8897-1432b19aad8c.2cb7514a-1e50-4280-8457-baacb97b50bf.vepdgtp4837vf0");
 633                 pathList.add("86ae128e-3d0a-41f7-a957-db1df9fe598c.9cc8f8ac-6869-4dd6-a6e1-74ecb9570dc4.vepdgtp4837svc_proxy0");
 634
 635                 capabilityDefinition.setPath(pathList);
 636                 list.add(capabilityDefinition);
 637                 capabilities.put(capabilityDefinition.getType(), list);
 638
 639                 return capabilities;
 640         }
 641
 642         @Test
 643         public void testBuildName() {
 644                 doReturn("1").when(instanceProxy).getActualComponentUid();
 645                 doReturn("2").when(vfInstance).getActualComponentUid();
 646                 doReturn("3").when(vfcInstance).getActualComponentUid();
 647                 // region proxy
 648                 Component proxyOrigin = new Resource();
 649
 650                 proxyOrigin.setName("vepdgtp4837svc_proxy0");
 651                 proxyOrigin.setComponentType(ComponentTypeEnum.RESOURCE);
 652                 proxyOrigin.setComponentInstances(asList(vfInstance));
 653
 654                 // endregion
 655                 // region vf+vfc
 656                 vfInstance.setName("vepdgtp4837vf0");
 657                 vfInstance.setNormalizedName("vepdgtp4837vf0");
 658                 vfInstance.setUniqueId(
 659                                 "5f172af9-1588-443e-8897-1432b19aad8c.2cb7514a-1e50-4280-8457-baacb97b50bf.vepdgtp4837vf0");
 660                 vfComponent.setName("vepdgtp4837vf0"); // origin
 661                 vfComponent.setComponentInstances(Arrays.asList(vfcInstance));
 662                 vfcInstance.setUniqueId("41d3a665-1313-4b5e-9bf0-e901ecf4b806.a77df84e-83eb-4edc-9823-d1f9f6549693.lb_1");
 663                 vfcInstance.setName("lb_1");
 664                 vfcInstance.setNormalizedName("lb_1");
 665                 vfcInstance.setName("41d3a665-1313-4b5e-9bf0-e901ecf4b806.a77df84e-83eb-4edc-9823-d1f9f6549693.lb_1");
 666                 vfcComponent.setName("lb_1");
 667                 // endregion
 668                 Map<String, List<CapabilityDefinition>> capabilities = newCapabilities("port");
 669                 vfcComponent.setCapabilities(capabilities);
 670                 Map<Component, ComponentInstance> map = Collections
 671                                 .unmodifiableMap(new HashMap<Component, ComponentInstance>() {
 672                                         {
 673                                                 put(proxyOrigin, null);
 674                                                 put(vfComponent, vfInstance);
 675                                                 put(vfcComponent, vfcInstance);
 676                                         }
 677                                 });
 678                 Map<String, Component> cache = Collections.unmodifiableMap(new HashMap<String, Component>() {
 679                         {
 680                                 put("1", proxyOrigin);
 681                                 put("2", vfComponent);
 682                                 put("3", vfcComponent);
 683                         }
 684                 });
 685                 instanceProxy.setCapabilities(capabilities);
 686                 proxyOrigin.setCapabilities(capabilities);
 687                 List<CapabilityDefinition> flatList = capabilities.values().stream().flatMap(List::stream)
 688                                 .collect(Collectors.toList());
 689                 flatList.stream().forEach((CapabilityDefinition capabilityDefinition) -> {
 690                         String name = capabiltyRequirementConvertor.buildCapabilityNameForComponentInstance(cache, instanceProxy,
 691                                         capabilityDefinition);
 692                         System.out.println("built name -> " + name);
 693                         assertThat(name).isEqualTo("vepdgtp4837vf0.lb_1." + capabilityDefinition.getName());
 694                 });
 695         }
 696 }