diff options
Diffstat (limited to 'catalog-model/src/test/java')
4 files changed, 617 insertions, 0 deletions
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 new file mode 100644 index 0000000000..3f80806292 --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ArtifactsOperationsTest.java @@ -0,0 +1,85 @@ +package org.openecomp.sdc.be.model.jsontitan.operations; + +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; +import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.MapArtifactDataDefinition; +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 java.util.Collections; +import java.util.HashMap; +import java.util.Map; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.*; + +public class ArtifactsOperationsTest { + + private static final String SERVICE_ID = "serviceId"; + private static final String INSTANCE_ID = "instanceId"; + private ArtifactsOperations testInstance = mock(ArtifactsOperations.class, CALLS_REAL_METHODS); + + @Test + public void getInstanceArtifacts_collectAllInstanceArtifacts() throws Exception { + Map<String, ToscaDataDefinition> instanceArtifacts = Collections.singletonMap(INSTANCE_ID, getArtifactsByInstance("name1")); + + Map<String, ToscaDataDefinition> instanceDeploymentArtifacts = new HashMap<>(); + instanceDeploymentArtifacts.put(INSTANCE_ID, getArtifactsByInstance("name2", "name3")); + instanceDeploymentArtifacts.put("instanceId2", getArtifactsByInstance("name4")); + + doReturn(Either.left(instanceArtifacts)).when(testInstance).getDataFromGraph(SERVICE_ID, EdgeLabelEnum.INSTANCE_ARTIFACTS); + doReturn(Either.left(instanceDeploymentArtifacts)).when(testInstance).getDataFromGraph(SERVICE_ID, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS); + Either<Map<String, ArtifactDefinition>, StorageOperationStatus> allInstArtifacts = testInstance.getAllInstanceArtifacts(SERVICE_ID, INSTANCE_ID); + + assertTrue(allInstArtifacts.isLeft()); + assertEquals(allInstArtifacts.left().value().size(), 3); + assertTrue(allInstArtifacts.left().value().containsKey("name1")); + assertTrue(allInstArtifacts.left().value().containsKey("name2")); + assertTrue(allInstArtifacts.left().value().containsKey("name3")); + assertFalse(allInstArtifacts.left().value().containsKey("name4"));//this key is of different instance + } + + @Test + public void getInstanceArtifacts_noArtifactsForInstance() throws Exception { + Map<String, ToscaDataDefinition> instanceArtifacts = Collections.singletonMap(INSTANCE_ID, getArtifactsByInstance("name1")); + + doReturn(Either.left(instanceArtifacts)).when(testInstance).getDataFromGraph(SERVICE_ID, EdgeLabelEnum.INSTANCE_ARTIFACTS); + doReturn(Either.left(new HashMap<>())).when(testInstance).getDataFromGraph(SERVICE_ID, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS); + Either<Map<String, ArtifactDefinition>, StorageOperationStatus> allInstArtifacts = testInstance.getAllInstanceArtifacts(SERVICE_ID, "someOtherInstance"); + + assertTrue(allInstArtifacts.isLeft()); + assertTrue(allInstArtifacts.left().value().isEmpty()); + } + + @Test + public void getInstanceArtifacts_errorGettingInstanceArtifacts() throws Exception { + doReturn(Either.right(TitanOperationStatus.GENERAL_ERROR)).when(testInstance).getDataFromGraph(SERVICE_ID, EdgeLabelEnum.INSTANCE_ARTIFACTS); + Either<Map<String, ArtifactDefinition>, StorageOperationStatus> allInstArtifacts = testInstance.getAllInstanceArtifacts(SERVICE_ID, INSTANCE_ID); + verify(testInstance, times(0)).getDataFromGraph(SERVICE_ID, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS); + assertTrue(allInstArtifacts.isRight()); + } + + @Test + public void getAllInstanceArtifacts_errorGettingDeploymentArtifacts() throws Exception { + doReturn(Either.left(new HashMap<>())).when(testInstance).getDataFromGraph(SERVICE_ID, EdgeLabelEnum.INSTANCE_ARTIFACTS); + doReturn(Either.right(TitanOperationStatus.GENERAL_ERROR)).when(testInstance).getDataFromGraph(SERVICE_ID, EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS); + Either<Map<String, ArtifactDefinition>, StorageOperationStatus> allInstArtifacts = testInstance.getAllInstanceArtifacts(SERVICE_ID, INSTANCE_ID); + assertTrue(allInstArtifacts.isRight()); + } + + private ToscaDataDefinition getArtifactsByInstance(String ... artifactsNames) { + MapArtifactDataDefinition artifactsByInstance = new MapArtifactDataDefinition(); + Map<String, ArtifactDataDefinition> artifactsByName = new HashMap<>(); + for (String artifactName : artifactsNames) { + artifactsByName.put(artifactName, new ArtifactDataDefinition()); + } + artifactsByInstance.setMapToscaDataDefinition(artifactsByName); + return artifactsByInstance; + } +} 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 new file mode 100644 index 0000000000..339023f9a4 --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaElementOperationTest.java @@ -0,0 +1,344 @@ +package org.openecomp.sdc.be.model.jsontitan.operations; + +import fj.data.Either; +import org.apache.cassandra.cql3.CQL3Type; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.TestName; +import org.junit.runner.RunWith; +import org.openecomp.sdc.be.dao.jsongraph.GraphVertex; +import org.openecomp.sdc.be.dao.jsongraph.TitanDao; +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 org.openecomp.sdc.be.model.LifecycleStateEnum; +import org.openecomp.sdc.be.model.ModelTestBase; +import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElement; +import org.openecomp.sdc.be.model.jsontitan.utils.GraphTestUtils; +import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +import java.util.*; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +/** + * Created by chaya on 6/12/2017. + */ + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration("classpath:application-context-test.xml") +public class ToscaElementOperationTest extends ModelTestBase{ + + private List<GraphVertex> allVertices = new ArrayList<>(); + private boolean isInitialized = false; + + @javax.annotation.Resource + ToscaElementOperationTestImpl toscaElementOperation; + + @javax.annotation.Resource + TitanDao titanDao; + + @BeforeClass + public static void initTest(){ + ModelTestBase.init(); + + } + + @Rule + public TestName testName = new TestName(); + + @Before + public void beforeTest() { + if (!isInitialized) { + GraphTestUtils.clearGraph(titanDao); + //exportGraphMl(titanDao.getGraph().left().value(),""); + initGraphForTest(); + isInitialized = true; + } + } + + @Test + public void testGetAllHighestResourcesNoFilter() { + + Either<List<ToscaElement>, StorageOperationStatus> highestResourcesRes = toscaElementOperation.getElementCatalogData(ComponentTypeEnum.RESOURCE, null, true); + assertTrue(highestResourcesRes.isLeft()); + List<ToscaElement> highestResources = highestResourcesRes.left().value(); + // calculate expected count value + long highestResourcesExpectedCount = calculateCount(new HashMap<GraphPropertyEnum, Object>() { + { + put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.RESOURCE.name()); + } + }, null); + assertEquals(highestResources.stream().count(), highestResourcesExpectedCount); + } + + @Test + public void testGetAllResourcesCertifiedNoFilter() { + Either<List<ToscaElement>, StorageOperationStatus> highestResourcesRes = toscaElementOperation.getElementCatalogData(ComponentTypeEnum.RESOURCE, null, false); + assertTrue(highestResourcesRes.isLeft()); + List<ToscaElement> highestResources = highestResourcesRes.left().value(); + // calculate expected count value + long highestResourcesExpectedCount = calculateCount(new HashMap<GraphPropertyEnum, Object>() { + { + put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.RESOURCE.name()); + put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + } + }, null); + highestResourcesExpectedCount += calculateCount(new HashMap<GraphPropertyEnum, Object>() { + { + put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.RESOURCE.name()); + put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); + } + }, new HashMap<GraphPropertyEnum, Object>() { + { + put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + } + }); + assertEquals(highestResources.stream().count(), highestResourcesExpectedCount); + } + + @Test + public void testGetHighestResourcesExclude() { + + // exclude VFCMT + List<ResourceTypeEnum> excludeList = Arrays.asList(ResourceTypeEnum.VFCMT); + assertTrue(genericTestGetResourcesWithExcludeList(excludeList)); + + // exclude CP & VL + excludeList = Arrays.asList(ResourceTypeEnum.VL, ResourceTypeEnum.CP); + assertTrue(genericTestGetResourcesWithExcludeList(excludeList)); + + // exclude CP & VL & VF & VFC + excludeList = Arrays.asList(ResourceTypeEnum.VL, ResourceTypeEnum.CP, ResourceTypeEnum.VF, ResourceTypeEnum.VFC); + assertTrue(genericTestGetResourcesWithExcludeList(excludeList)); + } + + @Test + public void testGetAllResourcesCertifiedExclude() { + // exclude VFCMT + List<ResourceTypeEnum> excludeList = Arrays.asList(ResourceTypeEnum.VFCMT); + assertTrue(genericTestGetCertifiedResourcesWithExcludeList(excludeList)); + + // exclude CP & VL + excludeList = Arrays.asList(ResourceTypeEnum.VL, ResourceTypeEnum.CP); + assertTrue(genericTestGetCertifiedResourcesWithExcludeList(excludeList)); + + // exclude CP & VL & VF & VFC + excludeList = Arrays.asList(ResourceTypeEnum.VL, ResourceTypeEnum.CP, ResourceTypeEnum.VF, ResourceTypeEnum.VFC); + assertTrue(genericTestGetCertifiedResourcesWithExcludeList(excludeList)); + } + + @Test + public void testGetAllHighestServicesNoFilter() { + Either<List<ToscaElement>, StorageOperationStatus> highestResourcesRes = toscaElementOperation.getElementCatalogData(ComponentTypeEnum.SERVICE, null, true); + assertTrue(highestResourcesRes.isLeft()); + List<ToscaElement> highestResources = highestResourcesRes.left().value(); + // calculate expected count value + long highestResourcesExpectedCount = calculateCount(new HashMap<GraphPropertyEnum, Object>() { + { + put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name()); + } + }, null); + assertEquals(highestResources.stream().count(), highestResourcesExpectedCount); + } + + @Test + public void testGetAllCertifiedServicesNoFilter() { + Either<List<ToscaElement>, StorageOperationStatus> highestResourcesRes = toscaElementOperation.getElementCatalogData(ComponentTypeEnum.SERVICE, null, false); + assertTrue(highestResourcesRes.isLeft()); + List<ToscaElement> highestResources = highestResourcesRes.left().value(); + // calculate expected count value + long highestResourcesExpectedCount = calculateCount(new HashMap<GraphPropertyEnum, Object>() { + { + put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name()); + put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + } + }, null); + highestResourcesExpectedCount += calculateCount(new HashMap<GraphPropertyEnum, Object>() { + { + put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name()); + put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); + } + }, new HashMap<GraphPropertyEnum, Object>() { + { + put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + } + }); + assertEquals(highestResources.stream().count(), highestResourcesExpectedCount); + } + + @Test + public void testGetServicesExcludeList() { + List<ResourceTypeEnum> excludeList = Arrays.asList(ResourceTypeEnum.VF, ResourceTypeEnum.VFCMT); + Either<List<ToscaElement>, StorageOperationStatus> highestResourcesRes = toscaElementOperation.getElementCatalogData(ComponentTypeEnum.SERVICE, excludeList, true); + assertTrue(highestResourcesRes.isLeft()); + List<ToscaElement> highestResources = highestResourcesRes.left().value(); + // calculate expected count value + long highestResourcesExpectedCount = calculateCount(new HashMap<GraphPropertyEnum, Object>() { + { + put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name()); + } + }, null); + assertEquals(highestResources.stream().count(), highestResourcesExpectedCount); + } + + @Test + public void testGetCertifiedServicesExcludeList() { + List<ResourceTypeEnum> excludeList = Arrays.asList(ResourceTypeEnum.VL); + Either<List<ToscaElement>, StorageOperationStatus> highestResourcesRes = toscaElementOperation.getElementCatalogData(ComponentTypeEnum.SERVICE, excludeList, false); + assertTrue(highestResourcesRes.isLeft()); + List<ToscaElement> highestResources = highestResourcesRes.left().value(); + // calculate expected count value + long highestResourcesExpectedCount = calculateCount(new HashMap<GraphPropertyEnum, Object>() { + { + put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name()); + put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); + } + }, null); + highestResourcesExpectedCount += calculateCount(new HashMap<GraphPropertyEnum, Object>() { + { + put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name()); + put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + } + }, new HashMap<GraphPropertyEnum, Object>() { + { + put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); + } + }); + assertEquals(highestResources.stream().count(), highestResourcesExpectedCount); + } + + private boolean genericTestGetResourcesWithExcludeList(List<ResourceTypeEnum> excludeList) { + Either<List<ToscaElement>, StorageOperationStatus> highestResourcesRes = toscaElementOperation.getElementCatalogData(ComponentTypeEnum.RESOURCE,excludeList, true); + assertTrue(highestResourcesRes.isLeft()); + List<ToscaElement> highestResources = highestResourcesRes.left().value(); + // calculate expected count value + long highestResourcesExpectedCount = calculateCount(new HashMap<GraphPropertyEnum, Object>() { + { + put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.RESOURCE.name()); + } + }, new HashMap<GraphPropertyEnum, Object>() { + { + put(GraphPropertyEnum.RESOURCE_TYPE, excludeList); + } + }); + return highestResources.stream().count() == (highestResourcesExpectedCount); + } + + private boolean genericTestGetCertifiedResourcesWithExcludeList(List<ResourceTypeEnum> excludeList) { + Either<List<ToscaElement>, StorageOperationStatus> highestResourcesRes = toscaElementOperation.getElementCatalogData(ComponentTypeEnum.RESOURCE, excludeList, false); + assertTrue(highestResourcesRes.isLeft()); + List<ToscaElement> highestResources = highestResourcesRes.left().value(); + // calculate expected count value + long highestResourcesExpectedCount = calculateCount(new HashMap<GraphPropertyEnum, Object>() { + { + put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.RESOURCE.name()); + put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + } + }, new HashMap<GraphPropertyEnum, Object>() { + { + put(GraphPropertyEnum.RESOURCE_TYPE, excludeList); + } + }); + highestResourcesExpectedCount += calculateCount(new HashMap<GraphPropertyEnum, Object>() { + { + put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.RESOURCE.name()); + put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); + } + }, new HashMap<GraphPropertyEnum, Object>() { + { + put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + put(GraphPropertyEnum.RESOURCE_TYPE, excludeList); + } + }); + return highestResources.stream().count() == highestResourcesExpectedCount; + } + + private void initGraphForTest() { + Map<GraphPropertyEnum, Object> highstVerticesProps = new HashMap<GraphPropertyEnum, Object>() { + { + put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + } + }; + + Map<GraphPropertyEnum, Object> certifiedVerticesProps = new HashMap<GraphPropertyEnum, Object>() { + { + put(GraphPropertyEnum.IS_HIGHEST_VERSION, true); + put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name()); + } + }; + + // add vertices with higestVersion = true + allVertices.add(GraphTestUtils.createResourceVertex(titanDao, highstVerticesProps, ResourceTypeEnum.VF)); + allVertices.add(GraphTestUtils.createResourceVertex(titanDao, highstVerticesProps, ResourceTypeEnum.VFC)); + allVertices.add(GraphTestUtils.createResourceVertex(titanDao, highstVerticesProps, ResourceTypeEnum.VFCMT)); + allVertices.add(GraphTestUtils.createResourceVertex(titanDao, highstVerticesProps, ResourceTypeEnum.VL)); + allVertices.add(GraphTestUtils.createResourceVertex(titanDao, highstVerticesProps, ResourceTypeEnum.CP)); + allVertices.add(GraphTestUtils.createServiceVertex(titanDao, highstVerticesProps)); + + // add vertices with non-additional properties + for (int i=0 ; i<2 ; i++) { + allVertices.add(GraphTestUtils.createResourceVertex(titanDao, new HashMap<>(), ResourceTypeEnum.VF)); + allVertices.add(GraphTestUtils.createResourceVertex(titanDao, new HashMap<>(), ResourceTypeEnum.VFC)); + allVertices.add(GraphTestUtils.createResourceVertex(titanDao, new HashMap<>(), ResourceTypeEnum.VFCMT)); + allVertices.add(GraphTestUtils.createResourceVertex(titanDao, new HashMap<>(), ResourceTypeEnum.VL)); + allVertices.add(GraphTestUtils.createResourceVertex(titanDao, new HashMap<>(), ResourceTypeEnum.CP)); + allVertices.add(GraphTestUtils.createServiceVertex(titanDao, new HashMap<>())); + } + + // add certified vertices + for (int i=0; i<3; i++) { + allVertices.add(GraphTestUtils.createResourceVertex(titanDao, certifiedVerticesProps, ResourceTypeEnum.VF)); + allVertices.add(GraphTestUtils.createResourceVertex(titanDao, certifiedVerticesProps, ResourceTypeEnum.VFC)); + allVertices.add(GraphTestUtils.createResourceVertex(titanDao, certifiedVerticesProps, ResourceTypeEnum.VFCMT)); + allVertices.add(GraphTestUtils.createResourceVertex(titanDao, certifiedVerticesProps, ResourceTypeEnum.VL)); + allVertices.add(GraphTestUtils.createResourceVertex(titanDao, certifiedVerticesProps, ResourceTypeEnum.CP)); + allVertices.add(GraphTestUtils.createServiceVertex(titanDao, certifiedVerticesProps)); + } + //allVertices.stream().forEach( v -> System.out.println("type: "+v.getMetadataProperty(GraphPropertyEnum.COMPONENT_TYPE))); + //String result = GraphTestUtils.exportGraphMl(titanDao.getGraph().left().value(), ""); + //System.out.println("graph is: " + result); + } + + private long calculateCount(HashMap<GraphPropertyEnum, Object> hasProps, Map<GraphPropertyEnum, Object> doesntHaveProps){ + return allVertices.stream(). + filter(v -> { + Map<GraphPropertyEnum, Object> vertexProps = v.getMetadataProperties(); + if (hasProps != null) { + for (Map.Entry<GraphPropertyEnum, Object> prop: hasProps.entrySet()){ + Object value = vertexProps.get(prop.getKey()); + if ( value == null || !value.equals(prop.getValue())) { + return false; + } + } + } + + if (doesntHaveProps != null) { + for (Map.Entry<GraphPropertyEnum, Object> prop : doesntHaveProps.entrySet()) { + Object value = vertexProps.get(prop.getKey()); + Object propValue = prop.getValue(); + if ( value != null && propValue != null && propValue instanceof List ) { + for (ResourceTypeEnum propVal : (List<ResourceTypeEnum>)propValue) { + if (propVal.name().equals(value)) { + return false; + } + } + } + else if (value != null && value.equals(propValue)){ + return false; + } + } + } + return true; + }).count(); + } +} 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 new file mode 100644 index 0000000000..27fbce4776 --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ToscaElementOperationTestImpl.java @@ -0,0 +1,74 @@ +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; +import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; +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; + +/** + * Created by cb478c on 6/13/2017. + */ +@org.springframework.stereotype.Component("test-tosca-element-operation") +public class ToscaElementOperationTestImpl extends ToscaElementOperation { + + @Override + protected <T extends ToscaElement> Either<T, StorageOperationStatus> getLightComponent(GraphVertex vertexComponent, ComponentTypeEnum nodeType, ComponentParametersView parametersFilter) { + titanDao.parseVertexProperties(vertexComponent, JsonParseFlagEnum.ParseMetadata); + T toscaElement = convertToComponent(vertexComponent); + return Either.left(toscaElement); + } + + @Override + public <T extends ToscaElement> Either<T, StorageOperationStatus> getToscaElement(String uniqueId, ComponentParametersView componentParametersView) { + return null; + } + + @Override + public <T extends ToscaElement> Either<T, StorageOperationStatus> getToscaElement(GraphVertex toscaElementVertex, ComponentParametersView componentParametersView) { + return null; + } + + @Override + public <T extends ToscaElement> Either<T, StorageOperationStatus> deleteToscaElement(GraphVertex toscaElementVertex) { + return null; + } + + @Override + public <T extends ToscaElement> Either<T, StorageOperationStatus> createToscaElement(ToscaElement toscaElement) { + return null; + } + + @Override + protected <T extends ToscaElement> TitanOperationStatus setCategoriesFromGraph(GraphVertex vertexComponent, T toscaElement) { + return null; + } + + @Override + protected <T extends ToscaElement> TitanOperationStatus setCapabilitiesFromGraph(GraphVertex componentV, T toscaElement) { + return null; + } + + @Override + protected <T extends ToscaElement> TitanOperationStatus setRequirementsFromGraph(GraphVertex componentV, T toscaElement) { + return null; + } + + @Override + protected <T extends ToscaElement> StorageOperationStatus validateCategories(T toscaElementToUpdate, GraphVertex elementV) { + return null; + } + + @Override + protected <T extends ToscaElement> StorageOperationStatus updateDerived(T toscaElementToUpdate, GraphVertex updateElementV) { + return null; + } + + @Override + public <T extends ToscaElement> void fillToscaElementVertexData(GraphVertex elementV, T toscaElementToUpdate, JsonParseFlagEnum flag) { + + } +} 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 new file mode 100644 index 0000000000..8e2a283559 --- /dev/null +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/utils/GraphTestUtils.java @@ -0,0 +1,114 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.sdc.be.model.jsontitan.utils; + +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; +import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; +import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; +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 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 GraphVertex createResourceVertex(TitanDao titanDao, Map<GraphPropertyEnum,Object> metadataProps, ResourceTypeEnum type) { + GraphVertex vertex = new GraphVertex(); + if (type == ResourceTypeEnum.VF) { + vertex.setLabel(VertexTypeEnum.TOPOLOGY_TEMPLATE); + vertex.addMetadataProperty(GraphPropertyEnum.LABEL, VertexTypeEnum.TOPOLOGY_TEMPLATE); + } else { + vertex.setLabel(VertexTypeEnum.NODE_TYPE); + vertex.addMetadataProperty(GraphPropertyEnum.LABEL, VertexTypeEnum.NODE_TYPE); + } + String uuid = UUID.randomUUID().toString(); + vertex.setUniqueId(uuid); + + vertex.addMetadataProperty(GraphPropertyEnum.UNIQUE_ID, uuid); + vertex.addMetadataProperty(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.RESOURCE.name()); + vertex.addMetadataProperty(GraphPropertyEnum.RESOURCE_TYPE, type.name()); + vertex.addMetadataProperty(GraphPropertyEnum.IS_ABSTRACT, false); + for (Map.Entry<GraphPropertyEnum, Object> prop : metadataProps.entrySet()) { + vertex.addMetadataProperty(prop.getKey(), prop.getValue()); + } + titanDao.createVertex(vertex); + titanDao.commit(); + return vertex; + } + + public static GraphVertex createServiceVertex(TitanDao titanDao, Map<GraphPropertyEnum, Object> metadataProps){ + GraphVertex vertex = new GraphVertex(VertexTypeEnum.TOPOLOGY_TEMPLATE); + String uuid = UUID.randomUUID().toString(); + vertex.setUniqueId(uuid); + vertex.addMetadataProperty(GraphPropertyEnum.LABEL, VertexTypeEnum.TOPOLOGY_TEMPLATE); + vertex.addMetadataProperty(GraphPropertyEnum.UNIQUE_ID, uuid); + vertex.addMetadataProperty(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name()); + for (Map.Entry<GraphPropertyEnum, Object> prop : metadataProps.entrySet()) { + vertex.addMetadataProperty(prop.getKey(), prop.getValue()); + } + titanDao.createVertex(vertex); + titanDao.commit(); + return vertex; + } + + public static void clearGraph(TitanDao titanDao) { + Either<TitanGraph, TitanOperationStatus> graphResult = titanDao.getGraph(); + TitanGraph graph = graphResult.left().value(); + + Iterable<TitanVertex> vertices = graph.query().vertices(); + if (vertices != null) { + Iterator<TitanVertex> iterator = vertices.iterator(); + while (iterator.hasNext()) { + TitanVertex vertex = iterator.next(); + vertex.remove(); + } + } + titanDao.commit(); + } + + public static String exportGraphMl(TitanGraph graph, String outputDirectory) { + 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; + graph.tx().commit(); + } catch (Exception e) { + graph.tx().rollback(); + e.printStackTrace(); + } + return result; + } +} |