diff options
Diffstat (limited to 'catalog-model/src/test/java/org')
20 files changed, 2182 insertions, 269 deletions
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/config/ModelOperationsSpringConfig.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/config/ModelOperationsSpringConfig.java new file mode 100644 index 0000000000..1215b5fc6f --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/config/ModelOperationsSpringConfig.java @@ -0,0 +1,9 @@ +package org.openecomp.sdc.be.model.config; + +import org.springframework.context.annotation.ComponentScan; +import org.springframework.context.annotation.Configuration; + +@Configuration +@ComponentScan({"org.openecomp.sdc.be.model.jsontitan.operations","org.openecomp.sdc.be.model.jsontitan.utils"}) +public class ModelOperationsSpringConfig { +} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ExternalReferencesOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ExternalReferencesOperationTest.java new file mode 100644 index 0000000000..c0ba256957 --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ExternalReferencesOperationTest.java @@ -0,0 +1,178 @@ +package org.openecomp.sdc.be.model.jsontitan.operations; + +import fj.data.Either; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mockito; +import org.openecomp.sdc.be.dao.api.ActionStatus; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.TitanDao; +import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; +import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; +import org.openecomp.sdc.be.datatypes.elements.MapComponentInstanceExternalRefs; +import org.openecomp.sdc.be.model.ModelTestBase; +import org.openecomp.sdc.be.model.jsontitan.utils.GraphTestUtils; +import org.openecomp.sdc.be.model.jsontitan.utils.IdMapper; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +import javax.annotation.Resource; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.when; + +/** + * Created by yavivi on 26/01/2018. + */ +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration("classpath:application-context-test.xml") +public class ExternalReferencesOperationTest extends ModelTestBase { + + @Resource + private ExternalReferencesOperation externalReferenceOperation; + + @Resource + private TitanDao titanDao; + + private boolean isInitialized; + + private GraphVertex serviceVertex; + + private String serviceVertexUuid; + private static final String COMPONENT_ID = "ci-MyComponentName"; + + private static final String MONITORING_OBJECT_TYPE = "monitoring"; + private static final String WORKFLOW_OBJECT_TYPE = "workflow"; + private static final String REF_1 = "ref1"; + private static final String REF_2 = "ref2"; + private static final String REF_3 = "ref3"; + private static final String REF_4 = "ref4"; + private static final String REF_5 = "ref5"; + + //workflow + private static final String REF_6 = "ref6"; + + private IdMapper idMapper; + + @BeforeClass + public static void initTest(){ + ModelTestBase.init(); + } + + @Before + public void beforeTest() { + idMapper = Mockito.mock(IdMapper.class); + this.externalReferenceOperation.setIdMapper(idMapper); + when(idMapper.mapComponentNameToUniqueId(Mockito.anyString(), Mockito.any(GraphVertex.class))).thenReturn(COMPONENT_ID); + if (!isInitialized) { + GraphTestUtils.clearGraph(titanDao); + initGraphForTest(); + isInitialized = true; + } + } + + @Test + public void testAddComponentInstanceExternalRef(){ + Either<String, ActionStatus> addResult = externalReferenceOperation.addExternalReference(this.serviceVertexUuid, COMPONENT_ID, MONITORING_OBJECT_TYPE, REF_4); + assertThat(addResult.isLeft()).isEqualTo(true); + + //commit changes to titan + final TitanOperationStatus commit = this.titanDao.commit(); + assertThat(commit).isEqualTo(TitanOperationStatus.OK); + + assertThat(getServiceExternalRefs()).contains(REF_1, REF_2, REF_3, REF_4); + } + + @Test + public void testGetComponentInstanceExternalRef(){ + assertThat(externalReferenceOperation.getExternalReferences(this.serviceVertexUuid, COMPONENT_ID, MONITORING_OBJECT_TYPE).left().value()).contains(REF_1, REF_2, REF_3, REF_5); + assertThat(externalReferenceOperation.getExternalReferences(this.serviceVertexUuid, COMPONENT_ID, WORKFLOW_OBJECT_TYPE).left().value()).containsExactly(REF_6); + } + + @Test + public void testGetComponentInstanceExternalRefForNonExistingObjectId(){ + assertThat(externalReferenceOperation.getExternalReferences(this.serviceVertexUuid, COMPONENT_ID, MONITORING_OBJECT_TYPE).left().value()).contains(REF_1, REF_2, REF_3, REF_5); + Either<List<String>, ActionStatus> getResult = externalReferenceOperation.getExternalReferences(this.serviceVertexUuid, COMPONENT_ID, "FAKE_OBJECT_TYPE"); + assertThat(getResult.left().value()).isEmpty(); + } + + @Test + public void testDeleteComponentInstanceExternalRef(){ + //Test the precondition + assertThat(getServiceExternalRefs()).contains(REF_5); + + //Remove REF 5 + Either<String, ActionStatus> deleteStatus = externalReferenceOperation.deleteExternalReference(this.serviceVertexUuid, COMPONENT_ID, MONITORING_OBJECT_TYPE, REF_5); + assertThat(deleteStatus.isLeft()).isEqualTo(true); + + //commit changes to titan + final TitanOperationStatus commit = this.titanDao.commit(); + assertThat(commit).isEqualTo(TitanOperationStatus.OK); + + //Check that ref does not exist anymore + assertThat(getServiceExternalRefs()).doesNotContain(REF_5).contains(REF_1, REF_2, REF_3); + } + + @Test + public void testUpdateComponentInstanceExternalRef(){ + //Test the precondition + assertThat(getServiceExternalRefs()).contains(REF_5).doesNotContain(REF_4); + + //Update REF 5 with REF_4 + Either<String, ActionStatus> updateResult = externalReferenceOperation.updateExternalReference(this.serviceVertexUuid, COMPONENT_ID, MONITORING_OBJECT_TYPE, REF_5, REF_4); + + assertThat(updateResult.isLeft()).isEqualTo(true); + + //commit changes to titan + final TitanOperationStatus commit = this.titanDao.commit(); + assertThat(commit).isEqualTo(TitanOperationStatus.OK); + + //Check that ref does not exist anymore + assertThat(getServiceExternalRefs()).doesNotContain(REF_5).contains(REF_1, REF_2, REF_3, REF_4); + } + + private List<String> getServiceExternalRefs(){ + //Get service vertex + final Either<GraphVertex, TitanOperationStatus> externalRefsVertexResult = this.titanDao.getChildVertex(this.serviceVertex, EdgeLabelEnum.EXTERNAL_REFS, JsonParseFlagEnum.ParseJson); + assertThat(externalRefsVertexResult.isLeft()).isEqualTo(true); + + GraphVertex externalRefVertex = externalRefsVertexResult.left().value(); + + //Get the full map + Map<String, MapComponentInstanceExternalRefs> componentInstancesMap = (Map<String, MapComponentInstanceExternalRefs>) externalRefVertex.getJson(); + assertThat(componentInstancesMap).isNotNull(); + + //Get Map of external refs by object type + final MapComponentInstanceExternalRefs mapComponentInstanceExternalRefs = componentInstancesMap.get(COMPONENT_ID); + + //Get List of references + //final List<String> externalRefsByObjectType = mapComponentInstanceExternalRefs.externalRefsByObjectType(objectType); + final List<String> externalRefsByObjectType = mapComponentInstanceExternalRefs.getExternalRefsByObjectType(MONITORING_OBJECT_TYPE); + + return externalRefsByObjectType; + } + + private void initGraphForTest() { + //create a service and add 1 ref + this.serviceVertex = GraphTestUtils.createServiceVertex(titanDao, new HashMap<>()); + this.serviceVertexUuid = this.serviceVertex.getUniqueId(); + + //monitoring references + externalReferenceOperation.addExternalReference(serviceVertexUuid, COMPONENT_ID, MONITORING_OBJECT_TYPE, REF_1); + externalReferenceOperation.addExternalReference(serviceVertexUuid, COMPONENT_ID, MONITORING_OBJECT_TYPE, REF_2); + externalReferenceOperation.addExternalReference(serviceVertexUuid, COMPONENT_ID, MONITORING_OBJECT_TYPE, REF_3); + externalReferenceOperation.addExternalReference(serviceVertexUuid, COMPONENT_ID, MONITORING_OBJECT_TYPE, REF_5); + + //workflow references + externalReferenceOperation.addExternalReference(serviceVertexUuid, COMPONENT_ID, WORKFLOW_OBJECT_TYPE, REF_6); + + final TitanOperationStatus commit = this.titanDao.commit(); + assertThat(commit).isEqualTo(TitanOperationStatus.OK); + } +}
\ No newline at end of file diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/NodeTemplateOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/NodeTemplateOperationTest.java index a1a257b893..71d54bca73 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/NodeTemplateOperationTest.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/NodeTemplateOperationTest.java @@ -25,7 +25,6 @@ import org.openecomp.sdc.be.model.RelationshipImpl; import org.openecomp.sdc.be.model.RelationshipInfo; import org.openecomp.sdc.be.model.RequirementCapabilityRelDef; import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; - import com.google.common.collect.Lists; import fj.data.Either; diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/PolicyOperationIntegrationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/PolicyOperationIntegrationTest.java new file mode 100644 index 0000000000..d4188744d8 --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/PolicyOperationIntegrationTest.java @@ -0,0 +1,133 @@ +package org.openecomp.sdc.be.model.jsontitan.operations; + +import fj.data.Either; +import org.junit.After; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.openecomp.sdc.be.dao.config.TitanSpringConfig; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.TitanDao; +import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; +import org.openecomp.sdc.be.datatypes.elements.PolicyDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; +import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; +import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; +import org.openecomp.sdc.be.model.Component; +import org.openecomp.sdc.be.model.ComponentParametersView; +import org.openecomp.sdc.be.model.ModelTestBase; +import org.openecomp.sdc.be.model.PolicyDefinition; +import org.openecomp.sdc.be.model.config.ModelOperationsSpringConfig; +import org.openecomp.sdc.be.model.jsontitan.datamodel.TopologyTemplate; +import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElement; +import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +import javax.annotation.Resource; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Map; + +import static org.apache.commons.collections.ListUtils.union; +import static org.assertj.core.api.Assertions.assertThat; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration(classes = {TitanSpringConfig.class, ModelOperationsSpringConfig.class}) +public class PolicyOperationIntegrationTest extends ModelTestBase { + + private static final String CONTAINER_ID = "container"; + public static final String POLICY_ID = "policy"; + @Resource + private TopologyTemplateOperation topologyTemplateOperation; + @Resource + private TitanDao titanDao; + @Resource + private PolicyOperation policyOperation; + private PropertyDataDefinition prop1, prop2; + private PolicyDefinition policy; + + @BeforeClass + public static void setupBeforeClass() { + + ModelTestBase.init(); + } + + @Before + public void setUp() throws Exception { + prop1 = new PropertyDataDefinition(); + prop1.setUniqueId("prop1"); + prop1.setName("prop1"); + prop1.setValue("prop1"); + + prop2 = new PropertyDataDefinition(); + prop2.setUniqueId("prop2"); + prop2.setName("prop2"); + prop2.setValue("prop2"); + + policy = new PolicyDefinition(); + policy.setUniqueId(POLICY_ID); + + policy.setProperties(Arrays.asList(prop1, prop2)); + + GraphVertex resource = new GraphVertex(VertexTypeEnum.TOPOLOGY_TEMPLATE); + resource.addMetadataProperty(GraphPropertyEnum.UNIQUE_ID, CONTAINER_ID); + titanDao.createVertex(resource); + GraphVertex loadedResource = titanDao.getVertexById(CONTAINER_ID).left().value(); + topologyTemplateOperation.addToscaDataToToscaElement(loadedResource, EdgeLabelEnum.POLICIES, VertexTypeEnum.POLICIES, policy, JsonPresentationFields.UNIQUE_ID); + titanDao.commit(); + } + + @After + public void tearDown() { + titanDao.rollback(); + } + + @Test + public void testUpdatePolicyProperties_singleProperty() { + PropertyDataDefinition prop1Copy = new PropertyDataDefinition(prop1); + prop1Copy.setValue("prop1NewValue"); + testUpdatePolicyProperties(Collections.singletonList(prop1Copy), Collections.singletonList(prop2)); + } + + @Test + public void testUpdatePolicyProperties_multipleProperties() { + PropertyDataDefinition prop1Copy = new PropertyDataDefinition(prop1); + prop1Copy.setValue("prop1NewValue"); + + PropertyDataDefinition prop2Copy = new PropertyDataDefinition(prop2); + prop2Copy.setValue("prop2NewValue"); + + testUpdatePolicyProperties(Arrays.asList(prop1Copy, prop2Copy), Collections.emptyList()); + } + + private void testUpdatePolicyProperties(List<PropertyDataDefinition> updatedProperties, List<PropertyDataDefinition> nonUpdatedPropeties) { + Component cmpt = new org.openecomp.sdc.be.model.Resource(); + cmpt.setUniqueId(CONTAINER_ID); + cmpt.setPolicies(Collections.singletonMap(POLICY_ID, policy)); + StorageOperationStatus storageOperationStatus = policyOperation.updatePolicyProperties(cmpt, POLICY_ID, updatedProperties); + assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.OK); + + ComponentParametersView componentParametersView = new ComponentParametersView(); + componentParametersView.disableAll(); + componentParametersView.setIgnorePolicies(false); + Either<ToscaElement, StorageOperationStatus> loadedCmptEither = topologyTemplateOperation.getToscaElement(CONTAINER_ID, componentParametersView); + + assertThat(loadedCmptEither.isLeft()); + ToscaElement loadedCmpt = loadedCmptEither.left().value(); + assertThat(loadedCmpt).isInstanceOf(TopologyTemplate.class); + @SuppressWarnings("unchecked") List<PropertyDataDefinition> allProperties = union(updatedProperties, nonUpdatedPropeties); + verifyPolicyPropertiesValuesUpdated((TopologyTemplate) loadedCmpt, allProperties); + } + + private void verifyPolicyPropertiesValuesUpdated(TopologyTemplate toscaElement, List<PropertyDataDefinition> expectedUpdatedProperties) { + Map<String, PolicyDataDefinition> policies = toscaElement.getPolicies(); + PolicyDataDefinition policy = policies.get(POLICY_ID); + List<PropertyDataDefinition> policyProperties = policy.getProperties(); + assertThat(policyProperties).usingElementComparatorOnFields("value") + .containsAll(expectedUpdatedProperties); + } +} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/PolicyOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/PolicyOperationTest.java new file mode 100644 index 0000000000..136f95b987 --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/PolicyOperationTest.java @@ -0,0 +1,93 @@ +package org.openecomp.sdc.be.model.jsontitan.operations; + +import fj.data.Either; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.Captor; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.junit.MockitoJUnitRunner; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.TitanDao; +import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; +import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; +import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; +import org.openecomp.sdc.be.model.Component; +import org.openecomp.sdc.be.model.PolicyDefinition; +import org.openecomp.sdc.be.model.Resource; +import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; + +import java.util.Arrays; +import java.util.Collections; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verifyZeroInteractions; +import static org.mockito.Mockito.when; + +@RunWith(MockitoJUnitRunner.class) +public class PolicyOperationTest { + + private static final String CONTAINER_ID = "containerId"; + private static final String POLICY_ID = "policyId"; + @InjectMocks + private PolicyOperation testInstance; + @Mock + private TitanDao titanDao; + @Mock + private TopologyTemplateOperation topologyTemplateOperation; + @Captor + private ArgumentCaptor<PolicyDefinition> policyDefCaptor; + private Component component; + private PolicyDefinition policyDefinition; + private PropertyDataDefinition prop1, prop2; + + @Before + public void setUp() throws Exception { + component = new Resource(); + component.setUniqueId(CONTAINER_ID); + policyDefinition = new PolicyDefinition(); + policyDefinition.setUniqueId(POLICY_ID); + prop1 = new PropertyDataDefinition(); + prop1.setName("prop1"); + prop1.setValue("prop1"); + + prop2 = new PropertyDataDefinition(); + prop2.setName("prop2"); + prop2.setValue("prop2"); + policyDefinition.setProperties(Arrays.asList(prop1, prop2)); + component.setPolicies(Collections.singletonMap(POLICY_ID, policyDefinition)); + } + + @Test + public void updatePolicyProperties_failedToFetchContainer() { + when(titanDao.getVertexById(CONTAINER_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.right(TitanOperationStatus.NOT_FOUND)); + StorageOperationStatus storageOperationStatus = testInstance.updatePolicyProperties(component, POLICY_ID, Collections.emptyList()); + assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.NOT_FOUND); + verifyZeroInteractions(topologyTemplateOperation); + } + + @Test + public void updatePolicyProperties_updateFailed() { + GraphVertex cmptVertex = new GraphVertex(); + when(titanDao.getVertexById(CONTAINER_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(cmptVertex)); + when(topologyTemplateOperation.updatePolicyOfToscaElement(cmptVertex, policyDefinition)).thenReturn(StorageOperationStatus.GENERAL_ERROR); + StorageOperationStatus storageOperationStatus = testInstance.updatePolicyProperties(component, POLICY_ID, Collections.emptyList()); + assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.GENERAL_ERROR); + } + + @Test + public void updatePolicyProperties() { + GraphVertex cmptVertex = new GraphVertex(); + when(titanDao.getVertexById(CONTAINER_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(cmptVertex)); + when(topologyTemplateOperation.updatePolicyOfToscaElement(eq(cmptVertex), policyDefCaptor.capture())).thenReturn(StorageOperationStatus.OK); + PropertyDataDefinition prop1Copy = new PropertyDataDefinition(prop1); + prop1Copy.setValue("prop1Copy"); + StorageOperationStatus storageOperationStatus = testInstance.updatePolicyProperties(component, POLICY_ID, Collections.singletonList(prop1Copy)); + assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.OK); + assertThat(policyDefCaptor.getValue().getProperties()).usingElementComparatorOnFields("value") + .containsExactlyInAnyOrder(prop1Copy, prop2); + } +} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/TopologyTemplateOperationCapabilityIntegrationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/TopologyTemplateOperationCapabilityIntegrationTest.java new file mode 100644 index 0000000000..103b27d3e6 --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/TopologyTemplateOperationCapabilityIntegrationTest.java @@ -0,0 +1,199 @@ +package org.openecomp.sdc.be.model.jsontitan.operations; + +import org.junit.After; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.openecomp.sdc.be.dao.config.TitanSpringConfig; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.TitanDao; +import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; +import org.openecomp.sdc.be.datatypes.elements.MapCapabiltyProperty; +import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition; +import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; +import org.openecomp.sdc.be.model.Component; +import org.openecomp.sdc.be.model.ComponentParametersView; +import org.openecomp.sdc.be.model.ModelTestBase; +import org.openecomp.sdc.be.model.PropertyDefinition; +import org.openecomp.sdc.be.model.config.ModelOperationsSpringConfig; +import org.openecomp.sdc.be.model.jsontitan.datamodel.TopologyTemplate; +import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +import javax.annotation.Resource; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import static org.assertj.core.api.Assertions.assertThat; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration(classes = {TitanSpringConfig.class, ModelOperationsSpringConfig.class}) +public class TopologyTemplateOperationCapabilityIntegrationTest extends ModelTestBase { + + private static final String CONTAINER_ID = "id"; + private Map<String, MapCapabiltyProperty> capabilitiesPropsMap; + private List<CapabilityPropertyDataObject> capabilitiesProperties; + + @Resource + private TopologyTemplateOperation topologyTemplateOperation; + + @Resource + private TitanDao titanDao; + private CapabilityPropertyDataObject capabilityProperty1; + private CapabilityPropertyDataObject capabilityProperty2; + private CapabilityPropertyDataObject capabilityProperty3; + + @BeforeClass + public static void setupBeforeClass() { + + ModelTestBase.init(); + } + + @Before + public void setUp() throws Exception { + + capabilitiesPropsMap = new HashMap<>(); + capabilityProperty1 = new CapabilityPropertyDataObject("instance1", "capability1", "prop1", "val1"); + capabilityProperty2 = new CapabilityPropertyDataObject("instance1", "capability2", "prop2", "val2"); + capabilityProperty3 = new CapabilityPropertyDataObject("instance2", "capability3", "prop3", "val3"); + capabilitiesProperties = Arrays.asList(capabilityProperty1, capabilityProperty2, capabilityProperty3); + + + //capablities props == Map<instance id, Map<capability id, Map<prop id, property>>> + capabilitiesProperties.forEach(capabilitiesProperty -> { + capabilitiesPropsMap.computeIfAbsent(capabilitiesProperty.getInstanceId(), k -> new MapCapabiltyProperty(new HashMap<>())) + .getMapToscaDataDefinition().computeIfAbsent(capabilitiesProperty.getCapabilityId(), k -> new MapPropertiesDataDefinition(new HashMap<>())) + .getMapToscaDataDefinition().computeIfAbsent(capabilitiesProperty.getPropName(), k -> new PropertyDefinition(createPropWithValue(capabilitiesProperty.getPropValue()))); + }); + + GraphVertex resource = new GraphVertex(VertexTypeEnum.TOPOLOGY_TEMPLATE); + resource.addMetadataProperty(GraphPropertyEnum.UNIQUE_ID, CONTAINER_ID); + titanDao.createVertex(resource); + GraphVertex loadedResource = titanDao.getVertexById(CONTAINER_ID).left().value(); + topologyTemplateOperation.assosiateElementToData(loadedResource, VertexTypeEnum.CALCULATED_CAP_PROPERTIES, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, capabilitiesPropsMap).left().value(); + titanDao.commit(); + + } + + @After + public void tearDown() throws Exception { + titanDao.rollback(); + } + + @Test + public void overrideCalculatedCapabilityProperties() { + Map<String, MapCapabiltyProperty> loadedCapPropsMap = fetchCapabilitiesProps(CONTAINER_ID); + compareCapabilitiesProperties(capabilitiesProperties, loadedCapPropsMap); + capabilityProperty1.setPropValue("newVal1"); + capabilityProperty3.setPropValue("newVal3"); + setPropertyValue(capabilitiesPropsMap, capabilityProperty1); + setPropertyValue(capabilitiesPropsMap, capabilityProperty3); + StorageOperationStatus storageOperationStatus = topologyTemplateOperation.overrideToscaDataOfToscaElement(CONTAINER_ID, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, capabilitiesPropsMap); + assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.OK); + Map<String, MapCapabiltyProperty> updatedCapPropsMap = fetchCapabilitiesProps(CONTAINER_ID); + compareCapabilitiesProperties(capabilitiesProperties, updatedCapPropsMap); + } + + @Test + public void updateToscaDataDeepElementsBlockToToscaElement() { + assertCapabilityPropValue(capabilityProperty1, "val1"); + assertCapabilityPropValue(capabilityProperty2, "val2"); + assertCapabilityPropValue(capabilityProperty3, "val3"); + + MapCapabiltyProperty instance1Props = capabilitiesPropsMap.get("instance1"); + capabilityProperty1.setPropValue("newVal1"); + setPropertyValue(capabilitiesPropsMap, capabilityProperty1); + + capabilityProperty3.setPropValue("newVal3"); + setPropertyValue(capabilitiesPropsMap, capabilityProperty3); + + Component component = new org.openecomp.sdc.be.model.Resource(); + component.setUniqueId(CONTAINER_ID); + StorageOperationStatus updateStatus = topologyTemplateOperation.updateToscaDataDeepElementsBlockToToscaElement(CONTAINER_ID, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, instance1Props, "instance1"); + + assertThat(updateStatus).isEqualTo(StorageOperationStatus.OK); + assertCapabilityPropValue(capabilityProperty1, "newVal1"); + assertCapabilityPropValue(capabilityProperty2, "val2"); + assertCapabilityPropValue(capabilityProperty3, "val3");//only instance1 props should be updated + } + + private Map<String, MapCapabiltyProperty> fetchCapabilitiesProps(String containerId) { + ComponentParametersView capabilityPropsFilter = new ComponentParametersView(true); + capabilityPropsFilter.setIgnoreCapabiltyProperties(false); + return ((TopologyTemplate) topologyTemplateOperation.getToscaElement(containerId, capabilityPropsFilter).left().value()).getCalculatedCapabilitiesProperties(); + } + + private void compareCapabilitiesProperties(List<CapabilityPropertyDataObject> expected, Map<String, MapCapabiltyProperty> actual) { + expected.forEach(expectedCapabilityProp -> { + assertThat(getPropertyValue(actual, expectedCapabilityProp.instanceId, expectedCapabilityProp.capabilityId, expectedCapabilityProp.propName)) + .isEqualTo(expectedCapabilityProp.propValue); + }); + } + + private String getPropertyValue(Map<String, MapCapabiltyProperty> capabilityPropertyMap, String instance, String capability, String prop) { + return capabilityPropertyMap.get(instance).getMapToscaDataDefinition().get(capability).getMapToscaDataDefinition().get(prop).getValue(); + } + + private void setPropertyValue(Map<String, MapCapabiltyProperty> capabilityPropertyMap, CapabilityPropertyDataObject capabilityProperty) { + setPropertyValue(capabilityPropertyMap.get(capabilityProperty.getInstanceId()), capabilityProperty); + + } + + private void setPropertyValue(MapCapabiltyProperty capabilitiesInstanceProperties, CapabilityPropertyDataObject capabilityProperty) { + capabilitiesInstanceProperties.getMapToscaDataDefinition().get(capabilityProperty.getCapabilityId()) + .getMapToscaDataDefinition().get(capabilityProperty.getPropName()) + .setValue(capabilityProperty.getPropValue()); + } + + private void assertCapabilityPropValue(CapabilityPropertyDataObject prop, String expectedValue) { + Map<String, MapCapabiltyProperty> loadedCapPropsMap = fetchCapabilitiesProps(CONTAINER_ID); + String propertyValue = getPropertyValue(loadedCapPropsMap, prop.getInstanceId(), prop.getCapabilityId(), prop.getPropName()); + assertThat(propertyValue).isEqualTo(expectedValue); + } + + + private PropertyDefinition createPropWithValue(String val) { + PropertyDefinition propertyDefinition = new PropertyDefinition(); + propertyDefinition.setValue(val); + return propertyDefinition; + } + + private static class CapabilityPropertyDataObject { + private String instanceId; + private String capabilityId; + private String propName; + private String propValue; + + CapabilityPropertyDataObject(String instanceId, String capabilityId, String propName, String propValue) { + this.instanceId = instanceId; + this.capabilityId = capabilityId; + this.propName = propName; + this.propValue = propValue; + } + + String getInstanceId() { + return instanceId; + } + + String getCapabilityId() { + return capabilityId; + } + + String getPropName() { + return propName; + } + + String getPropValue() { + return propValue; + } + + void setPropValue(String propValue) { + this.propValue = propValue; + } + } +} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/TopologyTemplateOperationIntegrationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/TopologyTemplateOperationIntegrationTest.java new file mode 100644 index 0000000000..d104cd3d42 --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/TopologyTemplateOperationIntegrationTest.java @@ -0,0 +1,199 @@ +package org.openecomp.sdc.be.model.jsontitan.operations; + +import org.junit.After; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.openecomp.sdc.be.dao.config.TitanSpringConfig; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.TitanDao; +import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; +import org.openecomp.sdc.be.datatypes.elements.MapCapabiltyProperty; +import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition; +import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; +import org.openecomp.sdc.be.model.Component; +import org.openecomp.sdc.be.model.ComponentParametersView; +import org.openecomp.sdc.be.model.ModelTestBase; +import org.openecomp.sdc.be.model.PropertyDefinition; +import org.openecomp.sdc.be.model.config.ModelOperationsSpringConfig; +import org.openecomp.sdc.be.model.jsontitan.datamodel.TopologyTemplate; +import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +import javax.annotation.Resource; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import static org.assertj.core.api.Assertions.assertThat; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration(classes = {TitanSpringConfig.class, ModelOperationsSpringConfig.class}) +public class TopologyTemplateOperationIntegrationTest extends ModelTestBase { + + private static final String CONTAINER_ID = "id"; + private Map<String, MapCapabiltyProperty> capabilitiesPropsMap; + private List<CapabilityPropertyDataObject> capabilitiesProperties; + + @Resource + private TopologyTemplateOperation topologyTemplateOperation; + + @Resource + private TitanDao titanDao; + private CapabilityPropertyDataObject capabilityProperty1; + private CapabilityPropertyDataObject capabilityProperty2; + private CapabilityPropertyDataObject capabilityProperty3; + + @BeforeClass + public static void setupBeforeClass() { + + ModelTestBase.init(); + } + + @Before + public void setUp() throws Exception { + + capabilitiesPropsMap = new HashMap<>(); + capabilityProperty1 = new CapabilityPropertyDataObject("instance1", "capability1", "prop1", "val1"); + capabilityProperty2 = new CapabilityPropertyDataObject("instance1", "capability2", "prop2", "val2"); + capabilityProperty3 = new CapabilityPropertyDataObject("instance2", "capability3", "prop3", "val3"); + capabilitiesProperties = Arrays.asList(capabilityProperty1, capabilityProperty2, capabilityProperty3); + + + //capablities props == Map<instance id, Map<capability id, Map<prop id, property>>> + capabilitiesProperties.forEach(capabilitiesProperty -> { + capabilitiesPropsMap.computeIfAbsent(capabilitiesProperty.getInstanceId(), k -> new MapCapabiltyProperty(new HashMap<>())) + .getMapToscaDataDefinition().computeIfAbsent(capabilitiesProperty.getCapabilityId(), k -> new MapPropertiesDataDefinition(new HashMap<>())) + .getMapToscaDataDefinition().computeIfAbsent(capabilitiesProperty.getPropName(), k -> new PropertyDefinition(createPropWithValue(capabilitiesProperty.getPropValue()))); + }); + + GraphVertex resource = new GraphVertex(VertexTypeEnum.TOPOLOGY_TEMPLATE); + resource.addMetadataProperty(GraphPropertyEnum.UNIQUE_ID, CONTAINER_ID); + titanDao.createVertex(resource); + GraphVertex loadedResource = titanDao.getVertexById(CONTAINER_ID).left().value(); + topologyTemplateOperation.assosiateElementToData(loadedResource, VertexTypeEnum.CALCULATED_CAP_PROPERTIES, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, capabilitiesPropsMap).left().value(); + titanDao.commit(); + + } + + @After + public void tearDown() throws Exception { + titanDao.rollback(); + } + + @Test + public void overrideCalculatedCapabilityProperties() { + Map<String, MapCapabiltyProperty> loadedCapPropsMap = fetchCapabilitiesProps(CONTAINER_ID); + compareCapabilitiesProperties(capabilitiesProperties, loadedCapPropsMap); + capabilityProperty1.setPropValue("newVal1"); + capabilityProperty3.setPropValue("newVal3"); + setPropertyValue(capabilitiesPropsMap, capabilityProperty1); + setPropertyValue(capabilitiesPropsMap, capabilityProperty3); + StorageOperationStatus storageOperationStatus = topologyTemplateOperation.overrideToscaDataOfToscaElement(CONTAINER_ID, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, capabilitiesPropsMap); + assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.OK); + Map<String, MapCapabiltyProperty> updatedCapPropsMap = fetchCapabilitiesProps(CONTAINER_ID); + compareCapabilitiesProperties(capabilitiesProperties, updatedCapPropsMap); + } + + @Test + public void updateToscaDataDeepElementsBlockToToscaElement() { + assertCapabilityPropValue(capabilityProperty1, "val1"); + assertCapabilityPropValue(capabilityProperty2, "val2"); + assertCapabilityPropValue(capabilityProperty3, "val3"); + + MapCapabiltyProperty instance1Props = capabilitiesPropsMap.get("instance1"); + capabilityProperty1.setPropValue("newVal1"); + setPropertyValue(capabilitiesPropsMap, capabilityProperty1); + + capabilityProperty3.setPropValue("newVal3"); + setPropertyValue(capabilitiesPropsMap, capabilityProperty3); + + Component component = new org.openecomp.sdc.be.model.Resource(); + component.setUniqueId(CONTAINER_ID); + StorageOperationStatus updateStatus = topologyTemplateOperation.updateToscaDataDeepElementsBlockToToscaElement(CONTAINER_ID, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, instance1Props, "instance1"); + + assertThat(updateStatus).isEqualTo(StorageOperationStatus.OK); + assertCapabilityPropValue(capabilityProperty1, "newVal1"); + assertCapabilityPropValue(capabilityProperty2, "val2"); + assertCapabilityPropValue(capabilityProperty3, "val3");//only instance1 props should be updated + } + + private Map<String, MapCapabiltyProperty> fetchCapabilitiesProps(String containerId) { + ComponentParametersView capabilityPropsFilter = new ComponentParametersView(true); + capabilityPropsFilter.setIgnoreCapabiltyProperties(false); + return ((TopologyTemplate) topologyTemplateOperation.getToscaElement(containerId, capabilityPropsFilter).left().value()).getCalculatedCapabilitiesProperties(); + } + + private void compareCapabilitiesProperties(List<CapabilityPropertyDataObject> expected, Map<String, MapCapabiltyProperty> actual) { + expected.forEach(expectedCapabilityProp -> { + assertThat(getPropertyValue(actual, expectedCapabilityProp.instanceId, expectedCapabilityProp.capabilityId, expectedCapabilityProp.propName)) + .isEqualTo(expectedCapabilityProp.propValue); + }); + } + + private String getPropertyValue(Map<String, MapCapabiltyProperty> capabilityPropertyMap, String instance, String capability, String prop) { + return capabilityPropertyMap.get(instance).getMapToscaDataDefinition().get(capability).getMapToscaDataDefinition().get(prop).getValue(); + } + + private void setPropertyValue(Map<String, MapCapabiltyProperty> capabilityPropertyMap, CapabilityPropertyDataObject capabilityProperty) { + setPropertyValue(capabilityPropertyMap.get(capabilityProperty.getInstanceId()), capabilityProperty); + + } + + private void setPropertyValue(MapCapabiltyProperty capabilitiesInstanceProperties, CapabilityPropertyDataObject capabilityProperty) { + capabilitiesInstanceProperties.getMapToscaDataDefinition().get(capabilityProperty.getCapabilityId()) + .getMapToscaDataDefinition().get(capabilityProperty.getPropName()) + .setValue(capabilityProperty.getPropValue()); + } + + private void assertCapabilityPropValue(CapabilityPropertyDataObject prop, String expectedValue) { + Map<String, MapCapabiltyProperty> loadedCapPropsMap = fetchCapabilitiesProps(CONTAINER_ID); + String propertyValue = getPropertyValue(loadedCapPropsMap, prop.getInstanceId(), prop.getCapabilityId(), prop.getPropName()); + assertThat(propertyValue).isEqualTo(expectedValue); + } + + + private PropertyDefinition createPropWithValue(String val) { + PropertyDefinition propertyDefinition = new PropertyDefinition(); + propertyDefinition.setValue(val); + return propertyDefinition; + } + + private static class CapabilityPropertyDataObject { + private String instanceId; + private String capabilityId; + private String propName; + private String propValue; + + CapabilityPropertyDataObject(String instanceId, String capabilityId, String propName, String propValue) { + this.instanceId = instanceId; + this.capabilityId = capabilityId; + this.propName = propName; + this.propValue = propValue; + } + + String getInstanceId() { + return instanceId; + } + + String getCapabilityId() { + return capabilityId; + } + + String getPropName() { + return propName; + } + + String getPropValue() { + return propValue; + } + + void setPropValue(String propValue) { + this.propValue = propValue; + } + } +} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/TopologyTemplateOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/TopologyTemplateOperationTest.java new file mode 100644 index 0000000000..7756a08cc1 --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/TopologyTemplateOperationTest.java @@ -0,0 +1,125 @@ +package org.openecomp.sdc.be.model.jsontitan.operations; + +import fj.data.Either; + +import org.apache.tinkerpop.gremlin.structure.Direction; +import org.apache.tinkerpop.gremlin.structure.Edge; +import org.apache.tinkerpop.gremlin.structure.Property; +import org.apache.tinkerpop.gremlin.structure.Vertex; +import org.apache.tinkerpop.gremlin.structure.VertexProperty.Cardinality; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.junit.MockitoJUnitRunner; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.TitanDao; +import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; +import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; +import org.openecomp.sdc.be.datatypes.elements.MapCapabiltyProperty; +import org.openecomp.sdc.be.datatypes.elements.MapDataDefinition; +import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; +import org.openecomp.sdc.be.model.PolicyDefinition; +import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; +import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter; +import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder; + +import com.thinkaurelius.titan.core.PropertyKey; +import com.thinkaurelius.titan.core.TitanEdge; +import com.thinkaurelius.titan.core.TitanTransaction; +import com.thinkaurelius.titan.core.TitanVertex; +import com.thinkaurelius.titan.core.TitanVertexProperty; +import com.thinkaurelius.titan.core.TitanVertexQuery; +import com.thinkaurelius.titan.core.VertexLabel; +import com.thinkaurelius.titan.diskstorage.EntryMetaData.Map; + +import java.util.Collections; +import java.util.HashMap; +import java.util.Iterator; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.when; + +@RunWith(MockitoJUnitRunner.class) +//error scenarios +public class TopologyTemplateOperationTest { + + private static final String CONTAINER_ID = "containerId"; + @InjectMocks + private TopologyTemplateOperation topologyTemplateOperation; + @Mock + private TitanDao titanDao; + + @Test + public void overrideToscaDataOfToscaElement_failedToFetchContainerVertex() { + when(titanDao.getVertexById(CONTAINER_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.right(TitanOperationStatus.INVALID_ID)); + StorageOperationStatus storageOperationStatus = topologyTemplateOperation.overrideToscaDataOfToscaElement(CONTAINER_ID, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, Collections.emptyMap()); + assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.INVALID_ID); + } + + @Test + public void overrideToscaDataOfToscaElement_failedToFetchDataVertex() { + GraphVertex containerVertex = new GraphVertex(); + when(titanDao.getVertexById(CONTAINER_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(containerVertex)); + when(titanDao.getChildVertex(containerVertex, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, JsonParseFlagEnum.ParseJson)).thenReturn(Either.right(TitanOperationStatus.NOT_FOUND)); + StorageOperationStatus storageOperationStatus = topologyTemplateOperation.overrideToscaDataOfToscaElement(CONTAINER_ID, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, Collections.emptyMap()); + assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.NOT_FOUND); + } + + @Test + public void updateToscaDataDeepElements_failedToFetchContainerVertex() { + when(titanDao.getVertexById(CONTAINER_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.right(TitanOperationStatus.INVALID_ID)); + StorageOperationStatus storageOperationStatus = topologyTemplateOperation.updateToscaDataDeepElementsBlockToToscaElement(CONTAINER_ID, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, new MapCapabiltyProperty(), ""); + assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.INVALID_ID); + } + + @Test + public void updateToscaDataDeepElements_failedToFetchDataVertex() { + GraphVertex containerVertex = new GraphVertex(); + when(titanDao.getVertexById(CONTAINER_ID, JsonParseFlagEnum.NoParse)).thenReturn(Either.left(containerVertex)); + when(titanDao.getChildVertex(containerVertex, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, JsonParseFlagEnum.ParseJson)).thenReturn(Either.right(TitanOperationStatus.NOT_FOUND)); + StorageOperationStatus storageOperationStatus = topologyTemplateOperation.updateToscaDataDeepElementsBlockToToscaElement(CONTAINER_ID, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, new MapCapabiltyProperty(), ""); + assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.NOT_FOUND); + } + + @Test + public void addPolicyToToscaElementSuccessTest(){ + TitanOperationStatus status = TitanOperationStatus.OK; + StorageOperationStatus result = addPolicyToToscaElementWithStatus(status); + assertThat(result).isEqualTo(StorageOperationStatus.OK); + } + + @Test + public void addPolicyToToscaElementFailureTest(){ + TitanOperationStatus status = TitanOperationStatus.ALREADY_EXIST; + StorageOperationStatus result = addPolicyToToscaElementWithStatus(status); + assertThat(result).isEqualTo(StorageOperationStatus.ENTITY_ALREADY_EXISTS); + } + + @SuppressWarnings("unchecked") + private StorageOperationStatus addPolicyToToscaElementWithStatus(TitanOperationStatus status) { + GraphVertex componentV = new GraphVertex(); + componentV.setVertex(Mockito.mock(TitanVertex.class)); + GraphVertex dataV = new GraphVertex(); + dataV.setVertex(Mockito.mock(TitanVertex.class)); + String componentName = "componentName"; + String componentId = UniqueIdBuilder.buildResourceUniqueId(); + String policyTypeName = "org.openecomp.policies.placement.valet.Affinity"; + componentV.setJsonMetadataField(JsonPresentationFields.NAME, componentName); + componentV.setUniqueId(componentId); + PolicyDefinition policy = new PolicyDefinition(); + policy.setPolicyTypeName(policyTypeName); + int counter = 0; + Either<GraphVertex, TitanOperationStatus> toscaDataVertexRes = Either.right(TitanOperationStatus.NOT_FOUND); + when(titanDao.getChildVertex(eq(componentV), eq(EdgeLabelEnum.POLICIES), eq(JsonParseFlagEnum.ParseJson))).thenReturn(toscaDataVertexRes); + Either<GraphVertex, TitanOperationStatus> createVertex = Either.left(dataV); + when(titanDao.createVertex(any(GraphVertex.class))).thenReturn(createVertex); + when(titanDao.createEdge(any(TitanVertex.class), any(TitanVertex.class), any(EdgeLabelEnum.class), any(HashMap.class))).thenReturn(status); + return topologyTemplateOperation.addPolicyToToscaElement(componentV, policy, counter); + } + +} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaElementOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaElementOperationTest.java index 806c22a8fb..d9148a18e1 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaElementOperationTest.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaElementOperationTest.java @@ -22,6 +22,7 @@ import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; import org.openecomp.sdc.be.model.LifecycleStateEnum; import org.openecomp.sdc.be.model.ModelTestBase; +import org.openecomp.sdc.be.model.catalog.CatalogComponent; import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElement; import org.openecomp.sdc.be.model.jsontitan.utils.GraphTestUtils; import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; @@ -81,6 +82,9 @@ public class ToscaElementOperationTest extends ModelTestBase{ }, null); assertEquals(highestResources.stream().count(), highestResourcesExpectedCount); } + + + @Test public void testGetAllResourcesCertifiedNoFilter() { @@ -268,6 +272,8 @@ public class ToscaElementOperationTest extends ModelTestBase{ } private void initGraphForTest() { + GraphTestUtils.createRootCatalogVertex(titanDao); + Map<GraphPropertyEnum, Object> highstVerticesProps = new HashMap<GraphPropertyEnum, Object>() { { put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaOperationFacadePoliciesTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaOperationFacadePoliciesTest.java new file mode 100644 index 0000000000..6a4a117360 --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaOperationFacadePoliciesTest.java @@ -0,0 +1,144 @@ +package org.openecomp.sdc.be.model.jsontitan.operations; + +import fj.data.Either; +import org.junit.After; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.openecomp.sdc.be.dao.config.TitanSpringConfig; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.TitanDao; +import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; +import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; +import org.openecomp.sdc.be.datatypes.elements.PolicyTargetType; +import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; +import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; +import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; +import org.openecomp.sdc.be.model.Component; +import org.openecomp.sdc.be.model.ComponentParametersView; +import org.openecomp.sdc.be.model.ModelTestBase; +import org.openecomp.sdc.be.model.PolicyDefinition; +import org.openecomp.sdc.be.model.config.ModelOperationsSpringConfig; +import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; + +import static java.util.Arrays.asList; +import static java.util.Collections.singletonList; +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.Assert.assertTrue; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration(classes = {TitanSpringConfig.class, ModelOperationsSpringConfig.class}) +public class ToscaOperationFacadePoliciesTest extends ModelTestBase { + + private static final String CONTAINER_ID = "containerId"; + private static final String CONTAINER_NAME = "containerName"; + @Autowired + private ToscaOperationFacade toscaOperationFacade; + @Autowired + private TitanDao titanDao; + + private PolicyDefinition policy1, policy2; + + @BeforeClass + public static void setupBeforeClass() { + ModelTestBase.init(); + } + + @Before + public void setUp() throws Exception { + policy1 = createPolicyDefinition("type1"); + policy2 = createPolicyDefinition("type2"); + createContainerVertexInDB(); + createPoliciesOnGraph(policy1, policy2); + } + + private void createPoliciesOnGraph(PolicyDefinition ... policies) { + for (int i = 0; i < policies.length; i++) { + PolicyDefinition policy = policies[i]; + Either<PolicyDefinition, StorageOperationStatus> createdPolicy = toscaOperationFacade.associatePolicyToComponent(CONTAINER_ID, policy, i); + assertTrue(createdPolicy.isLeft()); + } + } + + @After + public void tearDown() { + titanDao.rollback(); + } + + @Test + public void updatePoliciesTargetsOfComponent_updateSinglePolicy() { + List<String> updatedTargetIds = asList("instance1new", "instance2"); + PolicyDefinition originalPolicy2 = clonePolicyWithTargets(policy2); + updatePolicyTypeTargetsIds(policy1, PolicyTargetType.COMPONENT_INSTANCES, updatedTargetIds); + updatePolicyTypeTargetsIds(policy2, PolicyTargetType.COMPONENT_INSTANCES, updatedTargetIds); + + StorageOperationStatus storageOperationStatus = toscaOperationFacade.updatePoliciesOfComponent(CONTAINER_ID, singletonList(policy1)); + assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.OK); + Component updatedComponent = fetchComponentFromDB(); + verifyPolicyTargets(updatedComponent.getPolicyById(policy1.getUniqueId()), policy1); + verifyPolicyTargets(updatedComponent.getPolicyById(policy2.getUniqueId()), originalPolicy2); + } + + @Test + public void updatePoliciesTargetsOfComponent_updateMultiplePolicies() { + List<String> updatedTargetIds = asList("instance1new", "instance2"); + updatePolicyTypeTargetsIds(policy1, PolicyTargetType.COMPONENT_INSTANCES, updatedTargetIds); + updatePolicyTypeTargetsIds(policy2, PolicyTargetType.COMPONENT_INSTANCES, updatedTargetIds); + StorageOperationStatus storageOperationStatus = toscaOperationFacade.updatePoliciesOfComponent(CONTAINER_ID, asList(policy1, policy2)); + assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.OK); + Component updatedComponent = fetchComponentFromDB(); + verifyPolicyTargets(updatedComponent.getPolicyById(policy1.getUniqueId()), policy1); + verifyPolicyTargets(updatedComponent.getPolicyById(policy2.getUniqueId()), policy2); + } + + private PolicyDefinition clonePolicyWithTargets(PolicyDefinition policy) { + PolicyDefinition originalPolicy = new PolicyDefinition(policy); + Map<PolicyTargetType, List<String>> clonedTargetMap = policy.getTargets().entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, entry -> new ArrayList<>(entry.getValue()))); + originalPolicy.setTargets(clonedTargetMap); + return originalPolicy; + } + + private void verifyPolicyTargets(PolicyDefinition updatedPolicy, PolicyDefinition expectedPolicy) { + assertThat(updatedPolicy.getTargets()) + .isEqualTo(expectedPolicy.getTargets()); + } + + private void updatePolicyTypeTargetsIds(PolicyDefinition policy, PolicyTargetType targetType, List<String> updatedTargetIds) { + policy.getTargets().put(targetType, updatedTargetIds); + } + + private Component fetchComponentFromDB() { + ComponentParametersView componentParametersView = new ComponentParametersView(); + componentParametersView.disableAll(); + componentParametersView.setIgnorePolicies(false); + return toscaOperationFacade.getToscaElement(CONTAINER_ID, componentParametersView).left().value(); + } + + private void createContainerVertexInDB() { + GraphVertex resource = new GraphVertex(VertexTypeEnum.TOPOLOGY_TEMPLATE); + resource.addMetadataProperty(GraphPropertyEnum.UNIQUE_ID, CONTAINER_ID); + resource.addMetadataProperty(GraphPropertyEnum.NAME, CONTAINER_NAME); + resource.setJsonMetadataField(JsonPresentationFields.NAME, CONTAINER_NAME); + resource.setJsonMetadataField(JsonPresentationFields.COMPONENT_TYPE, ComponentTypeEnum.RESOURCE.name()); + Either<GraphVertex, TitanOperationStatus> container = titanDao.createVertex(resource); + assertTrue(container.isLeft()); + } + + private PolicyDefinition createPolicyDefinition(String type) { + PolicyDefinition policy = new PolicyDefinition(); + policy.setPolicyTypeName(type); + policy.setTargets(new HashMap<>()); + policy.getTargets().put(PolicyTargetType.COMPONENT_INSTANCES, asList("instance1", "instance2")); + return policy; + } +} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaOperationFacadeTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaOperationFacadeTest.java index 4a7d27812d..37d466c648 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaOperationFacadeTest.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaOperationFacadeTest.java @@ -1,15 +1,6 @@ package org.openecomp.sdc.be.model.jsontitan.operations; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; -import static org.mockito.Mockito.when; - -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.stream.Collectors; -import java.util.stream.IntStream; - +import fj.data.Either; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; @@ -29,11 +20,24 @@ import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; import org.openecomp.sdc.be.model.Component; import org.openecomp.sdc.be.model.ComponentParametersView; +import org.openecomp.sdc.be.model.PolicyDefinition; import org.openecomp.sdc.be.model.jsontitan.datamodel.TopologyTemplate; import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElement; import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; -import fj.data.Either; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; +import java.util.stream.IntStream; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyInt; +import static org.mockito.ArgumentMatchers.anyMap; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.when; @RunWith(MockitoJUnitRunner.class) public class ToscaOperationFacadeTest { @@ -58,16 +62,18 @@ public class ToscaOperationFacadeTest { @Test public void fetchMetaDataByResourceType() throws Exception { ArgumentCaptor<Map> criteriaCapture = ArgumentCaptor.forClass(Map.class); + ArgumentCaptor<Map> criteriaNotCapture = ArgumentCaptor.forClass(Map.class); ComponentParametersView dataFilter = new ComponentParametersView(); List<GraphVertex> mockVertices = getMockVertices(2); Either<List<GraphVertex>, TitanOperationStatus> returnedVertices = Either.left(mockVertices); - when(titanDaoMock.getByCriteria(Mockito.eq(null), criteriaCapture.capture(), Mockito.eq(JsonParseFlagEnum.ParseMetadata))).thenReturn(returnedVertices); + when(titanDaoMock.getByCriteria(eq(null), criteriaCapture.capture(), criteriaNotCapture.capture(), eq(JsonParseFlagEnum.ParseMetadata))).thenReturn(returnedVertices); when(topologyTemplateOperationMock.getToscaElement(mockVertices.get(0), dataFilter)).thenReturn(Either.left(getResourceToscaElement("0"))); when(topologyTemplateOperationMock.getToscaElement(mockVertices.get(1), dataFilter)).thenReturn(Either.left(getResourceToscaElement("1"))); Either<List<Component>, StorageOperationStatus> fetchedComponents = testInstance.fetchMetaDataByResourceType(ResourceTypeEnum.VF.getValue(), dataFilter); verifyCriteriaForHighestVersionAndVfResourceType(criteriaCapture); + verifyCriteriaNotIsDeleted(criteriaNotCapture); assertTrue(fetchedComponents.isLeft()); List<Component> cmpts = fetchedComponents.left().value(); @@ -83,17 +89,93 @@ public class ToscaOperationFacadeTest { assertEquals(criteria.get(GraphPropertyEnum.IS_HIGHEST_VERSION), true); } + private void verifyCriteriaNotIsDeleted(ArgumentCaptor<Map> criteriaNotCapture) { + Map<GraphPropertyEnum, Object> notCriteria = (Map<GraphPropertyEnum, Object>)criteriaNotCapture.getValue(); + assertEquals(1, notCriteria.size()); + assertEquals(notCriteria.get(GraphPropertyEnum.IS_DELETED), true); + } + @SuppressWarnings("unchecked") @Test public void fetchMetaDataByResourceType_failedToGetData() throws Exception { - when(titanDaoMock.getByCriteria(Mockito.eq(null), Mockito.anyMap(), Mockito.eq(JsonParseFlagEnum.ParseMetadata))).thenReturn(Either.right(TitanOperationStatus.GENERAL_ERROR)); + when(titanDaoMock.getByCriteria(eq(null), anyMap(), anyMap(), eq(JsonParseFlagEnum.ParseMetadata))).thenReturn(Either.right(TitanOperationStatus.GENERAL_ERROR)); Either<List<Component>, StorageOperationStatus> fetchedComponents = testInstance.fetchMetaDataByResourceType(ResourceTypeEnum.VF.getValue(), new ComponentParametersView()); assertTrue(fetchedComponents.isRight()); assertEquals(StorageOperationStatus.GENERAL_ERROR, fetchedComponents.right().value()); } + + @Test + public void associatePolicyToComponentSuccessTest(){ + Either<PolicyDefinition, StorageOperationStatus> result = associatePolicyToComponentWithStatus(StorageOperationStatus.OK); + assertTrue(result.isLeft()); + } + + @Test + public void associatePolicyToComponentFailureTest(){ + Either<PolicyDefinition, StorageOperationStatus> result = associatePolicyToComponentWithStatus(StorageOperationStatus.BAD_REQUEST); + assertTrue(result.isRight() && result.right().value() == StorageOperationStatus.BAD_REQUEST); + } + + @Test + public void updatePolicyOfComponentSuccessTest(){ + Either<PolicyDefinition, StorageOperationStatus> result = updatePolicyOfComponentWithStatus(StorageOperationStatus.OK); + assertTrue(result.isLeft()); + } + + @Test + public void updatePolicyOfComponentFailureTest(){ + Either<PolicyDefinition, StorageOperationStatus> result = updatePolicyOfComponentWithStatus(StorageOperationStatus.NOT_FOUND); + assertTrue(result.isRight() && result.right().value() == StorageOperationStatus.NOT_FOUND); + } + + @Test + public void removePolicyFromComponentSuccessTest(){ + removePolicyFromComponentWithStatus(StorageOperationStatus.OK); + } + + @Test + public void removePolicyFromComponentFailureTest(){ + removePolicyFromComponentWithStatus(StorageOperationStatus.NOT_FOUND); + } + + private Either<PolicyDefinition, StorageOperationStatus> associatePolicyToComponentWithStatus(StorageOperationStatus status) { + PolicyDefinition policy = new PolicyDefinition(); + String componentId = "componentId"; + int counter = 0; + GraphVertex vertex; + if(status == StorageOperationStatus.OK){ + vertex = getTopologyTemplateVertex(); + } else { + vertex = getNodeTypeVertex(); + } + Either<GraphVertex, TitanOperationStatus> getVertexEither = Either.left(vertex); + when(titanDaoMock.getVertexById(eq(componentId), eq(JsonParseFlagEnum.ParseMetadata))).thenReturn(getVertexEither); + when(topologyTemplateOperationMock.addPolicyToToscaElement(eq(vertex), any(PolicyDefinition.class), anyInt())).thenReturn(status); + return testInstance.associatePolicyToComponent(componentId, policy, counter); + } + + private Either<PolicyDefinition, StorageOperationStatus> updatePolicyOfComponentWithStatus(StorageOperationStatus status) { + PolicyDefinition policy = new PolicyDefinition(); + String componentId = "componentId"; + GraphVertex vertex = getTopologyTemplateVertex(); + when(titanDaoMock.getVertexById(eq(componentId), eq(JsonParseFlagEnum.NoParse))).thenReturn(Either.left(vertex)); + when(topologyTemplateOperationMock.updatePolicyOfToscaElement(eq(vertex), any(PolicyDefinition.class))).thenReturn(status); + return testInstance.updatePolicyOfComponent(componentId, policy); + } + private void removePolicyFromComponentWithStatus(StorageOperationStatus status) { + String componentId = "componentId"; + String policyId = "policyId"; + GraphVertex vertex = getTopologyTemplateVertex(); + Either<GraphVertex, TitanOperationStatus> getVertexEither = Either.left(vertex); + when(titanDaoMock.getVertexById(eq(componentId), eq(JsonParseFlagEnum.NoParse))).thenReturn(getVertexEither); + when(topologyTemplateOperationMock.removePolicyFromToscaElement(eq(vertex), eq(policyId))).thenReturn(status); + StorageOperationStatus result = testInstance.removePolicyFromComponent(componentId, policyId); + assertTrue(result == status); + } + private List<GraphVertex> getMockVertices(int numOfVertices) { - return IntStream.range(0, numOfVertices).mapToObj(i -> getMockVertex()).collect(Collectors.toList()); + return IntStream.range(0, numOfVertices).mapToObj(i -> getTopologyTemplateVertex()).collect(Collectors.toList()); } private ToscaElement getResourceToscaElement(String id) { @@ -104,9 +186,15 @@ public class ToscaOperationFacadeTest { return toscaElement; } - private GraphVertex getMockVertex() { + private GraphVertex getTopologyTemplateVertex() { GraphVertex graphVertex = new GraphVertex(); graphVertex.setLabel(VertexTypeEnum.TOPOLOGY_TEMPLATE); return graphVertex; } + + private GraphVertex getNodeTypeVertex() { + GraphVertex graphVertex = new GraphVertex(); + graphVertex.setLabel(VertexTypeEnum.NODE_TYPE); + return graphVertex; + } }
\ No newline at end of file diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/utils/GraphTestUtils.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/utils/GraphTestUtils.java index 862515c58e..72919b6136 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/utils/GraphTestUtils.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/utils/GraphTestUtils.java @@ -32,6 +32,7 @@ import org.apache.tinkerpop.gremlin.structure.io.IoCore; import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; import org.openecomp.sdc.be.dao.jsongraph.TitanDao; import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; +import org.openecomp.sdc.be.dao.jsongraph.utils.IdBuilderUtils; import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; @@ -44,6 +45,12 @@ import fj.data.Either; public final class GraphTestUtils { + public static void createRootCatalogVertex(TitanDao titanDao) { + GraphVertex catalogRootVertex = new GraphVertex(VertexTypeEnum.CATALOG_ROOT); + catalogRootVertex.setUniqueId(IdBuilderUtils.generateUniqueId()); + titanDao.createVertex(catalogRootVertex); + } + public static GraphVertex createResourceVertex(TitanDao titanDao, Map<GraphPropertyEnum,Object> metadataProps, ResourceTypeEnum type) { GraphVertex vertex = new GraphVertex(); if (type == ResourceTypeEnum.VF) { diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/GroupTypeOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/GroupTypeOperationTest.java new file mode 100644 index 0000000000..809134ecb6 --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/GroupTypeOperationTest.java @@ -0,0 +1,346 @@ +package org.openecomp.sdc.be.model.operations.impl; + +import fj.data.Either; +import org.apache.tinkerpop.gremlin.structure.Edge; +import org.junit.After; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels; +import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary; +import org.openecomp.sdc.be.dao.titan.TitanGenericDao; +import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; +import org.openecomp.sdc.be.model.CapabilityTypeDefinition; +import org.openecomp.sdc.be.model.GroupTypeDefinition; +import org.openecomp.sdc.be.model.ModelTestBase; +import org.openecomp.sdc.be.model.PropertyDefinition; +import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; +import org.openecomp.sdc.be.model.tosca.ToscaType; +import org.openecomp.sdc.be.resources.data.CapabilityTypeData; +import org.openecomp.sdc.be.resources.data.GroupTypeData; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +import javax.annotation.Resource; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import static com.google.common.collect.Sets.newHashSet; +import static java.util.Arrays.asList; +import static java.util.Collections.singletonList; +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.Assert.*; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration("classpath:application-context-test.xml") +public class GroupTypeOperationTest extends ModelTestBase { + private static final String TOSCA_GROUPS_ROOT = "tosca.groups.Root"; + + @Resource(name = "titan-generic-dao") + private TitanGenericDao titanDao; + + @Resource(name = "capability-type-operation") + private CapabilityTypeOperation capabilityTypeOperation; + + @Resource(name = "group-type-operation") + private GroupTypeOperation groupTypeOperation; + + @BeforeClass + public static void setupBeforeClass() { + ModelTestBase.init(); + } + + @After + public void tearDown() { + titanDao.rollback(); + } + + @Test + public void getAllGroupTypes() { + GroupTypeDefinition rootGroupDefinition = createRootGroupDefinition(); + GroupTypeDefinition type1 = createGroupType("type1"); + GroupTypeDefinition type2 = createGroupType("type2"); + groupTypeOperation.addGroupType(rootGroupDefinition); + groupTypeOperation.addGroupType(type1); + groupTypeOperation.addGroupType(type2); + + List<GroupTypeDefinition> allGroupTypesNoExclusion = groupTypeOperation.getAllGroupTypes(null); + assertThat(allGroupTypesNoExclusion) + .usingElementComparatorOnFields("type") + .containsExactlyInAnyOrder(rootGroupDefinition, type1, type2); + } + + @Test + public void getAllGroupTypes_whenPassingExclusionList_doNotReturnExcludedTypes() { + GroupTypeDefinition rootGroupDefinition = createRootGroupDefinition(); + GroupTypeDefinition type1 = createGroupType("type1"); + GroupTypeDefinition type2 = createGroupType("type2"); + groupTypeOperation.addGroupType(rootGroupDefinition); + groupTypeOperation.addGroupType(type1); + groupTypeOperation.addGroupType(type2); + + List<GroupTypeDefinition> allGroupTypes = groupTypeOperation.getAllGroupTypes(newHashSet("type1", "type2")); + assertThat(allGroupTypes) + .usingElementComparatorOnFields("type") + .containsExactly(rootGroupDefinition); + } + + @Test + public void groupTypeWithoutCapabilityTypeCreated() { + GroupTypeData rootNode = getOrCreateRootGroupTypeNode(); + + GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition(); + groupTypeDefinition.setDerivedFrom(TOSCA_GROUPS_ROOT); + groupTypeDefinition.setDescription("groups l3-networks in network collection"); + groupTypeDefinition.setType("org.openecomp.groups.NetworkCollection"); + groupTypeDefinition.setVersion("1.0"); + + List<PropertyDefinition> properties = asList( + buildProperty("network_collection_type", "l3-network", "network collection type, defined with default value"), + buildProperty("network_collection_subtype", "sub-interface", "network collection subtype, defined with default value"), + buildProperty("network_collection_role", null, "network collection role"), + buildProperty("network_collection_description", null, "network collection description, free format text")); + + groupTypeDefinition.setProperties(properties ); + + Either<GroupTypeDefinition, StorageOperationStatus> addGroupTypeResult = groupTypeOperation.addGroupType(groupTypeDefinition, false); + assertEquals("check group type added", true, addGroupTypeResult.isLeft()); + compareBetweenCreatedToSent(groupTypeDefinition, addGroupTypeResult.left().value()); + + addGroupTypeResult = groupTypeOperation.getGroupTypeByTypeAndVersion("org.openecomp.groups.NetworkCollection", "1.0"); + assertEquals("check group type added", true, addGroupTypeResult.isLeft()); + compareBetweenCreatedToSent(groupTypeDefinition, addGroupTypeResult.left().value()); + + Either<GroupTypeData, TitanOperationStatus> groupTypeResult = titanDao.getNode(GraphPropertiesDictionary.TYPE.getProperty(), groupTypeDefinition.getType(), GroupTypeData.class); + GroupTypeData groupTypeNode = extractVal(groupTypeResult); + + Either<Edge, TitanOperationStatus> edgeResult = titanDao.getEdgeByNodes(groupTypeNode, rootNode, GraphEdgeLabels.DERIVED_FROM); + validate(edgeResult); + } + + @Test + public void groupTypeWithCapabilityTypeAndEdgeCreated() { + GroupTypeData rootNode = getOrCreateRootGroupTypeNode(); + + CapabilityTypeDefinition capabilityTypeDef = createCapabilityType(); + Either<CapabilityTypeData, TitanOperationStatus> capabilityTypeResult = titanDao.getNode(GraphPropertiesDictionary.TYPE.getProperty(), capabilityTypeDef.getType(), CapabilityTypeData.class); + CapabilityTypeData capabilityTypeNode = extractVal(capabilityTypeResult); + + GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition(); + groupTypeDefinition.setDerivedFrom(TOSCA_GROUPS_ROOT); + groupTypeDefinition.setDescription("groups l3-networks in network collection"); + groupTypeDefinition.setType("org.openecomp.groups.NetworkCollection"); + groupTypeDefinition.setCapabilityTypes(asList(capabilityTypeDef)); + + List<PropertyDefinition> properties = asList( + buildProperty("vfc_instance_group_role", null, "role of this VFC group"), + buildProperty("vfc_parent_port_role", null, "common role of parent ports of VFCs in this group"), + buildProperty("network_collection_role", null, "network collection role assigned to this group"), + buildProperty("subinterface_role", null, "common role of subinterfaces of VFCs in this group, criteria the group is created")); + + groupTypeDefinition.setProperties(properties ); + + Either<GroupTypeDefinition, StorageOperationStatus> addGroupTypeResult = groupTypeOperation.addGroupType(groupTypeDefinition, true); + assertEquals("check group type added", true, addGroupTypeResult.isLeft()); + compareBetweenCreatedToSent(groupTypeDefinition, addGroupTypeResult.left().value()); + + Either<GroupTypeData, TitanOperationStatus> groupTypeResult = titanDao.getNode(GraphPropertiesDictionary.TYPE.getProperty(), groupTypeDefinition.getType(), GroupTypeData.class); + GroupTypeData groupTypeNode = extractVal(groupTypeResult); + + Either<Edge, TitanOperationStatus> edgeCapTypeResult = titanDao.getEdgeByNodes(groupTypeNode, capabilityTypeNode, GraphEdgeLabels.GROUP_TYPE_CAPABILITY_TYPE); + validate(edgeCapTypeResult); + + Either<Edge, TitanOperationStatus> edgeDerivedFromResult = titanDao.getEdgeByNodes(groupTypeNode, rootNode, GraphEdgeLabels.DERIVED_FROM); + validate(edgeDerivedFromResult); + } + + @Test + public void testUpgradeGroupTypeWithDerrivedFromEdge() { + GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition(); + groupTypeDefinition.setDerivedFrom(TOSCA_GROUPS_ROOT); + groupTypeDefinition.setDescription("groups l2-networks in network collection"); + groupTypeDefinition.setType("org.openecomp.groups.PrivateCollection"); + groupTypeDefinition.setVersion("1.0"); + + List<PropertyDefinition> properties = singletonList( + buildProperty("network_collection_type", "l2-network", "network collection type, defined with default value")); + + groupTypeDefinition.setProperties(properties ); + + Either<GroupTypeDefinition, StorageOperationStatus> addGroupTypeResult = groupTypeOperation.addGroupType(groupTypeDefinition, true); + assertEquals("check group type added", true, addGroupTypeResult.isLeft()); + compareBetweenCreatedToSent(groupTypeDefinition, addGroupTypeResult.left().value()); + + addGroupTypeResult = groupTypeOperation.getGroupTypeByTypeAndVersion("org.openecomp.groups.PrivateCollection", "1.0"); + assertEquals("check group type added", true, addGroupTypeResult.isLeft()); + compareBetweenCreatedToSent(groupTypeDefinition, addGroupTypeResult.left().value()); + + Either<GroupTypeDefinition, StorageOperationStatus> upgradeResult = groupTypeOperation.upgradeGroupType(groupTypeDefinition, groupTypeDefinition, true); + assertNotNull(upgradeResult); + assertTrue(upgradeResult.isLeft()); + } + + @Test + public void testUpgradeNonExistingGroupType() { + GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition(); + groupTypeDefinition.setDerivedFrom(TOSCA_GROUPS_ROOT); + groupTypeDefinition.setDescription("groups l2-networks in network collection"); + groupTypeDefinition.setType("org.openecomp.groups.MyCollection"); + groupTypeDefinition.setVersion("1.0"); + + Either<GroupTypeDefinition, StorageOperationStatus> upgradeResult = groupTypeOperation.upgradeGroupType(groupTypeDefinition, groupTypeDefinition, true); + assertNotNull(upgradeResult); + assertTrue(upgradeResult.isRight()); + } + + @Test + public void testUpgradeNotDerivedGroupType() { + GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition(); + groupTypeDefinition.setDescription("groups social-networks in school"); + groupTypeDefinition.setType("org.openecomp.groups.Teachers"); + groupTypeDefinition.setVersion("1.0"); + + Either<GroupTypeDefinition, StorageOperationStatus> addGroupTypeResult = groupTypeOperation.addGroupType(groupTypeDefinition, true); + assertEquals("check group type added", true, addGroupTypeResult.isLeft()); + compareBetweenCreatedToSent(groupTypeDefinition, addGroupTypeResult.left().value()); + + Either<GroupTypeDefinition, StorageOperationStatus> upgradeResult = groupTypeOperation.upgradeGroupType(groupTypeDefinition, groupTypeDefinition, true); + assertNotNull(upgradeResult); + assertTrue(upgradeResult.isLeft()); + assertEquals(groupTypeDefinition, upgradeResult.left().value()); + } + + @Test + public void testUpgradeGroupTypeWithNonExistingParent() { + GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition(); + groupTypeDefinition.setDescription("groups social-networks in work"); + groupTypeDefinition.setType("org.openecomp.groups.Cowokers"); + groupTypeDefinition.setVersion("1.0"); + + Either<GroupTypeDefinition, StorageOperationStatus> addGroupTypeResult = groupTypeOperation.addGroupType(groupTypeDefinition, true); + assertEquals("check group type added", true, addGroupTypeResult.isLeft()); + compareBetweenCreatedToSent(groupTypeDefinition, addGroupTypeResult.left().value()); + + groupTypeDefinition.setDerivedFrom("Non.existing.parent"); + Either<GroupTypeDefinition, StorageOperationStatus> upgradeResult = groupTypeOperation.upgradeGroupType(groupTypeDefinition, groupTypeDefinition, true); + assertNotNull(upgradeResult); + assertTrue(upgradeResult.isRight()); + } + + @Test + public void testUpgradeGroupType() { + GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition(); + groupTypeDefinition.setDescription("groups social-networks in university"); + groupTypeDefinition.setType("org.openecomp.groups.Students"); + groupTypeDefinition.setVersion("1.0"); + + Either<GroupTypeDefinition, StorageOperationStatus> addGroupTypeResult = groupTypeOperation.addGroupType(groupTypeDefinition, true); + assertEquals("check group type added", true, addGroupTypeResult.isLeft()); + compareBetweenCreatedToSent(groupTypeDefinition, addGroupTypeResult.left().value()); + + GroupTypeDefinition parentGroupTypeDefinition = new GroupTypeDefinition(); + parentGroupTypeDefinition.setDescription("groups social-networks in university"); + parentGroupTypeDefinition.setType("org.openecomp.groups.Parents"); + parentGroupTypeDefinition.setVersion("1.0"); + + Either<GroupTypeDefinition, StorageOperationStatus> addParentGroupTypeResult = groupTypeOperation.addGroupType(parentGroupTypeDefinition, true); + assertEquals("check group type added", true, addParentGroupTypeResult.isLeft()); + compareBetweenCreatedToSent(parentGroupTypeDefinition, addParentGroupTypeResult.left().value()); + + groupTypeDefinition.setDerivedFrom("org.openecomp.groups.Parents"); + Either<GroupTypeDefinition, StorageOperationStatus> upgradeResult = groupTypeOperation.upgradeGroupType(groupTypeDefinition, groupTypeDefinition, true); + assertNotNull(upgradeResult); + assertTrue(upgradeResult.isLeft()); + assertEquals(groupTypeDefinition, upgradeResult.left().value()); + } + + + private GroupTypeData getOrCreateRootGroupTypeNode() { + Either<GroupTypeData, TitanOperationStatus> groupTypeResult = titanDao.getNode(GraphPropertiesDictionary.TYPE.getProperty(), TOSCA_GROUPS_ROOT, GroupTypeData.class); + if(groupTypeResult.isLeft()) { + return groupTypeResult.left().value(); + } + + return createRootGroupTypeNode(); + } + + private GroupTypeData createRootGroupTypeNode() { + GroupTypeDefinition rootGroupDefinition = createRootGroupDefinition(); + Either<GroupTypeDefinition, StorageOperationStatus> addGroupTypeResult = groupTypeOperation.addGroupType(rootGroupDefinition, true); + assertEquals("check group type added", true, addGroupTypeResult.isLeft()); + + Either<GroupTypeData, TitanOperationStatus> groupTypeResult = titanDao.getNode(GraphPropertiesDictionary.TYPE.getProperty(), rootGroupDefinition.getType(), GroupTypeData.class); + return extractVal(groupTypeResult); + } + + private GroupTypeDefinition createRootGroupDefinition() { + GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition(); + groupTypeDefinition.setDescription("The TOSCA Group Type all other TOSCA Group Types derive from"); + groupTypeDefinition.setType(TOSCA_GROUPS_ROOT); + return groupTypeDefinition; + } + + private GroupTypeDefinition createGroupType(String type) { + GroupTypeDefinition groupTypeDefinition = new GroupTypeDefinition(); + groupTypeDefinition.setDescription("description for type " + type); + groupTypeDefinition.setType(type); + return groupTypeDefinition; + } + + private CapabilityTypeDefinition createCapabilityType() { + CapabilityTypeDefinition capabilityTypeDefinition = new CapabilityTypeDefinition(); + capabilityTypeDefinition.setDescription("ability to expose routing information of the internal network"); + capabilityTypeDefinition.setType("org.openecomp.capabilities.VLANAssignment"); + capabilityTypeDefinition.setVersion("1.0"); + + Map<String, PropertyDefinition> properties = new HashMap<>(); + properties.put("vfc_instance_group_reference", + buildProperty("vfc_instance_group_reference", null, "Ability to recognize capability per vfc instance group on vnf instance")); + + capabilityTypeDefinition.setProperties(properties); + + Either<CapabilityTypeDefinition, StorageOperationStatus> addCapabilityTypeResult = capabilityTypeOperation.addCapabilityType(capabilityTypeDefinition, true); + assertEquals("check capability type added", true, addCapabilityTypeResult.isLeft()); + + CapabilityTypeDefinition capabilityTypeAdded = addCapabilityTypeResult.left().value(); + compareBetweenCreatedToSent(capabilityTypeDefinition, capabilityTypeAdded); + + return capabilityTypeDefinition; + } + + private PropertyDefinition buildProperty(String name, String defaultValue, String description) { + PropertyDefinition property = new PropertyDefinition(); + property.setName(name); + property.setDefaultValue(defaultValue); + property.setRequired(true); + property.setDescription(description); + property.setType(ToscaType.STRING.name().toLowerCase()); + + return property; + } + + private void compareBetweenCreatedToSent(CapabilityTypeDefinition expected, CapabilityTypeDefinition actual) { + assertEquals(expected.getDerivedFrom(), actual.getDerivedFrom()); + assertEquals(expected.getType(), actual.getType()); + assertEquals(expected.getDescription(), actual.getDescription()); + } + + private void compareBetweenCreatedToSent(GroupTypeDefinition expected, GroupTypeDefinition actual) { + assertEquals(expected.getType(), actual.getType()); + assertEquals(expected.getDescription(), actual.getDescription()); + } + + private <T> void validate(Either<T, TitanOperationStatus> result) { + extractVal(result); + } + + private <T> T extractVal(Either<T, TitanOperationStatus> result) { + assertTrue(result.isLeft()); + T t = result.left().value(); + assertNotNull(t); + + return t; + } + +} diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/HeatParametersOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/HeatParametersOperationTest.java index 8b4ebbdaf8..05b9ec1b89 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/HeatParametersOperationTest.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/HeatParametersOperationTest.java @@ -20,13 +20,12 @@ package org.openecomp.sdc.be.model.operations.impl; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; +import static org.junit.Assert.*; import static org.mockito.ArgumentMatchers.any; -import static org.mockito.ArgumentMatchers.anyMap; -import static org.mockito.ArgumentMatchers.eq; import static org.mockito.ArgumentMatchers.isNull; +import static org.mockito.Matchers.anyMap; +import static org.mockito.Matchers.anyObject; +import static org.mockito.Matchers.eq; import static org.mockito.Mockito.when; import java.util.ArrayList; @@ -45,6 +44,7 @@ import org.openecomp.sdc.be.model.HeatParameterDefinition; import org.openecomp.sdc.be.model.ModelTestBase; import org.openecomp.sdc.be.model.heat.HeatParameterType; import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; +import org.openecomp.sdc.be.model.operations.impl.HeatParametersOperation; import org.openecomp.sdc.be.resources.data.HeatParameterData; import org.openecomp.sdc.be.resources.data.HeatParameterValueData; @@ -103,7 +103,7 @@ public class HeatParametersOperationTest extends ModelTestBase { Either<GraphRelation, TitanOperationStatus> relationResult = Either.left(graphRelation); when(titanGenericDao.createNode(any(HeatParameterData.class), eq(HeatParameterData.class))).thenReturn(either); - when(titanGenericDao.createRelation(any(GraphNode.class), any(GraphNode.class), eq(GraphEdgeLabels.HEAT_PARAMETER), anyMap())).thenReturn(relationResult); + when(titanGenericDao.createRelation(any(GraphNode.class), (GraphNode) any(GraphNode.class), eq(GraphEdgeLabels.HEAT_PARAMETER), anyMap())).thenReturn(relationResult); StorageOperationStatus result = heatParametersOperation.addPropertiesToGraph(parameters, "resourceId.artifactId", NodeTypeEnum.ArtifactRef); diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/PolicyTypeOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/PolicyTypeOperationTest.java index 516ee51bab..c7e59006cf 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/PolicyTypeOperationTest.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/PolicyTypeOperationTest.java @@ -20,40 +20,51 @@ package org.openecomp.sdc.be.model.operations.impl; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; - -import java.util.Iterator; - -import javax.annotation.Resource; - +import com.thinkaurelius.titan.core.TitanGraph; +import com.thinkaurelius.titan.core.TitanVertex; +import fj.data.Either; import org.apache.commons.lang.StringUtils; +import org.apache.commons.lang3.tuple.ImmutablePair; import org.junit.Before; import org.junit.BeforeClass; import org.junit.Test; import org.junit.runner.RunWith; +import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge; +import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels; import org.openecomp.sdc.be.dao.titan.TitanGenericDao; import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; import org.openecomp.sdc.be.datatypes.elements.PolicyTypeDataDefinition; +import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; import org.openecomp.sdc.be.model.ModelTestBase; import org.openecomp.sdc.be.model.PolicyTypeDefinition; +import org.openecomp.sdc.be.model.PropertyDefinition; import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; +import org.openecomp.sdc.be.resources.data.PolicyTypeData; +import org.springframework.beans.factory.annotation.Autowired; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; -import com.thinkaurelius.titan.core.TitanGraph; -import com.thinkaurelius.titan.core.TitanVertex; +import java.util.Iterator; +import java.util.List; +import java.util.stream.Stream; -import fj.data.Either; +import static com.google.common.collect.Sets.newHashSet; +import static java.util.Arrays.asList; +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("classpath:application-context-test.xml") - public class PolicyTypeOperationTest extends ModelTestBase { - @Resource(name = "policy-type-operation") + private static final String NULL_STRING = null; + @Autowired private PolicyTypeOperation policyTypeOperation; + @Autowired + private TitanGenericDao titanGenericDao; + @BeforeClass public static void setupBeforeClass() { ModelTestBase.init(); @@ -99,17 +110,269 @@ public class PolicyTypeOperationTest extends ModelTestBase { assertTrue(eitherPolicyTypeFetched.isLeft()); PolicyTypeDefinition policyTypeFetched = eitherPolicyTypeFetched.left().value(); assertEquals(policyTypeFetched.toString(), policyTypeCreated.toString()); + } + + @Test + public void testGetLatestPolicyTypeByType_derivedFromFetchedCorrectly() { + PolicyTypeDefinition rootPolicyType = createRootPolicyTypeOnGraph(); + String derivedFromRootType = rootPolicyType.getType(); + PolicyTypeDefinition policyType1 = createPolicyTypeDef("tosca.policies.type1", "desc1", derivedFromRootType); + policyTypeOperation.addPolicyType(policyType1); + Either<PolicyTypeDefinition, StorageOperationStatus> eitherPolicyTypeFetched = policyTypeOperation.getLatestPolicyTypeByType(policyType1.getType()); + assertThat(eitherPolicyTypeFetched.left().value().getDerivedFrom()).isEqualTo(rootPolicyType.getType()); + } + + @Test + public void testGetLatestPolicyTypeByType_whenGettingTypeGetPropertiesFromAllDerivedFromChain_policyTypeHasNoDirectProps() { + PropertyDefinition prop1 = createSimpleProperty("val1", "prop1", "string"); + PropertyDefinition prop2 = createSimpleProperty("val2", "prop2", "string"); + PolicyTypeDefinition policyType1 = createPolicyTypeDef("tosca.policies.type1", null, prop1, prop2); + PolicyTypeDefinition policyType2 = createPolicyTypeDef("tosca.policies.type2", "desc3", policyType1.getType(), null); + addPolicyTypesToDB(policyType1, policyType2); + Either<PolicyTypeDefinition, StorageOperationStatus> latestPolicyType2 = policyTypeOperation.getLatestPolicyTypeByType(policyType2.getType()); + assertThat(latestPolicyType2.isLeft()); + assertThat(latestPolicyType2.left().value().getProperties()) + .usingElementComparatorOnFields("defaultValue", "name", "type") + .containsExactlyInAnyOrder(prop1, prop2); + } + + @Test + public void testGetLatestPolicyTypeByType_whenGettingTypeGetPropertiesFromAllDerivedFromChain() { + PropertyDefinition prop1 = createSimpleProperty("val1", "prop1", "string"); + PropertyDefinition prop2 = createSimpleProperty("val2", "prop2", "string"); + PropertyDefinition prop3 = createSimpleProperty("val3", "prop3", "string"); + + PolicyTypeDefinition rootPolicyType = createPolicyTypeDef(prop1); + PolicyTypeDefinition policyType1 = createPolicyTypeDef("tosca.policies.type1", "desc1", rootPolicyType.getType(), null); + PolicyTypeDefinition policyType2 = createPolicyTypeDef("tosca.policies.type2", "desc2", policyType1.getType(), prop2); + PolicyTypeDefinition policyType3 = createPolicyTypeDef("tosca.policies.type3", "desc3", policyType2.getType(), null); + PolicyTypeDefinition policyType4 = createPolicyTypeDef("tosca.policies.type4", "desc4", policyType3.getType(), prop3); + + addPolicyTypesToDB(rootPolicyType, policyType1, policyType2, policyType3, policyType4); + + Either<PolicyTypeDefinition, StorageOperationStatus> latestPolicyType3 = policyTypeOperation.getLatestPolicyTypeByType(policyType4.getType()); + assertThat(latestPolicyType3.isLeft()); + assertThat(latestPolicyType3.left().value().getProperties()) + .usingElementComparatorOnFields("defaultValue", "name", "type") + .containsExactlyInAnyOrder(prop1, prop2, prop3); + } + + @Test + public void getAllPolicyTypes_noPolicies() { + Either<List<PolicyTypeDefinition>, StorageOperationStatus> allPolicyTypes = policyTypeOperation.getAllPolicyTypes(null); + assertThat(allPolicyTypes.isRight()); + assertThat(allPolicyTypes.right().value()).isEqualTo(StorageOperationStatus.NOT_FOUND); + } + + @Test + public void getAllPolicyTypes() { + PolicyTypeDefinition policyType1 = createPolicyTypeDef(); + PolicyTypeDefinition policyType2 = createPolicyTypeDef("tosca.policies.test1", "desc1", "tosca.policies.Root"); + addPolicyTypesToDB(policyType1, policyType2); + Either<List<PolicyTypeDefinition>, StorageOperationStatus> allPolicyTypesWithNoExcluded = policyTypeOperation.getAllPolicyTypes(null); + assertThat(allPolicyTypesWithNoExcluded.left().value()).hasSize(2); + assertThat(allPolicyTypesWithNoExcluded.left().value()).usingElementComparatorOnFields("uniqueId", "description", "version", "type") + .containsExactlyInAnyOrder(policyType1, policyType2); + } + + @Test + public void getAllPolicyTypes_whenPassingExcludedTypeList_dontReturnExcludedTypes() { + PolicyTypeDefinition policyType1 = createPolicyTypeDef(); + PolicyTypeDefinition policyType2 = createPolicyTypeDef("tosca.policies.test1", "desc1", "tosca.policies.Root"); + PolicyTypeDefinition policyType3 = createPolicyTypeDef("tosca.policies.test2", "desc2", "tosca.policies.Root"); + policyTypeOperation.addPolicyType(policyType1); + policyTypeOperation.addPolicyType(policyType2); + policyTypeOperation.addPolicyType(policyType3); + Either<List<PolicyTypeDefinition>, StorageOperationStatus> allPolicyTypes = policyTypeOperation.getAllPolicyTypes(newHashSet("tosca.policies.test1", "tosca.policies.test2")); + assertThat(allPolicyTypes.left().value()).hasSize(1); + assertThat(allPolicyTypes.left().value()).usingElementComparatorOnFields("type") + .containsExactly(policyType1); + } + + @Test + public void addPolicyType_whenDerivedFromNodeNotExist_returnNotFound() { + PolicyTypeDefinition type1 = createPolicyTypeDef("tosca.policies.type1", "desc1", "derivedFrom"); + Either<PolicyTypeDefinition, StorageOperationStatus> addedPolicyTypeResult = policyTypeOperation.addPolicyType(type1); + assertThat(addedPolicyTypeResult.right().value()).isEqualTo(StorageOperationStatus.NOT_FOUND); + } + + @Test//bug379696 + public void addPolicyType_derivedFromAddedCorrectly() { + PolicyTypeDefinition rootPolicyType = createRootPolicyTypeOnGraph(); + String derivedFromRootType = rootPolicyType.getType(); + PolicyTypeDefinition policyType1 = createPolicyTypeDef("tosca.policies.type1", "desc1", derivedFromRootType); + Either<PolicyTypeDefinition, StorageOperationStatus> addedPolicyTypeResult = policyTypeOperation.addPolicyType(policyType1); + assertThat(addedPolicyTypeResult.isLeft()).isTrue(); + + Either<PolicyTypeDefinition, StorageOperationStatus> fetchedPolicyType = policyTypeOperation.getLatestPolicyTypeByType(policyType1.getType()); + PolicyTypeDefinition fetchedPolicyTypeVal = fetchedPolicyType.left().value(); + assertThat(fetchedPolicyTypeVal.getDerivedFrom()).isEqualTo(derivedFromRootType); + verifyDerivedFromNodeEqualsToRootPolicyType(rootPolicyType, fetchedPolicyTypeVal.getUniqueId()); + + } + + @Test + public void updatePolicyType_returnNotFoundErrorIfTryingToUpdateANonExistingType() { + PolicyTypeDefinition currType = createPolicyTypeDef(); + PolicyTypeDefinition updatedType = createPolicyTypeDef(); + Either<PolicyTypeDefinition, StorageOperationStatus> updatePolicyTypeRes = policyTypeOperation.updatePolicyType(updatedType, currType); + assertThat(updatePolicyTypeRes.right().value()).isEqualTo(StorageOperationStatus.NOT_FOUND); + } + @Test + public void updatePolicyType_basicFields() { + PolicyTypeDefinition createdType = createPolicyTypeDef("type1", "description1", NULL_STRING); + Either<PolicyTypeDefinition, StorageOperationStatus> currPolicyType = policyTypeOperation.addPolicyType(createdType); + + PolicyTypeDefinition updatedType = createPolicyTypeDef("type1", "description2", NULL_STRING); + policyTypeOperation.updatePolicyType(updatedType, currPolicyType.left().value()); + + Either<PolicyTypeDefinition, StorageOperationStatus> fetchedUpdatedType = policyTypeOperation.getLatestPolicyTypeByType(createdType.getType()); + PolicyTypeDefinition fetchedPolicyType = fetchedUpdatedType.left().value(); + assertThat(fetchedPolicyType.getProperties()).isEmpty(); + assertThat(fetchedPolicyType) + .isEqualToIgnoringGivenFields(updatedType, "properties"); + + } + + @Test + public void updatePolicyType_updateProperties() { + PropertyDefinition prop1 = createSimpleProperty("val1", "prop1", "string"); + PolicyTypeDefinition policyType = createPolicyTypeDef(prop1); + Either<PolicyTypeDefinition, StorageOperationStatus> currPolicyType = policyTypeOperation.addPolicyType(policyType); + + PropertyDefinition updatedProp1 = duplicateProperty(prop1, "newVal1", "int"); + PropertyDefinition prop2 = createSimpleProperty("val2", "prop2", "string"); + PolicyTypeDefinition updatedPolicyType = createPolicyTypeDef(updatedProp1, prop2); + + policyTypeOperation.updatePolicyType(updatedPolicyType, currPolicyType.left().value()); + + Either<PolicyTypeDefinition, StorageOperationStatus> fetchedUpdatedType = policyTypeOperation.getLatestPolicyTypeByType(policyType.getType()); + assertThat(fetchedUpdatedType.left().value().getProperties()) + .usingElementComparatorOnFields("name", "defaultValue", "type") + .containsExactlyInAnyOrder(updatedProp1, prop2); + + } + + @Test + public void updatePolicyType_derivedFrom_whenNoPrevDerivedFrom_updateToNewDerivedFrom() { + PolicyTypeDefinition rootPolicyType = createPolicyTypeDef(); + PolicyTypeDefinition policyType1 = createPolicyTypeDef("type1", "descr", NULL_STRING); + PolicyTypeDefinition updatedPolicyType = createPolicyTypeDef("type1", "descr", rootPolicyType.getType()); + policyTypeOperation.addPolicyType(rootPolicyType); + Either<PolicyTypeDefinition, StorageOperationStatus> currPolicyType = policyTypeOperation.addPolicyType(policyType1); + policyTypeOperation.updatePolicyType(updatedPolicyType, currPolicyType.left().value()); + + Either<PolicyTypeDefinition, StorageOperationStatus> latestPolicyType = policyTypeOperation.getLatestPolicyTypeByType(policyType1.getType()); + assertThat(latestPolicyType.left().value().getDerivedFrom()).isEqualTo(rootPolicyType.getType()); + verifyDerivedFromNodeEqualsToRootPolicyType(rootPolicyType, latestPolicyType.left().value().getUniqueId()); + } + + @Test + public void updatePolicyType_derivedFrom_updateToNullDerivedFrom_derivedFromDeleted() { + PolicyTypeDefinition rootPolicyType = createPolicyTypeDef(); + PolicyTypeDefinition policyType1 = createPolicyTypeDef("type1", "descr", rootPolicyType.getType()); + PolicyTypeDefinition updatedPolicyType = createPolicyTypeDef("type1", "descr", null, new PropertyDefinition[]{}); + policyTypeOperation.addPolicyType(rootPolicyType); + Either<PolicyTypeDefinition, StorageOperationStatus> currPolicyType = policyTypeOperation.addPolicyType(policyType1); + + policyTypeOperation.updatePolicyType(updatedPolicyType, currPolicyType.left().value()); + + Either<PolicyTypeDefinition, StorageOperationStatus> latestPolicyType = policyTypeOperation.getLatestPolicyTypeByType(policyType1.getType()); + assertThat(latestPolicyType.left().value().getDerivedFrom()).isNull(); + verifyDerivedFromRelationDoesntExist(latestPolicyType.left().value().getUniqueId()); + } + + @Test + public void updatePolicyType_updateDerivedFrom() { + PolicyTypeDefinition rootPolicyType = createPolicyTypeDef(); + PolicyTypeDefinition derivedType1 = createPolicyTypeDef("derivedType1", "descr", NULL_STRING); + PolicyTypeDefinition policyType1 = createPolicyTypeDef("type1", "descr", derivedType1.getType()); + PolicyTypeDefinition updatedPolicyType = createPolicyTypeDef("type1", "descr", rootPolicyType.getType()); + + policyTypeOperation.addPolicyType(rootPolicyType); + policyTypeOperation.addPolicyType(derivedType1); + Either<PolicyTypeDefinition, StorageOperationStatus> currPolicyType = policyTypeOperation.addPolicyType(policyType1); + + policyTypeOperation.updatePolicyType(updatedPolicyType, currPolicyType.left().value()); + + Either<PolicyTypeDefinition, StorageOperationStatus> latestPolicyType = policyTypeOperation.getLatestPolicyTypeByType(policyType1.getType()); + assertThat(latestPolicyType.left().value().getDerivedFrom()).isEqualTo(rootPolicyType.getType()); + verifyDerivedFromNodeEqualsToRootPolicyType(rootPolicyType, latestPolicyType.left().value().getUniqueId()); + } + + private PropertyDefinition duplicateProperty(PropertyDefinition prop1, String updatedValue, String updatedType) { + PropertyDefinition updatedProp1 = new PropertyDefinition(prop1); + updatedProp1.setUniqueId(null); + updatedProp1.setDefaultValue(updatedValue); + updatedProp1.setType(updatedType); + return updatedProp1; + } + + private PropertyDefinition createSimpleProperty(String defaultValue, String name, String type) { + PropertyDefinition prop1 = new PropertyDefinition(); + prop1.setDefaultValue(defaultValue); + prop1.setName(name); + prop1.setType(type); + return prop1; } + private void verifyDerivedFromNodeEqualsToRootPolicyType(PolicyTypeDefinition rootPolicyType, String parentPolicyId) { + Either<ImmutablePair<PolicyTypeData, GraphEdge>, TitanOperationStatus> derivedFromRelation = titanGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.PolicyType), parentPolicyId, GraphEdgeLabels.DERIVED_FROM, + NodeTypeEnum.PolicyType, PolicyTypeData.class); + assertThat(derivedFromRelation.left().value().getLeft().getPolicyTypeDataDefinition()) + .isEqualToComparingFieldByField(rootPolicyType); + } + + private void verifyDerivedFromRelationDoesntExist(String parentPolicyId) { + Either<ImmutablePair<PolicyTypeData, GraphEdge>, TitanOperationStatus> derivedFromRelation = titanGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.PolicyType), parentPolicyId, GraphEdgeLabels.DERIVED_FROM, + NodeTypeEnum.PolicyType, PolicyTypeData.class); + assertThat(derivedFromRelation.right().value()) + .isEqualTo(TitanOperationStatus.NOT_FOUND); + } + + private PolicyTypeDefinition createRootPolicyTypeOnGraph() { + PolicyTypeDefinition rootPolicyType = createPolicyTypeDef(); + policyTypeOperation.addPolicyType(rootPolicyType); + return rootPolicyType; + + } + private PolicyTypeDefinition createPolicyTypeDef() { + return createPolicyTypeDef("tosca.policies.Root", "description: The TOSCA Policy Type all other TOSCA Policy Types derive from", null, new PropertyDefinition[]{}); + } + + private PolicyTypeDefinition createPolicyTypeDef(PropertyDefinition ... props) { + return createPolicyTypeDef("tosca.policies.Root", null, props); + } + + private PolicyTypeDefinition createPolicyTypeDef(String type, String derivedFrom, PropertyDefinition ... props) { + PolicyTypeDefinition policyType = createPolicyTypeDef(type, "description: The TOSCA Policy Type all other TOSCA Policy Types derive from", derivedFrom); + policyType.setProperties(asList(props)); + return policyType; + } + + private PolicyTypeDefinition createPolicyTypeDef(String type, String description, String derivedFrom) { + return createPolicyTypeDef(type, description, derivedFrom, null); + } + + private PolicyTypeDefinition createPolicyTypeDef(String type, String description, String derivedFrom, PropertyDefinition ... props) { PolicyTypeDataDefinition policyTypeDataDefinition = new PolicyTypeDataDefinition(); - policyTypeDataDefinition.setDescription("description: The TOSCA Policy Type all other TOSCA Policy Types derive from"); - policyTypeDataDefinition.setType("tosca.policies.Root"); + policyTypeDataDefinition.setDescription(description); + policyTypeDataDefinition.setType(type); + policyTypeDataDefinition.setDerivedFrom(derivedFrom); PolicyTypeDefinition policyTypeDefinition = new PolicyTypeDefinition(policyTypeDataDefinition); policyTypeDefinition.setHighestVersion(true); policyTypeDefinition.setVersion("1.0"); + if (props != null) { + policyTypeDefinition.setProperties(asList(props)); + } return policyTypeDefinition; } + private void addPolicyTypesToDB(PolicyTypeDefinition ... policyTypeDefinitions) { + Stream.of(policyTypeDefinitions).forEach(policyTypeOperation::addPolicyType); + } + + } diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/PropertyOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/PropertyOperationTest.java index d862c56790..88f3a24b5d 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/PropertyOperationTest.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/PropertyOperationTest.java @@ -20,19 +20,6 @@ package org.openecomp.sdc.be.model.operations.impl; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.HashMap; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Set; - import org.junit.Before; import org.junit.Test; import org.mockito.Mockito; @@ -48,11 +35,21 @@ import org.openecomp.sdc.be.model.tosca.constraints.GreaterThanConstraint; import org.openecomp.sdc.be.model.tosca.constraints.InRangeConstraint; import org.openecomp.sdc.be.model.tosca.constraints.LessOrEqualConstraint; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import static org.junit.Assert.*; + public class PropertyOperationTest extends ModelTestBase { TitanGenericDao titanGenericDao = Mockito.mock(TitanGenericDao.class); - PropertyOperation propertyOperation = new PropertyOperation(titanGenericDao); + PropertyOperation propertyOperation = new PropertyOperation(titanGenericDao, null); @Before public void setup() { diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ToscaElementLifecycleOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ToscaElementLifecycleOperationTest.java index 53bd753fa3..6e9fdc2928 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ToscaElementLifecycleOperationTest.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ToscaElementLifecycleOperationTest.java @@ -45,6 +45,7 @@ import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; import org.openecomp.sdc.be.dao.jsongraph.TitanDao; import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; +import org.openecomp.sdc.be.dao.jsongraph.utils.IdBuilderUtils; import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition; import org.openecomp.sdc.be.datatypes.elements.MapDataDefinition; @@ -57,6 +58,7 @@ import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition; import org.openecomp.sdc.be.model.LifecycleStateEnum; import org.openecomp.sdc.be.model.ModelTestBase; +import org.openecomp.sdc.be.model.catalog.CatalogComponent; import org.openecomp.sdc.be.model.category.CategoryDefinition; import org.openecomp.sdc.be.model.category.SubCategoryDefinition; import org.openecomp.sdc.be.model.jsontitan.datamodel.NodeType; @@ -65,6 +67,7 @@ import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElement; import org.openecomp.sdc.be.model.jsontitan.operations.NodeTypeOperation; import org.openecomp.sdc.be.model.jsontitan.operations.TopologyTemplateOperation; import org.openecomp.sdc.be.model.jsontitan.operations.ToscaElementLifecycleOperation; +import org.openecomp.sdc.be.model.jsontitan.utils.GraphTestUtils; import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; import org.openecomp.sdc.common.util.ValidationUtils; import org.springframework.test.context.ContextConfiguration; @@ -78,23 +81,23 @@ import fj.data.Either; @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("classpath:application-context-test.xml") public class ToscaElementLifecycleOperationTest extends ModelTestBase { - + @javax.annotation.Resource protected TitanDao titanDao; @javax.annotation.Resource private NodeTypeOperation nodeTypeOperation; - + @javax.annotation.Resource private TopologyTemplateOperation topologyTemplateOperation; - + @javax.annotation.Resource private ToscaElementLifecycleOperation lifecycleOperation; - + String categoryName = "category"; String subcategory = "mycategory"; String outputDirectory = "C:\\Output"; - + @Rule public TestName name = new TestName(); @@ -102,11 +105,12 @@ public class ToscaElementLifecycleOperationTest extends ModelTestBase { public static void initLifecycleOperation() { ModelTestBase.init(); } - + private GraphVertex ownerVertex; private GraphVertex modifierVertex; private GraphVertex vfVertex; private GraphVertex serviceVertex; + private GraphVertex rootVertex; @Before public void setupBefore() { @@ -114,222 +118,271 @@ public class ToscaElementLifecycleOperationTest extends ModelTestBase { createUsers(); createResourceCategory(); createServiceCategory(); - createRootNodeType(); + GraphTestUtils.createRootCatalogVertex(titanDao); + rootVertex = createRootNodeType(); createNodeType("firstVf"); - createTopologyTemplate("firstService"); + serviceVertex = createTopologyTemplate("firstService"); } - @Test public void lifecycleTest() { - Either<ToscaElement, StorageOperationStatus> res = lifecycleOperation - .checkinToscaELement(LifecycleStateEnum.findState((String) vfVertex.getMetadataProperty(GraphPropertyEnum.STATE)), - vfVertex.getUniqueId(), modifierVertex.getUniqueId(), ownerVertex.getUniqueId()); + Either<ToscaElement, StorageOperationStatus> res = lifecycleOperation.checkinToscaELement(LifecycleStateEnum.findState((String) vfVertex.getMetadataProperty(GraphPropertyEnum.STATE)), vfVertex.getUniqueId(), modifierVertex.getUniqueId(), + ownerVertex.getUniqueId()); StorageOperationStatus status; - + assertTrue(res.isLeft()); + // 1-node type + // 2-vf + // 3- service + verifyInCatalogData(3, null); + String id = res.left().value().getUniqueId(); - + res = lifecycleOperation.checkoutToscaElement(id, ownerVertex.getUniqueId(), modifierVertex.getUniqueId()); assertTrue(res.isLeft()); id = res.left().value().getUniqueId(); - + + verifyInCatalogData(3, null); + PropertyDataDefinition prop55 = new PropertyDataDefinition(); prop55.setName("prop55"); prop55.setDefaultValue("def55"); - + status = nodeTypeOperation.addToscaDataToToscaElement(id, EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, prop55, JsonPresentationFields.NAME); assertTrue(status == StorageOperationStatus.OK); - + CapabilityDataDefinition cap1 = new CapabilityDataDefinition(); cap1.setName("cap1"); cap1.setDescription("create"); cap1.setUniqueId(UniqueIdBuilder.buildCapabilityUid(id, "cap1")); - + status = nodeTypeOperation.addToscaDataToToscaElement(id, EdgeLabelEnum.CAPABILITIES, VertexTypeEnum.CAPABILTIES, cap1, JsonPresentationFields.NAME); assertTrue(status == StorageOperationStatus.OK); - + res = lifecycleOperation.checkinToscaELement(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, id, ownerVertex.getUniqueId(), ownerVertex.getUniqueId()); assertTrue(res.isLeft()); id = res.left().value().getUniqueId(); - + res = lifecycleOperation.checkoutToscaElement(id, ownerVertex.getUniqueId(), ownerVertex.getUniqueId()); assertTrue(res.isLeft()); id = res.left().value().getUniqueId(); - + prop55.setDefaultValue("AAAAAAAA"); status = nodeTypeOperation.updateToscaDataOfToscaElement(id, EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, prop55, JsonPresentationFields.NAME); assertTrue(status == StorageOperationStatus.OK); - + cap1.setDescription("update"); - + status = nodeTypeOperation.updateToscaDataOfToscaElement(id, EdgeLabelEnum.CAPABILITIES, VertexTypeEnum.CAPABILTIES, cap1, JsonPresentationFields.NAME); assertTrue(status == StorageOperationStatus.OK); - + PropertyDataDefinition prop66 = new PropertyDataDefinition(); prop66.setName("prop66"); prop66.setDefaultValue("def66"); - + status = nodeTypeOperation.addToscaDataToToscaElement(id, EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, prop66, JsonPresentationFields.NAME); assertTrue(status == StorageOperationStatus.OK); - + res = lifecycleOperation.requestCertificationToscaElement(id, modifierVertex.getUniqueId(), ownerVertex.getUniqueId()); assertTrue(res.isLeft()); id = res.left().value().getUniqueId(); - + res = lifecycleOperation.startCertificationToscaElement(id, modifierVertex.getUniqueId(), ownerVertex.getUniqueId()); assertTrue(res.isLeft()); id = res.left().value().getUniqueId(); - + res = lifecycleOperation.certifyToscaElement(id, modifierVertex.getUniqueId(), ownerVertex.getUniqueId()); assertTrue(res.isLeft()); id = res.left().value().getUniqueId(); + + verifyInCatalogData(3, null); res = lifecycleOperation.checkoutToscaElement(id, ownerVertex.getUniqueId(), modifierVertex.getUniqueId()); assertTrue(res.isLeft()); id = res.left().value().getUniqueId(); + + verifyInCatalogData(4, null); PropertyDataDefinition prop77 = new PropertyDataDefinition(); prop77.setName("prop77"); prop77.setDefaultValue("def77"); - + status = nodeTypeOperation.addToscaDataToToscaElement(id, EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, prop77, JsonPresentationFields.NAME); assertTrue(status == StorageOperationStatus.OK); - + res = lifecycleOperation.checkinToscaELement(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, id, ownerVertex.getUniqueId(), ownerVertex.getUniqueId()); assertTrue(res.isLeft()); id = res.left().value().getUniqueId(); - + res = lifecycleOperation.checkoutToscaElement(id, ownerVertex.getUniqueId(), ownerVertex.getUniqueId()); assertTrue(res.isLeft()); id = res.left().value().getUniqueId(); - + PropertyDataDefinition prop88 = new PropertyDataDefinition(); prop88.setName("prop88"); prop88.setDefaultValue("def88"); - + status = nodeTypeOperation.addToscaDataToToscaElement(id, EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, prop88, JsonPresentationFields.NAME); assertTrue(status == StorageOperationStatus.OK); - + res = lifecycleOperation.requestCertificationToscaElement(id, modifierVertex.getUniqueId(), ownerVertex.getUniqueId()); assertTrue(res.isLeft()); id = res.left().value().getUniqueId(); - + res = lifecycleOperation.startCertificationToscaElement(id, modifierVertex.getUniqueId(), ownerVertex.getUniqueId()); assertTrue(res.isLeft()); id = res.left().value().getUniqueId(); - + res = lifecycleOperation.certifyToscaElement(id, modifierVertex.getUniqueId(), ownerVertex.getUniqueId()); assertTrue(res.isLeft()); id = res.left().value().getUniqueId(); + verifyInCatalogData(3, null); res = lifecycleOperation.checkoutToscaElement(id, ownerVertex.getUniqueId(), ownerVertex.getUniqueId()); assertTrue(res.isLeft()); id = res.left().value().getUniqueId(); + + verifyInCatalogData(4, null); PropertyDataDefinition prop99 = new PropertyDataDefinition(); prop99.setName("prop99"); prop99.setDefaultValue("def99"); - + status = nodeTypeOperation.addToscaDataToToscaElement(id, EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, prop99, JsonPresentationFields.NAME); assertTrue(status == StorageOperationStatus.OK); - + res = lifecycleOperation.requestCertificationToscaElement(id, modifierVertex.getUniqueId(), ownerVertex.getUniqueId()); assertTrue(res.isLeft()); id = res.left().value().getUniqueId(); - + res = lifecycleOperation.startCertificationToscaElement(id, modifierVertex.getUniqueId(), ownerVertex.getUniqueId()); assertTrue(res.isLeft()); id = res.left().value().getUniqueId(); - + status = nodeTypeOperation.deleteToscaDataElement(id, EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, "prop99", JsonPresentationFields.NAME); assertTrue(status == StorageOperationStatus.OK); - - //cancel certification + + // cancel certification res = lifecycleOperation.cancelOrFailCertification(id, modifierVertex.getUniqueId(), ownerVertex.getUniqueId(), LifecycleStateEnum.READY_FOR_CERTIFICATION); assertTrue(res.isLeft()); id = res.left().value().getUniqueId(); - + res = lifecycleOperation.startCertificationToscaElement(id, modifierVertex.getUniqueId(), ownerVertex.getUniqueId()); assertTrue(res.isLeft()); id = res.left().value().getUniqueId(); - - //fail certification + + // fail certification res = lifecycleOperation.cancelOrFailCertification(id, modifierVertex.getUniqueId(), ownerVertex.getUniqueId(), LifecycleStateEnum.NOT_CERTIFIED_CHECKIN); assertTrue(res.isLeft()); id = res.left().value().getUniqueId(); - - //exportGraphMl(titanDao.getGraph().left().value()); - + verifyInCatalogData(4, null); + // exportGraphMl(titanDao.getGraph().left().value()); + } @Test public void serviceConformanceLevelTest() { - Either<ToscaElement, StorageOperationStatus> res = lifecycleOperation - .checkinToscaELement(LifecycleStateEnum.findState((String) serviceVertex.getMetadataProperty(GraphPropertyEnum.STATE)), - serviceVertex.getUniqueId(), modifierVertex.getUniqueId(), ownerVertex.getUniqueId()); - + Either<ToscaElement, StorageOperationStatus> res = lifecycleOperation.checkinToscaELement(LifecycleStateEnum.findState((String) serviceVertex.getMetadataProperty(GraphPropertyEnum.STATE)), serviceVertex.getUniqueId(), + modifierVertex.getUniqueId(), ownerVertex.getUniqueId()); + assertTrue(res.isLeft()); String id = res.left().value().getUniqueId(); - + res = lifecycleOperation.checkoutToscaElement(id, ownerVertex.getUniqueId(), modifierVertex.getUniqueId()); assertTrue(res.isLeft()); - + String conformanceLevel = res.left().value().getMetadataValue(JsonPresentationFields.CONFORMANCE_LEVEL).toString(); assertEquals(conformanceLevel, ModelTestBase.configurationManager.getConfiguration().getToscaConformanceLevel()); } - - private void createResourceCategory() { + + @Test + public void catalogTest() { + // start position - 3 in catalog + List<String> expectedIds = new ArrayList<String>(); + expectedIds.add(rootVertex.getUniqueId()); + expectedIds.add(vfVertex.getUniqueId()); + expectedIds.add(serviceVertex.getUniqueId()); + + verifyInCatalogData(3, expectedIds); + GraphVertex vertex4 = createTopologyTemplate("topTemp4"); + expectedIds.add(vertex4.getUniqueId()); + verifyInCatalogData(4, expectedIds); + + Either<ToscaElement, StorageOperationStatus> res = lifecycleOperation.undoCheckout(vertex4.getUniqueId()); + expectedIds.remove(vertex4.getUniqueId()); + verifyInCatalogData(3, expectedIds); + + vertex4 = createTopologyTemplate("topTemp4"); + expectedIds.add(vertex4.getUniqueId()); + verifyInCatalogData(4, expectedIds); + + res = lifecycleOperation.checkinToscaELement(LifecycleStateEnum.findState((String) vertex4.getMetadataProperty(GraphPropertyEnum.STATE)), vertex4.getUniqueId(), modifierVertex.getUniqueId(), ownerVertex.getUniqueId()); + Either<ToscaElement, StorageOperationStatus> certifyToscaElement = lifecycleOperation.certifyToscaElement(vertex4.getUniqueId(), modifierVertex.getUniqueId(), ownerVertex.getUniqueId()); + assertTrue(certifyToscaElement.isLeft()); + expectedIds.remove(vertex4.getUniqueId()); + String certifiedId = certifyToscaElement.left().value().getUniqueId(); + expectedIds.add(certifiedId); + verifyInCatalogData(4, expectedIds); + + res = lifecycleOperation.checkoutToscaElement(certifiedId, modifierVertex.getUniqueId(), ownerVertex.getUniqueId()); + assertTrue(certifyToscaElement.isLeft()); + expectedIds.add(res.left().value().getUniqueId()); + verifyInCatalogData(5, expectedIds); + } + + private void createResourceCategory() { + GraphVertex cat = new GraphVertex(VertexTypeEnum.RESOURCE_CATEGORY); Map<GraphPropertyEnum, Object> metadataProperties = new HashMap<>(); String catId = UniqueIdBuilder.buildComponentCategoryUid(categoryName, VertexTypeEnum.RESOURCE_CATEGORY); cat.setUniqueId(catId); - metadataProperties.put(GraphPropertyEnum.UNIQUE_ID,catId); + metadataProperties.put(GraphPropertyEnum.UNIQUE_ID, catId); metadataProperties.put(GraphPropertyEnum.LABEL, VertexTypeEnum.RESOURCE_CATEGORY.getName()); - metadataProperties.put(GraphPropertyEnum.NAME,categoryName); + metadataProperties.put(GraphPropertyEnum.NAME, categoryName); metadataProperties.put(GraphPropertyEnum.NORMALIZED_NAME, ValidationUtils.normalizeCategoryName4Uniqueness(categoryName)); cat.setMetadataProperties(metadataProperties); cat.updateMetadataJsonWithCurrentMetadataProperties(); - + GraphVertex subCat = new GraphVertex(VertexTypeEnum.RESOURCE_SUBCATEGORY); metadataProperties = new HashMap<>(); String subCatId = UniqueIdBuilder.buildSubCategoryUid(cat.getUniqueId(), subcategory); subCat.setUniqueId(subCatId); - metadataProperties.put(GraphPropertyEnum.UNIQUE_ID,subCatId); + metadataProperties.put(GraphPropertyEnum.UNIQUE_ID, subCatId); metadataProperties.put(GraphPropertyEnum.LABEL, VertexTypeEnum.RESOURCE_SUBCATEGORY.getName()); - metadataProperties.put(GraphPropertyEnum.NAME,subcategory); + metadataProperties.put(GraphPropertyEnum.NAME, subcategory); + metadataProperties.put(GraphPropertyEnum.NORMALIZED_NAME, ValidationUtils.normalizeCategoryName4Uniqueness(subcategory)); subCat.setMetadataProperties(metadataProperties); subCat.updateMetadataJsonWithCurrentMetadataProperties(); - + Either<GraphVertex, TitanOperationStatus> catRes = titanDao.createVertex(cat); - + Either<GraphVertex, TitanOperationStatus> subCatRes = titanDao.createVertex(subCat); - + TitanOperationStatus status = titanDao.createEdge(catRes.left().value().getVertex(), subCatRes.left().value().getVertex(), EdgeLabelEnum.SUB_CATEGORY, new HashMap<>()); assertEquals(TitanOperationStatus.OK, status); } - + private void createServiceCategory() { - + GraphVertex cat = new GraphVertex(VertexTypeEnum.SERVICE_CATEGORY); Map<GraphPropertyEnum, Object> metadataProperties = new HashMap<>(); String catId = UniqueIdBuilder.buildComponentCategoryUid(categoryName, VertexTypeEnum.SERVICE_CATEGORY); cat.setUniqueId(catId); - metadataProperties.put(GraphPropertyEnum.UNIQUE_ID,catId); + metadataProperties.put(GraphPropertyEnum.UNIQUE_ID, catId); metadataProperties.put(GraphPropertyEnum.LABEL, VertexTypeEnum.SERVICE_CATEGORY.getName()); - metadataProperties.put(GraphPropertyEnum.NAME,categoryName); + metadataProperties.put(GraphPropertyEnum.NAME, categoryName); metadataProperties.put(GraphPropertyEnum.NORMALIZED_NAME, ValidationUtils.normalizeCategoryName4Uniqueness(categoryName)); cat.setMetadataProperties(metadataProperties); cat.updateMetadataJsonWithCurrentMetadataProperties(); - + Either<GraphVertex, TitanOperationStatus> catRes = titanDao.createVertex(cat); - + assertTrue(catRes.isLeft()); } - - private TopologyTemplate createTopologyTemplate(String name) { - + + private GraphVertex createTopologyTemplate(String name) { + TopologyTemplate service = new TopologyTemplate(); String uniqueId = UniqueIdBuilder.buildResourceUniqueId(); service.setUniqueId(uniqueId); @@ -337,28 +390,28 @@ public class ToscaElementLifecycleOperationTest extends ModelTestBase { service.getMetadata().put(JsonPresentationFields.NAME.getPresentation(), name); service.getMetadata().put(JsonPresentationFields.UNIQUE_ID.getPresentation(), uniqueId); service.getMetadata().put(JsonPresentationFields.VERSION.getPresentation(), "0.1"); - service.getMetadata().put(JsonPresentationFields.TYPE.getPresentation(),ResourceTypeEnum.VF.name()); - service.getMetadata().put(JsonPresentationFields.COMPONENT_TYPE.getPresentation(),ComponentTypeEnum.RESOURCE); + service.getMetadata().put(JsonPresentationFields.TYPE.getPresentation(), ResourceTypeEnum.VF.name()); + service.getMetadata().put(JsonPresentationFields.COMPONENT_TYPE.getPresentation(), ComponentTypeEnum.RESOURCE); List<CategoryDefinition> categories = new ArrayList<>(); CategoryDefinition cat = new CategoryDefinition(); categories.add(cat); cat.setName(categoryName); service.setCategories(categories); - + service.setComponentType(ComponentTypeEnum.SERVICE); Either<TopologyTemplate, StorageOperationStatus> createRes = topologyTemplateOperation.createTopologyTemplate(service); assertTrue(createRes.isLeft()); - - Either<GraphVertex, TitanOperationStatus> getNodeTyeRes= titanDao.getVertexById(createRes.left().value().getUniqueId()); + + Either<GraphVertex, TitanOperationStatus> getNodeTyeRes = titanDao.getVertexById(createRes.left().value().getUniqueId()); assertTrue(getNodeTyeRes.isLeft()); - - serviceVertex = getNodeTyeRes.left().value(); - - return service; + + // serviceVertex = getNodeTyeRes.left().value(); + + return getNodeTyeRes.left().value(); } - + private <T extends ToscaDataDefinition> NodeType createNodeType(String nodeTypeName) { - + NodeType vf = new NodeType(); String uniqueId = UniqueIdBuilder.buildResourceUniqueId(); vf.setUniqueId(uniqueId); @@ -366,8 +419,8 @@ public class ToscaElementLifecycleOperationTest extends ModelTestBase { vf.getMetadata().put(JsonPresentationFields.NAME.getPresentation(), nodeTypeName); vf.getMetadata().put(JsonPresentationFields.UNIQUE_ID.getPresentation(), uniqueId); vf.getMetadata().put(JsonPresentationFields.VERSION.getPresentation(), "0.1"); - vf.getMetadata().put(JsonPresentationFields.TYPE.getPresentation(),ResourceTypeEnum.VF.name()); - vf.getMetadata().put(JsonPresentationFields.COMPONENT_TYPE.getPresentation(),ComponentTypeEnum.RESOURCE); + vf.getMetadata().put(JsonPresentationFields.TYPE.getPresentation(), ResourceTypeEnum.VF.name()); + vf.getMetadata().put(JsonPresentationFields.COMPONENT_TYPE.getPresentation(), ComponentTypeEnum.RESOURCE); List<CategoryDefinition> categories = new ArrayList<>(); CategoryDefinition cat = new CategoryDefinition(); categories.add(cat); @@ -378,95 +431,90 @@ public class ToscaElementLifecycleOperationTest extends ModelTestBase { subCategories.add(subCat); cat.setSubcategories(subCategories); vf.setCategories(categories); - - + List<String> derivedFrom = new ArrayList<>(); derivedFrom.add("root"); vf.setDerivedFrom(derivedFrom); - -// Map<String, PropertyDataDefinition> properties = new HashMap<>(); -// PropertyDataDefinition prop1 = new PropertyDataDefinition(); -// prop1.setName("prop1"); -// prop1.setDefaultValue("def1"); -// -// properties.put("prop1", prop1); -// -// PropertyDataDefinition prop2 = new PropertyDataDefinition(); -// prop2.setName("prop2"); -// prop2.setDefaultValue("def2"); -// properties.put("prop2", prop2); -// -// PropertyDataDefinition prop3 = new PropertyDataDefinition(); -// prop3.setName("prop3"); -// prop3.setDefaultValue("def3"); -// properties.put("prop3", prop3); -// -// vf.setProperties(properties); - vf.setComponentType(ComponentTypeEnum.RESOURCE); + + // Map<String, PropertyDataDefinition> properties = new HashMap<>(); + // PropertyDataDefinition prop1 = new PropertyDataDefinition(); + // prop1.setName("prop1"); + // prop1.setDefaultValue("def1"); + // + // properties.put("prop1", prop1); + // + // PropertyDataDefinition prop2 = new PropertyDataDefinition(); + // prop2.setName("prop2"); + // prop2.setDefaultValue("def2"); + // properties.put("prop2", prop2); + // + // PropertyDataDefinition prop3 = new PropertyDataDefinition(); + // prop3.setName("prop3"); + // prop3.setDefaultValue("def3"); + // properties.put("prop3", prop3); + // + // vf.setProperties(properties); + vf.setComponentType(ComponentTypeEnum.RESOURCE); Either<NodeType, StorageOperationStatus> createVFRes = nodeTypeOperation.createNodeType(vf); assertTrue(createVFRes.isLeft()); - - Either<GraphVertex, TitanOperationStatus> getNodeTyeRes= titanDao.getVertexById(createVFRes.left().value().getUniqueId()); + + Either<GraphVertex, TitanOperationStatus> getNodeTyeRes = titanDao.getVertexById(createVFRes.left().value().getUniqueId()); assertTrue(getNodeTyeRes.isLeft()); - + vfVertex = getNodeTyeRes.left().value(); - - - - List<PropertyDataDefinition> addProperties = new ArrayList<>(); - PropertyDataDefinition prop11 = new PropertyDataDefinition(); - prop11.setName("prop11"); - prop11.setDefaultValue("def11"); - - addProperties.add(prop11); - - PropertyDataDefinition prop22 = new PropertyDataDefinition(); - prop22.setName("prop22"); - prop22.setDefaultValue("def22"); - addProperties.add(prop22); - - StorageOperationStatus status = nodeTypeOperation.addToscaDataToToscaElement(vfVertex, EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, addProperties, JsonPresentationFields.NAME); - assertTrue(status == StorageOperationStatus.OK); - - PropertyDataDefinition prop33 = new PropertyDataDefinition(); - prop33.setName("prop33"); - prop33.setDefaultValue("def33"); - - status = nodeTypeOperation.addToscaDataToToscaElement(vfVertex, EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, prop33, JsonPresentationFields.NAME); - assertTrue(status == StorageOperationStatus.OK); - - PropertyDataDefinition prop44 = new PropertyDataDefinition(); - prop44.setName("prop44"); - prop44.setDefaultValue("def44"); - - status = nodeTypeOperation.addToscaDataToToscaElement(vfVertex.getUniqueId(), EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, prop44, JsonPresentationFields.NAME); - assertTrue(status == StorageOperationStatus.OK); - - - PropertyDataDefinition capProp = new PropertyDataDefinition(); - capProp.setName( "capProp"); - capProp.setDefaultValue( "capPropDef"); - - MapDataDefinition dataToCreate = new MapPropertiesDataDefinition(); - dataToCreate.put("capProp", capProp); - - Map<String, MapDataDefinition> capProps = new HashMap(); - capProps.put("capName", dataToCreate); - - Either<GraphVertex, StorageOperationStatus> res = nodeTypeOperation.assosiateElementToData(vfVertex, VertexTypeEnum.CAPABILITIES_PROPERTIES, EdgeLabelEnum.CAPABILITIES_PROPERTIES, capProps); - + + List<PropertyDataDefinition> addProperties = new ArrayList<>(); + PropertyDataDefinition prop11 = new PropertyDataDefinition(); + prop11.setName("prop11"); + prop11.setDefaultValue("def11"); + + addProperties.add(prop11); + + PropertyDataDefinition prop22 = new PropertyDataDefinition(); + prop22.setName("prop22"); + prop22.setDefaultValue("def22"); + addProperties.add(prop22); + + StorageOperationStatus status = nodeTypeOperation.addToscaDataToToscaElement(vfVertex, EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, addProperties, JsonPresentationFields.NAME); + assertTrue(status == StorageOperationStatus.OK); + + PropertyDataDefinition prop33 = new PropertyDataDefinition(); + prop33.setName("prop33"); + prop33.setDefaultValue("def33"); + + status = nodeTypeOperation.addToscaDataToToscaElement(vfVertex, EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, prop33, JsonPresentationFields.NAME); + assertTrue(status == StorageOperationStatus.OK); + + PropertyDataDefinition prop44 = new PropertyDataDefinition(); + prop44.setName("prop44"); + prop44.setDefaultValue("def44"); + + status = nodeTypeOperation.addToscaDataToToscaElement(vfVertex.getUniqueId(), EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, prop44, JsonPresentationFields.NAME); + assertTrue(status == StorageOperationStatus.OK); + + PropertyDataDefinition capProp = new PropertyDataDefinition(); + capProp.setName("capProp"); + capProp.setDefaultValue("capPropDef"); + + MapDataDefinition dataToCreate = new MapPropertiesDataDefinition(); + dataToCreate.put("capProp", capProp); + + Map<String, MapDataDefinition> capProps = new HashMap(); + capProps.put("capName", dataToCreate); + + Either<GraphVertex, StorageOperationStatus> res = nodeTypeOperation.assosiateElementToData(vfVertex, VertexTypeEnum.CAPABILITIES_PROPERTIES, EdgeLabelEnum.CAPABILITIES_PROPERTIES, capProps); + // exportGraphMl(titanDao.getGraph().left().value()); - - List<String> pathKeys = new ArrayList<>(); - pathKeys.add("capName"); - capProp.setDefaultValue( "BBBB"); - status = nodeTypeOperation.updateToscaDataDeepElementOfToscaElement(vfVertex, EdgeLabelEnum.CAPABILITIES_PROPERTIES, VertexTypeEnum.CAPABILITIES_PROPERTIES, - capProp, pathKeys, JsonPresentationFields.NAME); + + List<String> pathKeys = new ArrayList<>(); + pathKeys.add("capName"); + capProp.setDefaultValue("BBBB"); + status = nodeTypeOperation.updateToscaDataDeepElementOfToscaElement(vfVertex, EdgeLabelEnum.CAPABILITIES_PROPERTIES, VertexTypeEnum.CAPABILITIES_PROPERTIES, capProp, pathKeys, JsonPresentationFields.NAME); return vf; } - - private void createRootNodeType() { - + + private GraphVertex createRootNodeType() { + NodeType vf = new NodeType(); String uniqueId = UniqueIdBuilder.buildResourceUniqueId(); vf.setUniqueId(uniqueId); @@ -475,11 +523,11 @@ public class ToscaElementLifecycleOperationTest extends ModelTestBase { vf.getMetadata().put(JsonPresentationFields.NAME.getPresentation(), "root"); vf.getMetadata().put(JsonPresentationFields.UNIQUE_ID.getPresentation(), uniqueId); vf.getMetadata().put(JsonPresentationFields.VERSION.getPresentation(), "1.0"); - vf.getMetadata().put(JsonPresentationFields.TYPE.getPresentation(),ResourceTypeEnum.VFC.name()); + vf.getMetadata().put(JsonPresentationFields.TYPE.getPresentation(), ResourceTypeEnum.VFC.name()); vf.getMetadata().put(JsonPresentationFields.LIFECYCLE_STATE.getPresentation(), LifecycleStateEnum.CERTIFIED.name()); vf.getMetadata().put(JsonPresentationFields.TOSCA_RESOURCE_NAME.getPresentation(), "root"); vf.getMetadata().put(JsonPresentationFields.HIGHEST_VERSION.getPresentation(), true); - + List<CategoryDefinition> categories = new ArrayList<>(); CategoryDefinition cat = new CategoryDefinition(); categories.add(cat); @@ -490,42 +538,42 @@ public class ToscaElementLifecycleOperationTest extends ModelTestBase { subCategories.add(subCat); cat.setSubcategories(subCategories); vf.setCategories(categories); - - + List<String> derivedFrom = new ArrayList<>(); vf.setDerivedFrom(derivedFrom); - - Map<String, PropertyDataDefinition> properties = new HashMap<>(); - PropertyDataDefinition prop1 = new PropertyDataDefinition(); - prop1.setName("derived1"); - prop1.setDefaultValue("deriveddef1"); - - properties.put("derived1", prop1); - - PropertyDataDefinition prop2 = new PropertyDataDefinition(); - prop2.setUniqueId("derived2"); - prop2.setName("deriveddef2"); - properties.put("derived2", prop2); - - PropertyDataDefinition prop3 = new PropertyDataDefinition(); - prop3.setName("derived3"); - prop3.setDefaultValue("deriveddef3"); - properties.put("derived3", prop3); - - vf.setProperties(properties); - vf.setComponentType(ComponentTypeEnum.RESOURCE); + + Map<String, PropertyDataDefinition> properties = new HashMap<>(); + PropertyDataDefinition prop1 = new PropertyDataDefinition(); + prop1.setName("derived1"); + prop1.setDefaultValue("deriveddef1"); + + properties.put("derived1", prop1); + + PropertyDataDefinition prop2 = new PropertyDataDefinition(); + prop2.setUniqueId("derived2"); + prop2.setName("deriveddef2"); + properties.put("derived2", prop2); + + PropertyDataDefinition prop3 = new PropertyDataDefinition(); + prop3.setName("derived3"); + prop3.setDefaultValue("deriveddef3"); + properties.put("derived3", prop3); + + vf.setProperties(properties); + vf.setComponentType(ComponentTypeEnum.RESOURCE); Either<NodeType, StorageOperationStatus> createVFRes = nodeTypeOperation.createNodeType(vf); assertTrue(createVFRes.isLeft()); - - Either<GraphVertex, TitanOperationStatus> getNodeTyeRes= titanDao.getVertexById(createVFRes.left().value().getUniqueId()); + + Either<GraphVertex, TitanOperationStatus> getNodeTyeRes = titanDao.getVertexById(createVFRes.left().value().getUniqueId()); assertTrue(getNodeTyeRes.isLeft()); + return getNodeTyeRes.left().value(); } private void createUsers() { - + GraphVertex ownerV = new GraphVertex(VertexTypeEnum.USER); ownerV.setUniqueId("user1"); - + Map<GraphPropertyEnum, Object> metadataProperties = new HashMap<>(); metadataProperties.put(GraphPropertyEnum.USERID, ownerV.getUniqueId()); metadataProperties.put(GraphPropertyEnum.LABEL, VertexTypeEnum.USER.getName()); @@ -535,12 +583,12 @@ public class ToscaElementLifecycleOperationTest extends ModelTestBase { ownerV.setJson(new HashMap<>()); Either<GraphVertex, TitanOperationStatus> createUserRes = titanDao.createVertex(ownerV); assertTrue(createUserRes.isLeft()); - + ownerVertex = createUserRes.left().value(); - + GraphVertex modifierV = new GraphVertex(VertexTypeEnum.USER); modifierV.setUniqueId("user2"); - + metadataProperties = new HashMap<>(); metadataProperties.put(GraphPropertyEnum.USERID, modifierV.getUniqueId()); metadataProperties.put(GraphPropertyEnum.LABEL, VertexTypeEnum.USER.getName()); @@ -550,12 +598,24 @@ public class ToscaElementLifecycleOperationTest extends ModelTestBase { modifierV.setJson(new HashMap<>()); createUserRes = titanDao.createVertex(modifierV); assertTrue(createUserRes.isLeft()); - + modifierVertex = createUserRes.left().value(); - + Either<GraphVertex, TitanOperationStatus> getOwnerRes = lifecycleOperation.findUser(ownerVertex.getUniqueId()); assertTrue(getOwnerRes.isLeft()); - + + } + + public void verifyInCatalogData(int expected, List<String> expectedIds) { + + Either<List<CatalogComponent>, StorageOperationStatus> highestResourcesRes = topologyTemplateOperation.getElementCatalogData(); + assertTrue(highestResourcesRes.isLeft()); + List<CatalogComponent> highestResources = highestResourcesRes.left().value(); + // calculate expected count value + assertEquals(expected, highestResources.stream().count()); + if (expectedIds != null) { + highestResources.forEach(a -> assertTrue(expectedIds.contains(a.getUniqueId()))); + } } @After @@ -594,5 +654,5 @@ public class ToscaElementLifecycleOperationTest extends ModelTestBase { return result; } - + } diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/tosca/converters/DataTypePropertyConverterTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/tosca/converters/DataTypePropertyConverterTest.java index d5425504e6..e15d784c7a 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/tosca/converters/DataTypePropertyConverterTest.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/tosca/converters/DataTypePropertyConverterTest.java @@ -1,19 +1,19 @@ package org.openecomp.sdc.be.model.tosca.converters; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNull; +import com.google.gson.JsonObject; +import org.junit.Before; +import org.junit.Test; +import org.openecomp.sdc.be.model.DataTypeDefinition; +import org.openecomp.sdc.be.model.PropertyDefinition; +import javax.json.Json; import java.util.Arrays; import java.util.Collections; import java.util.HashMap; import java.util.Map; -import org.junit.Before; -import org.junit.Test; -import org.openecomp.sdc.be.model.DataTypeDefinition; -import org.openecomp.sdc.be.model.PropertyDefinition; - -import com.google.gson.JsonObject; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; public class DataTypePropertyConverterTest { diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/tosca/converters/ToscaFloatConverterTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/tosca/converters/ToscaFloatConverterTest.java index 5367dcb8a3..7e9388ee1b 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/tosca/converters/ToscaFloatConverterTest.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/tosca/converters/ToscaFloatConverterTest.java @@ -2,22 +2,73 @@ package org.openecomp.sdc.be.model.tosca.converters; import org.junit.Test; +import java.util.Collections; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatExceptionOfType; +import static org.junit.Assert.assertNull; + public class ToscaFloatConverterTest { - private ToscaFloatConverter createTestSubject() { - return ToscaFloatConverter.getInstance(); - } + @Test + public void convertEmptyString_returnNull() { + assertNull(executeFloatConversion("")); + } + + @Test + public void convertNull_returnNull() { + assertNull(executeFloatConversion(null)); + } + + @Test + public void convertWholeNumber() { + assertThat(executeFloatConversion("1234")) + .isEqualTo("1234"); + } + + @Test + public void convertFloatNumber() { + assertThat(executeFloatConversion("3.141")) + .isEqualTo("3.141"); + } + + @Test + public void convertNotValidFloat() { + assertThatExceptionOfType(NumberFormatException.class).isThrownBy(() -> executeFloatConversion("123.55.66")); + } + + @Test + public void convertNumericWithSpecialChars() { + assertThatExceptionOfType(NumberFormatException.class).isThrownBy(() -> executeFloatConversion("123,55")); + assertThatExceptionOfType(NumberFormatException.class).isThrownBy(() -> executeFloatConversion("123&55")); + assertThatExceptionOfType(NumberFormatException.class).isThrownBy(() -> executeFloatConversion("123$$55")); + assertThatExceptionOfType(NumberFormatException.class).isThrownBy(() -> executeFloatConversion("123#55")); + } + + @Test + public void convertNonNumeric() { + assertThatExceptionOfType(NumberFormatException.class).isThrownBy(() -> executeFloatConversion("1234ABC")); + } - - @Test - public void testGetInstance() throws Exception { - ToscaFloatConverter result; + @Test + public void convertNumericWithCapitalFloatSign() { + assertThat(executeFloatConversion("1234F")) + .isEqualTo("1234"); + } - // default test - result = ToscaFloatConverter.getInstance(); - } + @Test + public void convertNumericWithSmallLetterFloatSign() { + assertThat(executeFloatConversion("1234f")) + .isEqualTo("1234"); + } - + @Test + public void convertNumericWithFloatSignNotAtTheEnd_ThrowsException() { + assertThatExceptionOfType(NumberFormatException.class).isThrownBy(() -> executeFloatConversion("12f34")); + } + private String executeFloatConversion(String s) { + return ToscaFloatConverter.getInstance().convert(s, null, Collections.emptyMap()); + } }
\ No newline at end of file diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/tosca/validators/MapValidatorTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/tosca/validators/MapValidatorTest.java new file mode 100644 index 0000000000..6f33b19de3 --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/tosca/validators/MapValidatorTest.java @@ -0,0 +1,16 @@ +package org.openecomp.sdc.be.model.tosca.validators; + +import org.junit.Test; + +import java.util.Collections; + +import static org.junit.Assert.*; + +public class MapValidatorTest { + + @Test + public void isValid_nonMapString() { + assertFalse(MapValidator.getInstance().isValid("abc", "string", Collections.emptyMap())); + assertFalse(MapValidator.getInstance().isValid("1", "string", Collections.emptyMap())); + } +}
\ No newline at end of file |