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

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