diff options
Diffstat (limited to 'catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan')
24 files changed, 1528 insertions, 1293 deletions
diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/datamodel/NodeTypeTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/datamodel/NodeTypeTest.java deleted file mode 100644 index aae9d6f2a0..0000000000 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/datamodel/NodeTypeTest.java +++ /dev/null @@ -1,173 +0,0 @@ -package org.openecomp.sdc.be.model.jsontitan.datamodel; - -import java.util.List; -import java.util.Map; - -import org.junit.Test; -import org.openecomp.sdc.be.datatypes.elements.InterfaceDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.ListRequirementDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; - - -public class NodeTypeTest { - - private NodeType createTestSubject() { - return new NodeType(); - } - - - @Test - public void testGetDerivedList() throws Exception { - NodeType testSubject; - List<String> result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getDerivedList(); - } - - - @Test - public void testSetDerivedList() throws Exception { - NodeType testSubject; - List<String> derivedList = null; - - // default test - testSubject = createTestSubject(); - testSubject.setDerivedList(derivedList); - } - - - @Test - public void testGetDerivedFrom() throws Exception { - NodeType testSubject; - List<String> result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getDerivedFrom(); - } - - - @Test - public void testSetDerivedFrom() throws Exception { - NodeType testSubject; - List<String> derivedFrom = null; - - // default test - testSubject = createTestSubject(); - testSubject.setDerivedFrom(derivedFrom); - } - - - @Test - public void testGetAttributes() throws Exception { - NodeType testSubject; - Map<String, PropertyDataDefinition> result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getAttributes(); - } - - - @Test - public void testSetAttributes() throws Exception { - NodeType testSubject; - Map<String, PropertyDataDefinition> attributes = null; - - // default test - testSubject = createTestSubject(); - testSubject.setAttributes(attributes); - } - - - @Test - public void testGetCapabilties() throws Exception { - NodeType testSubject; - Map<String, ListCapabilityDataDefinition> result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getCapabilties(); - } - - - @Test - public void testSetCapabilties() throws Exception { - NodeType testSubject; - Map<String, ListCapabilityDataDefinition> capabilties = null; - - // default test - testSubject = createTestSubject(); - testSubject.setCapabilties(capabilties); - } - - - @Test - public void testGetRequirements() throws Exception { - NodeType testSubject; - Map<String, ListRequirementDataDefinition> result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getRequirements(); - } - - - @Test - public void testSetRequirements() throws Exception { - NodeType testSubject; - Map<String, ListRequirementDataDefinition> requirements = null; - - // default test - testSubject = createTestSubject(); - testSubject.setRequirements(requirements); - } - - - @Test - public void testGetCapabiltiesProperties() throws Exception { - NodeType testSubject; - Map<String, MapPropertiesDataDefinition> result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getCapabiltiesProperties(); - } - - - @Test - public void testSetCapabiltiesProperties() throws Exception { - NodeType testSubject; - Map<String, MapPropertiesDataDefinition> capabiltiesProperties = null; - - // default test - testSubject = createTestSubject(); - testSubject.setCapabiltiesProperties(capabiltiesProperties); - } - - - @Test - public void testGetInterfaceArtifacts() throws Exception { - NodeType testSubject; - Map<String, InterfaceDataDefinition> result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getInterfaceArtifacts(); - } - - - @Test - public void testSetInterfaceArtifacts() throws Exception { - NodeType testSubject; - Map<String, InterfaceDataDefinition> interfaceArtifacts = null; - - // default test - testSubject = createTestSubject(); - testSubject.setInterfaceArtifacts(interfaceArtifacts); - } -}
\ No newline at end of file diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/datamodel/TopologyTemplateTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/datamodel/TopologyTemplateTest.java deleted file mode 100644 index 0f1b91807d..0000000000 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/datamodel/TopologyTemplateTest.java +++ /dev/null @@ -1,414 +0,0 @@ -package org.openecomp.sdc.be.model.jsontitan.datamodel; - -import java.util.Map; - -import org.junit.Test; -import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.CompositionDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.GroupDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.MapArtifactDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.MapCapabiltyProperty; -import org.openecomp.sdc.be.datatypes.elements.MapGroupsDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.MapListCapabiltyDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.MapListRequirementDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.RelationshipInstDataDefinition; -import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition; - - -public class TopologyTemplateTest { - - private TopologyTemplate createTestSubject() { - return new TopologyTemplate(); - } - - - @Test - public void testGetInputs() throws Exception { - TopologyTemplate testSubject; - Map<String, PropertyDataDefinition> result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getInputs(); - } - - - @Test - public void testSetInputs() throws Exception { - TopologyTemplate testSubject; - Map<String, PropertyDataDefinition> inputs = null; - - // default test - testSubject = createTestSubject(); - testSubject.setInputs(inputs); - } - - - @Test - public void testGetInstInputs() throws Exception { - TopologyTemplate testSubject; - Map<String, MapPropertiesDataDefinition> result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getInstInputs(); - } - - - @Test - public void testSetInstInputs() throws Exception { - TopologyTemplate testSubject; - Map<String, MapPropertiesDataDefinition> instInputs = null; - - // default test - testSubject = createTestSubject(); - testSubject.setInstInputs(instInputs); - } - - - @Test - public void testGetHeatParameters() throws Exception { - TopologyTemplate testSubject; - Map<String, ? extends ToscaDataDefinition> result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getHeatParameters(); - } - - - @Test - public void testSetHeatParameters() throws Exception { - TopologyTemplate testSubject; - Map<String, ? extends ToscaDataDefinition> heatParameters = null; - - // default test - testSubject = createTestSubject(); - testSubject.setHeatParameters(heatParameters); - } - - - @Test - public void testGetInstAttributes() throws Exception { - TopologyTemplate testSubject; - Map<String, MapPropertiesDataDefinition> result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getInstAttributes(); - } - - - @Test - public void testSetInstAttributes() throws Exception { - TopologyTemplate testSubject; - Map<String, MapPropertiesDataDefinition> instAttributes = null; - - // default test - testSubject = createTestSubject(); - testSubject.setInstAttributes(instAttributes); - } - - - @Test - public void testGetInstProperties() throws Exception { - TopologyTemplate testSubject; - Map<String, MapPropertiesDataDefinition> result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getInstProperties(); - } - - - @Test - public void testSetInstProperties() throws Exception { - TopologyTemplate testSubject; - Map<String, MapPropertiesDataDefinition> instProperties = null; - - // default test - testSubject = createTestSubject(); - testSubject.setInstProperties(instProperties); - } - - - @Test - public void testGetGroups() throws Exception { - TopologyTemplate testSubject; - Map<String, GroupDataDefinition> result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getGroups(); - } - - - @Test - public void testSetGroups() throws Exception { - TopologyTemplate testSubject; - Map<String, GroupDataDefinition> groups = null; - - // default test - testSubject = createTestSubject(); - testSubject.setGroups(groups); - } - - - @Test - public void testGetInstGroups() throws Exception { - TopologyTemplate testSubject; - Map<String, MapGroupsDataDefinition> result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getInstGroups(); - } - - - @Test - public void testSetInstGroups() throws Exception { - TopologyTemplate testSubject; - Map<String, MapGroupsDataDefinition> instGroups = null; - - // default test - testSubject = createTestSubject(); - testSubject.setInstGroups(instGroups); - } - - - @Test - public void testGetServiceApiArtifacts() throws Exception { - TopologyTemplate testSubject; - Map<String, ArtifactDataDefinition> result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getServiceApiArtifacts(); - } - - - @Test - public void testSetServiceApiArtifacts() throws Exception { - TopologyTemplate testSubject; - Map<String, ArtifactDataDefinition> serviceApiArtifacts = null; - - // default test - testSubject = createTestSubject(); - testSubject.setServiceApiArtifacts(serviceApiArtifacts); - } - - - @Test - public void testGetCompositions() throws Exception { - TopologyTemplate testSubject; - Map<String, CompositionDataDefinition> result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getCompositions(); - } - - - @Test - public void testSetCompositions() throws Exception { - TopologyTemplate testSubject; - Map<String, CompositionDataDefinition> compositions = null; - - // default test - testSubject = createTestSubject(); - testSubject.setCompositions(compositions); - } - - - @Test - public void testGetCalculatedCapabilities() throws Exception { - TopologyTemplate testSubject; - Map<String, MapListCapabiltyDataDefinition> result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getCalculatedCapabilities(); - } - - - @Test - public void testSetCalculatedCapabilities() throws Exception { - TopologyTemplate testSubject; - Map<String, MapListCapabiltyDataDefinition> calculatedCapabilities = null; - - // default test - testSubject = createTestSubject(); - testSubject.setCalculatedCapabilities(calculatedCapabilities); - } - - - @Test - public void testGetCalculatedRequirements() throws Exception { - TopologyTemplate testSubject; - Map<String, MapListRequirementDataDefinition> result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getCalculatedRequirements(); - } - - - @Test - public void testSetCalculatedRequirements() throws Exception { - TopologyTemplate testSubject; - Map<String, MapListRequirementDataDefinition> calculatedRequirements = null; - - // default test - testSubject = createTestSubject(); - testSubject.setCalculatedRequirements(calculatedRequirements); - } - - - @Test - public void testGetFullfilledCapabilities() throws Exception { - TopologyTemplate testSubject; - Map<String, MapListCapabiltyDataDefinition> result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getFullfilledCapabilities(); - } - - - @Test - public void testSetFullfilledCapabilities() throws Exception { - TopologyTemplate testSubject; - Map<String, MapListCapabiltyDataDefinition> fullfilledCapabilities = null; - - // default test - testSubject = createTestSubject(); - testSubject.setFullfilledCapabilities(fullfilledCapabilities); - } - - - @Test - public void testGetFullfilledRequirements() throws Exception { - TopologyTemplate testSubject; - Map<String, MapListRequirementDataDefinition> result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getFullfilledRequirements(); - } - - - @Test - public void testSetFullfilledRequirements() throws Exception { - TopologyTemplate testSubject; - Map<String, MapListRequirementDataDefinition> fullfilledRequirements = null; - - // default test - testSubject = createTestSubject(); - testSubject.setFullfilledRequirements(fullfilledRequirements); - } - - - @Test - public void testGetInstDeploymentArtifacts() throws Exception { - TopologyTemplate testSubject; - Map<String, MapArtifactDataDefinition> result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getInstDeploymentArtifacts(); - } - - - @Test - public void testSetInstDeploymentArtifacts() throws Exception { - TopologyTemplate testSubject; - Map<String, MapArtifactDataDefinition> instDeploymentArtifacts = null; - - // default test - testSubject = createTestSubject(); - testSubject.setInstDeploymentArtifacts(instDeploymentArtifacts); - } - - - @Test - public void testGetCalculatedCapabilitiesProperties() throws Exception { - TopologyTemplate testSubject; - Map<String, MapCapabiltyProperty> result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getCalculatedCapabilitiesProperties(); - } - - - @Test - public void testSetCalculatedCapabilitiesProperties() throws Exception { - TopologyTemplate testSubject; - Map<String, MapCapabiltyProperty> calculatedCapabilitiesProperties = null; - - // default test - testSubject = createTestSubject(); - testSubject.setCalculatedCapabilitiesProperties(calculatedCapabilitiesProperties); - } - - - @Test - public void testGetInstanceArtifacts() throws Exception { - TopologyTemplate testSubject; - Map<String, MapArtifactDataDefinition> result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getInstanceArtifacts(); - } - - - @Test - public void testSetInstanceArtifacts() throws Exception { - TopologyTemplate testSubject; - Map<String, MapArtifactDataDefinition> instanceArtifacts = null; - - // default test - testSubject = createTestSubject(); - testSubject.setInstanceArtifacts(instanceArtifacts); - } - - - - - - @Test - public void testGetComponentInstances() throws Exception { - TopologyTemplate testSubject; - Map<String, ComponentInstanceDataDefinition> result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getComponentInstances(); - } - - - @Test - public void testSetComponentInstances() throws Exception { - TopologyTemplate testSubject; - Map<String, ComponentInstanceDataDefinition> instances = null; - - // default test - testSubject = createTestSubject(); - testSubject.setComponentInstances(instances); - } - - - @Test - public void testGetRelations() throws Exception { - TopologyTemplate testSubject; - Map<String, RelationshipInstDataDefinition> result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getRelations(); - } -}
\ No newline at end of file diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/datamodel/ToscaElementTypeEnumTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/datamodel/ToscaElementTypeEnumTest.java deleted file mode 100644 index a112c9e51e..0000000000 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/datamodel/ToscaElementTypeEnumTest.java +++ /dev/null @@ -1,25 +0,0 @@ -package org.openecomp.sdc.be.model.jsontitan.datamodel; - -import org.junit.Test; - - -public class ToscaElementTypeEnumTest { - - private ToscaElementTypeEnum createTestSubject() { - return ToscaElementTypeEnum.TopologyTemplate; - } - - - - - - @Test - public void testGetValue() throws Exception { - ToscaElementTypeEnum testSubject; - String result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getValue(); - } -}
\ No newline at end of file diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/enums/JsonConstantKeysEnumTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/enums/JsonConstantKeysEnumTest.java deleted file mode 100644 index b00b13e162..0000000000 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/enums/JsonConstantKeysEnumTest.java +++ /dev/null @@ -1,22 +0,0 @@ -package org.openecomp.sdc.be.model.jsontitan.enums; - -import org.junit.Test; - - -public class JsonConstantKeysEnumTest { - - private JsonConstantKeysEnum createTestSubject() { - return JsonConstantKeysEnum.COMPOSITION; - } - - - @Test - public void testGetValue() throws Exception { - JsonConstantKeysEnum testSubject; - String result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getValue(); - } -}
\ No newline at end of file diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ArchiveOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ArchiveOperationTest.java new file mode 100644 index 0000000000..1b9da4dbc1 --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ArchiveOperationTest.java @@ -0,0 +1,486 @@ +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.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.ComponentInstanceDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.CompositionDataDefinition; +import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; +import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; +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.jsontitan.enums.JsonConstantKeysEnum; +import org.openecomp.sdc.be.model.jsontitan.utils.GraphTestUtils; +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; + +/** + * Created by yavivi on 21/03/2018. + */ +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration("classpath:application-context-test.xml") +public class ArchiveOperationTest extends ModelTestBase { + + private static final String CI_UID_RES1_CP = "cp_uid"; + private static final String CI_UID_RES2_VL = "vl_uid"; + private static final String CI_UID_SVC_PROXY = "svc_proxy_uid"; + + @Resource + private ArchiveOperation archiveOperation; + + @Resource + private TitanDao titanDao; + + private boolean isInitialized; + + private GraphVertex serviceVertex1; + private GraphVertex archivedVertex1; + + GraphVertex archiveVertex; + GraphVertex catalogVertex; + + private GraphVertex serviceVertex1_0; + private GraphVertex serviceVertex1_1; + private GraphVertex serviceVertex2_0; + private GraphVertex serviceVertex3_0; + private GraphVertex serviceVertex3_1; + + private GraphVertex serviceVertex0_1; + private GraphVertex serviceVertex0_2; + private GraphVertex serviceVertex0_3; + private GraphVertex serviceVertex0_4; + private GraphVertex serviceVertex0_5; + + //Composition Elements + private GraphVertex compositionService; + private GraphVertex compositionResource1; + private GraphVertex compositionResource2; + private GraphVertex compositionServiceProxy; + private GraphVertex compositionAnotherService; + + //For VSP Archive Notification + private GraphVertex vfResource0_1; + private GraphVertex vfResource0_2; + private GraphVertex vfResource1_0; + private String csarUuid = "123456789";; + + @BeforeClass + public static void initTest(){ + ModelTestBase.init(); + } + + @Before + public void beforeTest() { + if (!isInitialized) { + GraphTestUtils.clearGraph(titanDao); + initGraphForTest(); + isInitialized = true; + } + } + + @Test + public void testArchiveComponentSingleVersion(){ + String componentId = serviceVertex1.getUniqueId(); + Either<List<String>, ActionStatus> actionStatus = this.archiveOperation.archiveComponent(componentId); + assertThat(actionStatus.isLeft()).isTrue(); + assertArchived(serviceVertex1.getUniqueId()); + } + + @Test + public void testArchiveComponentFailsWhenInCheckoutSingleVersion(){ + checkoutComponent(serviceVertex1); + String componentId = serviceVertex1.getUniqueId(); + Either<List<String>, ActionStatus> actionStatus = this.archiveOperation.archiveComponent(componentId); + assertThat(actionStatus.isLeft()).isFalse(); + assertThat(actionStatus.right().value()).isEqualTo(ActionStatus.INVALID_SERVICE_STATE); + } + + @Test + public void testArchiveWithWrongId() { + Either<List<String>, ActionStatus> actionStatus = this.archiveOperation.archiveComponent("fakeComponentId"); + assertThat(actionStatus.isLeft()).isFalse(); + assertThat(actionStatus.right().value()).isEqualTo(ActionStatus.RESOURCE_NOT_FOUND); + } + + @Test + public void testAlreadyArchived() { + Either<List<String>, ActionStatus> actionStatus = this.archiveOperation.archiveComponent(archivedVertex1.getUniqueId()); + assertThat(actionStatus.isLeft()).isTrue(); + assertThat(actionStatus.left().value()).containsExactly(archivedVertex1.getUniqueId()); + } + + @Test + public void testScenario2_archive_1_0(){ + Either<List<String>, ActionStatus> actionStatus = this.archiveOperation.archiveComponent(serviceVertex1_0.getUniqueId()); + assertThat(actionStatus.isLeft()).isTrue(); + assertThat(actionStatus.left().value()).containsExactlyInAnyOrder(serviceVertex1_0.getUniqueId(), serviceVertex1_1.getUniqueId()); + assertArchived(serviceVertex1_0.getUniqueId()); + assertArchived(serviceVertex1_1.getUniqueId()); + } + + @Test + public void testScenario2_archive_1_1(){ + Either<List<String>, ActionStatus> actionStatus = this.archiveOperation.archiveComponent(serviceVertex1_1.getUniqueId()); + assertThat(actionStatus.left().value()).containsExactlyInAnyOrder(serviceVertex1_0.getUniqueId(), serviceVertex1_1.getUniqueId()); + assertArchived(serviceVertex1_0.getUniqueId()); + assertArchived(serviceVertex1_1.getUniqueId()); + } + + @Test + public void testScenario4_oneLowOneHighestVersion(){ + Either<List<String>, ActionStatus> actionStatus = this.archiveOperation.archiveComponent(serviceVertex0_2.getUniqueId()); + assertThat(actionStatus.left().value()).containsExactlyInAnyOrder(serviceVertex0_2.getUniqueId(), serviceVertex0_1.getUniqueId(), serviceVertex0_3.getUniqueId(), serviceVertex0_4.getUniqueId(), serviceVertex0_5.getUniqueId()); + assertArchived(serviceVertex0_1.getUniqueId()); + assertArchived(serviceVertex0_2.getUniqueId()); + assertArchived(serviceVertex0_3.getUniqueId()); + assertArchived(serviceVertex0_4.getUniqueId()); + assertArchived(serviceVertex0_5.getUniqueId()); + + actionStatus = this.archiveOperation.restoreComponent(serviceVertex0_2.getUniqueId()); + assertThat(actionStatus.isLeft()).isTrue(); + assertThat(actionStatus.left().value()).containsExactlyInAnyOrder(serviceVertex0_2.getUniqueId(), serviceVertex0_1.getUniqueId(), serviceVertex0_3.getUniqueId(), serviceVertex0_4.getUniqueId(), serviceVertex0_5.getUniqueId()); + } + + + /////////////// Continue Here ////////////////// + @Test + public void testScenario4_archiveFromNonHighest(){ + Either<List<String>, ActionStatus> actionStatus = this.archiveOperation.archiveComponent(serviceVertex0_2.getUniqueId()); + assertArchived(serviceVertex0_1.getUniqueId()); + assertArchived(serviceVertex0_2.getUniqueId()); + assertArchived(serviceVertex0_3.getUniqueId()); + assertArchived(serviceVertex0_4.getUniqueId()); + assertArchived(serviceVertex0_5.getUniqueId()); + + actionStatus = this.archiveOperation.restoreComponent(serviceVertex0_3.getUniqueId()); + assertRestored(serviceVertex0_1.getUniqueId()); + assertRestored(serviceVertex0_2.getUniqueId()); + assertRestored(serviceVertex0_3.getUniqueId()); + assertRestored(serviceVertex0_4.getUniqueId()); + assertRestored(serviceVertex0_5.getUniqueId()); + } + + @Test + public void testArchiveFailsWhenHighestVersionIsInCheckoutState(){ + checkoutComponent(serviceVertex0_5); + Either<List<String>, ActionStatus> actionStatus = this.archiveOperation.archiveComponent(serviceVertex0_2.getUniqueId()); + assertThat(actionStatus.right().value()).isEqualTo(ActionStatus.INVALID_SERVICE_STATE); + } + + @Test + public void testScenario3_archive_3_0(){ + Either<List<String>, ActionStatus> actionStatus = this.archiveOperation.archiveComponent(serviceVertex3_0.getUniqueId()); + assertArchived(serviceVertex3_0.getUniqueId()); + assertArchived(serviceVertex3_1.getUniqueId()); + assertArchivedProps(serviceVertex2_0.getUniqueId()); + } + + @Test + public void testArchivedOriginsCalculation(){ + + //Archive the CP resource + this.archiveOperation.archiveComponent(this.compositionResource1.getUniqueId()); + this.archiveOperation.archiveComponent(this.compositionServiceProxy.getUniqueId()); + + List<String> ciWithArchivedOrigins = this.archiveOperation.setArchivedOriginsFlagInComponentInstances(this.compositionService); + + //Validate that method returns the CI of CP + assertThat(ciWithArchivedOrigins).containsExactlyInAnyOrder(CI_UID_RES1_CP, CI_UID_SVC_PROXY); + + Map<String, CompositionDataDefinition> compositionsJson = (Map<String, CompositionDataDefinition>) this.compositionService.getJson(); + + assertThat(compositionsJson).isNotNull(); + assertThat(compositionsJson.get(JsonConstantKeysEnum.COMPOSITION.getValue())).isNotNull(); + + CompositionDataDefinition composition = compositionsJson.get(JsonConstantKeysEnum.COMPOSITION.getValue()); + + //Get all component instances from composition + Map<String, ComponentInstanceDataDefinition> componentInstances = composition.getComponentInstances(); + for (ComponentInstanceDataDefinition ci : componentInstances.values()) { + //Verify that exactly 2 CIs are marked as archived + if (ci.getUniqueId().equals(CI_UID_RES1_CP) || ci.getUniqueId().equals(CI_UID_SVC_PROXY)) { + assertThat(ci.isOriginArchived()).isTrue(); + } + } + + } + + @Test + public void testNoArchivedOriginsCalculation(){ + List<String> ciWithArchivedOrigins = this.archiveOperation.setArchivedOriginsFlagInComponentInstances(this.compositionService); + + //Validate that method returns the CI of CP + assertThat(ciWithArchivedOrigins).isEmpty(); + } + + @Test + public void testOnVspArchivedAndRestored(){ + this.archiveOperation.onVspArchived(csarUuid); + //assertOnCommit(); + + assertOnVspArchived(true); + + this.archiveOperation.onVspRestored(csarUuid); + //assertOnCommit(); + assertOnVspArchived(false); + + //Not Found CSAR UUID + ActionStatus result = this.archiveOperation.onVspRestored("fakeUuid"); + //assertOnCommit(); + assertThat(result).isEqualTo(ActionStatus.RESOURCE_NOT_FOUND); + } + + private void assertOnVspArchived(boolean expectedValue) { + GraphVertex v = titanDao.getVertexById(vfResource0_1.getUniqueId()).left().value(); + assertThat(v.getMetadataProperty(GraphPropertyEnum.IS_VSP_ARCHIVED)).isEqualTo(expectedValue); + + v = titanDao.getVertexById(vfResource0_2.getUniqueId()).left().value(); + assertThat(v.getMetadataProperty(GraphPropertyEnum.IS_VSP_ARCHIVED)).isEqualTo(expectedValue); + + v = titanDao.getVertexById(vfResource1_0.getUniqueId()).left().value(); + assertThat(v.getMetadataProperty(GraphPropertyEnum.IS_VSP_ARCHIVED)).isEqualTo(expectedValue); + } + + /************************** + * Utility Methods + *************************/ + + private void checkoutComponent(GraphVertex serviceVertex0_5) { + Either<GraphVertex, TitanOperationStatus> vE = titanDao.getVertexById(serviceVertex0_5.getUniqueId()); + GraphVertex v = vE.left().value(); + v.addMetadataProperty(GraphPropertyEnum.STATE, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); + v.setJsonMetadataField(JsonPresentationFields.LIFECYCLE_STATE, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); + titanDao.updateVertex(v); + assertOnCommit(); + } + + private void assertOnCommit(){ + final TitanOperationStatus commit = this.titanDao.commit(); + assertThat(commit).isEqualTo(TitanOperationStatus.OK); + } + + private void assertArchived(String componentUniqueId) { + assertArchivedOrRestored(ArchiveOperation.Action.ARCHIVE, componentUniqueId); + } + + private void assertRestored(String componentUniqueId) { + assertArchivedOrRestored(ArchiveOperation.Action.RESTORE, componentUniqueId); + } + + private void assertArchivedOrRestored(ArchiveOperation.Action action, String componentUniqueId) { + GraphVertex v = titanDao.getVertexById(componentUniqueId).left().value(); + + EdgeLabelEnum requiredEdge = action == ArchiveOperation.Action.ARCHIVE ? EdgeLabelEnum.ARCHIVE_ELEMENT : EdgeLabelEnum.CATALOG_ELEMENT; + EdgeLabelEnum otherEdge = action == ArchiveOperation.Action.ARCHIVE ? EdgeLabelEnum.CATALOG_ELEMENT : EdgeLabelEnum.ARCHIVE_ELEMENT; + + GraphVertex parent = null; + Either<GraphVertex, TitanOperationStatus> otherLookup = null; + Boolean isHighest = (Boolean) v.getMetadataProperty(GraphPropertyEnum.IS_HIGHEST_VERSION); + if (isHighest != null && isHighest) { + //Highest version are linked to Archive/Catalog Root + parent = titanDao.getParentVertex(v, requiredEdge, JsonParseFlagEnum.NoParse).left().value(); + otherLookup = titanDao.getParentVertex(v, otherEdge, JsonParseFlagEnum.NoParse); + assertThat(otherLookup.isRight()).isTrue(); //Verify that component is not linked to Catalog/Archive Root + assertThat(parent.getUniqueId()).isEqualTo(action == ArchiveOperation.Action.ARCHIVE ? this.archiveVertex.getUniqueId() : this.catalogVertex.getUniqueId()); //Verify that parent is indeed Archive Root + } + + assertArchivedOrRestoredProps(action, v); + } + + private void assertArchivedProps(String uniqueId) { + GraphVertex v = + titanDao.getVertexById(uniqueId).left().value(); + assertArchivedOrRestoredProps(ArchiveOperation.Action.ARCHIVE, v); + } + + private void assertRestoredProps(String uniqueId) { + GraphVertex v = + titanDao.getVertexById(uniqueId).left().value(); + assertArchivedOrRestoredProps(ArchiveOperation.Action.RESTORE, v); + } + + private void assertArchivedOrRestoredProps(ArchiveOperation.Action action, GraphVertex v) { + Object isArchived = v.getMetadataProperty(GraphPropertyEnum.IS_ARCHIVED); + Object archiveTime = v.getMetadataProperty(GraphPropertyEnum.ARCHIVE_TIME); + assertThat(isArchived).isNotNull().isEqualTo(action == ArchiveOperation.Action.ARCHIVE ? true : false); + assertThat(archiveTime).isNotNull(); + } + + /******************************* + * Preperation Methods + *******************************/ + private void initGraphForTest() { + //Create Catalog Root + this.catalogVertex = GraphTestUtils.createRootCatalogVertex(titanDao); + //Create Archive Root + this.archiveVertex = GraphTestUtils.createRootArchiveVertex(titanDao); + + createScenario1_SingleVersionNode(); + createScenario2_TwoHighestVersions(); + createScenario3_TwoHighestVersionsOneLowest(); + createMiscServices(); + createServiceCompositionForCalculatingArchivedOrigins(); + createScenario4_1Highest4LowestVersions(); + createResourcesForArchivedVsp(); + + assertOnCommit(); + } + + private void createScenario1_SingleVersionNode() { + //Create Service for Scenario 1 Tests (1 Service) + this.serviceVertex1 = GraphTestUtils.createServiceVertex(titanDao, propsForHighestVersion()); + + //Connect Service to Catalog Root + titanDao.createEdge(catalogVertex, serviceVertex1, EdgeLabelEnum.CATALOG_ELEMENT, null); + } + + private void createScenario2_TwoHighestVersions() { + //Create Service for Scenario 2 Tests (1 Service) + this.serviceVertex1_0 = GraphTestUtils.createServiceVertex(titanDao, propsForHighestVersion()); + this.serviceVertex1_1 = GraphTestUtils.createServiceVertex(titanDao, propsForHighestVersion()); + + titanDao.createEdge(serviceVertex1_0, serviceVertex1_1, EdgeLabelEnum.VERSION, null); + + //Connect 1.0 and 1.1 to Catalog Root + titanDao.createEdge(catalogVertex, serviceVertex1_0, EdgeLabelEnum.CATALOG_ELEMENT, null); + titanDao.createEdge(catalogVertex, serviceVertex1_1, EdgeLabelEnum.CATALOG_ELEMENT, null); + } + + private void createScenario3_TwoHighestVersionsOneLowest() { + //Create Service for Scenario 1 Tests (1 Service) + this.serviceVertex2_0 = GraphTestUtils.createServiceVertex(titanDao, propsForNonHighestVersion()); //NonHighestVersion + this.serviceVertex3_0 = GraphTestUtils.createServiceVertex(titanDao, propsForHighestVersion()); + this.serviceVertex3_1 = GraphTestUtils.createServiceVertex(titanDao, propsForHighestVersion()); + + //Connect version edges + titanDao.createEdge(serviceVertex2_0, serviceVertex3_0, EdgeLabelEnum.VERSION, null); + titanDao.createEdge(serviceVertex3_0, serviceVertex3_1, EdgeLabelEnum.VERSION, null); + + //Connect 3.0 and 3.1 to Catalog Root + titanDao.createEdge(catalogVertex, serviceVertex3_0, EdgeLabelEnum.CATALOG_ELEMENT, null); + titanDao.createEdge(catalogVertex, serviceVertex3_1, EdgeLabelEnum.CATALOG_ELEMENT, null); + } + + private void createScenario4_1Highest4LowestVersions() { + //2 Lowest version only + this.serviceVertex0_1 = GraphTestUtils.createServiceVertex(titanDao, propsForNonHighestVersion()); + this.serviceVertex0_2 = GraphTestUtils.createServiceVertex(titanDao, propsForNonHighestVersion()); + this.serviceVertex0_3 = GraphTestUtils.createServiceVertex(titanDao, propsForNonHighestVersion()); + this.serviceVertex0_4 = GraphTestUtils.createServiceVertex(titanDao, propsForNonHighestVersion()); + this.serviceVertex0_5 = GraphTestUtils.createServiceVertex(titanDao, propsForHighestVersion()); + + titanDao.createEdge(serviceVertex0_1, serviceVertex0_2, EdgeLabelEnum.VERSION, null); + titanDao.createEdge(serviceVertex0_2, serviceVertex0_3, EdgeLabelEnum.VERSION, null); + titanDao.createEdge(serviceVertex0_3, serviceVertex0_4, EdgeLabelEnum.VERSION, null); + titanDao.createEdge(serviceVertex0_4, serviceVertex0_5, EdgeLabelEnum.VERSION, null); + + titanDao.createEdge(catalogVertex, serviceVertex0_5, EdgeLabelEnum.CATALOG_ELEMENT, null); + } + + private void createResourcesForArchivedVsp(){ + Map<GraphPropertyEnum, Object> vfPropsNonHighest = propsForNonHighestVersion(); + Map<GraphPropertyEnum, Object> vfPropsHighest = propsForNonHighestVersion(); + + vfPropsNonHighest.put(GraphPropertyEnum.CSAR_UUID, csarUuid); + vfPropsNonHighest.put(GraphPropertyEnum.IS_VSP_ARCHIVED, false); + vfPropsHighest.put(GraphPropertyEnum.CSAR_UUID, csarUuid); + vfPropsHighest.put(GraphPropertyEnum.IS_VSP_ARCHIVED, false); + + this.vfResource0_1 = GraphTestUtils.createResourceVertex(titanDao, vfPropsNonHighest, ResourceTypeEnum.VF); + this.vfResource0_2 = GraphTestUtils.createResourceVertex(titanDao, vfPropsNonHighest, ResourceTypeEnum.VF); + this.vfResource1_0 = GraphTestUtils.createResourceVertex(titanDao, vfPropsHighest, ResourceTypeEnum.VF); + + titanDao.createEdge(vfResource0_1, vfResource0_2, EdgeLabelEnum.VERSION, null); + titanDao.createEdge(vfResource0_2, vfResource1_0, EdgeLabelEnum.VERSION, null); + } + + private void createMiscServices() { + //Create Service for Scenario 1 Tests (1 Service) + this.archivedVertex1 = GraphTestUtils.createServiceVertex(titanDao, new HashMap<>()); + + //Connect Service to Catalog Root + titanDao.createEdge(archiveVertex, archivedVertex1, EdgeLabelEnum.ARCHIVE_ELEMENT, null); + } + + private void createServiceCompositionForCalculatingArchivedOrigins(){ + //Service that point to another service in composition + this.compositionService = GraphTestUtils.createServiceVertex(titanDao, propsForHighestVersion()); + this.compositionAnotherService = GraphTestUtils.createServiceVertex(titanDao, propsForHighestVersion()); + + this.compositionResource1 = GraphTestUtils.createResourceVertex(titanDao, propsForHighestVersion(), ResourceTypeEnum.CP); + this.compositionResource2 = GraphTestUtils.createResourceVertex(titanDao, propsForHighestVersion(), ResourceTypeEnum.VL); + this.compositionServiceProxy = GraphTestUtils.createResourceVertex(titanDao, propsForHighestVersion(), ResourceTypeEnum.ServiceProxy); + + titanDao.createEdge(compositionService, compositionResource1, EdgeLabelEnum.INSTANCE_OF, null); + titanDao.createEdge(compositionService, compositionResource2, EdgeLabelEnum.INSTANCE_OF, null); + titanDao.createEdge(compositionService, compositionServiceProxy, EdgeLabelEnum.INSTANCE_OF, null); + titanDao.createEdge(compositionService, compositionAnotherService, EdgeLabelEnum.PROXY_OF, null); + + createAndAttachCompositionJson(compositionService); + } + + private void createAndAttachCompositionJson(GraphVertex compositionService) { + //Full composition json + Map<String, CompositionDataDefinition> compositions = new HashMap<>(); + //Single composition data + CompositionDataDefinition composition = new CompositionDataDefinition(); + //Instances Map + Map<String, ComponentInstanceDataDefinition> instances = new HashMap<>(); + + //Prepare Instances Map + ComponentInstanceDataDefinition instance = new ComponentInstanceDataDefinition(); + instance.setUniqueId(CI_UID_RES1_CP); + instance.setComponentUid(compositionResource1.getUniqueId()); + instances.put(CI_UID_RES1_CP, instance); + + instance = new ComponentInstanceDataDefinition(); + instance.setUniqueId(CI_UID_RES2_VL); + instance.setComponentUid(compositionResource2.getUniqueId()); + instances.put(CI_UID_RES2_VL, instance); + + instance = new ComponentInstanceDataDefinition(); + instance.setUniqueId(CI_UID_SVC_PROXY); + instance.setComponentUid(compositionServiceProxy.getUniqueId()); + instances.put(CI_UID_SVC_PROXY, instance); + + //Add Instances to Composition + composition.setComponentInstances(instances); + //Add to full composition + compositions.put(JsonConstantKeysEnum.COMPOSITION.getValue(), composition); + //Add Full Json to vertex + compositionService.setJson(compositions); + //System.out.println(JsonParserUtils.toJson(compositions)); + titanDao.updateVertex(compositionService); + } + + private Map<GraphPropertyEnum, Object> propsForHighestVersion(){ + Map<GraphPropertyEnum, Object> props = new HashMap(); + props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + props.put(GraphPropertyEnum.STATE, LifecycleStateEnum.NOT_CERTIFIED_CHECKIN); + return props; + } + + private Map<GraphPropertyEnum, Object> propsForNonHighestVersion(){ + Map<GraphPropertyEnum, Object> props = new HashMap(); + props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, false); + props.put(GraphPropertyEnum.STATE, LifecycleStateEnum.NOT_CERTIFIED_CHECKIN); + return props; + } + +}
\ No newline at end of file diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ArtifactsOperationsTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ArtifactsOperationsTest.java index a8fb60999c..410cef9ae8 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ArtifactsOperationsTest.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ArtifactsOperationsTest.java @@ -1,18 +1,6 @@ package org.openecomp.sdc.be.model.jsontitan.operations; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; -import static org.mockito.Mockito.CALLS_REAL_METHODS; -import static org.mockito.Mockito.doReturn; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.times; -import static org.mockito.Mockito.verify; - -import java.util.Collections; -import java.util.HashMap; -import java.util.Map; - +import fj.data.Either; import org.junit.Test; import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum; import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; @@ -22,7 +10,12 @@ import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition; import org.openecomp.sdc.be.model.ArtifactDefinition; import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; -import fj.data.Either; +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; + +import static org.junit.Assert.*; +import static org.mockito.Mockito.*; public class ArtifactsOperationsTest { 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 index efa4020d0c..e580fd51bb 100644 --- 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 @@ -1,14 +1,6 @@ package org.openecomp.sdc.be.model.jsontitan.operations; -import static org.assertj.core.api.Assertions.assertThat; -import static org.mockito.Mockito.when; - -import java.util.HashMap; -import java.util.List; -import java.util.Map; - -import javax.annotation.Resource; - +import fj.data.Either; import org.junit.Before; import org.junit.BeforeClass; import org.junit.Test; @@ -24,10 +16,15 @@ 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.openecomp.sdc.be.model.operations.StorageException; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; -import fj.data.Either; +import javax.annotation.Resource; +import java.util.*; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.when; /** * Created by yavivi on 26/01/2018. @@ -36,6 +33,18 @@ import fj.data.Either; @ContextConfiguration("classpath:application-context-test.xml") public class ExternalReferencesOperationTest extends ModelTestBase { + private static final String COMPONENT_ID = "ci-MyComponentName"; + private static final String COMPONENT2_ID = "ci-MyComponentName2"; + 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"; + @Resource private ExternalReferencesOperation externalReferenceOperation; @@ -45,20 +54,12 @@ public class ExternalReferencesOperationTest extends ModelTestBase { private boolean isInitialized; private GraphVertex serviceVertex; + private GraphVertex serviceVertex2; + private GraphVertex serviceVertex3; 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 String serviceVertex2Uuid; + private String serviceVertex3Uuid; private IdMapper idMapper; @@ -92,6 +93,44 @@ public class ExternalReferencesOperationTest extends ModelTestBase { } @Test + public void testAddExternalReferences_success() { + Map<String, List<String>> refsMap = Collections.singletonMap(MONITORING_OBJECT_TYPE, Arrays.asList(REF_1, REF_2)); + externalReferenceOperation.addAllExternalReferences(serviceVertex3Uuid, COMPONENT_ID, refsMap); + Map<String, List<String>> allExternalReferences = externalReferenceOperation.getAllExternalReferences(serviceVertex3Uuid, COMPONENT_ID); + assertThat(allExternalReferences.size()).isEqualTo(1); + assertThat(allExternalReferences).flatExtracting(MONITORING_OBJECT_TYPE).containsExactly(REF_1, REF_2); + externalReferenceOperation.addAllExternalReferences(serviceVertex3Uuid, COMPONENT2_ID, refsMap); + Map<String, List<String>> allExternalReferences2 = externalReferenceOperation.getAllExternalReferences(serviceVertex3Uuid, COMPONENT2_ID); + assertThat(allExternalReferences2.size()).isEqualTo(1); + assertThat(allExternalReferences2).flatExtracting(MONITORING_OBJECT_TYPE).containsExactly(REF_1, REF_2); + } + + @Test + public void testGetAllCIExternalRefs_success() { + Map<String, List<String>> allExternalReferences = externalReferenceOperation.getAllExternalReferences(serviceVertexUuid, COMPONENT_ID); + assertThat(allExternalReferences.size()).isEqualTo(2); + assertThat(allExternalReferences).flatExtracting(WORKFLOW_OBJECT_TYPE).containsExactly(REF_6); + assertThat(allExternalReferences).flatExtracting(MONITORING_OBJECT_TYPE).containsExactly(REF_1, REF_2, REF_3, REF_5); + } + + @Test + public void testGetAllCIExternalRefs_noRefsExist() { + Map<String, List<String>> allExternalReferences = externalReferenceOperation.getAllExternalReferences(serviceVertex2Uuid, COMPONENT_ID); + assertThat(allExternalReferences.size()).isZero(); + } + + @Test + public void testGetAllCIExternalRefs_noSuchComponentInstance() { + Map<String, List<String>> allExternalReferences = externalReferenceOperation.getAllExternalReferences(serviceVertex2Uuid, "FAKE"); + assertThat(allExternalReferences.size()).isZero(); + } + + @Test(expected=StorageException.class) + public void testGetAllCIExternalRefs_nonExitingService_throwsException() { + externalReferenceOperation.getAllExternalReferences("FAKE", COMPONENT_ID); + } + + @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); @@ -155,13 +194,12 @@ public class ExternalReferencesOperationTest extends ModelTestBase { //Get List of references //final List<String> externalRefsByObjectType = mapComponentInstanceExternalRefs.externalRefsByObjectType(objectType); - final List<String> externalRefsByObjectType = mapComponentInstanceExternalRefs.getExternalRefsByObjectType(MONITORING_OBJECT_TYPE); - return externalRefsByObjectType; + return mapComponentInstanceExternalRefs.getExternalRefsByObjectType(MONITORING_OBJECT_TYPE); } private void initGraphForTest() { - //create a service and add 1 ref + //create a service this.serviceVertex = GraphTestUtils.createServiceVertex(titanDao, new HashMap<>()); this.serviceVertexUuid = this.serviceVertex.getUniqueId(); @@ -174,6 +212,14 @@ public class ExternalReferencesOperationTest extends ModelTestBase { //workflow references externalReferenceOperation.addExternalReference(serviceVertexUuid, COMPONENT_ID, WORKFLOW_OBJECT_TYPE, REF_6); + //create a service without refs + serviceVertex2 = GraphTestUtils.createServiceVertex(titanDao, new HashMap<>()); + serviceVertex2Uuid = serviceVertex2.getUniqueId(); + + //create a service for adding all references + serviceVertex3 = GraphTestUtils.createServiceVertex(titanDao, new HashMap<>()); + serviceVertex3Uuid = serviceVertex3.getUniqueId(); + final TitanOperationStatus commit = this.titanDao.commit(); assertThat(commit).isEqualTo(TitanOperationStatus.OK); } diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/GroupsOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/GroupsOperationTest.java new file mode 100644 index 0000000000..191546d5c0 --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/GroupsOperationTest.java @@ -0,0 +1,102 @@ +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.titan.TitanOperationStatus; +import org.openecomp.sdc.be.model.*; +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.List; + +import static java.util.Arrays.asList; +import static org.assertj.core.api.Assertions.assertThat; + + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration(classes = {TitanSpringConfig.class, ModelOperationsSpringConfig.class}) +public class GroupsOperationTest extends ModelTestBase { + + @Autowired + private GroupsOperation groupsOperation; + + @Autowired + TitanDao titanDao; + + @Autowired + private ToscaOperationFacade toscaOperationFacade; + private Component container; + + @BeforeClass + public static void initClass() { + ModelTestBase.init(); + } + + @Before + public void setUp() throws Exception { + container = new Resource(); + container.setUniqueId(CONTAINER_ID); + Either<GraphVertex, TitanOperationStatus> createdCmpt = titanDao.createVertex(createBasicContainerGraphVertex()); + assertThat(createdCmpt.isLeft()).isTrue(); + + } + + @After + public void tearDown() throws Exception { + titanDao.rollback(); + } + + @Test + public void addGroups_whenContainerHasNoGroups_associateContainerWithGroup() { + GroupDefinition g1 = createGroupDefinition("g1"); + GroupDefinition g2 = createGroupDefinition("g2"); + Either<List<GroupDefinition>, StorageOperationStatus> createGroups = groupsOperation.addGroups(container, asList(g1, g2)); + assertThat(createGroups.isLeft()).isTrue(); + + ComponentParametersView getGroupsFilter = new ComponentParametersView(true); + getGroupsFilter.setIgnoreGroups(false); + Component cmptWithGroups = toscaOperationFacade.getToscaElement(CONTAINER_ID, getGroupsFilter).left().value(); + assertThat(cmptWithGroups.getGroups()) + .usingElementComparatorOnFields("name", "uniqueId") + .containsExactlyInAnyOrder(g1, g2); + } + + @Test + public void addGroups_whenContainerHasGroups_addTheGivenGroupsToTheGroupsList() { + GroupDefinition g1 = createGroupDefinition("g1"); + GroupDefinition g2 = createGroupDefinition("g2"); + groupsOperation.addGroups(container, asList(g1, g2)).left().value(); + + GroupDefinition g3 = createGroupDefinition("g3"); + GroupDefinition g4 = createGroupDefinition("g4"); + + groupsOperation.addGroups(container, asList(g3, g4)).left().value(); + + ComponentParametersView getGroupsFilter = new ComponentParametersView(true); + getGroupsFilter.setIgnoreGroups(false); + Component cmptWithGroups = toscaOperationFacade.getToscaElement(CONTAINER_ID, getGroupsFilter).left().value(); + assertThat(cmptWithGroups.getGroups()) + .usingElementComparatorOnFields("name", "uniqueId") + .containsExactlyInAnyOrder(g1, g2, g3, g4); + + } + + private GroupDefinition createGroupDefinition(String id) { + GroupDefinition groupDefinition = new GroupDefinition(); + groupDefinition.setUniqueId(id); + groupDefinition.setName("name" + id); + return groupDefinition; + } + + +}
\ No newline at end of file diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/InterfacesOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/InterfacesOperationTest.java index c3e8ce3eb6..f2aefa0aa3 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/InterfacesOperationTest.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/InterfacesOperationTest.java @@ -3,11 +3,7 @@ package org.openecomp.sdc.be.model.jsontitan.operations; import com.thinkaurelius.titan.core.TitanGraph; import com.thinkaurelius.titan.core.TitanVertex; import fj.data.Either; -import org.junit.After; -import org.junit.Assert; -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.*; import org.junit.runner.RunWith; import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; import org.openecomp.sdc.be.dao.jsongraph.TitanDao; @@ -23,11 +19,7 @@ import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition; -import org.openecomp.sdc.be.model.InterfaceDefinition; -import org.openecomp.sdc.be.model.LifecycleStateEnum; -import org.openecomp.sdc.be.model.ModelTestBase; -import org.openecomp.sdc.be.model.Operation; -import org.openecomp.sdc.be.model.User; +import org.openecomp.sdc.be.model.*; 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; @@ -42,11 +34,11 @@ import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; import javax.annotation.Resource; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.Iterator; -import java.util.List; -import java.util.Map; +import java.io.BufferedOutputStream; +import java.io.File; +import java.io.FileOutputStream; +import java.io.OutputStream; +import java.util.*; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; @@ -365,7 +357,7 @@ public class InterfacesOperationTest extends ModelTestBase{ Map<String, MapDataDefinition> capProps = new HashMap(); capProps.put("capName", dataToCreate); - Either<GraphVertex, StorageOperationStatus> res = nodeTypeOperation.assosiateElementToData(vfVertex, VertexTypeEnum.CAPABILITIES_PROPERTIES, EdgeLabelEnum.CAPABILITIES_PROPERTIES, capProps); + Either<GraphVertex, StorageOperationStatus> res = nodeTypeOperation.associateElementToData(vfVertex, VertexTypeEnum.CAPABILITIES_PROPERTIES, EdgeLabelEnum.CAPABILITIES_PROPERTIES, capProps); List<String> pathKeys = new ArrayList<>(); pathKeys.add("capName"); diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/NodeTemplateOperationGraphTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/NodeTemplateOperationGraphTest.java new file mode 100644 index 0000000000..ac8d8e7e8d --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/NodeTemplateOperationGraphTest.java @@ -0,0 +1,239 @@ +package org.openecomp.sdc.be.model.jsontitan.operations; + +import com.thinkaurelius.titan.core.TitanGraph; +import com.thinkaurelius.titan.core.TitanVertex; +import fj.data.Either; +import org.apache.tinkerpop.gremlin.structure.Direction; +import org.apache.tinkerpop.gremlin.structure.Edge; +import org.apache.tinkerpop.gremlin.structure.Vertex; +import org.apache.tinkerpop.gremlin.structure.io.IoCore; +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.EdgePropertyEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; +import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; +import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition; +import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; +import org.openecomp.sdc.be.model.ModelTestBase; +import org.openecomp.sdc.be.model.config.ModelOperationsSpringConfig; +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.io.BufferedOutputStream; +import java.io.File; +import java.io.FileOutputStream; +import java.io.OutputStream; +import java.util.*; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.Assert.*; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration(classes = {TitanSpringConfig.class, ModelOperationsSpringConfig.class}) +public class NodeTemplateOperationGraphTest extends ModelTestBase{ + @Resource + private TitanDao titanDao; + @Resource + private NodeTemplateOperation nodeTemplateOperation; + + private TitanGraph graphT; + private GraphVertex containerVertex; + private String containeId; + + @BeforeClass + public static void setupBeforeClass() { + + ModelTestBase.init(); + } + @Before + public void before(){ + + Either<TitanGraph, TitanOperationStatus> graph = titanDao.getGraph(); + graphT = graph.left().value(); + + containerVertex = new GraphVertex(VertexTypeEnum.TOPOLOGY_TEMPLATE); + containeId = "containerId"; + containerVertex.setUniqueId(containeId); + Either<GraphVertex, TitanOperationStatus> createVertex = titanDao.createVertex(containerVertex); + assertTrue(createVertex.isLeft()); + } + + @After + public void after(){ + titanDao.rollback(); + + } + + + String outputDirectory = "C:\\Output"; + + @Test + public void testCreateInstanceEdge(){ + + Map<String, List<String>> mapOriginToInstId = new HashMap<>(); + createIntancesFromSameResource(mapOriginToInstId, 1, 3); + createIntancesFromSameResource(mapOriginToInstId, 2, 4); + createIntancesFromSameResource(mapOriginToInstId, 3, 1); + +// exportGraphMl(graphT); + + validateOnGraph(mapOriginToInstId, 3); + } + + @Test + public void testRemoveInstanceEdge(){ + //create 3 instances from same resource orig1 + Map<String, List<String>> mapOriginToInstId = new HashMap<>(); + String originId = createIntancesFromSameResource(mapOriginToInstId, 1, 3); + validateOnGraph(mapOriginToInstId, 1); + + //remove instance 2 + String instanceId = removeInstanceEdge(containerVertex, originId, 1, 1); + mapOriginToInstId.get(originId).remove(instanceId); + validateOnGraph(mapOriginToInstId, 1); + + //create new instance from orig1 + instanceId = createInstanceEdge(containerVertex, originId, 1, 4, false, null); + mapOriginToInstId.get(originId).add(instanceId); + validateOnGraph(mapOriginToInstId, 1); + + //create 1 instance from same resource orig2 + originId = createIntancesFromSameResource(mapOriginToInstId, 2, 1); + validateOnGraph(mapOriginToInstId, 2); + + //remove instance of orig 2 + instanceId = removeInstanceEdge(containerVertex, originId, 2, 1); + mapOriginToInstId.get(originId).remove(instanceId); + validateOnGraph(mapOriginToInstId, 1); + + } + + @Test + public void testProxyInstanceEdge(){ + Map<String, List<String>> mapOriginToInstId = new HashMap<>(); + String proxyId = createOrigin(2); + createIntancesFromSameResource(mapOriginToInstId, 1, 1, true, proxyId); + + validateOnGraph(mapOriginToInstId, 1); + } + private void validateOnGraph(Map<String, List<String>> mapOriginToInstId, int expectedEdgeCount) { + validateOnGraph(mapOriginToInstId, expectedEdgeCount, false); + } + private void validateOnGraph(Map<String, List<String>> mapOriginToInstId, int expectedEdgeCount, boolean validateProxy) { + Iterable vertices = graphT.query().has(GraphPropertyEnum.UNIQUE_ID.getProperty(), containeId).vertices(); + assertNotNull(vertices); + Iterator<TitanVertex> iterator = vertices.iterator(); + assertTrue(iterator.hasNext()); + Vertex containerV = iterator.next(); + validatePerEdgeType(mapOriginToInstId, expectedEdgeCount, containerV, EdgeLabelEnum.INSTANCE_OF); + if ( validateProxy ){ + validatePerEdgeType(mapOriginToInstId, expectedEdgeCount, containerV, EdgeLabelEnum.PROXY_OF); + } + } + private void validatePerEdgeType(Map<String, List<String>> mapOriginToInstId, int expectedEdgeCount, Vertex containerV, EdgeLabelEnum edgeLabel) { + Iterator<Edge> edges = containerV.edges(Direction.OUT, edgeLabel.name()); + assertNotNull(edges); + + int counter = 0; + while (edges.hasNext()){ + Edge edge = edges.next(); + counter++; + validateEdge(edge, mapOriginToInstId); + } + assertEquals("check edge size", expectedEdgeCount, counter); + } + + + private String createIntancesFromSameResource(Map<String, List<String>> mapOriginToInstId, int originIndex, int countInstances) { + return createIntancesFromSameResource(mapOriginToInstId, originIndex, countInstances, false, null); + } + + private String createIntancesFromSameResource(Map<String, List<String>> mapOriginToInstId, int originIndex, int countInstances, boolean isProxy, String proxyId) { + + List<String> exp = new ArrayList(); + String originId = createOrigin(originIndex); + + for ( int i = 0; i < countInstances; i++){ + String instanceId = createInstanceEdge(containerVertex, originId, originIndex, i+1, isProxy, proxyId); + exp.add(instanceId); + } + mapOriginToInstId.put(originId, exp); + if ( isProxy ){ + mapOriginToInstId.put(proxyId, exp); + } + return originId; + } + + private String createInstanceEdge(GraphVertex containerVertex, String originId, int originIndex, int insIndex, boolean isProxy, String proxyId) { + ComponentInstanceDataDefinition componentInstance = new ComponentInstanceDataDefinition(); + componentInstance.setComponentUid(originId); + String instanceId = buildInstanceId(originIndex, insIndex); + componentInstance.setUniqueId(instanceId); + componentInstance.setIsProxy(isProxy); + componentInstance.setSourceModelUid(proxyId); + StorageOperationStatus edgeStatus = nodeTemplateOperation.createInstanceEdge(containerVertex, componentInstance); + assertEquals("assertion createInstanceEdge", StorageOperationStatus.OK, edgeStatus); + return instanceId; + } + + private String buildInstanceId(int originIndex, int insIndex) { + StringBuffer sb = new StringBuffer("instanceId_"); + sb.append(originIndex).append("-").append(insIndex); + return sb.toString(); + } + private String removeInstanceEdge(GraphVertex containerVertex, String originId, int originIndex, int insIndex) { + ComponentInstanceDataDefinition componentInstance = new ComponentInstanceDataDefinition(); + componentInstance.setComponentUid(originId); + String instanceId = buildInstanceId(originIndex, insIndex); + componentInstance.setUniqueId(instanceId); + StorageOperationStatus edgeStatus = nodeTemplateOperation.removeInstanceEdge(containerVertex, componentInstance); + assertEquals("assertion removeInstanceEdge", StorageOperationStatus.OK, edgeStatus); + return instanceId; + } + + + private String createOrigin(int index) { + Either<GraphVertex, TitanOperationStatus> createVertex; + GraphVertex originVertex = new GraphVertex(VertexTypeEnum.NODE_TYPE); + String originId = "originId_" + index; + originVertex.setUniqueId(originId); + createVertex = titanDao.createVertex(originVertex); + assertTrue(createVertex.isLeft()); + return originId; + } + private void validateEdge(Edge edge, Map<String, List<String>> mapOriginToInstId) { + List<String> expextedInList; + + Vertex originV = edge.inVertex(); + String id = (String) titanDao.getProperty((TitanVertex)originV, GraphPropertyEnum.UNIQUE_ID.getProperty()); + expextedInList = mapOriginToInstId.get(id); + + List<String> list = (List<String>) titanDao.getProperty(edge, EdgePropertyEnum.INSTANCES); + assertThat(list).hasSameSizeAs(expextedInList); + assertThat(list).containsOnlyElementsOf(expextedInList); + } + + private String exportGraphMl(TitanGraph graph) { + String result = null; + String outputFile = outputDirectory + File.separator + "exportGraph." + System.currentTimeMillis() + ".graphml"; + try { + try (final OutputStream os = new BufferedOutputStream(new FileOutputStream(outputFile))) { + graph.io(IoCore.graphml()).writer().normalize(true).create().writeGraph(os, graph); + } + result = outputFile; + } catch (Exception e) { + e.printStackTrace(); + } + return result; + + } +} 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 65baa42e16..fcde5b2605 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 @@ -1,13 +1,7 @@ package org.openecomp.sdc.be.model.jsontitan.operations; -import static org.junit.Assert.assertTrue; -import static org.mockito.ArgumentMatchers.eq; -import static org.mockito.Mockito.when; - -import java.util.HashMap; -import java.util.List; -import java.util.Map; - +import com.google.common.collect.Lists; +import fj.data.Either; import org.junit.Assert; import org.junit.BeforeClass; import org.junit.Test; @@ -17,198 +11,181 @@ 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.ArtifactDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.ListRequirementDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.MapArtifactDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.MapListCapabiltyDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.MapListRequirementDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition; -import org.openecomp.sdc.be.model.ArtifactDefinition; -import org.openecomp.sdc.be.model.CapabilityRequirementRelationship; -import org.openecomp.sdc.be.model.Component; -import org.openecomp.sdc.be.model.GroupDefinition; -import org.openecomp.sdc.be.model.ModelTestBase; -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.User; +import org.openecomp.sdc.be.datatypes.elements.*; +import org.openecomp.sdc.be.model.*; +import org.openecomp.sdc.be.datatypes.elements.MapListCapabilityDataDefinition; import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; -import com.google.common.collect.Lists; +import java.util.HashMap; +import java.util.List; +import java.util.Map; -import fj.data.Either; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertSame; +import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.when; public class NodeTemplateOperationTest extends ModelTestBase { - private final static String COMPONENT_ID = "componentId"; - private final static String TO_INSTANCE_ID = "toInstanceId"; - private final static String FROM_INSTANCE_ID = "fromInstanceId"; - private final static String RELATION_ID = "relationId"; - private final static String CAPABILITY_OWNER_ID = "capabilityOwnerId"; - private final static String CAPABILITY_UID = "capabilityUid"; - private final static String CAPABILITY_NAME = "capabilityName"; - private final static String REQUIREMENT_OWNER_ID = "requirementOwnerId"; - private final static String REQUIREMENT_UID = "requirementUid"; - private final static String REQUIREMENT_NAME = "requirementName"; - private final static String RELATIONSHIP_TYPE = "relationshipType"; - - private static Map<String, MapListCapabiltyDataDefinition> fulfilledCapability; - private static Map<String, MapListRequirementDataDefinition> fulfilledRequirement; - private static CapabilityDataDefinition capability; - private static RequirementDataDefinition requirement; - private static RequirementCapabilityRelDef relation; - - private static TitanDao titanDao; - private static NodeTemplateOperation operation; - - @BeforeClass - public static void setup() { - init(); - titanDao = Mockito.mock(TitanDao.class); - operation = new NodeTemplateOperation(); - operation.setTitanDao(titanDao); - buildDataDefinition(); - } - - private static void buildDataDefinition() { - buildCapabiltyDataDefinition(); - buildRequirementDataDefinition(); - buildRelation(); - } - - @Test - public void testGetFulfilledCapabilityByRelationSuccess() { - GraphVertex vertex = Mockito.mock(GraphVertex.class); - Either<GraphVertex, TitanOperationStatus> vertexRes = Either.left(vertex); - when(titanDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes); - - GraphVertex dataVertex = new GraphVertex(); - dataVertex.setJson(fulfilledCapability); - Either<GraphVertex, TitanOperationStatus> childVertexRes = Either.left(dataVertex); - when(titanDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_CAPABILITIES), - eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes); - Either<CapabilityDataDefinition, StorageOperationStatus> result = operation.getFulfilledCapabilityByRelation( - COMPONENT_ID, TO_INSTANCE_ID, relation, (rel, cap) -> isBelongingCapability(rel, cap)); - assertTrue(result.isLeft()); - assertTrue(result.left().value().equals(capability)); - } - - @Test - public void testGetFulfilledRequirementByRelationSuccess() { - GraphVertex vertex = Mockito.mock(GraphVertex.class); - Either<GraphVertex, TitanOperationStatus> vertexRes = Either.left(vertex); - when(titanDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes); - - GraphVertex dataVertex = new GraphVertex(); - dataVertex.setJson(fulfilledRequirement); - Either<GraphVertex, TitanOperationStatus> childVertexRes = Either.left(dataVertex); - when(titanDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_REQUIREMENTS), - eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes); - Either<RequirementDataDefinition, StorageOperationStatus> result = operation.getFulfilledRequirementByRelation( - COMPONENT_ID, FROM_INSTANCE_ID, relation, (rel, req) -> isBelongingRequirement(rel, req)); - assertTrue(result.isLeft()); - assertTrue(result.left().value().equals(requirement)); - } - - @Test - public void testGetFulfilledCapabilityByRelationNotFoundFailure() { - GraphVertex vertex = Mockito.mock(GraphVertex.class); - Either<GraphVertex, TitanOperationStatus> vertexRes = Either.left(vertex); - when(titanDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes); - - Either<GraphVertex, TitanOperationStatus> childVertexRes = Either.right(TitanOperationStatus.NOT_FOUND); - when(titanDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_CAPABILITIES), - eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes); - Either<CapabilityDataDefinition, StorageOperationStatus> result = operation.getFulfilledCapabilityByRelation( - COMPONENT_ID, TO_INSTANCE_ID, relation, (rel, cap) -> isBelongingCapability(rel, cap)); - assertTrue(result.isRight()); - assertTrue(result.right().value() == StorageOperationStatus.NOT_FOUND); - } - - @Test - public void testGetFulfilledRequirementByRelationNotFoundFailure() { - GraphVertex vertex = Mockito.mock(GraphVertex.class); - Either<GraphVertex, TitanOperationStatus> vertexRes = Either.left(vertex); - when(titanDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes); - - Either<GraphVertex, TitanOperationStatus> childVertexRes = Either.right(TitanOperationStatus.NOT_FOUND); - when(titanDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_REQUIREMENTS), - eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes); - Either<RequirementDataDefinition, StorageOperationStatus> result = operation.getFulfilledRequirementByRelation( - COMPONENT_ID, FROM_INSTANCE_ID, relation, (rel, req) -> isBelongingRequirement(rel, req)); - assertTrue(result.isRight()); - assertTrue(result.right().value() == StorageOperationStatus.NOT_FOUND); - } - - private static void buildRequirementDataDefinition() { - buildRequirement(); - fulfilledRequirement = new HashMap<>(); - MapListRequirementDataDefinition mapListRequirementDataDefinition = new MapListRequirementDataDefinition(); - mapListRequirementDataDefinition.add(requirement.getCapability(), requirement); - fulfilledRequirement.put(FROM_INSTANCE_ID, mapListRequirementDataDefinition); - - } - - private static void buildRequirement() { - requirement = new RequirementDataDefinition(); - requirement.setOwnerId(REQUIREMENT_OWNER_ID); - requirement.setUniqueId(REQUIREMENT_UID); - requirement.setName(REQUIREMENT_NAME); - requirement.setRelationship(RELATIONSHIP_TYPE); - } - - private static void buildCapabiltyDataDefinition() { - buildCapability(); - fulfilledCapability = new HashMap<>(); - MapListCapabiltyDataDefinition mapListCapabiltyDataDefinition = new MapListCapabiltyDataDefinition(); - mapListCapabiltyDataDefinition.add(capability.getType(), capability); - fulfilledCapability.put(TO_INSTANCE_ID, mapListCapabiltyDataDefinition); - } - - private static void buildCapability() { - capability = new CapabilityDataDefinition(); - capability.setOwnerId(CAPABILITY_OWNER_ID); - capability.setUniqueId(CAPABILITY_UID); - capability.setName(CAPABILITY_NAME); - } - - private static void buildRelation() { - - relation = new RequirementCapabilityRelDef(); - CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship(); - RelationshipInfo relationInfo = new RelationshipInfo(); - relationInfo.setId(RELATION_ID); - relationship.setRelation(relationInfo); - - relation.setRelationships(Lists.newArrayList(relationship)); - relation.setToNode(TO_INSTANCE_ID); - relation.setFromNode(FROM_INSTANCE_ID); - - relationInfo.setCapabilityOwnerId(CAPABILITY_OWNER_ID); - relationInfo.setCapabilityUid(CAPABILITY_UID); - relationInfo.setCapability(CAPABILITY_NAME); - relationInfo.setRequirementOwnerId(REQUIREMENT_OWNER_ID); - relationInfo.setRequirementUid(REQUIREMENT_UID); - relationInfo.setRequirement(REQUIREMENT_NAME); - RelationshipImpl relationshipImpl = new RelationshipImpl(); - relationshipImpl.setType(RELATIONSHIP_TYPE); - relationInfo.setRelationships(relationshipImpl); - } - - private boolean isBelongingRequirement(RelationshipInfo relationshipInfo, RequirementDataDefinition req) { - return req.getRelationship().equals(relationshipInfo.getRelationship().getType()) - && req.getName().equals(relationshipInfo.getRequirement()) - && req.getUniqueId().equals(relationshipInfo.getRequirementUid()) - && req.getOwnerId().equals(relationshipInfo.getRequirementOwnerId()); - } - - private boolean isBelongingCapability(RelationshipInfo relationshipInfo, CapabilityDataDefinition cap) { - return cap.getName().equals(relationshipInfo.getCapability()) - && cap.getUniqueId().equals(relationshipInfo.getCapabilityUid()) - && cap.getOwnerId().equals(relationshipInfo.getCapabilityOwnerId()); + private final static String COMPONENT_ID = "componentId"; + private final static String TO_INSTANCE_ID = "toInstanceId"; + private final static String FROM_INSTANCE_ID = "fromInstanceId"; + private final static String RELATION_ID = "relationId"; + private final static String CAPABILITY_OWNER_ID = "capabilityOwnerId"; + private final static String CAPABILITY_UID = "capabilityUid"; + private final static String CAPABILITY_NAME = "capabilityName"; + private final static String REQUIREMENT_OWNER_ID = "requirementOwnerId"; + private final static String REQUIREMENT_UID = "requirementUid"; + private final static String REQUIREMENT_NAME = "requirementName"; + private final static String RELATIONSHIP_TYPE = "relationshipType"; + + private static Map<String, MapListCapabilityDataDefinition> fulfilledCapability; + private static Map<String, MapListRequirementDataDefinition> fulfilledRequirement; + private static CapabilityDataDefinition capability; + private static RequirementDataDefinition requirement; + private static RequirementCapabilityRelDef relation; + + private static TitanDao titanDao; + private static NodeTemplateOperation operation; + + @BeforeClass + public static void setup() { + init(); + titanDao = Mockito.mock(TitanDao.class); + operation = new NodeTemplateOperation(); + operation.setTitanDao(titanDao); + buildDataDefinition(); + } + + private static void buildDataDefinition() { + buildCapabiltyDataDefinition(); + buildRequirementDataDefinition(); + buildRelation(); + } + + @Test + public void testGetFulfilledCapabilityByRelationSuccess(){ + GraphVertex vertex = Mockito.mock(GraphVertex.class); + Either<GraphVertex, TitanOperationStatus> vertexRes = Either.left(vertex); + when(titanDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes); + + GraphVertex dataVertex = new GraphVertex(); + dataVertex.setJson(fulfilledCapability); + Either<GraphVertex, TitanOperationStatus> childVertexRes = Either.left(dataVertex); + when(titanDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_CAPABILITIES), eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes); + Either<CapabilityDataDefinition, StorageOperationStatus> result = operation.getFulfilledCapabilityByRelation(COMPONENT_ID, TO_INSTANCE_ID, relation, this::isBelongingCapability); + assertTrue(result.isLeft()); + assertEquals(result.left().value(), capability); + } + + @Test + public void testGetFulfilledRequirementByRelationSuccess(){ + GraphVertex vertex = Mockito.mock(GraphVertex.class); + Either<GraphVertex, TitanOperationStatus> vertexRes = Either.left(vertex); + when(titanDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes); + + GraphVertex dataVertex = new GraphVertex(); + dataVertex.setJson(fulfilledRequirement); + Either<GraphVertex, TitanOperationStatus> childVertexRes = Either.left(dataVertex); + when(titanDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_REQUIREMENTS), eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes); + Either<RequirementDataDefinition, StorageOperationStatus> result = operation.getFulfilledRequirementByRelation(COMPONENT_ID, FROM_INSTANCE_ID, relation, this::isBelongingRequirement); + assertTrue(result.isLeft()); + assertEquals(result.left().value(), requirement); + } + + @Test + public void testGetFulfilledCapabilityByRelationNotFoundFailure(){ + GraphVertex vertex = Mockito.mock(GraphVertex.class); + Either<GraphVertex, TitanOperationStatus> vertexRes = Either.left(vertex); + when(titanDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes); + + Either<GraphVertex, TitanOperationStatus> childVertexRes = Either.right(TitanOperationStatus.NOT_FOUND); + when(titanDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_CAPABILITIES), eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes); + Either<CapabilityDataDefinition, StorageOperationStatus> result = operation.getFulfilledCapabilityByRelation(COMPONENT_ID, TO_INSTANCE_ID, relation, this::isBelongingCapability); + assertTrue(result.isRight()); + assertSame(result.right().value(), StorageOperationStatus.NOT_FOUND); + } + + @Test + public void testGetFulfilledRequirementByRelationNotFoundFailure(){ + GraphVertex vertex = Mockito.mock(GraphVertex.class); + Either<GraphVertex, TitanOperationStatus> vertexRes = Either.left(vertex); + when(titanDao.getVertexById(eq(COMPONENT_ID), eq(JsonParseFlagEnum.ParseAll))).thenReturn(vertexRes); + + Either<GraphVertex, TitanOperationStatus> childVertexRes = Either.right(TitanOperationStatus.NOT_FOUND); + when(titanDao.getChildVertex(eq(vertex), eq(EdgeLabelEnum.FULLFILLED_REQUIREMENTS), eq(JsonParseFlagEnum.ParseJson))).thenReturn(childVertexRes); + Either<RequirementDataDefinition, StorageOperationStatus> result = operation.getFulfilledRequirementByRelation(COMPONENT_ID, FROM_INSTANCE_ID, relation, this::isBelongingRequirement); + assertTrue(result.isRight()); + assertSame(result.right().value(), StorageOperationStatus.NOT_FOUND); + } + + private static void buildRequirementDataDefinition() { + buildRequirement(); + fulfilledRequirement = new HashMap<>(); + MapListRequirementDataDefinition mapListRequirementDataDefinition = new MapListRequirementDataDefinition(); + mapListRequirementDataDefinition.add(requirement.getCapability(), requirement); + fulfilledRequirement.put(FROM_INSTANCE_ID, mapListRequirementDataDefinition); + + } + + private static void buildRequirement() { + requirement = new RequirementDataDefinition(); + requirement.setOwnerId(REQUIREMENT_OWNER_ID); + requirement.setUniqueId(REQUIREMENT_UID); + requirement.setName(REQUIREMENT_NAME); + requirement.setRelationship(RELATIONSHIP_TYPE); + } + + private static void buildCapabiltyDataDefinition() { + buildCapability(); + fulfilledCapability = new HashMap<>(); + MapListCapabilityDataDefinition mapListCapabiltyDataDefinition = new MapListCapabilityDataDefinition(); + mapListCapabiltyDataDefinition.add(capability.getType(), capability); + fulfilledCapability.put(TO_INSTANCE_ID, mapListCapabiltyDataDefinition); + } + + private static void buildCapability() { + capability = new CapabilityDataDefinition(); + capability.setOwnerId(CAPABILITY_OWNER_ID); + capability.setUniqueId(CAPABILITY_UID); + capability.setName(CAPABILITY_NAME); + } + + private static void buildRelation() { + + relation = new RequirementCapabilityRelDef(); + CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship(); + RelationshipInfo relationInfo = new RelationshipInfo(); + relationInfo.setId(RELATION_ID); + relationship.setRelation(relationInfo); + + relation.setRelationships(Lists.newArrayList(relationship)); + relation.setToNode(TO_INSTANCE_ID); + relation.setFromNode(FROM_INSTANCE_ID); + + relationInfo.setCapabilityOwnerId(CAPABILITY_OWNER_ID); + relationInfo.setCapabilityUid(CAPABILITY_UID); + relationInfo.setCapability(CAPABILITY_NAME); + relationInfo.setRequirementOwnerId(REQUIREMENT_OWNER_ID); + relationInfo.setRequirementUid(REQUIREMENT_UID); + relationInfo.setRequirement(REQUIREMENT_NAME); + RelationshipImpl relationshipImpl = new RelationshipImpl(); + relationshipImpl.setType(RELATIONSHIP_TYPE); + relationInfo.setRelationships(relationshipImpl); + } + + private boolean isBelongingRequirement(RelationshipInfo relationshipInfo, RequirementDataDefinition req) { + return req.getRelationship().equals(relationshipInfo.getRelationship().getType()) && + req.getName().equals(relationshipInfo.getRequirement()) && + req.getUniqueId().equals(relationshipInfo.getRequirementUid()) && + req.getOwnerId().equals(relationshipInfo.getRequirementOwnerId()); + } + + private boolean isBelongingCapability(RelationshipInfo relationshipInfo, CapabilityDataDefinition cap) { + return cap.getName().equals(relationshipInfo.getCapability()) && + cap.getUniqueId().equals(relationshipInfo.getCapabilityUid()) && + cap.getOwnerId().equals(relationshipInfo.getCapabilityOwnerId()); } private NodeTemplateOperation createTestSubject() { @@ -222,7 +199,7 @@ public class NodeTemplateOperationTest extends ModelTestBase { // default test result = NodeTemplateOperation.getDefaultHeatTimeout(); - } + } @@ -270,7 +247,7 @@ public class NodeTemplateOperationTest extends ModelTestBase { NodeTemplateOperation testSubject; Map<String, ListCapabilityDataDefinition> capabilities = null; ComponentInstanceDataDefinition componentInstance = null; - MapListCapabiltyDataDefinition result; + MapListCapabilityDataDefinition result; // test 1 testSubject = createTestSubject(); 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 index 6a257d33de..ee88e9a515 100644 --- 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 @@ -1,15 +1,6 @@ package org.openecomp.sdc.be.model.jsontitan.operations; -import static org.apache.commons.collections.ListUtils.union; -import static org.assertj.core.api.Assertions.assertThat; - -import java.util.Arrays; -import java.util.Collections; -import java.util.List; -import java.util.Map; - -import javax.annotation.Resource; - +import fj.data.Either; import org.junit.After; import org.junit.Before; import org.junit.BeforeClass; @@ -35,7 +26,14 @@ import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; -import fj.data.Either; +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}) @@ -80,7 +78,7 @@ public class PolicyOperationIntegrationTest extends ModelTestBase { titanDao.createVertex(resource); GraphVertex loadedResource = titanDao.getVertexById(CONTAINER_ID).left().value(); topologyTemplateOperation.addToscaDataToToscaElement(loadedResource, EdgeLabelEnum.POLICIES, VertexTypeEnum.POLICIES, policy, JsonPresentationFields.UNIQUE_ID); - titanDao.commit(); +// titanDao.commit(); } @After @@ -118,7 +116,7 @@ public class PolicyOperationIntegrationTest extends ModelTestBase { componentParametersView.setIgnorePolicies(false); Either<ToscaElement, StorageOperationStatus> loadedCmptEither = topologyTemplateOperation.getToscaElement(CONTAINER_ID, componentParametersView); - assertThat(loadedCmptEither.isLeft()); + assertThat(loadedCmptEither.isLeft()).isTrue(); ToscaElement loadedCmpt = loadedCmptEither.left().value(); assertThat(loadedCmpt).isInstanceOf(TopologyTemplate.class); @SuppressWarnings("unchecked") List<PropertyDataDefinition> allProperties = union(updatedProperties, nonUpdatedPropeties); 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 index 23b6b3153d..136f95b987 100644 --- 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 @@ -1,13 +1,6 @@ package org.openecomp.sdc.be.model.jsontitan.operations; -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; - -import java.util.Arrays; -import java.util.Collections; - +import fj.data.Either; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; @@ -26,7 +19,13 @@ import org.openecomp.sdc.be.model.PolicyDefinition; import org.openecomp.sdc.be.model.Resource; import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; -import fj.data.Either; +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 { 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 index 325b4c9ef8..1f30d27f8a 100644 --- 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 @@ -1,14 +1,5 @@ package org.openecomp.sdc.be.model.jsontitan.operations; -import static org.assertj.core.api.Assertions.assertThat; - -import java.util.Arrays; -import java.util.HashMap; -import java.util.List; -import java.util.Map; - -import javax.annotation.Resource; - import org.junit.After; import org.junit.Before; import org.junit.BeforeClass; @@ -19,7 +10,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.datatypes.elements.MapCapabiltyProperty; +import org.openecomp.sdc.be.datatypes.elements.MapCapabilityProperty; import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition; import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; import org.openecomp.sdc.be.model.Component; @@ -32,12 +23,20 @@ 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 Map<String, MapCapabilityProperty> capabilitiesPropsMap; private List<CapabilityPropertyDataObject> capabilitiesProperties; @Resource @@ -67,7 +66,7 @@ public class TopologyTemplateOperationCapabilityIntegrationTest extends ModelTes //capablities props == Map<instance id, Map<capability id, Map<prop id, property>>> capabilitiesProperties.forEach(capabilitiesProperty -> { - capabilitiesPropsMap.computeIfAbsent(capabilitiesProperty.getInstanceId(), k -> new MapCapabiltyProperty(new HashMap<>())) + capabilitiesPropsMap.computeIfAbsent(capabilitiesProperty.getInstanceId(), k -> new MapCapabilityProperty(new HashMap<>())) .getMapToscaDataDefinition().computeIfAbsent(capabilitiesProperty.getCapabilityId(), k -> new MapPropertiesDataDefinition(new HashMap<>())) .getMapToscaDataDefinition().computeIfAbsent(capabilitiesProperty.getPropName(), k -> new PropertyDefinition(createPropWithValue(capabilitiesProperty.getPropValue()))); }); @@ -76,19 +75,17 @@ public class TopologyTemplateOperationCapabilityIntegrationTest extends ModelTes 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(); - + topologyTemplateOperation.associateElementToData(loadedResource, VertexTypeEnum.CALCULATED_CAP_PROPERTIES, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, capabilitiesPropsMap).left().value(); } @After - public void tearDown() throws Exception { + public void tearDown() { titanDao.rollback(); } @Test public void overrideCalculatedCapabilityProperties() { - Map<String, MapCapabiltyProperty> loadedCapPropsMap = fetchCapabilitiesProps(CONTAINER_ID); + Map<String, MapCapabilityProperty> loadedCapPropsMap = fetchCapabilitiesProps(CONTAINER_ID); compareCapabilitiesProperties(capabilitiesProperties, loadedCapPropsMap); capabilityProperty1.setPropValue("newVal1"); capabilityProperty3.setPropValue("newVal3"); @@ -96,7 +93,7 @@ public class TopologyTemplateOperationCapabilityIntegrationTest extends ModelTes 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); + Map<String, MapCapabilityProperty> updatedCapPropsMap = fetchCapabilitiesProps(CONTAINER_ID); compareCapabilitiesProperties(capabilitiesProperties, updatedCapPropsMap); } @@ -106,7 +103,7 @@ public class TopologyTemplateOperationCapabilityIntegrationTest extends ModelTes assertCapabilityPropValue(capabilityProperty2, "val2"); assertCapabilityPropValue(capabilityProperty3, "val3"); - MapCapabiltyProperty instance1Props = capabilitiesPropsMap.get("instance1"); + MapCapabilityProperty instance1Props = capabilitiesPropsMap.get("instance1"); capabilityProperty1.setPropValue("newVal1"); setPropertyValue(capabilitiesPropsMap, capabilityProperty1); @@ -123,36 +120,36 @@ public class TopologyTemplateOperationCapabilityIntegrationTest extends ModelTes assertCapabilityPropValue(capabilityProperty3, "val3");//only instance1 props should be updated } - private Map<String, MapCapabiltyProperty> fetchCapabilitiesProps(String containerId) { + private Map<String, MapCapabilityProperty> 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) { + private void compareCapabilitiesProperties(List<CapabilityPropertyDataObject> expected, Map<String, MapCapabilityProperty> 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) { + private String getPropertyValue(Map<String, MapCapabilityProperty> 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) { + private void setPropertyValue(Map<String, MapCapabilityProperty> capabilityPropertyMap, CapabilityPropertyDataObject capabilityProperty) { setPropertyValue(capabilityPropertyMap.get(capabilityProperty.getInstanceId()), capabilityProperty); } - private void setPropertyValue(MapCapabiltyProperty capabilitiesInstanceProperties, CapabilityPropertyDataObject capabilityProperty) { + private void setPropertyValue(MapCapabilityProperty 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); + Map<String, MapCapabilityProperty> loadedCapPropsMap = fetchCapabilitiesProps(CONTAINER_ID); String propertyValue = getPropertyValue(loadedCapPropsMap, prop.getInstanceId(), prop.getCapabilityId(), prop.getPropName()); assertThat(propertyValue).isEqualTo(expectedValue); } 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 deleted file mode 100644 index d7a698654e..0000000000 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/TopologyTemplateOperationIntegrationTest.java +++ /dev/null @@ -1,200 +0,0 @@ -package org.openecomp.sdc.be.model.jsontitan.operations; - -import static org.assertj.core.api.Assertions.assertThat; - -import java.util.Arrays; -import java.util.HashMap; -import java.util.List; -import java.util.Map; - -import javax.annotation.Resource; - -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; - -@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 index e8655b5036..6193c5d6b9 100644 --- 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 @@ -1,13 +1,7 @@ package org.openecomp.sdc.be.model.jsontitan.operations; -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; - -import java.util.Collections; -import java.util.HashMap; - +import com.thinkaurelius.titan.core.TitanVertex; +import fj.data.Either; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.InjectMocks; @@ -19,15 +13,19 @@ 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.MapCapabilityProperty; 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.UniqueIdBuilder; -import com.thinkaurelius.titan.core.TitanVertex; +import java.util.Collections; +import java.util.HashMap; -import fj.data.Either; +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 @@ -58,7 +56,7 @@ public class TopologyTemplateOperationTest { @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(), ""); + StorageOperationStatus storageOperationStatus = topologyTemplateOperation.updateToscaDataDeepElementsBlockToToscaElement(CONTAINER_ID, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, new MapCapabilityProperty(), ""); assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.INVALID_ID); } @@ -67,44 +65,44 @@ public class TopologyTemplateOperationTest { 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(), ""); + StorageOperationStatus storageOperationStatus = topologyTemplateOperation.updateToscaDataDeepElementsBlockToToscaElement(CONTAINER_ID, EdgeLabelEnum.CALCULATED_CAP_PROPERTIES, new MapCapabilityProperty(), ""); assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.NOT_FOUND); } - @Test + @Test public void addPolicyToToscaElementSuccessTest(){ - TitanOperationStatus status = TitanOperationStatus.OK; - StorageOperationStatus result = addPolicyToToscaElementWithStatus(status); - assertThat(result).isEqualTo(StorageOperationStatus.OK); + TitanOperationStatus status = TitanOperationStatus.OK; + StorageOperationStatus result = addPolicyToToscaElementWithStatus(status); + assertThat(result).isEqualTo(StorageOperationStatus.OK); } - @Test + @Test public void addPolicyToToscaElementFailureTest(){ - TitanOperationStatus status = TitanOperationStatus.ALREADY_EXIST; - StorageOperationStatus result = addPolicyToToscaElementWithStatus(status); - assertThat(result).isEqualTo(StorageOperationStatus.ENTITY_ALREADY_EXISTS); + 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); - } + @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/ToscaElementOperationCatalogTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaElementOperationCatalogTest.java new file mode 100644 index 0000000000..bffefd86cd --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaElementOperationCatalogTest.java @@ -0,0 +1,73 @@ +package org.openecomp.sdc.be.model.jsontitan.operations; + +import fj.data.Either; +import org.apache.tinkerpop.gremlin.structure.Vertex; +import org.apache.tinkerpop.gremlin.structure.VertexProperty; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.junit.MockitoJUnitRunner; +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.neo4j.GraphPropertiesDictionary; +import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; +import org.openecomp.sdc.be.model.catalog.CatalogComponent; + +import java.util.ArrayList; +import java.util.List; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.when; + +@RunWith(MockitoJUnitRunner.class) +public class ToscaElementOperationCatalogTest { + + private ArrayList<Vertex> vertexList = new ArrayList<>(); + + @Mock + Vertex vertex; + @Mock + TitanDao titanDao; + @Mock + VertexProperty<Object> property; + + @InjectMocks + private ToscaElementOperation toscaOperation = new TopologyTemplateOperation(); + + @Before + public void setUp() { + vertexList.add(vertex); + when(titanDao.getCatalogOrArchiveVerticies(true)).thenReturn(Either.left(vertexList.iterator())); + when(titanDao.getChildVertex(vertex, EdgeLabelEnum.CATEGORY, JsonParseFlagEnum.NoParse)) + .thenReturn(Either.right(TitanOperationStatus.NOT_FOUND)); + when(vertex.property(GraphPropertiesDictionary.METADATA.getProperty())).thenReturn(property); + } + + @Test + public void getComponentFromCatalogWhenDeleteIsTrue() { + final String vertexJsonIsDeletedTrue = "{\"lifecycleState\":\"CERTIFIED\",\"componentType\":\"RESOURCE\",\"vendorRelease\":\"1\",\"contactId\":\"ah7840\",\"lastUpdateDate\":1496119811038,\"icon\":\"att\",\"description\":\"Cloud\",\"creationDate\":1459432094781,\"vendorName\":\"AT&T\",\"mandatory\":false,\"version\":\"1.0\",\"tags\":[\"Cloud\"],\"highestVersion\":true,\"systemName\":\"Cloud\",\"name\":\"Cloud\",\"isDeleted\":true,\"invariantUuid\":\"ab5263fd-115c-41f2-8d0c-8b9279bce2b2\",\"UUID\":\"208cf7df-68a1-4ae7-afc9-409ea8012332\",\"normalizedName\":\"cloud\",\"toscaResourceName\":\"org.openecomp.resource.Endpoint.Cloud\",\"uniqueId\":\"9674e7e1-bc1a-41fe-b503-fbe996801475\",\"resourceType\":\"VFC\"}"; + when(property.value()).thenReturn(vertexJsonIsDeletedTrue); + List<CatalogComponent> componentList = toscaOperation.getElementCatalogData(true, null).left().value(); + assertTrue(componentList.isEmpty()); + } + + @Test + public void getComponentFromCatalogWhenDeleteNotFound() { + final String vertexJsonIsDeletedNotFound = "{\"lifecycleState\":\"CERTIFIED\",\"componentType\":\"RESOURCE\",\"vendorRelease\":\"1\",\"contactId\":\"ah7840\",\"lastUpdateDate\":1496119811038,\"icon\":\"att\",\"description\":\"Cloud\",\"creationDate\":1459432094781,\"vendorName\":\"AT&T\",\"mandatory\":false,\"version\":\"1.0\",\"tags\":[\"Cloud\"],\"highestVersion\":true,\"systemName\":\"Cloud\",\"name\":\"Cloud\",\"invariantUuid\":\"ab5263fd-115c-41f2-8d0c-8b9279bce2b2\",\"UUID\":\"208cf7df-68a1-4ae7-afc9-409ea8012332\",\"normalizedName\":\"cloud\",\"toscaResourceName\":\"org.openecomp.resource.Endpoint.Cloud\",\"uniqueId\":\"9674e7e1-bc1a-41fe-b503-fbe996801475\",\"resourceType\":\"VFC\"}"; + when(property.value()).thenReturn(vertexJsonIsDeletedNotFound); + List<CatalogComponent> componentList = toscaOperation.getElementCatalogData(true, null).left().value(); + assertEquals(1, componentList.size()); + } + + @Test + public void getComponentFromCatalogWhenDeleteIsFalse() { + final String vertexJsonIsDeletedFalse = "{\"lifecycleState\":\"CERTIFIED\",\"componentType\":\"RESOURCE\",\"vendorRelease\":\"1\",\"contactId\":\"ah7840\",\"lastUpdateDate\":1496119811038,\"icon\":\"att\",\"description\":\"Cloud\",\"creationDate\":1459432094781,\"vendorName\":\"AT&T\",\"mandatory\":false,\"version\":\"1.0\",\"tags\":[\"Cloud\"],\"highestVersion\":true,\"systemName\":\"Cloud\",\"name\":\"Cloud\",\"isDeleted\":false,\"invariantUuid\":\"ab5263fd-115c-41f2-8d0c-8b9279bce2b2\",\"UUID\":\"208cf7df-68a1-4ae7-afc9-409ea8012332\",\"normalizedName\":\"cloud\",\"toscaResourceName\":\"org.openecomp.resource.Endpoint.Cloud\",\"uniqueId\":\"9674e7e1-bc1a-41fe-b503-fbe996801475\",\"resourceType\":\"VFC\"}"; + when(property.value()).thenReturn(vertexJsonIsDeletedFalse); + List<CatalogComponent> componentList = toscaOperation.getElementCatalogData(true, null).left().value(); + assertEquals(1, componentList.size()); + } +} 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 054e71a83e..9f8d015a44 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 @@ -1,14 +1,6 @@ package org.openecomp.sdc.be.model.jsontitan.operations; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.HashMap; -import java.util.List; -import java.util.Map; - +import fj.data.Either; import org.junit.Before; import org.junit.BeforeClass; import org.junit.Rule; @@ -28,7 +20,10 @@ import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; -import fj.data.Either; +import java.util.*; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; /** * Created by chaya on 6/12/2017. @@ -42,10 +37,10 @@ public class ToscaElementOperationTest extends ModelTestBase{ private boolean isInitialized = false; @javax.annotation.Resource - ToscaElementOperationTestImpl toscaElementOperation; + private ToscaElementOperationTestImpl toscaElementOperation; @javax.annotation.Resource - TitanDao titanDao; + private TitanDao titanDao; @BeforeClass public static void initTest(){ @@ -271,7 +266,7 @@ public class ToscaElementOperationTest extends ModelTestBase{ } private void initGraphForTest() { - GraphTestUtils.createRootCatalogVertex(titanDao); + GraphTestUtils.createRootCatalogVertex(titanDao); Map<GraphPropertyEnum, Object> highstVerticesProps = new HashMap<GraphPropertyEnum, Object>() { { diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaElementOperationTestImpl.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaElementOperationTestImpl.java index da3ae71399..27fbce4776 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaElementOperationTestImpl.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaElementOperationTestImpl.java @@ -1,5 +1,6 @@ package org.openecomp.sdc.be.model.jsontitan.operations; +import fj.data.Either; import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum; import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; @@ -8,8 +9,6 @@ import org.openecomp.sdc.be.model.ComponentParametersView; import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElement; import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; -import fj.data.Either; - /** * Created by cb478c on 6/13/2017. */ 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 index 9b31b0bfd7..05688304d1 100644 --- 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 @@ -1,16 +1,6 @@ package org.openecomp.sdc.be.model.jsontitan.operations; -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; - -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.stream.Collectors; - +import fj.data.Either; import org.junit.After; import org.junit.Before; import org.junit.BeforeClass; @@ -19,12 +9,8 @@ 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; @@ -35,14 +21,21 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; -import fj.data.Either; +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 @@ -126,11 +119,7 @@ public class ToscaOperationFacadePoliciesTest extends ModelTestBase { } 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()); + GraphVertex resource = createBasicContainerGraphVertex(); Either<GraphVertex, TitanOperationStatus> container = titanDao.createVertex(resource); assertTrue(container.isLeft()); } 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 46ef5f39f0..851800def8 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,19 +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.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; - -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; @@ -21,7 +8,7 @@ import org.mockito.ArgumentCaptor; import org.mockito.InjectMocks; import org.mockito.Mock; import org.mockito.MockitoAnnotations; -import org.mockito.runners.MockitoJUnitRunner; +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; @@ -37,7 +24,17 @@ 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.assertSame; +import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.*; +import static org.mockito.Mockito.when; @RunWith(MockitoJUnitRunner.class) public class ToscaOperationFacadeTest { @@ -106,73 +103,73 @@ public class ToscaOperationFacadeTest { @Test public void associatePolicyToComponentSuccessTest(){ - Either<PolicyDefinition, StorageOperationStatus> result = associatePolicyToComponentWithStatus(StorageOperationStatus.OK); - assertTrue(result.isLeft()); + Either<PolicyDefinition, StorageOperationStatus> result = associatePolicyToComponentWithStatus(StorageOperationStatus.OK); + assertTrue(result.isLeft()); } - @Test + @Test public void associatePolicyToComponentFailureTest(){ - Either<PolicyDefinition, StorageOperationStatus> result = associatePolicyToComponentWithStatus(StorageOperationStatus.BAD_REQUEST); - assertTrue(result.isRight() && result.right().value() == StorageOperationStatus.BAD_REQUEST); + 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()); + Either<PolicyDefinition, StorageOperationStatus> result = updatePolicyOfComponentWithStatus(StorageOperationStatus.OK); + assertTrue(result.isLeft()); } - @Test + @Test public void updatePolicyOfComponentFailureTest(){ - Either<PolicyDefinition, StorageOperationStatus> result = updatePolicyOfComponentWithStatus(StorageOperationStatus.NOT_FOUND); - assertTrue(result.isRight() && result.right().value() == StorageOperationStatus.NOT_FOUND); + Either<PolicyDefinition, StorageOperationStatus> result = updatePolicyOfComponentWithStatus(StorageOperationStatus.NOT_FOUND); + assertTrue(result.isRight() && result.right().value() == StorageOperationStatus.NOT_FOUND); } @Test public void removePolicyFromComponentSuccessTest(){ - removePolicyFromComponentWithStatus(StorageOperationStatus.OK); + removePolicyFromComponentWithStatus(StorageOperationStatus.OK); } @Test public void removePolicyFromComponentFailureTest(){ - removePolicyFromComponentWithStatus(StorageOperationStatus.NOT_FOUND); + 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); + 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); - } + 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); + assertSame(result, status); + } private List<GraphVertex> getMockVertices(int numOfVertices) { return IntStream.range(0, numOfVertices).mapToObj(i -> getTopologyTemplateVertex()).collect(Collectors.toList()); diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/UpgradeOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/UpgradeOperationTest.java new file mode 100644 index 0000000000..acb9af6a33 --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/UpgradeOperationTest.java @@ -0,0 +1,183 @@ +package org.openecomp.sdc.be.model.jsontitan.operations; + +import fj.data.Either; +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.api.ActionStatus; +import org.openecomp.sdc.be.dao.jsongraph.TitanDao; +import org.openecomp.sdc.be.dao.jsongraph.utils.IdBuilderUtils; +import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; +import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; +import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; +import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; +import org.openecomp.sdc.be.model.*; +import org.openecomp.sdc.be.model.category.CategoryDefinition; +import org.openecomp.sdc.be.model.category.SubCategoryDefinition; +import org.openecomp.sdc.be.model.jsontitan.datamodel.TopologyTemplate; +import org.openecomp.sdc.be.model.jsontitan.utils.GraphTestUtils; +import org.openecomp.sdc.be.model.operations.api.IElementOperation; +import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; +import org.openecomp.sdc.be.model.operations.impl.UserAdminOperation; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +import javax.annotation.Resource; +import java.util.ArrayList; +import java.util.List; + +import static org.assertj.core.api.Assertions.assertThat; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration("classpath:application-context-test.xml") +public class UpgradeOperationTest extends ModelTestBase { + + private boolean isInitialized; + @Resource + private TitanDao titanDao; + @Resource + private UpgradeOperation upgradeOperation; + @Resource + private TopologyTemplateOperation topologyTemplateOperation; + @Resource + private NodeTemplateOperation nodeTemplateOperation; + @Resource + private UserAdminOperation userAdminOperation; + @javax.annotation.Resource + private IElementOperation elementOperation; + + private User user; + + private CategoryDefinition resourceCategory; + private CategoryDefinition serviceCategory; + + + @BeforeClass + public static void initTest() { + ModelTestBase.init(); + } + + @Before + public void beforeTest() { + if (!isInitialized) { + GraphTestUtils.clearGraph(titanDao); + initGraphForTest(); + isInitialized = true; + } + } + + @Test + public void testGetSimpleDependency() { + + TopologyTemplate vf = createVf("vf1"); + + TopologyTemplate service = createServiceWitnInstance("service1", vf); + + + Either<List<ComponentDependency>, StorageOperationStatus> result = upgradeOperation.getComponentDependencies(vf.getUniqueId()); + assertThat(result.isLeft()).isTrue(); + List<ComponentDependency> dependencies = result.left().value(); + assertThat(dependencies).hasSize(1); + + ComponentDependency dependency = dependencies.get(0); + assertThat(dependency.getName()).isEqualTo(vf.getName()); + assertThat(dependency.getVersion()).isEqualTo(vf.getVersion()); + assertThat(dependency.getDependencies()).hasSize(1); + + ComponentDependency container = dependency.getDependencies().get(0); + assertThat(container.getName()).isEqualTo(service.getName()); + assertThat(container.getVersion()).isEqualTo(service.getVersion()); + assertThat(container.getDependencies()).isNull(); + + } + + /******************************* + * Preperation Methods + *******************************/ + private void initGraphForTest() { + + user = new User("Jim", "Tom", "jt123a", "1@mail.com", "DESIGNER", System.currentTimeMillis()); + Either<User, StorageOperationStatus> saveUserData = userAdminOperation.saveUserData(user); + assertThat(saveUserData.isLeft()).isTrue(); + + GraphTestUtils.createRootCatalogVertex(titanDao); + resourceCategory = createResourceCategories(); + serviceCategory = createServiceCategory(); + + } + + private TopologyTemplate createServiceWitnInstance(String name, TopologyTemplate createdVf) { + + TopologyTemplate serviceNew = createTopologyTemplate(ComponentTypeEnum.SERVICE, name); + List<CategoryDefinition> categoriesService = new ArrayList<>(); + categoriesService.add(serviceCategory); + serviceNew.setCategories(categoriesService); + + Either<TopologyTemplate, StorageOperationStatus> createService = topologyTemplateOperation.createTopologyTemplate(serviceNew); + assertThat(createService.isLeft()).isTrue(); + + ComponentInstance vfInstance = new ComponentInstance(); + vfInstance.setUniqueId(createdVf.getUniqueId() + createdVf.getName()); + vfInstance.setComponentUid(createdVf.getUniqueId()); + vfInstance.setName(createdVf.getName()); + Either<ImmutablePair<TopologyTemplate, String>, StorageOperationStatus> addInstance = nodeTemplateOperation.addComponentInstanceToTopologyTemplate(serviceNew, createdVf, "0", vfInstance, false, user); + assertThat(addInstance.isLeft()).isTrue(); + return serviceNew; + } + + private CategoryDefinition createServiceCategory() { + CategoryDefinition categoryService = new CategoryDefinition(); + categoryService.setName("servicecategory"); + categoryService.setNormalizedName("servicecategory"); + categoryService.setUniqueId("servicecategory"); + Either<CategoryDefinition, ActionStatus> createCategory = elementOperation.createCategory(categoryService , NodeTypeEnum.ServiceNewCategory); + + assertThat(createCategory.isLeft()).isTrue(); + return categoryService; + } + + private TopologyTemplate createVf(String name) { + + TopologyTemplate resource = createTopologyTemplate(ComponentTypeEnum.RESOURCE, name); + + resource.setResourceType(ResourceTypeEnum.VF); + List<CategoryDefinition> categories = new ArrayList<>(); + categories.add(resourceCategory); + resource.setCategories(categories); + Either<TopologyTemplate, StorageOperationStatus> createVf = topologyTemplateOperation.createTopologyTemplate(resource); + assertThat( createVf.isLeft()).isTrue(); + return resource; + } + + private CategoryDefinition createResourceCategories() { + CategoryDefinition category = new CategoryDefinition(); + category.setName("category1"); + category.setNormalizedName("category1"); + category.setUniqueId("category1"); + Either<CategoryDefinition, ActionStatus> createCategory = elementOperation.createCategory(category , NodeTypeEnum.ResourceNewCategory); + assertThat(createCategory.isLeft()).isTrue(); + + SubCategoryDefinition subCategory = new SubCategoryDefinition(); + + subCategory.setName("subcategory1"); + subCategory.setNormalizedName("subcategory1"); + subCategory.setUniqueId("subcategory1"); + elementOperation.createSubCategory(createCategory.left().value().getUniqueId(), subCategory, NodeTypeEnum.ResourceSubcategory); + category.addSubCategory(subCategory); + return category; + } + + private TopologyTemplate createTopologyTemplate(ComponentTypeEnum type, String name) { + TopologyTemplate template = new TopologyTemplate(); + template.setUniqueId(IdBuilderUtils.generateUniqueId()); + template.setComponentType(type); + template.setHighestVersion(true); + template.setLifecycleState(LifecycleStateEnum.CERTIFIED); + template.setMetadataValue(JsonPresentationFields.NAME, name); + template.setMetadataValue(JsonPresentationFields.VERSION, "1.0"); + template.setCreatorUserId(user.getUserId()); + return template; + } +} 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 72919b6136..71dd472a1c 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 @@ -20,14 +20,9 @@ package org.openecomp.sdc.be.model.jsontitan.utils; -import java.io.BufferedOutputStream; -import java.io.File; -import java.io.FileOutputStream; -import java.io.OutputStream; -import java.util.Iterator; -import java.util.Map; -import java.util.UUID; - +import com.thinkaurelius.titan.core.TitanGraph; +import com.thinkaurelius.titan.core.TitanVertex; +import fj.data.Either; import org.apache.tinkerpop.gremlin.structure.io.IoCore; import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; import org.openecomp.sdc.be.dao.jsongraph.TitanDao; @@ -38,18 +33,29 @@ import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; -import com.thinkaurelius.titan.core.TitanGraph; -import com.thinkaurelius.titan.core.TitanVertex; - -import fj.data.Either; +import java.io.BufferedOutputStream; +import java.io.File; +import java.io.FileOutputStream; +import java.io.OutputStream; +import java.util.Iterator; +import java.util.Map; +import java.util.UUID; 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 createRootCatalogVertex(TitanDao titanDao) { + GraphVertex catalogRootVertex = new GraphVertex(VertexTypeEnum.CATALOG_ROOT); + catalogRootVertex.setUniqueId(IdBuilderUtils.generateUniqueId()); + return titanDao.createVertex(catalogRootVertex) + .either(v -> v, s -> null); + } + + public static GraphVertex createRootArchiveVertex(TitanDao titanDao) { + GraphVertex archiveRootVertex = new GraphVertex(VertexTypeEnum.ARCHIVE_ROOT); + archiveRootVertex.setUniqueId(IdBuilderUtils.generateUniqueId()); + return titanDao.createVertex(archiveRootVertex) + .either(v -> v, s -> null); + } public static GraphVertex createResourceVertex(TitanDao titanDao, Map<GraphPropertyEnum,Object> metadataProps, ResourceTypeEnum type) { GraphVertex vertex = new GraphVertex(); diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/utils/InterfaceUtilsTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/utils/InterfaceUtilsTest.java index 9a7ccc7f26..9d44232cd0 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/utils/InterfaceUtilsTest.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/utils/InterfaceUtilsTest.java @@ -1,15 +1,15 @@ package org.openecomp.sdc.be.model.jsontitan.utils; -import java.util.Collection; -import java.util.List; -import java.util.Map; -import java.util.Optional; - import org.junit.Test; import org.openecomp.sdc.be.model.InterfaceDefinition; import org.openecomp.sdc.be.model.Operation; import org.openecomp.sdc.be.model.Resource; +import java.util.Collection; +import java.util.List; +import java.util.Map; +import java.util.Optional; + public class InterfaceUtilsTest { private InterfaceUtils createTestSubject() { |