catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/utils/ModelConverterTest.java

   1 /*
   2
   3  * Copyright (c) 2018 Huawei Intellectual Property.
   4
   5  *
   6
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8
   9  * you may not use this file except in compliance with the License.
  10
  11  * You may obtain a copy of the License at
  12
  13  *
  14
  15  *     http://www.apache.org/licenses/LICENSE-2.0
  16
  17  *
  18
  19  * Unless required by applicable law or agreed to in writing, software
  20
  21  * distributed under the License is distributed on an "AS IS" BASIS,
  22
  23  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  24
  25  * See the License for the specific language governing permissions and
  26
  27  * limitations under the License.
  28
  29  */
  30 package org.openecomp.sdc.be.model.jsonjanusgraph.utils;
  31
  32 import java.util.HashMap;
  33
  34 import org.junit.jupiter.api.Test;
  35 import org.junit.jupiter.api.extension.ExtendWith;
  36 import org.mockito.InjectMocks;
  37
  38 import org.mockito.junit.jupiter.MockitoExtension;
  39 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
  40 import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
  41 import org.openecomp.sdc.be.datatypes.elements.AttributeDataDefinition;
  42 import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition;
  43 import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition;
  44 import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition;
  45 import org.openecomp.sdc.be.datatypes.elements.MapAttributesDataDefinition;
  46 import org.openecomp.sdc.be.datatypes.elements.MapCapabilityProperty;
  47 import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition;
  48 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
  49 import org.openecomp.sdc.be.datatypes.elements.RelationshipInstDataDefinition;
  50 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  51 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  52 import org.openecomp.sdc.be.model.AttributeDefinition;
  53 import org.openecomp.sdc.be.model.ComponentInstance;
  54 import org.openecomp.sdc.be.model.CapabilityDefinition;
  55 import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
  56 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
  57 import org.openecomp.sdc.be.model.OutputDefinition;
  58 import org.openecomp.sdc.be.model.Resource;
  59 import org.openecomp.sdc.be.model.RelationshipInfo;
  60 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
  61 import org.openecomp.sdc.be.model.RelationshipTypeDefinition;
  62 import org.openecomp.sdc.be.model.RelationshipImpl;
  63
  64 import org.openecomp.sdc.be.model.Service;
  65 import org.openecomp.sdc.be.model.Component;
  66
  67
  68 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.TopologyTemplate;
  69 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.NodeType;
  70 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElementTypeEnum;
  71
  72 import java.util.LinkedList;
  73 import java.util.List;
  74 import java.util.Map;
  75 import org.openecomp.sdc.be.model.tosca.ToscaType;
  76 import org.openecomp.sdc.be.ui.model.OperationUi;
  77 import org.openecomp.sdc.be.ui.model.PropertyAssignmentUi;
  78
  79 import static org.junit.jupiter.api.Assertions.assertEquals;
  80 import static org.junit.jupiter.api.Assertions.assertFalse;
  81 import static org.junit.jupiter.api.Assertions.assertTrue;
  82 import static org.junit.jupiter.api.Assertions.assertNull;
  83 import static org.junit.jupiter.api.Assertions.assertNotNull;
  84
  85
  86 @ExtendWith(MockitoExtension.class)
  87 public class ModelConverterTest {
  88     @InjectMocks
  89     private ModelConverter test;
  90
  91     @Test
  92     public void testConvertToToscaElementService()
  93     {
  94         Service service = new Service();
  95         service.setComponentType(ComponentTypeEnum.SERVICE);
  96         TopologyTemplate template = test.convertToToscaElement(service);
  97         assertEquals(ToscaElementTypeEnum.TOPOLOGY_TEMPLATE, template.getToscaType());
  98     }
  99
 100     @Test
 101     public void testConvertToToscaElementResource()
 102     {
 103         Resource resource = new Resource();
 104         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 105         NodeType nodeType = test.convertToToscaElement(resource);
 106         assertEquals(ToscaElementTypeEnum.NODE_TYPE, nodeType.getToscaType());
 107     }
 108
 109     @Test
 110     public void testConvertFromToscaElementService()
 111     {
 112         TopologyTemplate topologyTemplate = new TopologyTemplate();
 113         topologyTemplate.setComponentType(ComponentTypeEnum.SERVICE);
 114         Component component = test.convertFromToscaElement(topologyTemplate);
 115         assertEquals(ToscaElementTypeEnum.TOPOLOGY_TEMPLATE.getValue(), component.getToscaType());
 116
 117         topologyTemplate.setComponentType(ComponentTypeEnum.PRODUCT);
 118         component = test.convertFromToscaElement(topologyTemplate);
 119         assertEquals(ToscaElementTypeEnum.TOPOLOGY_TEMPLATE.getValue(), component.getToscaType());
 120
 121         NodeType nodeType = new NodeType();
 122         nodeType.setComponentType(ComponentTypeEnum.RESOURCE);
 123         topologyTemplate.setToscaType(ToscaElementTypeEnum.NODE_TYPE);
 124         component = test.convertFromToscaElement(nodeType);
 125         assertEquals(ToscaElementTypeEnum.NODE_TYPE.getValue(), component.getToscaType());
 126
 127         topologyTemplate.setComponentType(ComponentTypeEnum.RESOURCE_INSTANCE);
 128         assertNull(test.convertFromToscaElement(topologyTemplate));
 129     }
 130
 131     @Test
 132     public void testConvertFromToscaElementServiceWithSelfCapabilities()
 133     {
 134         TopologyTemplate topologyTemplate = new TopologyTemplate();
 135
 136         Map<String, MapPropertiesDataDefinition> capabilitiesProperties = CapabilityTestUtils
 137                 .createCapPropsForTopologyTemplate(topologyTemplate);
 138
 139         topologyTemplate.setCapabilitiesProperties(capabilitiesProperties);
 140
 141         topologyTemplate.setComponentType(ComponentTypeEnum.SERVICE);
 142         Component component = test.convertFromToscaElement(topologyTemplate);
 143         assertEquals(ToscaElementTypeEnum.TOPOLOGY_TEMPLATE.getValue(), component.getToscaType());
 144     }
 145
 146     @Test
 147     public void testConvertFromToscaElementResource()
 148     {
 149         TopologyTemplate topologyTemplate = new TopologyTemplate();
 150         topologyTemplate.setComponentType(ComponentTypeEnum.RESOURCE);
 151         Component component = test.convertFromToscaElement(topologyTemplate);
 152         assertEquals(ToscaElementTypeEnum.TOPOLOGY_TEMPLATE.getValue(), component.getToscaType());
 153     }
 154
 155     @Test
 156     public void testConvertFromToscaElementResourceType() {
 157         TopologyTemplate topologyTemplate = new TopologyTemplate();
 158         topologyTemplate.setComponentType(ComponentTypeEnum.RESOURCE);
 159         topologyTemplate.setResourceType(ResourceTypeEnum.PNF);
 160         Resource resource = test.convertFromToscaElement(topologyTemplate);
 161         assertEquals(ResourceTypeEnum.PNF, resource.getResourceType());
 162     }
 163
 164     @Test
 165     public void testConvertFromToscaElementResourceOutputs() {
 166         final TopologyTemplate topologyTemplate = new TopologyTemplate();
 167         topologyTemplate.setComponentType(ComponentTypeEnum.RESOURCE);
 168         final OutputDefinition outputDefinition = new OutputDefinition();
 169         final Map<String, AttributeDataDefinition> map = new HashMap<>();
 170         map.put("mock", outputDefinition);
 171         topologyTemplate.setOutputs(map);
 172         final Resource resource = test.convertFromToscaElement(topologyTemplate);
 173         assertNotNull(resource.getOutputs());
 174         assertFalse(resource.getOutputs().isEmpty());
 175     }
 176
 177     @Test
 178     public void testConvertFromToscaElementResourceComponentInstancesOutputs() {
 179         final TopologyTemplate topologyTemplate = new TopologyTemplate();
 180         topologyTemplate.setComponentType(ComponentTypeEnum.RESOURCE);
 181
 182         final Map<String, MapAttributesDataDefinition> instOutputs = new HashMap<>();
 183         final MapAttributesDataDefinition mapAttributesDataDefinition = new MapAttributesDataDefinition();
 184         final AttributeDefinition attributeDefinition = new AttributeDefinition();
 185         final Map<String, AttributeDataDefinition> mapToscaDataDefinition = new HashMap<>();
 186         mapToscaDataDefinition.put("mock", attributeDefinition);
 187         mapAttributesDataDefinition.setMapToscaDataDefinition(mapToscaDataDefinition);
 188         instOutputs.put("mock", mapAttributesDataDefinition);
 189         topologyTemplate.setInstOutputs(instOutputs);
 190
 191         final Map<String, ComponentInstanceDataDefinition> componentInstanceDataDefinitionMap = new HashMap<>();
 192         componentInstanceDataDefinitionMap.put("mock", new ComponentInstance());
 193         topologyTemplate.setComponentInstances(componentInstanceDataDefinitionMap);
 194
 195         final Resource resource = test.convertFromToscaElement(topologyTemplate);
 196         assertNotNull(resource);
 197         assertNotNull(resource.getComponentInstancesOutputs());
 198         assertFalse(resource.getComponentInstancesOutputs().isEmpty());
 199     }
 200
 201     @Test
 202     public void testIsAtomicComponent() {
 203         Resource component = new Resource();
 204         component.setComponentType(ComponentTypeEnum.SERVICE);
 205         assertFalse(test.isAtomicComponent(component));
 206
 207         component.setComponentType(ComponentTypeEnum.RESOURCE);
 208         assertTrue(test.isAtomicComponent(component));
 209
 210         ResourceTypeEnum resourceType = null;
 211         assertFalse(test.isAtomicComponent(resourceType));
 212     }
 213
 214     @Test
 215     public void testGetVertexType()
 216     {
 217         VertexTypeEnum result;
 218         Resource component = new Resource();
 219         component.setComponentType(ComponentTypeEnum.SERVICE);
 220         assertEquals("topology_template", test.getVertexType(component).getName());
 221         component.setComponentType(ComponentTypeEnum.RESOURCE);
 222         assertEquals("node_type", test.getVertexType(component).getName());
 223
 224         assertEquals(VertexTypeEnum.TOPOLOGY_TEMPLATE, test.getVertexType("Service"));
 225         assertEquals(VertexTypeEnum.NODE_TYPE, test.getVertexType("VFC"));
 226     }
 227
 228     @Test
 229     public void testConvertRelation()
 230     {
 231         RelationshipTypeDefinition relationshipDef = new RelationshipTypeDefinition();
 232         relationshipDef.setFromId("formId");
 233         relationshipDef.setToId("toId");
 234         relationshipDef.setOriginUI(true);
 235         RequirementCapabilityRelDef result = ModelConverter.convertRelation(relationshipDef);
 236
 237         assertEquals("formId", result.getFromNode());
 238         assertEquals("toId", result.getToNode());
 239         assertEquals(true, result.isOriginUI());
 240         assertEquals(1, result.getRelationships().size());
 241     }
 242
 243     @Test
 244     public void testConvertRelationToToscaRelation()
 245     {
 246         RequirementCapabilityRelDef reqCap = new RequirementCapabilityRelDef();
 247         reqCap.setOriginUI(true);
 248         reqCap.setFromNode("fromNode");
 249         reqCap.setToNode("toNode");
 250         List<CapabilityRequirementRelationship> list = new LinkedList<>();
 251         CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
 252         RelationshipInfo info = new RelationshipInfo();
 253         info.setCapabilityOwnerId("capOwnerId");
 254         info.setId("id");
 255         info.setCapabilityUid("capUid");
 256         info.setRequirementOwnerId("reqOwnerId");
 257         info.setRequirementUid("reqUid");
 258         info.setRequirement("req");
 259         info.setCapability("cap");
 260         RelationshipImpl relationshipImpl = new RelationshipImpl();
 261         relationshipImpl.setType("type");
 262         info.setRelationships(relationshipImpl);
 263         relationship.setRelation(info);
 264         list.add(relationship);
 265         reqCap.setRelationships(list);
 266
 267         List<RelationshipInstDataDefinition> result = ModelConverter.convertRelationToToscaRelation(reqCap);
 268         assertEquals(1, result.size());
 269         assertEquals("capOwnerId", result.get(0).getCapabilityOwnerId());
 270         assertEquals("id", result.get(0).getUniqueId());
 271         assertEquals("capUid", result.get(0).getCapabilityId());
 272         assertEquals("reqOwnerId", result.get(0).getRequirementOwnerId());
 273         assertEquals("reqUid", result.get(0).getRequirementId());
 274         assertEquals("req", result.get(0).getRequirement());
 275         assertEquals("cap", result.get(0).getCapability());
 276         assertEquals("type", result.get(0).getType());
 277         assertEquals(true, result.get(0).isOriginUI());
 278         assertEquals("fromNode", result.get(0).getFromId());
 279         assertEquals("toNode", result.get(0).getToId());
 280     }
 281
 282     @Test
 283     void testConvertRelationTemplateToToscaRelation()
 284     {
 285         RequirementCapabilityRelDef reqCap = new RequirementCapabilityRelDef();
 286         reqCap.setOriginUI(true);
 287         reqCap.setFromNode("fromNode");
 288         reqCap.setToNode("toNode");
 289         List<CapabilityRequirementRelationship> list = new LinkedList<>();
 290         CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
 291         RelationshipInfo info = new RelationshipInfo();
 292         info.setCapabilityOwnerId("capOwnerId");
 293         info.setId("id");
 294         info.setCapabilityUid("capUid");
 295         info.setRequirementOwnerId("reqOwnerId");
 296         info.setRequirementUid("reqUid");
 297         info.setRequirement("req");
 298         info.setCapability("cap");
 299         RelationshipImpl relationshipImpl = new RelationshipImpl();
 300         relationshipImpl.setType("type");
 301         info.setRelationships(relationshipImpl);
 302         relationship.setRelation(info);
 303         OperationUi operationUi = new OperationUi();
 304         operationUi.setInterfaceType("tosca.interfaces.relationship.Configure");
 305         operationUi.setOperationType("add_source");
 306         final ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition();
 307         artifactDataDefinition.setArtifactName("impl");
 308         operationUi.setImplementation(artifactDataDefinition);
 309         PropertyAssignmentUi propertyAssignmentUi = new PropertyAssignmentUi();
 310         propertyAssignmentUi.setName("strInput1");
 311         propertyAssignmentUi.setType(ToscaType.STRING.getType());
 312         propertyAssignmentUi.setValue("inputValue");
 313         operationUi.setInputs(List.of(propertyAssignmentUi));
 314         relationship.setOperations(List.of(operationUi));
 315         list.add(relationship);
 316         reqCap.setRelationships(list);
 317
 318         List<RelationshipInstDataDefinition> result = ModelConverter.convertRelationToToscaRelation(reqCap);
 319         assertEquals(1, result.size());
 320         assertEquals(false, result.get(0).getInterfaces().isEmpty());
 321         assertEquals(false, result.get(0).getInterfaces().getListToscaDataDefinition().get(0).getOperations().isEmpty());
 322         assertEquals(false, result.get(0).getInterfaces().getListToscaDataDefinition().get(0).getOperations().get("add_source").getInputs().isEmpty());
 323     }
 324
 325     @Test
 326     public void testConvertToMapOfMapCapabilityPropertiesonvertRelation()
 327     {
 328         Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
 329         MapCapabilityProperty result = ModelConverter.convertToMapOfMapCapabilityProperties(capabilities, "ownerId", true);
 330         assertNotNull(result);
 331         assertEquals(0, result.getMapToscaDataDefinition().size());
 332
 333         List<CapabilityDefinition> list = new LinkedList<>();
 334         CapabilityDefinition capDef = new CapabilityDefinition();
 335         List<ComponentInstanceProperty> properties = new LinkedList<>();
 336         ComponentInstanceProperty property = new ComponentInstanceProperty();
 337         properties.add(property);
 338         capDef.setProperties(properties);
 339         list.add(capDef);
 340         capabilities.put("test", list);
 341         result = ModelConverter.convertToMapOfMapCapabilityProperties(capabilities, "ownerId", true);
 342         assertEquals(1, result.getMapToscaDataDefinition().size());
 343     }
 344
 345     @Test
 346     public void testBuildCapabilityPropertyKey()
 347     {
 348         CapabilityDefinition capDef = new CapabilityDefinition();
 349         capDef.setOwnerId("owner");
 350         String result = ModelConverter.buildCapabilityPropertyKey(true,"type","name", "capId", capDef);
 351
 352         assertEquals("capId#owner#type#name", result);
 353     }
 354
 355     @Test
 356     public void testConvertToMapOfMapCapabiltyProperties()
 357     {
 358         Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
 359         List<CapabilityDefinition> list = new LinkedList<>();
 360         CapabilityDefinition capDef = new CapabilityDefinition();
 361         List<ComponentInstanceProperty> properties = new LinkedList<>();
 362         ComponentInstanceProperty property = new ComponentInstanceProperty();
 363         properties.add(property);
 364         capDef.setProperties(properties);
 365         list.add(capDef);
 366         capabilities.put("test", list);
 367
 368         MapCapabilityProperty result = ModelConverter.convertToMapOfMapCapabiltyProperties(capabilities, "ownerId", true);
 369
 370         assertEquals(1, result.getMapToscaDataDefinition().size());
 371         assertNotNull(result.getMapToscaDataDefinition().get("ownerId#ownerId#test#null"));
 372     }
 373
 374     @Test
 375     public void testGetCapabilitiesMapFromMapObject()
 376     {
 377         assertNull(ModelConverter.getCapabilitiesMapFromMapObject(null, null));
 378
 379         Map<String, ListCapabilityDataDefinition> toscaCapabilities = new HashMap<>();
 380         Map<String, MapPropertiesDataDefinition> toscaCapPropMap = new HashMap<>();
 381         ListCapabilityDataDefinition dataDefList = new ListCapabilityDataDefinition();
 382         List<CapabilityDataDefinition> capDataDefList = new LinkedList<>();
 383         CapabilityDataDefinition capDataDef = new CapabilityDataDefinition();
 384         capDataDef.setName("test");
 385         capDataDefList.add(capDataDef);
 386         dataDefList.setListToscaDataDefinition(capDataDefList);
 387         MapPropertiesDataDefinition dataDefMap = new MapPropertiesDataDefinition();
 388         Map<String, PropertyDataDefinition> propDataMap = new HashMap<>();
 389         PropertyDataDefinition propertyDataDefinition = new PropertyDataDefinition();
 390         propDataMap.put("propMap", propertyDataDefinition);
 391         dataDefMap.setMapToscaDataDefinition(propDataMap);
 392         toscaCapabilities.put("prop", dataDefList);
 393         toscaCapPropMap.put("prop#test", dataDefMap);
 394
 395         Map<String, List<CapabilityDefinition>> result = ModelConverter.getCapabilitiesMapFromMapObject(toscaCapabilities, toscaCapPropMap);
 396         assertEquals(1, result.size());
 397     }
 398 }