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

   1 package org.openecomp.sdc.be.tosca;
   2
   3 import java.util.Iterator;
   4 import org.junit.Before;
   5 import org.junit.Test;
   6 import org.mockito.InjectMocks;
   7 import org.mockito.Mock;
   8 import org.mockito.Mockito;
   9 import org.mockito.MockitoAnnotations;
  10 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
  11 import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition;
  12 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  13 import org.openecomp.sdc.be.model.CapabilityDefinition;
  14 import org.openecomp.sdc.be.model.Component;
  15 import org.openecomp.sdc.be.model.ComponentInstance;
  16 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
  17 import org.openecomp.sdc.be.model.ComponentParametersView;
  18 import org.openecomp.sdc.be.model.DataTypeDefinition;
  19 import org.openecomp.sdc.be.model.RequirementDefinition;
  20 import org.openecomp.sdc.be.model.Resource;
  21 import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
  22 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  23 import org.openecomp.sdc.be.tosca.model.SubstitutionMapping;
  24 import org.openecomp.sdc.be.tosca.model.ToscaNodeTemplate;
  25 import org.openecomp.sdc.be.tosca.model.ToscaNodeType;
  26 import org.openecomp.sdc.be.tosca.model.ToscaTemplateCapability;
  27
  28
  29 import fj.data.Either;
  30 import mockit.Deencapsulation;
  31
  32 import java.util.*;
  33 import java.util.stream.Collectors;
  34
  35 import static java.util.Arrays.asList;
  36 import static org.assertj.core.api.Assertions.assertThat;
  37 import static org.mockito.Mockito.doReturn;
  38
  39 public class CapabilityRequirementConverterTest {
  40
  41         @InjectMocks
  42         CapabilityRequirementConverter testSubject;
  43
  44         @Mock
  45         ToscaOperationFacade toscaOperationFacade;
  46
  47         CapabilityRequirementConverter capabiltyRequirementConvertor = Mockito.spy(new CapabilityRequirementConverter());
  48         ComponentInstance instanceProxy = Mockito.spy(new ComponentInstance());
  49         ComponentInstance vfInstance = Mockito.spy(new ComponentInstance());
  50         Component vfComponent = Mockito.spy(new Resource());
  51         ComponentInstance vfcInstance = Mockito.spy(new ComponentInstance());
  52         Component vfcComponent = Mockito.spy(new Resource());
  53
  54         @Before
  55         public void setUpMock() throws Exception {
  56                 MockitoAnnotations.initMocks(this);
  57         }
  58
  59         @Test
  60         public void testGetInstance() {
  61                 CapabilityRequirementConverter.getInstance();
  62         }
  63
  64         @Test
  65         public void testConvertComponentInstanceCapabilties() {
  66                 Map<String, List<CapabilityDefinition>> capabilities = newCapabilities("port");
  67                 vfInstance.setCapabilities(capabilities);
  68                 ToscaNodeTemplate nodeTemplate = new ToscaNodeTemplate();
  69                 Map<String, DataTypeDefinition> testDataTypes = new HashMap<String, DataTypeDefinition>();
  70
  71                 capabilities.get("att.Node").clear();
  72                 testSubject.convertComponentInstanceCapabilities(vfInstance, testDataTypes, nodeTemplate);
  73
  74                 capabilities = newCapabilities("port");
  75                 vfInstance.setCapabilities(capabilities);
  76                 vfInstance.setComponentUid("uid");
  77
  78                 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
  79                                 Mockito.any(ComponentParametersView.class)))
  80                                 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
  81
  82                 testSubject.convertComponentInstanceCapabilities(vfInstance, testDataTypes, nodeTemplate);
  83
  84         }
  85
  86         @Test
  87         public void testConvertComponentInstanceCapabilties_1() {
  88                 Map<String, List<CapabilityDefinition>> capabilities = newCapabilities("port");
  89                 ToscaNodeTemplate nodeTemplate = new ToscaNodeTemplate();
  90                 Map<String, DataTypeDefinition> testDataTypes = new HashMap<String, DataTypeDefinition>();
  91
  92                 vfInstance.setComponentUid("uid");
  93
  94                 vfInstance.setCapabilities(capabilities);
  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
 105
 106         @Test
 107         public void testConvertSubstitutionMappingRequirements() {
 108                 Map<String, Component> componentsCache = new HashMap<>();
 109                 SubstitutionMapping substitution = new SubstitutionMapping();
 110                 Map<String, List<RequirementDefinition>> requirementsMap = new HashMap<String, List<RequirementDefinition>>();
 111                 List<RequirementDefinition> requirementsArray = new ArrayList<RequirementDefinition>();
 112                 RequirementDefinition definition = new RequirementDefinition();
 113                 definition.setOwnerId("id");
 114                 definition.setName("name");
 115                 definition.setParentName("parentName");
 116                 List<String> path = new ArrayList<>();
 117                 path.add("path1");
 118                 path.add("path2");
 119                 definition.setPath(path);
 120                 requirementsArray.add(definition);
 121                 requirementsMap.put("key", requirementsArray);
 122                 List<ComponentInstance> instances = new ArrayList<>();
 123                 ComponentInstance instance = new ComponentInstance();
 124                 instance.setUniqueId("uid");
 125                 instances.add(instance);
 126                 vfComponent.setRequirements(requirementsMap);
 127                 vfComponent.setComponentInstances(instances);
 128
 129                 testSubject.convertSubstitutionMappingRequirements(componentsCache, vfComponent, substitution);
 130         }
 131
 132         @Test
 133         public void testConvertSubstitutionMappingRequirements_1() {
 134                 Map<String, Component> componentsCache = new HashMap<>();
 135                 SubstitutionMapping substitution = new SubstitutionMapping();
 136                 Map<String, List<RequirementDefinition>> requirementsMap = new HashMap<String, List<RequirementDefinition>>();
 137                 List<RequirementDefinition> requirementsArray = new ArrayList<RequirementDefinition>();
 138                 RequirementDefinition definition = new RequirementDefinition();
 139                 definition.setName("name");
 140                 definition.setParentName("parentName");
 141                 List<String> path = new ArrayList<>();
 142                 path.add("path1.");
 143                 path.add("id");
 144                 definition.setPath(path);
 145                 requirementsArray.add(definition);
 146                 requirementsMap.put("key", requirementsArray);
 147                 List<ComponentInstance> instances = new ArrayList<>();
 148                 ComponentInstance instance = new ComponentInstance();
 149                 instance.setUniqueId("id");
 150                 instance.setComponentUid("id");
 151                 instances.add(instance);
 152                 vfComponent.setRequirements(requirementsMap);
 153                 vfComponent.setComponentInstances(instances);
 154
 155                 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
 156                                 Mockito.any(ComponentParametersView.class))).thenReturn(Either.left(vfcComponent));
 157
 158                 testSubject.convertSubstitutionMappingRequirements(componentsCache, vfComponent, substitution);
 159         }
 160
 161         @Test
 162         public void testConvertSubstitutionMappingRequirementsAsMap() {
 163                 Map<String, Component> componentsCache = new HashMap<>();
 164                 vfComponent.setRequirements(null);
 165
 166                 Deencapsulation.invoke(testSubject, "convertSubstitutionMappingRequirementsAsMap", componentsCache,
 167                                 vfComponent);
 168         }
 169
 170         @Test
 171         public void testBuildAddSubstitutionMappingsRequirements() {
 172                 Map<String, Component> componentsCache = new HashMap<>();
 173                 Map<String, List<RequirementDefinition>> requirementsMap = new HashMap<String, List<RequirementDefinition>>();
 174                 List<RequirementDefinition> requirementsArray = new ArrayList<RequirementDefinition>();
 175                 RequirementDefinition definition = new RequirementDefinition();
 176                 definition.setOwnerId("id");
 177                 definition.setName("name");
 178                 definition.setParentName("parentName");
 179                 List<String> path = new ArrayList<>();
 180                 path.add("path1");
 181                 path.add("path2");
 182                 definition.setPath(path);
 183                 requirementsArray.add(definition);
 184                 requirementsMap.put("key", requirementsArray);
 185                 vfComponent.setRequirements(requirementsMap);
 186                 List<ComponentInstance> componentInstances = new ArrayList<>();
 187                 ComponentInstance instance = new ComponentInstance();
 188                 instance.setUniqueId("id");
 189                 componentInstances.add(instance);
 190
 191                 vfComponent.setComponentInstances(componentInstances);
 192
 193                 Deencapsulation.invoke(testSubject, "buildAddSubstitutionMappingsRequirements", componentsCache, vfComponent,
 194                                 requirementsMap);
 195         }
 196
 197         @Test
 198         public void testBuildAddSubstitutionMappingsCapabilities() {
 199                 Map<String, Component> componentsCache = new HashMap<>();
 200                 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
 201
 202                 Deencapsulation.invoke(testSubject, "buildAddSubstitutionMappingsCapabilities", componentsCache, vfComponent,
 203                                 capabilities);
 204         }
 205
 206         @Test
 207         public void testBuildAddSubstitutionMappingsCapabilities_1() {
 208                 Map<String, Component> componentsCache = new HashMap<>();
 209                 Map<String, List<CapabilityDefinition>> capabilitiesMap = new HashMap<String, List<CapabilityDefinition>>();
 210                 List<CapabilityDefinition> capabilitiesArray = new ArrayList<CapabilityDefinition>();
 211                 CapabilityDefinition definition = new CapabilityDefinition();
 212                 definition.setOwnerId("id");
 213                 definition.setName("name");
 214                 definition.setParentName("parentName");
 215                 List<String> path = new ArrayList<>();
 216                 path.add("path1");
 217                 path.add("path2");
 218                 definition.setPath(path);
 219                 capabilitiesArray.add(definition);
 220                 capabilitiesMap.put("key", capabilitiesArray);
 221                 vfComponent.setCapabilities(capabilitiesMap);
 222                 List<ComponentInstance> componentInstances = new ArrayList<>();
 223                 ComponentInstance instance = new ComponentInstance();
 224                 instance.setUniqueId("id");
 225                 componentInstances.add(instance);
 226
 227                 vfComponent.setComponentInstances(componentInstances);
 228
 229                 Deencapsulation.invoke(testSubject, "buildAddSubstitutionMappingsCapabilities", componentsCache, vfComponent,
 230                                 capabilitiesMap);
 231         }
 232
 233         @Test
 234         public void testConvertProxyCapabilities() {
 235                 Map<String, Component> componentsCache = new HashMap<>();
 236                 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 237
 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                 testSubject.convertProxyCapabilities(componentsCache, vfComponent, vfComponent, instance, dataTypes);
 246         }
 247
 248         @Test
 249         public void testConvertProxyCapabilitiesWhenCapabilitiesNotNull() {
 250                 Map<String, Component> componentsCache = new HashMap<>();
 251                 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 252
 253                 List<ComponentInstance> componentInstances = new ArrayList<>();
 254                 ComponentInstance instance = new ComponentInstance();
 255                 instance.setUniqueId("id");
 256                 componentInstances.add(instance);
 257
 258                 vfComponent.setComponentInstances(componentInstances);
 259
 260                 Map<String, List<CapabilityDefinition>> capabilitiesMap = new HashMap<String, List<CapabilityDefinition>>();
 261                 List<CapabilityDefinition> capabilitiesArray = new ArrayList<CapabilityDefinition>();
 262                 CapabilityDefinition definition = new CapabilityDefinition();
 263                 definition.setOwnerId("id");
 264                 capabilitiesArray.add(definition);
 265                 capabilitiesMap.put("key", capabilitiesArray);
 266                 vfComponent.setUniqueId("id");
 267
 268                 instance.setCapabilities(capabilitiesMap);
 269                 instance.setComponentUid("uid");
 270
 271                 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
 272                                 Mockito.any(ComponentParametersView.class)))
 273                                 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
 274
 275                 testSubject.convertProxyCapabilities(componentsCache, vfComponent, vfComponent, instance, dataTypes);
 276         }
 277
 278         @Test
 279         public void testConvertSubstitutionMappingCapabilities() {
 280                 Map<String, Component> componentsCache = new HashMap<>();
 281
 282                 testSubject.convertSubstitutionMappingCapabilities(componentsCache, vfComponent);
 283
 284                 Map<String, List<CapabilityDefinition>> capabilitiesMap = new HashMap<String, List<CapabilityDefinition>>();
 285                 List<CapabilityDefinition> capabilitiesArray = new ArrayList<CapabilityDefinition>();
 286                 CapabilityDefinition definition = new CapabilityDefinition();
 287                 definition.setOwnerId("id");
 288                 definition.setName("name");
 289                 definition.setParentName("parentName");
 290                 List<String> path = new ArrayList<>();
 291                 path.add("path1");
 292                 path.add("id");
 293                 definition.setPath(path);
 294                 capabilitiesArray.add(definition);
 295                 capabilitiesMap.put("key", capabilitiesArray);
 296                 vfComponent.setCapabilities(capabilitiesMap);
 297
 298                 List<ComponentInstance> instances = new ArrayList<>();
 299                 ComponentInstance instance = new ComponentInstance();
 300                 instance.setUniqueId("uid");
 301                 instances.add(instance);
 302                 vfComponent.setComponentInstances(instances);
 303
 304                 testSubject.convertSubstitutionMappingCapabilities(componentsCache, vfComponent);
 305         }
 306
 307
 308         @Test
 309         public void testAppendNameRecursively() {
 310                 Map<String, Component> componentsCache = new HashMap<>();
 311                 StringBuilder builder = new StringBuilder();
 312                 List<String> path = new ArrayList<>();
 313
 314                 path.add("id");
 315                 Iterator<String> iter = path.iterator();
 316                 List<ComponentInstance> resourceInstances = new ArrayList<>();
 317                 ComponentInstance instance = new ComponentInstance();
 318                 instance.setUniqueId("id");
 319                 instance.setComponentUid("uid");
 320                 resourceInstances.add(instance);
 321                 vfComponent.setComponentInstances(resourceInstances);
 322
 323                 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
 324                                 Mockito.any(ComponentParametersView.class)))
 325                                 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
 326
 327                 Deencapsulation.invoke(testSubject, "appendNameRecursively", componentsCache, vfComponent, iter, builder);
 328
 329         }
 330
 331         @Test
 332         public void testGetFilter() {
 333                 ComponentInstance instance = new ComponentInstance();
 334                 instance.setIsProxy(true);
 335
 336                 Deencapsulation.invoke(testSubject, "getFilter", instance);
 337         }
 338
 339         @Test
 340         public void testGetReducedPathByOwner() throws Exception {
 341                 List<String> pathList = new ArrayList<>();
 342                 String uniqueId = "41d3a665-1313-4b5e-9bf0-e901ecf4b806.a77df84e-83eb-4edc-9823-d1f9f6549693.lb_2";
 343
 344                 String exerpt = "41d3a665-1313-4b5e-9bf0-e901ecf4b806.a77df84e-83eb-4edc-9823-d1f9f6549693.lb_1";
 345                 String duplicate = "a77df84e-83eb-4edc-9823-d1f9f6549693.c79e9a4a-b172-4323-a2e2-1c48d6603241.lb_swu_direct_4_rvmi";
 346                 pathList.add(exerpt);
 347                 pathList.add(duplicate);
 348                 pathList.add(duplicate);
 349                 pathList.add(uniqueId);
 350
 351                 pathList.add("5f172af9-1588-443e-8897-1432b19aad8c.2cb7514a-1e50-4280-8457-baacb97b50bf.vepdgtp4837vf0");
 352                 pathList.add("86ae128e-3d0a-41f7-a957-db1df9fe598c.9cc8f8ac-6869-4dd6-a6e1-74ecb9570dc4.vepdgtp4837svc_proxy0");
 353
 354         List<String> reducedMap = new CapabilityRequirementConverter().getReducedPathByOwner( pathList , uniqueId );
 355
 356                 assertThat(reducedMap).isNotNull().doesNotContain(exerpt).containsOnlyOnce(duplicate).hasSize(4);
 357
 358                 List<String> path = new ArrayList<String>();
 359
 360                 capabiltyRequirementConvertor.getReducedPathByOwner(path, uniqueId);
 361
 362                 path.add("");
 363                 capabiltyRequirementConvertor.getReducedPathByOwner(path, uniqueId);
 364                 capabiltyRequirementConvertor.getReducedPathByOwner(path, "");
 365         }
 366
 367         // generate stub capability
 368         private Map<String, List<CapabilityDefinition>> newCapabilities(String capabilityName) {
 369                 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
 370                 List<CapabilityDefinition> list = new ArrayList<>();
 371                 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
 372                 capabilityDefinition.setName(capabilityName);
 373                 capabilityDefinition.setType("att.Node");
 374                 List<ComponentInstanceProperty> properties = new ArrayList<>();
 375                 ComponentInstanceProperty prop = new ComponentInstanceProperty();
 376                 prop.setValue("value");
 377                 properties.add(prop);
 378                 capabilityDefinition.setProperties(properties);
 379                 List<String> pathList = new ArrayList<>();
 380
 381                 capabilityDefinition.setOwnerId("41d3a665-1313-4b5e-9bf0-e901ecf4b806.a77df84e-83eb-4edc-9823-d1f9f6549693");
 382                 pathList.add("41d3a665-1313-4b5e-9bf0-e901ecf4b806.a77df84e-83eb-4edc-9823-d1f9f6549693.lb_1");
 383                 // pathList.add("a77df84e-83eb-4edc-9823-d1f9f6549693.c79e9a4a-b172-4323-a2e2-1c48d6603241.lb_swu_direct_4_rvmi");
 384                 pathList.add("5f172af9-1588-443e-8897-1432b19aad8c.2cb7514a-1e50-4280-8457-baacb97b50bf.vepdgtp4837vf0");
 385                 pathList.add("86ae128e-3d0a-41f7-a957-db1df9fe598c.9cc8f8ac-6869-4dd6-a6e1-74ecb9570dc4.vepdgtp4837svc_proxy0");
 386
 387                 capabilityDefinition.setPath(pathList);
 388                 list.add(capabilityDefinition);
 389                 capabilities.put(capabilityDefinition.getType(), list);
 390
 391                 return capabilities;
 392         }
 393
 394         @Test
 395         public void testBuildName() {
 396                 doReturn("1").when(instanceProxy).getActualComponentUid();
 397                 doReturn("2").when(vfInstance).getActualComponentUid();
 398                 doReturn("3").when(vfcInstance).getActualComponentUid();
 399                 // region proxy
 400                 Component proxyOrigin = new Resource();
 401
 402                 proxyOrigin.setName("vepdgtp4837svc_proxy0");
 403                 proxyOrigin.setComponentType(ComponentTypeEnum.RESOURCE);
 404                 proxyOrigin.setComponentInstances(asList(vfInstance));
 405
 406                 // endregion
 407                 // region vf+vfc
 408                 vfInstance.setName("vepdgtp4837vf0");
 409                 vfInstance.setNormalizedName("vepdgtp4837vf0");
 410                 vfInstance.setUniqueId(
 411                                 "5f172af9-1588-443e-8897-1432b19aad8c.2cb7514a-1e50-4280-8457-baacb97b50bf.vepdgtp4837vf0");
 412                 vfComponent.setName("vepdgtp4837vf0"); // origin
 413                 vfComponent.setComponentInstances(Arrays.asList(vfcInstance));
 414                 vfcInstance.setUniqueId("41d3a665-1313-4b5e-9bf0-e901ecf4b806.a77df84e-83eb-4edc-9823-d1f9f6549693.lb_1");
 415                 vfcInstance.setName("lb_1");
 416                 vfcInstance.setNormalizedName("lb_1");
 417                 vfcInstance.setName("41d3a665-1313-4b5e-9bf0-e901ecf4b806.a77df84e-83eb-4edc-9823-d1f9f6549693.lb_1");
 418                 vfcComponent.setName("lb_1");
 419                 // endregion
 420                 Map<String, List<CapabilityDefinition>> capabilities = newCapabilities("port");
 421                 vfcComponent.setCapabilities(capabilities);
 422                 Map<Component, ComponentInstance> map = Collections
 423                                 .unmodifiableMap(new HashMap<Component, ComponentInstance>() {
 424                                         {
 425                                                 put(proxyOrigin, null);
 426                                                 put(vfComponent, vfInstance);
 427                                                 put(vfcComponent, vfcInstance);
 428                                         }
 429                                 });
 430                 Map<String, Component> cache = Collections.unmodifiableMap(new HashMap<String, Component>() {
 431                         {
 432                                 put("1", proxyOrigin);
 433                                 put("2", vfComponent);
 434                                 put("3", vfcComponent);
 435                         }
 436                 });
 437                 instanceProxy.setCapabilities(capabilities);
 438                 proxyOrigin.setCapabilities(capabilities);
 439                 List<CapabilityDefinition> flatList = capabilities.values().stream().flatMap(List::stream)
 440                                 .collect(Collectors.toList());
 441                 flatList.stream().forEach((CapabilityDefinition capabilityDefinition) -> {
 442                         String name = capabiltyRequirementConvertor.buildCapabilityNameForComponentInstance(cache, instanceProxy,
 443                                         capabilityDefinition);
 444                         System.out.println("built name -> " + name);
 445                         assertThat(name).isEqualTo("vepdgtp4837vf0.lb_1." + capabilityDefinition.getName());
 446                 });
 447         }
 448 }