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

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