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
  33 import java.util.HashMap;
  34
  35 import org.junit.jupiter.api.Test;
  36 import org.junit.jupiter.api.extension.ExtendWith;
  37 import org.mockito.InjectMocks;
  38
  39 import org.mockito.junit.jupiter.MockitoExtension;
  40 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
  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
  76 import static org.junit.jupiter.api.Assertions.assertEquals;
  77 import static org.junit.jupiter.api.Assertions.assertFalse;
  78 import static org.junit.jupiter.api.Assertions.assertTrue;
  79 import static org.junit.jupiter.api.Assertions.assertNull;
  80 import static org.junit.jupiter.api.Assertions.assertNotNull;
  81
  82
  83 @ExtendWith(MockitoExtension.class)
  84 public class ModelConverterTest {
  85     @InjectMocks
  86     private ModelConverter test;
  87
  88     @Test
  89     public void testConvertToToscaElementService()
  90     {
  91         Service service = new Service();
  92         service.setComponentType(ComponentTypeEnum.SERVICE);
  93         TopologyTemplate template = test.convertToToscaElement(service);
  94         assertEquals(ToscaElementTypeEnum.TOPOLOGY_TEMPLATE, template.getToscaType());
  95     }
  96
  97     @Test
  98     public void testConvertToToscaElementResource()
  99     {
 100         Resource resource = new Resource();
 101         resource.setComponentType(ComponentTypeEnum.RESOURCE);
 102         NodeType nodeType = test.convertToToscaElement(resource);
 103         assertEquals(ToscaElementTypeEnum.NODE_TYPE, nodeType.getToscaType());
 104     }
 105
 106     @Test
 107     public void testConvertFromToscaElementService()
 108     {
 109         TopologyTemplate topologyTemplate = new TopologyTemplate();
 110         topologyTemplate.setComponentType(ComponentTypeEnum.SERVICE);
 111         Component component = test.convertFromToscaElement(topologyTemplate);
 112         assertEquals(ToscaElementTypeEnum.TOPOLOGY_TEMPLATE.getValue(), component.getToscaType());
 113
 114         topologyTemplate.setComponentType(ComponentTypeEnum.PRODUCT);
 115         component = test.convertFromToscaElement(topologyTemplate);
 116         assertEquals(ToscaElementTypeEnum.TOPOLOGY_TEMPLATE.getValue(), component.getToscaType());
 117
 118         NodeType nodeType = new NodeType();
 119         nodeType.setComponentType(ComponentTypeEnum.RESOURCE);
 120         topologyTemplate.setToscaType(ToscaElementTypeEnum.NODE_TYPE);
 121         component = test.convertFromToscaElement(nodeType);
 122         assertEquals(ToscaElementTypeEnum.NODE_TYPE.getValue(), component.getToscaType());
 123
 124         topologyTemplate.setComponentType(ComponentTypeEnum.RESOURCE_INSTANCE);
 125         assertNull(test.convertFromToscaElement(topologyTemplate));
 126     }
 127
 128     @Test
 129     public void testConvertFromToscaElementServiceWithSelfCapabilities()
 130     {
 131         TopologyTemplate topologyTemplate = new TopologyTemplate();
 132
 133         Map<String, MapPropertiesDataDefinition> capabilitiesProperties = CapabilityTestUtils
 134                 .createCapPropsForTopologyTemplate(topologyTemplate);
 135
 136         topologyTemplate.setCapabilitiesProperties(capabilitiesProperties);
 137
 138         topologyTemplate.setComponentType(ComponentTypeEnum.SERVICE);
 139         Component component = test.convertFromToscaElement(topologyTemplate);
 140         assertEquals(ToscaElementTypeEnum.TOPOLOGY_TEMPLATE.getValue(), component.getToscaType());
 141     }
 142
 143     @Test
 144     public void testConvertFromToscaElementResource()
 145     {
 146         TopologyTemplate topologyTemplate = new TopologyTemplate();
 147         topologyTemplate.setComponentType(ComponentTypeEnum.RESOURCE);
 148         Component component = test.convertFromToscaElement(topologyTemplate);
 149         assertEquals(ToscaElementTypeEnum.TOPOLOGY_TEMPLATE.getValue(), component.getToscaType());
 150     }
 151
 152     @Test
 153     public void testConvertFromToscaElementResourceType() {
 154         TopologyTemplate topologyTemplate = new TopologyTemplate();
 155         topologyTemplate.setComponentType(ComponentTypeEnum.RESOURCE);
 156         topologyTemplate.setResourceType(ResourceTypeEnum.PNF);
 157         Resource resource = test.convertFromToscaElement(topologyTemplate);
 158         assertEquals(ResourceTypeEnum.PNF, resource.getResourceType());
 159     }
 160
 161     @Test
 162     public void testConvertFromToscaElementResourceOutputs() {
 163         final TopologyTemplate topologyTemplate = new TopologyTemplate();
 164         topologyTemplate.setComponentType(ComponentTypeEnum.RESOURCE);
 165         final OutputDefinition outputDefinition = new OutputDefinition();
 166         final Map<String, AttributeDataDefinition> map = new HashMap<>();
 167         map.put("mock", outputDefinition);
 168         topologyTemplate.setOutputs(map);
 169         final Resource resource = test.convertFromToscaElement(topologyTemplate);
 170         assertNotNull(resource.getOutputs());
 171         assertFalse(resource.getOutputs().isEmpty());
 172     }
 173
 174     @Test
 175     public void testConvertFromToscaElementResourceComponentInstancesOutputs() {
 176         final TopologyTemplate topologyTemplate = new TopologyTemplate();
 177         topologyTemplate.setComponentType(ComponentTypeEnum.RESOURCE);
 178
 179         final Map<String, MapAttributesDataDefinition> instOutputs = new HashMap<>();
 180         final MapAttributesDataDefinition mapAttributesDataDefinition = new MapAttributesDataDefinition();
 181         final AttributeDefinition attributeDefinition = new AttributeDefinition();
 182         final Map<String, AttributeDataDefinition> mapToscaDataDefinition = new HashMap<>();
 183         mapToscaDataDefinition.put("mock", attributeDefinition);
 184         mapAttributesDataDefinition.setMapToscaDataDefinition(mapToscaDataDefinition);
 185         instOutputs.put("mock", mapAttributesDataDefinition);
 186         topologyTemplate.setInstOutputs(instOutputs);
 187
 188         final Map<String, ComponentInstanceDataDefinition> componentInstanceDataDefinitionMap = new HashMap<>();
 189         componentInstanceDataDefinitionMap.put("mock", new ComponentInstance());
 190         topologyTemplate.setComponentInstances(componentInstanceDataDefinitionMap);
 191
 192         final Resource resource = test.convertFromToscaElement(topologyTemplate);
 193         assertNotNull(resource);
 194         assertNotNull(resource.getComponentInstancesOutputs());
 195         assertFalse(resource.getComponentInstancesOutputs().isEmpty());
 196     }
 197
 198     @Test
 199     public void testIsAtomicComponent() {
 200         Resource component = new Resource();
 201         component.setComponentType(ComponentTypeEnum.SERVICE);
 202         assertFalse(test.isAtomicComponent(component));
 203
 204         component.setComponentType(ComponentTypeEnum.RESOURCE);
 205         assertTrue(test.isAtomicComponent(component));
 206
 207         ResourceTypeEnum resourceType = null;
 208         assertFalse(test.isAtomicComponent(resourceType));
 209     }
 210
 211     @Test
 212     public void testGetVertexType()
 213     {
 214         VertexTypeEnum result;
 215         Resource component = new Resource();
 216         component.setComponentType(ComponentTypeEnum.SERVICE);
 217         assertEquals("topology_template", test.getVertexType(component).getName());
 218         component.setComponentType(ComponentTypeEnum.RESOURCE);
 219         assertEquals("node_type", test.getVertexType(component).getName());
 220
 221         assertEquals(VertexTypeEnum.TOPOLOGY_TEMPLATE, test.getVertexType("Service"));
 222         assertEquals(VertexTypeEnum.NODE_TYPE, test.getVertexType("VFC"));
 223     }
 224
 225     @Test
 226     public void testConvertRelation()
 227     {
 228         RelationshipTypeDefinition relationshipDef = new RelationshipTypeDefinition();
 229         relationshipDef.setFromId("formId");
 230         relationshipDef.setToId("toId");
 231         relationshipDef.setOriginUI(true);
 232         RequirementCapabilityRelDef result = ModelConverter.convertRelation(relationshipDef);
 233
 234         assertEquals("formId", result.getFromNode());
 235         assertEquals("toId", result.getToNode());
 236         assertEquals(true, result.isOriginUI());
 237         assertEquals(1, result.getRelationships().size());
 238     }
 239
 240     @Test
 241     public void testConvertRelationToToscaRelation()
 242     {
 243         RequirementCapabilityRelDef reqCap = new RequirementCapabilityRelDef();
 244         reqCap.setOriginUI(true);
 245         reqCap.setFromNode("fromNode");
 246         reqCap.setToNode("toNode");
 247         List<CapabilityRequirementRelationship> list = new LinkedList<>();
 248         CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
 249         RelationshipInfo info = new RelationshipInfo();
 250         info.setCapabilityOwnerId("capOwnerId");
 251         info.setId("id");
 252         info.setCapabilityUid("capUid");
 253         info.setRequirementOwnerId("reqOwnerId");
 254         info.setRequirementUid("reqUid");
 255         info.setRequirement("req");
 256         info.setCapability("cap");
 257         RelationshipImpl relationshipImpl = new RelationshipImpl();
 258         relationshipImpl.setType("type");
 259         info.setRelationships(relationshipImpl);
 260         relationship.setRelation(info);
 261         list.add(relationship);
 262         reqCap.setRelationships(list);
 263
 264         List<RelationshipInstDataDefinition> result = ModelConverter.convertRelationToToscaRelation(reqCap);
 265         assertEquals(1, result.size());
 266         assertEquals("capOwnerId", result.get(0).getCapabilityOwnerId());
 267         assertEquals("id", result.get(0).getUniqueId());
 268         assertEquals("capUid", result.get(0).getCapabilityId());
 269         assertEquals("reqOwnerId", result.get(0).getRequirementOwnerId());
 270         assertEquals("reqUid", result.get(0).getRequirementId());
 271         assertEquals("req", result.get(0).getRequirement());
 272         assertEquals("cap", result.get(0).getCapability());
 273         assertEquals("type", result.get(0).getType());
 274         assertEquals(true, result.get(0).isOriginUI());
 275         assertEquals("fromNode", result.get(0).getFromId());
 276         assertEquals("toNode", result.get(0).getToId());
 277     }
 278
 279     @Test
 280     public void testConvertToMapOfMapCapabilityPropertiesonvertRelation()
 281     {
 282         Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
 283         MapCapabilityProperty result = ModelConverter.convertToMapOfMapCapabilityProperties(capabilities, "ownerId", true);
 284         assertNotNull(result);
 285         assertEquals(0, result.getMapToscaDataDefinition().size());
 286
 287         List<CapabilityDefinition> list = new LinkedList<>();
 288         CapabilityDefinition capDef = new CapabilityDefinition();
 289         List<ComponentInstanceProperty> properties = new LinkedList<>();
 290         ComponentInstanceProperty property = new ComponentInstanceProperty();
 291         properties.add(property);
 292         capDef.setProperties(properties);
 293         list.add(capDef);
 294         capabilities.put("test", list);
 295         result = ModelConverter.convertToMapOfMapCapabilityProperties(capabilities, "ownerId", true);
 296         assertEquals(1, result.getMapToscaDataDefinition().size());
 297     }
 298
 299     @Test
 300     public void testBuildCapabilityPropertyKey()
 301     {
 302         CapabilityDefinition capDef = new CapabilityDefinition();
 303         capDef.setOwnerId("owner");
 304         String result = ModelConverter.buildCapabilityPropertyKey(true,"type","name", "capId", capDef);
 305
 306         assertEquals("capId#owner#type#name", result);
 307     }
 308
 309     @Test
 310     public void testConvertToMapOfMapCapabiltyProperties()
 311     {
 312         Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
 313         List<CapabilityDefinition> list = new LinkedList<>();
 314         CapabilityDefinition capDef = new CapabilityDefinition();
 315         List<ComponentInstanceProperty> properties = new LinkedList<>();
 316         ComponentInstanceProperty property = new ComponentInstanceProperty();
 317         properties.add(property);
 318         capDef.setProperties(properties);
 319         list.add(capDef);
 320         capabilities.put("test", list);
 321
 322         MapCapabilityProperty result = ModelConverter.convertToMapOfMapCapabiltyProperties(capabilities, "ownerId", true);
 323
 324         assertEquals(1, result.getMapToscaDataDefinition().size());
 325         assertNotNull(result.getMapToscaDataDefinition().get("ownerId#ownerId#test#null"));
 326     }
 327
 328     @Test
 329     public void testGetCapabilitiesMapFromMapObject()
 330     {
 331         assertNull(ModelConverter.getCapabilitiesMapFromMapObject(null, null));
 332
 333         Map<String, ListCapabilityDataDefinition> toscaCapabilities = new HashMap<>();
 334         Map<String, MapPropertiesDataDefinition> toscaCapPropMap = new HashMap<>();
 335         ListCapabilityDataDefinition dataDefList = new ListCapabilityDataDefinition();
 336         List<CapabilityDataDefinition> capDataDefList = new LinkedList<>();
 337         CapabilityDataDefinition capDataDef = new CapabilityDataDefinition();
 338         capDataDef.setName("test");
 339         capDataDefList.add(capDataDef);
 340         dataDefList.setListToscaDataDefinition(capDataDefList);
 341         MapPropertiesDataDefinition dataDefMap = new MapPropertiesDataDefinition();
 342         Map<String, PropertyDataDefinition> propDataMap = new HashMap<>();
 343         PropertyDataDefinition propertyDataDefinition = new PropertyDataDefinition();
 344         propDataMap.put("propMap", propertyDataDefinition);
 345         dataDefMap.setMapToscaDataDefinition(propDataMap);
 346         toscaCapabilities.put("prop", dataDefList);
 347         toscaCapPropMap.put("prop#test", dataDefMap);
 348
 349         Map<String, List<CapabilityDefinition>> result = ModelConverter.getCapabilitiesMapFromMapObject(toscaCapabilities, toscaCapPropMap);
 350         assertEquals(1, result.size());
 351     }
 352 }