catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/TopologyTemplateOperationCapabilityIntegrationTest.java

   1 package org.openecomp.sdc.be.model.jsonjanusgraph.operations;
   2
   3 import org.junit.After;
   4 import org.junit.Before;
   5 import org.junit.BeforeClass;
   6 import org.junit.Test;
   7 import org.junit.runner.RunWith;
   8 import org.openecomp.sdc.be.dao.config.JanusGraphSpringConfig;
   9 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
  10 import org.openecomp.sdc.be.dao.jsongraph.HealingJanusGraphDao;
  11 import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
  12 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
  13 import org.openecomp.sdc.be.datatypes.elements.MapCapabilityProperty;
  14 import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition;
  15 import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
  16 import org.openecomp.sdc.be.model.Component;
  17 import org.openecomp.sdc.be.model.ComponentParametersView;
  18 import org.openecomp.sdc.be.model.ModelTestBase;
  19 import org.openecomp.sdc.be.model.PropertyDefinition;
  20 import org.openecomp.sdc.be.model.config.ModelOperationsSpringConfig;
  21 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.TopologyTemplate;
  22 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  23 import org.springframework.test.context.ContextConfiguration;
  24 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  25
  26 import javax.annotation.Resource;
  27 import java.util.Arrays;
  28 import java.util.HashMap;
  29 import java.util.List;
  30 import java.util.Map;
  31
  32 import static org.assertj.core.api.Assertions.assertThat;
  33
  34 @RunWith(SpringJUnit4ClassRunner.class)
  35 @ContextConfiguration(classes = {JanusGraphSpringConfig.class, ModelOperationsSpringConfig.class})
  36 public class TopologyTemplateOperationCapabilityIntegrationTest extends ModelTestBase {
  37
  38     private static final String CONTAINER_ID = "id";
  39     private Map<String, MapCapabilityProperty> capabilitiesPropsMap;
  40     private List<CapabilityPropertyDataObject> capabilitiesProperties;
  41
  42     @Resource
  43     private TopologyTemplateOperation topologyTemplateOperation;
  44
  45     @Resource
  46     private HealingJanusGraphDao janusGraphDao;
  47     private CapabilityPropertyDataObject capabilityProperty1;
  48     private CapabilityPropertyDataObject capabilityProperty2;
  49     private CapabilityPropertyDataObject capabilityProperty3;
  50
  51     @BeforeClass
  52     public static void setupBeforeClass() {
  53
  54         ModelTestBase.init();
  55     }
  56
  57     @Before
  58     public void setUp() throws Exception {
  59
  60         capabilitiesPropsMap = new HashMap<>();
  61         capabilityProperty1 = new CapabilityPropertyDataObject("instance1", "capability1", "prop1", "val1");
  62         capabilityProperty2 = new CapabilityPropertyDataObject("instance1", "capability2", "prop2", "val2");
  63         capabilityProperty3 = new CapabilityPropertyDataObject("instance2", "capability3", "prop3", "val3");
  64         capabilitiesProperties = Arrays.asList(capabilityProperty1, capabilityProperty2, capabilityProperty3);
  65
  66
  67         //capablities props == Map<instance id, Map<capability id, Map<prop id, property>>>
  68         capabilitiesProperties.forEach(capabilitiesProperty -> {
  69             capabilitiesPropsMap.computeIfAbsent(capabilitiesProperty.getInstanceId(), k -> new MapCapabilityProperty(new HashMap<>()))
  70                              .getMapToscaDataDefinition().computeIfAbsent(capabilitiesProperty.getCapabilityId(), k -> new MapPropertiesDataDefinition(new HashMap<>()))
  71                              .getMapToscaDataDefinition().computeIfAbsent(capabilitiesProperty.getPropName(), k -> new PropertyDefinition(createPropWithValue(capabilitiesProperty.getPropValue())));
  72         });
  73
  74         GraphVertex resource = new GraphVertex(VertexTypeEnum.TOPOLOGY_TEMPLATE);
  75         resource.addMetadataProperty(GraphPropertyEnum.UNIQUE_ID, CONTAINER_ID);
  76         janusGraphDao.createVertex(resource);
  77         GraphVertex loadedResource = janusGraphDao.getVertexById(CONTAINER_ID).left().value();
  78         topologyTemplateOperation.associateElementToData(loadedResource, VertexTypeEnum.CALCULATED_CAP_PROPERTIES, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, capabilitiesPropsMap).left().value();
  79     }
  80
  81     @After
  82     public void tearDown() {
  83         janusGraphDao.rollback();
  84     }
  85
  86     @Test
  87     public void overrideCalculatedCapabilityProperties() {
  88         Map<String, MapCapabilityProperty> loadedCapPropsMap = fetchCapabilitiesProps(CONTAINER_ID);
  89         compareCapabilitiesProperties(capabilitiesProperties, loadedCapPropsMap);
  90         capabilityProperty1.setPropValue("newVal1");
  91         capabilityProperty3.setPropValue("newVal3");
  92         setPropertyValue(capabilitiesPropsMap, capabilityProperty1);
  93         setPropertyValue(capabilitiesPropsMap, capabilityProperty3);
  94         StorageOperationStatus storageOperationStatus = topologyTemplateOperation.overrideToscaDataOfToscaElement(CONTAINER_ID, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, capabilitiesPropsMap);
  95         assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.OK);
  96         Map<String, MapCapabilityProperty> updatedCapPropsMap = fetchCapabilitiesProps(CONTAINER_ID);
  97         compareCapabilitiesProperties(capabilitiesProperties, updatedCapPropsMap);
  98     }
  99
 100     @Test
 101     public void updateToscaDataDeepElementsBlockToToscaElement() {
 102         assertCapabilityPropValue(capabilityProperty1, "val1");
 103         assertCapabilityPropValue(capabilityProperty2, "val2");
 104         assertCapabilityPropValue(capabilityProperty3, "val3");
 105
 106         MapCapabilityProperty instance1Props = capabilitiesPropsMap.get("instance1");
 107         capabilityProperty1.setPropValue("newVal1");
 108         setPropertyValue(capabilitiesPropsMap, capabilityProperty1);
 109
 110         capabilityProperty3.setPropValue("newVal3");
 111         setPropertyValue(capabilitiesPropsMap, capabilityProperty3);
 112
 113         Component component = new org.openecomp.sdc.be.model.Resource();
 114         component.setUniqueId(CONTAINER_ID);
 115         StorageOperationStatus updateStatus = topologyTemplateOperation.updateToscaDataDeepElementsBlockToToscaElement(CONTAINER_ID, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, instance1Props, "instance1");
 116
 117         assertThat(updateStatus).isEqualTo(StorageOperationStatus.OK);
 118         assertCapabilityPropValue(capabilityProperty1, "newVal1");
 119         assertCapabilityPropValue(capabilityProperty2, "val2");
 120         assertCapabilityPropValue(capabilityProperty3, "val3");//only instance1 props should be updated
 121     }
 122
 123     private Map<String, MapCapabilityProperty> fetchCapabilitiesProps(String containerId) {
 124         ComponentParametersView capabilityPropsFilter = new ComponentParametersView(true);
 125         capabilityPropsFilter.setIgnoreCapabiltyProperties(false);
 126         return ((TopologyTemplate) topologyTemplateOperation.getToscaElement(containerId, capabilityPropsFilter).left().value()).getCalculatedCapabilitiesProperties();
 127     }
 128
 129     private void compareCapabilitiesProperties(List<CapabilityPropertyDataObject> expected, Map<String, MapCapabilityProperty> actual) {
 130         expected.forEach(expectedCapabilityProp -> {
 131             assertThat(getPropertyValue(actual, expectedCapabilityProp.instanceId, expectedCapabilityProp.capabilityId, expectedCapabilityProp.propName))
 132                     .isEqualTo(expectedCapabilityProp.propValue);
 133         });
 134     }
 135
 136     private String getPropertyValue(Map<String, MapCapabilityProperty> capabilityPropertyMap, String instance, String capability, String prop) {
 137         return capabilityPropertyMap.get(instance).getMapToscaDataDefinition().get(capability).getMapToscaDataDefinition().get(prop).getValue();
 138     }
 139
 140     private void setPropertyValue(Map<String, MapCapabilityProperty> capabilityPropertyMap, CapabilityPropertyDataObject capabilityProperty) {
 141         setPropertyValue(capabilityPropertyMap.get(capabilityProperty.getInstanceId()), capabilityProperty);
 142
 143     }
 144
 145     private void setPropertyValue(MapCapabilityProperty capabilitiesInstanceProperties, CapabilityPropertyDataObject capabilityProperty) {
 146         capabilitiesInstanceProperties.getMapToscaDataDefinition().get(capabilityProperty.getCapabilityId())
 147                                       .getMapToscaDataDefinition().get(capabilityProperty.getPropName())
 148                                       .setValue(capabilityProperty.getPropValue());
 149     }
 150
 151     private void assertCapabilityPropValue(CapabilityPropertyDataObject prop, String expectedValue) {
 152         Map<String, MapCapabilityProperty> loadedCapPropsMap = fetchCapabilitiesProps(CONTAINER_ID);
 153         String propertyValue = getPropertyValue(loadedCapPropsMap, prop.getInstanceId(), prop.getCapabilityId(), prop.getPropName());
 154         assertThat(propertyValue).isEqualTo(expectedValue);
 155     }
 156
 157
 158     private PropertyDefinition createPropWithValue(String val) {
 159         PropertyDefinition propertyDefinition = new PropertyDefinition();
 160         propertyDefinition.setValue(val);
 161         return propertyDefinition;
 162     }
 163
 164     private static class CapabilityPropertyDataObject {
 165         private String instanceId;
 166         private String capabilityId;
 167         private String propName;
 168         private String propValue;
 169
 170         CapabilityPropertyDataObject(String instanceId, String capabilityId, String propName, String propValue) {
 171             this.instanceId = instanceId;
 172             this.capabilityId = capabilityId;
 173             this.propName = propName;
 174             this.propValue = propValue;
 175         }
 176
 177         String getInstanceId() {
 178             return instanceId;
 179         }
 180
 181         String getCapabilityId() {
 182             return capabilityId;
 183         }
 184
 185         String getPropName() {
 186             return propName;
 187         }
 188
 189         String getPropValue() {
 190             return propValue;
 191         }
 192
 193         void setPropValue(String propValue) {
 194             this.propValue = propValue;
 195         }
 196     }
 197 }