From 2623c8402a57e2035db69a9d92d2851050916801 Mon Sep 17 00:00:00 2001 From: shrikantawachar Date: Mon, 20 May 2019 12:11:54 +0530 Subject: Upgrade SDC from Titan to Janus Graph Upgrade SDC from Titan to Janus Graph Change-Id: I67fb8b8e60cc6751697bc5ff2f06754c92803786 Issue-ID: SDC-2296 Signed-off-by: shrikantawachar --- .../be/dao/cassandra/HealingPipelineDaoTest.java | 36 +- .../sdc/be/dao/janusgraph/JanusGraphUtilsTest.java | 21 + .../sdc/be/dao/jsongraph/GraphVertexTest.java | 6 +- .../be/dao/jsongraph/JanusGraphDaoMockTest.java | 586 +++++++++++++++++++ .../sdc/be/dao/jsongraph/JanusGraphDaoTest.java | 312 ++++++++++ .../sdc/be/dao/jsongraph/TitanDaoMockTest.java | 586 ------------------- .../sdc/be/dao/jsongraph/TitanDaoTest.java | 312 ---------- .../openecomp/sdc/be/dao/titan/TitanUtilsTest.java | 21 - .../sdc/be/resources/JanusGraphGenericDaoTest.java | 630 ++++++++++++++++++++ .../sdc/be/resources/TitanGenericDaoTest.java | 631 --------------------- 10 files changed, 1570 insertions(+), 1571 deletions(-) create mode 100644 catalog-dao/src/test/java/org/openecomp/sdc/be/dao/janusgraph/JanusGraphUtilsTest.java create mode 100644 catalog-dao/src/test/java/org/openecomp/sdc/be/dao/jsongraph/JanusGraphDaoMockTest.java create mode 100644 catalog-dao/src/test/java/org/openecomp/sdc/be/dao/jsongraph/JanusGraphDaoTest.java delete mode 100644 catalog-dao/src/test/java/org/openecomp/sdc/be/dao/jsongraph/TitanDaoMockTest.java delete mode 100644 catalog-dao/src/test/java/org/openecomp/sdc/be/dao/jsongraph/TitanDaoTest.java delete mode 100644 catalog-dao/src/test/java/org/openecomp/sdc/be/dao/titan/TitanUtilsTest.java create mode 100644 catalog-dao/src/test/java/org/openecomp/sdc/be/resources/JanusGraphGenericDaoTest.java delete mode 100644 catalog-dao/src/test/java/org/openecomp/sdc/be/resources/TitanGenericDaoTest.java (limited to 'catalog-dao/src/test/java/org') diff --git a/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/cassandra/HealingPipelineDaoTest.java b/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/cassandra/HealingPipelineDaoTest.java index 83b68920b9..c0d9e4644c 100644 --- a/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/cassandra/HealingPipelineDaoTest.java +++ b/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/cassandra/HealingPipelineDaoTest.java @@ -17,10 +17,10 @@ package org.openecomp.sdc.be.dao.cassandra; import com.google.common.collect.ImmutableListMultimap; -import com.thinkaurelius.titan.core.TitanVertex; -import com.thinkaurelius.titan.graphdb.relations.StandardVertexProperty; -import com.thinkaurelius.titan.graphdb.types.system.EmptyVertex; -import com.thinkaurelius.titan.graphdb.types.system.ImplicitKey; +import org.janusgraph.core.JanusGraphVertex; +import org.janusgraph.graphdb.relations.StandardVertexProperty; +import org.janusgraph.graphdb.types.system.EmptyVertex; +import org.janusgraph.graphdb.types.system.ImplicitKey; import java.util.HashMap; import org.junit.Test; import org.mockito.Mockito; @@ -85,7 +85,7 @@ public class HealingPipelineDaoTest { } @Test - public void testPipelineFilter3AttributesTitanVertex() { + public void testPipelineFilter3AttributesJanusGraphVertex() { // init data HealingPipelineDao healingPipelineDao = new HealingPipelineDao(); healingPipelineDao.setHealVersion(7); @@ -95,16 +95,16 @@ public class HealingPipelineDaoTest { assertEquals(2, healingPipelineDao.getHealersForVertex(GraphEdgeLabels.CAPABILITY.getProperty(), HealVersionBuilder.build(5)).size()); - TitanVertex titanVertex = Mockito.mock(TitanVertex.class); + JanusGraphVertex janusGraphVertex = Mockito.mock(JanusGraphVertex.class); final int version = 5; StandardVertexProperty vertexProperty = new StandardVertexProperty(1, ImplicitKey.ID, new EmptyVertex(), version, (byte) 1); - Mockito.when(titanVertex.property(GraphPropertyEnum.HEALING_VERSION.getProperty())).thenReturn(vertexProperty); + Mockito.when(janusGraphVertex.property(GraphPropertyEnum.HEALING_VERSION.getProperty())).thenReturn(vertexProperty); // perform test - Optional optional = healingPipelineDao.performGraphReadHealing(titanVertex, GraphEdgeLabels.CAPABILITY); + Optional optional = healingPipelineDao.performGraphReadHealing(janusGraphVertex, GraphEdgeLabels.CAPABILITY); assertTrue(optional.isPresent()); - final TitanVertex changedVertex = (TitanVertex) optional.get(); + final JanusGraphVertex changedVertex = (JanusGraphVertex) optional.get(); //validate result assertNotNull(changedVertex); @@ -112,7 +112,7 @@ public class HealingPipelineDaoTest { } @Test - public void testPipelineFilterGenericTitanDao() { + public void testPipelineFilterGenericJanusGraphDao() { // init data HealingPipelineDao healingPipelineDao = new HealingPipelineDao(); healingPipelineDao.setHealVersion(7); @@ -140,7 +140,7 @@ public class HealingPipelineDaoTest { } @Test - public void testPipelineFilterTitanGraph1Attributes() { + public void testPipelineFilterJanusGraph1Attributes() { // init data HealingPipelineDao healingPipelineDao = new HealingPipelineDao(); healingPipelineDao.setHealVersion(7); @@ -217,9 +217,9 @@ public class HealingPipelineDaoTest { .put(GraphEdgeLabels.ATTRIBUTE.getProperty(), new GraphNodeHealTestMock(4)) .put(GraphEdgeLabels.ATTRIBUTE.getProperty(), new GraphNodeHealTestMock(5)) .put(GraphEdgeLabels.ATTRIBUTE.getProperty(), new GraphNodeHealTestMock(6)) - .put(GraphEdgeLabels.CAPABILITY.getProperty(), new TitanVertexHealTestMock(4)) - .put(GraphEdgeLabels.CAPABILITY.getProperty(), new TitanVertexHealTestMock(5)) - .put(GraphEdgeLabels.CAPABILITY.getProperty(), new TitanVertexHealTestMock(6)).build(); + .put(GraphEdgeLabels.CAPABILITY.getProperty(), new JanusGraphVertexHealTestMock(4)) + .put(GraphEdgeLabels.CAPABILITY.getProperty(), new JanusGraphVertexHealTestMock(5)) + .put(GraphEdgeLabels.CAPABILITY.getProperty(), new JanusGraphVertexHealTestMock(6)).build(); } public GraphEdge createGraphEdge(GraphEdgeLabels graphEdgeLabels){ @@ -247,7 +247,7 @@ public class HealingPipelineDaoTest { } - private class GraphNodeHealTestMock extends AbstractTitanVertexHeal { + private class GraphNodeHealTestMock extends AbstractJanusGraphVertexHeal { private HealVersion healVersion; public GraphNodeHealTestMock(int i) { @@ -266,10 +266,10 @@ public class HealingPipelineDaoTest { } - private class TitanVertexHealTestMock implements Heal { + private class JanusGraphVertexHealTestMock implements Heal { private HealVersion healVersion; - public TitanVertexHealTestMock(int i) { + public JanusGraphVertexHealTestMock(int i) { healVersion = HealVersionBuilder.build(i); } @@ -279,7 +279,7 @@ public class HealingPipelineDaoTest { } @Override - public void healData(TitanVertex parentV) { + public void healData(JanusGraphVertex parentV) { } } diff --git a/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/janusgraph/JanusGraphUtilsTest.java b/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/janusgraph/JanusGraphUtilsTest.java new file mode 100644 index 0000000000..b3fd59e8b6 --- /dev/null +++ b/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/janusgraph/JanusGraphUtilsTest.java @@ -0,0 +1,21 @@ +package org.openecomp.sdc.be.dao.janusgraph; + +import org.janusgraph.graphdb.query.JanusGraphPredicate; +import org.apache.tinkerpop.gremlin.structure.T; +import org.junit.Test; + +import java.util.Collection; +import java.util.Map; +import java.util.Map.Entry; +public class JanusGraphUtilsTest { + + @Test + public void testBuildNotInPredicate() throws Exception { + String propKey = ""; + Collection notInCollection = null; + Map> result; + + // default test + result = JanusGraphUtils.buildNotInPredicate(propKey, notInCollection); + } +} \ No newline at end of file diff --git a/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/jsongraph/GraphVertexTest.java b/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/jsongraph/GraphVertexTest.java index b336bc65e9..8ce20191fd 100644 --- a/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/jsongraph/GraphVertexTest.java +++ b/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/jsongraph/GraphVertexTest.java @@ -1,6 +1,6 @@ package org.openecomp.sdc.be.dao.jsongraph; -import com.thinkaurelius.titan.core.TitanVertex; +import org.janusgraph.core.JanusGraphVertex; import org.junit.Test; import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; @@ -70,7 +70,7 @@ public class GraphVertexTest { @Test public void testGetVertex() throws Exception { GraphVertex testSubject; - TitanVertex result; + JanusGraphVertex result; // default test testSubject = createTestSubject(); @@ -81,7 +81,7 @@ public class GraphVertexTest { @Test public void testSetVertex() throws Exception { GraphVertex testSubject; - TitanVertex vertex = null; + JanusGraphVertex vertex = null; // default test testSubject = createTestSubject(); diff --git a/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/jsongraph/JanusGraphDaoMockTest.java b/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/jsongraph/JanusGraphDaoMockTest.java new file mode 100644 index 0000000000..72a9d54336 --- /dev/null +++ b/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/jsongraph/JanusGraphDaoMockTest.java @@ -0,0 +1,586 @@ +package org.openecomp.sdc.be.dao.jsongraph; + +import org.janusgraph.core.JanusGraph; +import org.janusgraph.core.JanusGraphVertex; +import fj.data.Either; +import mockit.Deencapsulation; +import org.apache.commons.lang3.tuple.ImmutablePair; +import org.apache.tinkerpop.gremlin.structure.Direction; +import org.apache.tinkerpop.gremlin.structure.Edge; +import org.apache.tinkerpop.gremlin.structure.Element; +import org.apache.tinkerpop.gremlin.structure.Vertex; +import org.junit.Before; +import org.junit.Test; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; +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.JsonParseFlagEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphClient; +import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; + +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; + +public class JanusGraphDaoMockTest { + + @InjectMocks + JanusGraphDao testSubject; + + @Mock + JanusGraphClient janusGraphClient; + + @Before + public void setUp() throws Exception { + MockitoAnnotations.initMocks(this); + } + + @Test + public void testCommit() throws Exception { + JanusGraphOperationStatus result; + + // default test + result = testSubject.commit(); + } + + @Test + public void testRollback() throws Exception { + JanusGraphOperationStatus result; + + // default test + result = testSubject.rollback(); + } + + @Test + public void testGetGraph() throws Exception { + + Either result; + + // default test + + result = testSubject.getGraph(); + } + + @Test + public void testCreateVertex() throws Exception { + + GraphVertex graphVertex = new GraphVertex(); + graphVertex.setLabel(VertexTypeEnum.ADDITIONAL_INFORMATION); + Either result; + + JanusGraph tg = Mockito.mock(JanusGraph.class); + Either value = Either.left(tg); + // default test + JanusGraphVertex value2 = Mockito.mock(JanusGraphVertex.class); + Mockito.when(tg.addVertex()).thenReturn(value2); + Mockito.when(janusGraphClient.getGraph()).thenReturn(value); + result = testSubject.createVertex(graphVertex); + } + + @Test + public void testCreateVertexErrorGetGraph() throws Exception { + + GraphVertex graphVertex = new GraphVertex(); + graphVertex.setLabel(VertexTypeEnum.ADDITIONAL_INFORMATION); + Either result; + + Either value = Either.right(JanusGraphOperationStatus.GENERAL_ERROR); + // default test + Mockito.when(janusGraphClient.getGraph()).thenReturn(value); + result = testSubject.createVertex(graphVertex); + } + + @Test + public void testCreateVertexException() throws Exception { + + GraphVertex graphVertex = new GraphVertex(); + graphVertex.setLabel(VertexTypeEnum.ADDITIONAL_INFORMATION); + Either result; + + JanusGraph tg = Mockito.mock(JanusGraph.class); + Either value = Either.left(tg); + // default test + Mockito.when(tg.addVertex()).thenThrow(RuntimeException.class); + Mockito.when(janusGraphClient.getGraph()).thenReturn(value); + result = testSubject.createVertex(graphVertex); + } + + @Test + public void testGetVertexByPropertyAndLabel() throws Exception { + Either result; + + // default test + Mockito.when(janusGraphClient.getGraph()).thenReturn(Either.right(JanusGraphOperationStatus.GENERAL_ERROR)); + result = testSubject.getVertexByPropertyAndLabel(GraphPropertyEnum.COMPONENT_TYPE, "mock", + VertexTypeEnum.ADDITIONAL_INFORMATION); + } + + @Test + public void testGetFirstFoundVertex() throws Exception { + Iterable vertices = Mockito.mock(Iterable.class); + Either result; + + Iterator value = Mockito.mock(Iterator.class); + Mockito.when(vertices.iterator()).thenReturn(value); + Mockito.when(value.hasNext()).thenReturn(true); + JanusGraphVertex value2 = Mockito.mock(JanusGraphVertex.class); + Mockito.when(value.next()).thenReturn(value2); + + // default test + result = Deencapsulation.invoke(testSubject, "getFirstFoundVertex", JsonParseFlagEnum.NoParse, vertices); + } + + @Test + public void testGetFirstFoundVertexNotFound() throws Exception { + Iterable vertices = Mockito.mock(Iterable.class); + Either result; + + Iterator value = Mockito.mock(Iterator.class); + Mockito.when(vertices.iterator()).thenReturn(value); + Mockito.when(value.hasNext()).thenReturn(false); + JanusGraphVertex value2 = Mockito.mock(JanusGraphVertex.class); + Mockito.when(value.next()).thenReturn(value2); + + // default test + result = Deencapsulation.invoke(testSubject, "getFirstFoundVertex", JsonParseFlagEnum.NoParse, vertices); + } + + @Test + public void testGetVertexById_1Exception() throws Exception { + + String id = "mock"; + Either result; + + JanusGraph tg = Mockito.mock(JanusGraph.class); + Either value = Either.left(tg); + // default test + JanusGraphVertex value2 = Mockito.mock(JanusGraphVertex.class); + Mockito.when(tg.addVertex()).thenReturn(value2); + Mockito.when(janusGraphClient.getGraph()).thenReturn(value); + + // test 1 + result = testSubject.getVertexById(id, JsonParseFlagEnum.NoParse); + // Assert.assertEquals(null, result); + } + + @Test + public void testGetVertexById_1GraphClosed() throws Exception { + + String id = "mock"; + Either result; + + Object b; + Either value = Either.right(JanusGraphOperationStatus.GENERAL_ERROR); + // default test + JanusGraphVertex value2 = Mockito.mock(JanusGraphVertex.class); + Mockito.when(janusGraphClient.getGraph()).thenReturn(value); + + // test 1 + result = testSubject.getVertexById(id, JsonParseFlagEnum.NoParse); + // Assert.assertEquals(null, result); + } + + @Test + public void testSetVertexProperties_1() throws Exception { + Vertex vertex = Mockito.mock(Vertex.class); + Map properties = new HashMap<>(); + properties.put("mock", "mock"); + + // default test + testSubject.setVertexProperties(vertex, properties); + } + + @Test + public void testCreateAndFill() throws Exception { + + JanusGraphVertex vertex = Mockito.mock(JanusGraphVertex.class); + JsonParseFlagEnum parseFlag = null; + GraphVertex result; + + // default test + + result = Deencapsulation.invoke(testSubject, "createAndFill", vertex, JsonParseFlagEnum.NoParse); + } + + @Test + public void testParseVertexProperties() throws Exception { + + GraphVertex graphVertex = new GraphVertex(); + JanusGraphVertex vertex = Mockito.mock(JanusGraphVertex.class); + graphVertex.setVertex(vertex); + JsonParseFlagEnum parseFlag = null; + + // default test + + testSubject.parseVertexProperties(graphVertex, JsonParseFlagEnum.NoParse); + } + + + @Test + public void testCreateEdge() throws Exception { + + GraphVertex from = Mockito.mock(GraphVertex.class); + GraphVertex to = Mockito.mock(GraphVertex.class); + + JanusGraphVertex value = Mockito.mock(JanusGraphVertex.class); + Mockito.when(from.getVertex()).thenReturn(value); + Mockito.when(to.getVertex()).thenReturn(value); + Map properties = new HashMap<>(); + JanusGraphOperationStatus result; + + // default test + + result = testSubject.createEdge(from, to, EdgeLabelEnum.ADDITIONAL_INFORMATION, properties); + from = new GraphVertex(); + to = new GraphVertex(); + result = testSubject.createEdge(from, to, EdgeLabelEnum.ADDITIONAL_INFORMATION, properties); + } + + @Test + public void testSetEdgeProperties() throws Exception { + + Element element = Mockito.mock(Element.class); + Map properties = new HashMap<>(); + + // test 1 + + properties.put(EdgePropertyEnum.STATE, "mock"); + testSubject.setEdgeProperties(element, properties); + } + + @Test + public void testGetByCriteria() throws Exception { + Map props = new HashMap<>(); + Either, JanusGraphOperationStatus> result; + + JanusGraph tg = Mockito.mock(JanusGraph.class); + Either value = Either.left(tg); + JanusGraphVertex value2 = Mockito.mock(JanusGraphVertex.class); + Mockito.when(tg.addVertex()).thenReturn(value2); + Mockito.when(janusGraphClient.getGraph()).thenReturn(value); + + // default test + result = testSubject.getByCriteria(VertexTypeEnum.ADDITIONAL_INFORMATION, props); + } + + @Test + public void testGetByCriteria_1() throws Exception { + + Map props = new HashMap<>(); + Either, JanusGraphOperationStatus> result; + + Either value = Either.right(JanusGraphOperationStatus.GENERAL_ERROR); + JanusGraphVertex value2 = Mockito.mock(JanusGraphVertex.class); + Mockito.when(janusGraphClient.getGraph()).thenReturn(value); + + // default test + result = testSubject.getByCriteria(VertexTypeEnum.ADDITIONAL_INFORMATION, props, JsonParseFlagEnum.NoParse); + } + + @Test + public void testGetCatalogVerticies() throws Exception { + Either, JanusGraphOperationStatus> result; + + Either value = Either.right(JanusGraphOperationStatus.GENERAL_ERROR); + // default test + JanusGraphVertex value2 = Mockito.mock(JanusGraphVertex.class); + Mockito.when(janusGraphClient.getGraph()).thenReturn(value); + + // default test + result = testSubject.getCatalogOrArchiveVerticies(true); + } + + @Test + public void testGetChildVertex() throws Exception { + + GraphVertex parentVertex = new GraphVertex(); + EdgeLabelEnum edgeLabel = null; + JsonParseFlagEnum parseFlag = null; + Either result; + + Either value = Either.right(JanusGraphOperationStatus.GENERAL_ERROR); + JanusGraphVertex value2 = Mockito.mock(JanusGraphVertex.class); + Mockito.when(janusGraphClient.getGraph()).thenReturn(value); + + // default test + result = testSubject.getChildVertex(parentVertex, EdgeLabelEnum.ADDITIONAL_INFORMATION, JsonParseFlagEnum.NoParse); + } + + @Test + public void testGetChildVertex_1() throws Exception { + + Vertex parentVertex = null; + EdgeLabelEnum edgeLabel = null; + JsonParseFlagEnum parseFlag = null; + Either result; + + Either value = Either.right(JanusGraphOperationStatus.GENERAL_ERROR); + JanusGraphVertex value2 = Mockito.mock(JanusGraphVertex.class); + Mockito.when(janusGraphClient.getGraph()).thenReturn(value); + + // default test + result = testSubject.getChildVertex(parentVertex, edgeLabel, parseFlag); + } + + + @Test + public void testGetParentVertex_1() throws Exception { + + Vertex parentVertex = null; + EdgeLabelEnum edgeLabel = null; + JsonParseFlagEnum parseFlag = null; + Either result; + + // default test + + result = testSubject.getParentVertex(parentVertex, edgeLabel, parseFlag); + } + + @Test + public void testGetParentVertecies_1() throws Exception { + + Vertex parentVertex = null; + EdgeLabelEnum edgeLabel = null; + JsonParseFlagEnum parseFlag = null; + Either, JanusGraphOperationStatus> result; + + // default test + + result = testSubject.getParentVertecies(parentVertex, edgeLabel, parseFlag); + } + + @Test + public void testGetAdjacentVerticies() throws Exception { + + Vertex parentVertex = null; + EdgeLabelEnum edgeLabel = null; + JsonParseFlagEnum parseFlag = null; + Direction direction = null; + Either, JanusGraphOperationStatus> result; + + Either value = Either.right(JanusGraphOperationStatus.GENERAL_ERROR); + JanusGraphVertex value2 = Mockito.mock(JanusGraphVertex.class); + Mockito.when(janusGraphClient.getGraph()).thenReturn(value); + // default test + result = Deencapsulation.invoke(testSubject, "getAdjacentVerticies", + new Object[] { Vertex.class, EdgeLabelEnum.class, JsonParseFlagEnum.class, Direction.class }); + } + + @Test + public void testGetChildrenVertecies_1() throws Exception { + + Vertex parentVertex = null; + EdgeLabelEnum edgeLabel = null; + JsonParseFlagEnum parseFlag = null; + Either, JanusGraphOperationStatus> result; + + // default test + + result = testSubject.getChildrenVertecies(parentVertex, edgeLabel, parseFlag); + } + + + @Test + public void testDeleteBelongingEdgeByCriteria() throws Exception { + + GraphVertex vertex = null; + EdgeLabelEnum label = null; + Map properties = null; + Either result; + + // default test + + result = testSubject.deleteBelongingEdgeByCriteria(vertex, label, properties); + } + + @Test + public void testDeleteEdge() throws Exception { + + GraphVertex fromVertex = new GraphVertex(); + GraphVertex toVertex = new GraphVertex(); + Either result; + + Either value = Either.right(JanusGraphOperationStatus.GENERAL_ERROR); + JanusGraphVertex value2 = Mockito.mock(JanusGraphVertex.class); + Mockito.when(janusGraphClient.getGraph()).thenReturn(value); + + // default test + result = testSubject.deleteEdge(fromVertex, toVertex, EdgeLabelEnum.ADDITIONAL_INFORMATION); + } + + @Test + public void testDeleteEdgeByDirection() throws Exception { + GraphVertex fromVertex = new GraphVertex(); + JanusGraphOperationStatus result; + + // default test + result = testSubject.deleteEdgeByDirection(fromVertex, Direction.BOTH, EdgeLabelEnum.ADDITIONAL_INFORMATION); + } + + @Test + public void testDeleteEdgeByDirectionMock() throws Exception { + GraphVertex fromVertex = Mockito.mock(GraphVertex.class); + JanusGraphOperationStatus result; + + JanusGraphVertex value = Mockito.mock(JanusGraphVertex.class);; + Mockito.when(fromVertex.getVertex()).thenReturn(value); + Iterator value2 = Mockito.mock(Iterator.class);; + Mockito.when(value.edges(Mockito.any(), Mockito.any())).thenReturn(value2); + Mockito.when(value2.hasNext()).thenReturn(true, false); + Edge value3 = Mockito.mock(Edge.class);; + Mockito.when(value2.next()).thenReturn(value3); + // default test + result = testSubject.deleteEdgeByDirection(fromVertex, Direction.BOTH, EdgeLabelEnum.ADDITIONAL_INFORMATION); + } + + @Test + public void testUpdateVertex() throws Exception { + + GraphVertex graphVertex = new GraphVertex(); + Either result; + + // default test + + result = testSubject.updateVertex(graphVertex); + } + + @Test + public void testGetVerticesByUniqueIdAndParseFlag() throws Exception { + + Map> verticesToGet = new HashMap<>(); + Either, JanusGraphOperationStatus> result; + + // default test + result = testSubject.getVerticesByUniqueIdAndParseFlag(verticesToGet); + ImmutablePair value3 = ImmutablePair.of(GraphPropertyEnum.COMPONENT_TYPE, JsonParseFlagEnum.NoParse); + verticesToGet.put("mock", value3); + try { + result = testSubject.getVerticesByUniqueIdAndParseFlag(verticesToGet); + } catch (Exception e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + + @Test + public void testCreateEdge_2() throws Exception { + + Vertex from = null; + Vertex to = null; + EdgeLabelEnum label = null; + Edge edgeToCopy = null; + JanusGraphOperationStatus result; + + // default test + + result = testSubject.createEdge(from, to, label, edgeToCopy); + } + + + @Test + public void testReplaceEdgeLabel() throws Exception { + + Vertex fromVertex = null; + Vertex toVertex = null; + Edge prevEdge = null; + EdgeLabelEnum prevLabel = null; + EdgeLabelEnum newLabel = null; + JanusGraphOperationStatus result; + + // default test + + result = testSubject.replaceEdgeLabel(fromVertex, toVertex, prevEdge, prevLabel, newLabel); + } + + @Test + public void testUpdateVertexMetadataPropertiesWithJson() throws Exception { + + Vertex vertex = Mockito.mock(Vertex.class);; + Map properties = new HashMap<>(); + properties.put(GraphPropertyEnum.COMPONENT_TYPE, "mock"); + JanusGraphOperationStatus result; + + // default test + + result = testSubject.updateVertexMetadataPropertiesWithJson(vertex, properties); + } + + //TODO Last + @Test + public void testDisassociateAndDeleteLast() throws Exception { + + GraphVertex vertex = Mockito.mock(GraphVertex.class); + JanusGraphOperationStatus result; + + JanusGraphVertex value = Mockito.mock(JanusGraphVertex.class); + Iterator mockiter = Mockito.mock(Iterator.class); + Edge nextmock = Mockito.mock(Edge.class); + Mockito.when(vertex.getVertex()).thenReturn(value); + Mockito.when(value.edges(Mockito.any(), Mockito.any())).thenReturn(mockiter); + Mockito.when(mockiter.hasNext()).thenReturn(true, false); + Mockito.when(mockiter.next()).thenReturn(nextmock); + Vertex secondVertex = Mockito.mock(Vertex.class); + Mockito.when(nextmock.outVertex()).thenReturn(secondVertex); + Mockito.when(nextmock.inVertex()).thenReturn(secondVertex); + Iterator restOfEdges = Mockito.mock(Iterator.class); + Mockito.when(secondVertex.edges(Mockito.any(), Mockito.any())).thenReturn(restOfEdges); + Mockito.when(restOfEdges.hasNext()).thenReturn(false); + + // default test + result = testSubject.disassociateAndDeleteLast(vertex, Direction.OUT, EdgeLabelEnum.ADDITIONAL_INFORMATION); + } + + @Test + public void testDisassociateAndDeleteLastOut() throws Exception { + + GraphVertex vertex = Mockito.mock(GraphVertex.class); + JanusGraphOperationStatus result; + + JanusGraphVertex value = Mockito.mock(JanusGraphVertex.class); + Iterator mockiter = Mockito.mock(Iterator.class); + Edge nextmock = Mockito.mock(Edge.class); + Mockito.when(vertex.getVertex()).thenReturn(value); + Mockito.when(value.edges(Mockito.any(), Mockito.any())).thenReturn(mockiter); + Mockito.when(mockiter.hasNext()).thenReturn(true, false); + Mockito.when(mockiter.next()).thenReturn(nextmock); + Vertex secondVertex = Mockito.mock(Vertex.class); + Mockito.when(nextmock.outVertex()).thenReturn(secondVertex); + Mockito.when(nextmock.inVertex()).thenReturn(secondVertex); + Iterator restOfEdges = Mockito.mock(Iterator.class); + Mockito.when(secondVertex.edges(Mockito.any(), Mockito.any())).thenReturn(restOfEdges); + Mockito.when(restOfEdges.hasNext()).thenReturn(false); + + // default test + result = testSubject.disassociateAndDeleteLast(vertex, Direction.IN, EdgeLabelEnum.ADDITIONAL_INFORMATION); + } + + @Test + public void testDisassociateAndDeleteLastException() throws Exception { + + GraphVertex vertex = Mockito.mock(GraphVertex.class); + JanusGraphOperationStatus result; + + Mockito.when(vertex.getVertex()).thenThrow(RuntimeException.class); + + // default test + result = testSubject.disassociateAndDeleteLast(vertex, Direction.OUT, EdgeLabelEnum.ADDITIONAL_INFORMATION); + } + + @Test + public void testMoveEdge() throws Exception { + + GraphVertex vertexA = new GraphVertex(); + GraphVertex vertexB = new GraphVertex(); + JanusGraphOperationStatus result; + + // default test + + result = testSubject.moveEdge(vertexA, vertexB, EdgeLabelEnum.ADDITIONAL_INFORMATION, Direction.BOTH); + } +} \ No newline at end of file diff --git a/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/jsongraph/JanusGraphDaoTest.java b/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/jsongraph/JanusGraphDaoTest.java new file mode 100644 index 0000000000..9019de9d24 --- /dev/null +++ b/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/jsongraph/JanusGraphDaoTest.java @@ -0,0 +1,312 @@ +package org.openecomp.sdc.be.dao.jsongraph; + +import org.janusgraph.core.JanusGraph; +import fj.data.Either; +import org.apache.tinkerpop.gremlin.structure.Edge; +import org.apache.tinkerpop.gremlin.structure.Element; +import org.apache.tinkerpop.gremlin.structure.Property; +import org.apache.tinkerpop.gremlin.structure.Vertex; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mockito; +import org.openecomp.sdc.be.dao.DAOJanusGraphStrategy; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphClient; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; +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.JsonParseFlagEnum; +import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; +import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; +import org.openecomp.sdc.be.utils.DAOConfDependentTest; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.Iterator; +import java.util.List; +import java.util.Map; + +public class JanusGraphDaoTest extends DAOConfDependentTest{ + + + private static Logger logger = LoggerFactory.getLogger(JanusGraphDaoTest.class); + private JanusGraphDao dao = new JanusGraphDao(new JanusGraphClient(new DAOJanusGraphStrategy())); + + @Before + public void init(){ + dao.janusGraphClient.createGraph(); + } + + @After + public void end(){ + dao.janusGraphClient.cleanupGraph(); + } + + @Test + public void testCreateVertex() throws Exception { + Either result; + + // default test + GraphVertex graphVertex = new GraphVertex(VertexTypeEnum.REQUIREMENTS); + result = dao.createVertex(graphVertex); + + graphVertex = new GraphVertex(); + result = dao.createVertex(graphVertex); + } + + @Test + public void testGetVertexByLabel() throws Exception { + Either result; + + // default test + result = dao.getVertexByLabel(VertexTypeEnum.ADDITIONAL_INFORMATION); + } + + @Test + public void testCommit() throws Exception { + JanusGraphOperationStatus result; + + // default test + + result = dao.commit(); + } + + + @Test + public void testRollback() throws Exception { + + JanusGraphOperationStatus result; + + // default test + + result = dao.rollback(); + } + + @Test + public void testGetGraph() throws Exception { + + Either result; + + // default test + + result = dao.getGraph(); + } + + @Test + public void testGetVertexByPropertyAndLabel() throws Exception { + + GraphPropertyEnum name = null; + Object value = null; + VertexTypeEnum label = null; + Either result; + + // default test + + result = dao.getVertexByPropertyAndLabel(name, value, label); + + result = dao.getVertexByPropertyAndLabel(GraphPropertyEnum.COMPONENT_TYPE, new Object(), VertexTypeEnum.ADDITIONAL_INFORMATION); + } + + @Test + public void testGetVertexByPropertyAndLabel_1() throws Exception { + + GraphPropertyEnum name = null; + Object value = null; + VertexTypeEnum label = null; + JsonParseFlagEnum parseFlag = null; + Either result; + + // default test + + result = dao.getVertexByPropertyAndLabel(name, value, label, parseFlag); + } + + + @Test + public void testGetVertexById() throws Exception { + + String id = ""; + Either result; + + // default test + + result = dao.getVertexById(id); + } + + @Test + public void testGetVertexById_1() throws Exception { + + String id = ""; + JsonParseFlagEnum parseFlag = null; + Either result; + + // test 1 + + id = null; + result = dao.getVertexById(id, parseFlag); + + // test 2 + + id = ""; + result = dao.getVertexById(id, parseFlag); + } + + @Test + public void testGetVertexProperties() throws Exception { + + Element element = null; + Map result; + + // test 1 + + element = null; + result = dao.getVertexProperties(element); + } + + + @Test + public void testGetEdgeProperties() throws Exception { + + Element element = null; + Map result; + + // test 1 + + element = null; + result = dao.getEdgeProperties(element); + } + + @Test + public void testGetByCriteria() throws Exception { + + VertexTypeEnum type = null; + Map props = null; + Either, JanusGraphOperationStatus> result; + + // default test + + result = dao.getByCriteria(type, props); + } + + @Test + public void testGetByCriteria_1() throws Exception { + + VertexTypeEnum type = null; + Map props = null; + JsonParseFlagEnum parseFlag = null; + Either, JanusGraphOperationStatus> result; + + // default test + + result = dao.getByCriteria(type, props, parseFlag); + } + + + @Test + public void testGetByCriteria_2() throws Exception { + + VertexTypeEnum type = null; + Map props = null; + Map hasNotProps = null; + JsonParseFlagEnum parseFlag = null; + Either, JanusGraphOperationStatus> result; + + // default test + + result = dao.getByCriteria(type, props, hasNotProps, parseFlag); + } + + @Test + public void testGetCatalogVerticies() throws Exception { + + Either, JanusGraphOperationStatus> result; + + // default test + + result = dao.getCatalogOrArchiveVerticies(true); + } + + @Test + public void testGetParentVertecies_1() throws Exception { + + Vertex parentVertex = null; + EdgeLabelEnum edgeLabel = null; + JsonParseFlagEnum parseFlag = null; + Either, JanusGraphOperationStatus> result; + + // default test + + result = dao.getParentVertecies(parentVertex, edgeLabel, parseFlag); + } + + @Test + public void testGetChildrenVertecies_1() throws Exception { + + Vertex parentVertex = null; + EdgeLabelEnum edgeLabel = null; + JsonParseFlagEnum parseFlag = null; + Either, JanusGraphOperationStatus> result; + + // default test + + result = dao.getChildrenVertecies(parentVertex, edgeLabel, parseFlag); + } + + @Test + public void testUpdateVertexMetadataPropertiesWithJson() throws Exception { + + Vertex vertex = null; + Map properties = null; + JanusGraphOperationStatus result; + + // default test + + result = dao.updateVertexMetadataPropertiesWithJson(vertex, properties); + } + + @Test + public void testGetProperty() throws Exception { + Edge edge = Mockito.mock(Edge.class);; + Object result; + + Property value = Mockito.mock(Property.class); + Mockito.when(edge.property(Mockito.any())).thenReturn(value); + + // default test + result = dao.getProperty(edge, EdgePropertyEnum.STATE); + } + + @Test + public void testGetProperty_1() throws Exception { + Edge edge = Mockito.mock(Edge.class);; + Object result; + + // default test + result = dao.getProperty(edge, EdgePropertyEnum.STATE); + } + + @Test + public void testGetPropertyexception() throws Exception { + Edge edge = Mockito.mock(Edge.class);; + Object result; + + Property value = Mockito.mock(Property.class); + Mockito.when(edge.property(Mockito.any())).thenThrow(RuntimeException.class); + + // default test + result = dao.getProperty(edge, EdgePropertyEnum.STATE); + } + + @Test + public void testGetBelongingEdgeByCriteria_1() throws Exception { + + String parentId = ""; + EdgeLabelEnum label = null; + Map properties = null; + Either result; + + // default test + + result = dao.getBelongingEdgeByCriteria(parentId, label, properties); + } +} \ No newline at end of file diff --git a/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/jsongraph/TitanDaoMockTest.java b/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/jsongraph/TitanDaoMockTest.java deleted file mode 100644 index 5703e53c9c..0000000000 --- a/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/jsongraph/TitanDaoMockTest.java +++ /dev/null @@ -1,586 +0,0 @@ -package org.openecomp.sdc.be.dao.jsongraph; - -import com.thinkaurelius.titan.core.TitanGraph; -import com.thinkaurelius.titan.core.TitanVertex; -import fj.data.Either; -import mockit.Deencapsulation; -import org.apache.commons.lang3.tuple.ImmutablePair; -import org.apache.tinkerpop.gremlin.structure.Direction; -import org.apache.tinkerpop.gremlin.structure.Edge; -import org.apache.tinkerpop.gremlin.structure.Element; -import org.apache.tinkerpop.gremlin.structure.Vertex; -import org.junit.Before; -import org.junit.Test; -import org.mockito.InjectMocks; -import org.mockito.Mock; -import org.mockito.Mockito; -import org.mockito.MockitoAnnotations; -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.JsonParseFlagEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; -import org.openecomp.sdc.be.dao.titan.TitanGraphClient; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; -import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; - -import java.util.HashMap; -import java.util.Iterator; -import java.util.List; -import java.util.Map; - -public class TitanDaoMockTest { - - @InjectMocks - TitanDao testSubject; - - @Mock - TitanGraphClient titanClient; - - @Before - public void setUp() throws Exception { - MockitoAnnotations.initMocks(this); - } - - @Test - public void testCommit() throws Exception { - TitanOperationStatus result; - - // default test - result = testSubject.commit(); - } - - @Test - public void testRollback() throws Exception { - TitanOperationStatus result; - - // default test - result = testSubject.rollback(); - } - - @Test - public void testGetGraph() throws Exception { - - Either result; - - // default test - - result = testSubject.getGraph(); - } - - @Test - public void testCreateVertex() throws Exception { - - GraphVertex graphVertex = new GraphVertex(); - graphVertex.setLabel(VertexTypeEnum.ADDITIONAL_INFORMATION); - Either result; - - TitanGraph tg = Mockito.mock(TitanGraph.class); - Either value = Either.left(tg); - // default test - TitanVertex value2 = Mockito.mock(TitanVertex.class); - Mockito.when(tg.addVertex()).thenReturn(value2); - Mockito.when(titanClient.getGraph()).thenReturn(value); - result = testSubject.createVertex(graphVertex); - } - - @Test - public void testCreateVertexErrorGetGraph() throws Exception { - - GraphVertex graphVertex = new GraphVertex(); - graphVertex.setLabel(VertexTypeEnum.ADDITIONAL_INFORMATION); - Either result; - - Either value = Either.right(TitanOperationStatus.GENERAL_ERROR); - // default test - Mockito.when(titanClient.getGraph()).thenReturn(value); - result = testSubject.createVertex(graphVertex); - } - - @Test - public void testCreateVertexException() throws Exception { - - GraphVertex graphVertex = new GraphVertex(); - graphVertex.setLabel(VertexTypeEnum.ADDITIONAL_INFORMATION); - Either result; - - TitanGraph tg = Mockito.mock(TitanGraph.class); - Either value = Either.left(tg); - // default test - Mockito.when(tg.addVertex()).thenThrow(RuntimeException.class); - Mockito.when(titanClient.getGraph()).thenReturn(value); - result = testSubject.createVertex(graphVertex); - } - - @Test - public void testGetVertexByPropertyAndLabel() throws Exception { - Either result; - - // default test - Mockito.when(titanClient.getGraph()).thenReturn(Either.right(TitanOperationStatus.GENERAL_ERROR)); - result = testSubject.getVertexByPropertyAndLabel(GraphPropertyEnum.COMPONENT_TYPE, "mock", - VertexTypeEnum.ADDITIONAL_INFORMATION); - } - - @Test - public void testGetFirstFoundVertex() throws Exception { - Iterable vertices = Mockito.mock(Iterable.class); - Either result; - - Iterator value = Mockito.mock(Iterator.class); - Mockito.when(vertices.iterator()).thenReturn(value); - Mockito.when(value.hasNext()).thenReturn(true); - TitanVertex value2 = Mockito.mock(TitanVertex.class); - Mockito.when(value.next()).thenReturn(value2); - - // default test - result = Deencapsulation.invoke(testSubject, "getFirstFoundVertex", JsonParseFlagEnum.NoParse, vertices); - } - - @Test - public void testGetFirstFoundVertexNotFound() throws Exception { - Iterable vertices = Mockito.mock(Iterable.class); - Either result; - - Iterator value = Mockito.mock(Iterator.class); - Mockito.when(vertices.iterator()).thenReturn(value); - Mockito.when(value.hasNext()).thenReturn(false); - TitanVertex value2 = Mockito.mock(TitanVertex.class); - Mockito.when(value.next()).thenReturn(value2); - - // default test - result = Deencapsulation.invoke(testSubject, "getFirstFoundVertex", JsonParseFlagEnum.NoParse, vertices); - } - - @Test - public void testGetVertexById_1Exception() throws Exception { - - String id = "mock"; - Either result; - - TitanGraph tg = Mockito.mock(TitanGraph.class); - Either value = Either.left(tg); - // default test - TitanVertex value2 = Mockito.mock(TitanVertex.class); - Mockito.when(tg.addVertex()).thenReturn(value2); - Mockito.when(titanClient.getGraph()).thenReturn(value); - - // test 1 - result = testSubject.getVertexById(id, JsonParseFlagEnum.NoParse); - // Assert.assertEquals(null, result); - } - - @Test - public void testGetVertexById_1GraphClosed() throws Exception { - - String id = "mock"; - Either result; - - Object b; - Either value = Either.right(TitanOperationStatus.GENERAL_ERROR); - // default test - TitanVertex value2 = Mockito.mock(TitanVertex.class); - Mockito.when(titanClient.getGraph()).thenReturn(value); - - // test 1 - result = testSubject.getVertexById(id, JsonParseFlagEnum.NoParse); - // Assert.assertEquals(null, result); - } - - @Test - public void testSetVertexProperties_1() throws Exception { - Vertex vertex = Mockito.mock(Vertex.class); - Map properties = new HashMap<>(); - properties.put("mock", "mock"); - - // default test - testSubject.setVertexProperties(vertex, properties); - } - - @Test - public void testCreateAndFill() throws Exception { - - TitanVertex vertex = Mockito.mock(TitanVertex.class); - JsonParseFlagEnum parseFlag = null; - GraphVertex result; - - // default test - - result = Deencapsulation.invoke(testSubject, "createAndFill", vertex, JsonParseFlagEnum.NoParse); - } - - @Test - public void testParseVertexProperties() throws Exception { - - GraphVertex graphVertex = new GraphVertex(); - TitanVertex vertex = Mockito.mock(TitanVertex.class); - graphVertex.setVertex(vertex); - JsonParseFlagEnum parseFlag = null; - - // default test - - testSubject.parseVertexProperties(graphVertex, JsonParseFlagEnum.NoParse); - } - - - @Test - public void testCreateEdge() throws Exception { - - GraphVertex from = Mockito.mock(GraphVertex.class); - GraphVertex to = Mockito.mock(GraphVertex.class); - - TitanVertex value = Mockito.mock(TitanVertex.class); - Mockito.when(from.getVertex()).thenReturn(value); - Mockito.when(to.getVertex()).thenReturn(value); - Map properties = new HashMap<>(); - TitanOperationStatus result; - - // default test - - result = testSubject.createEdge(from, to, EdgeLabelEnum.ADDITIONAL_INFORMATION, properties); - from = new GraphVertex(); - to = new GraphVertex(); - result = testSubject.createEdge(from, to, EdgeLabelEnum.ADDITIONAL_INFORMATION, properties); - } - - @Test - public void testSetEdgeProperties() throws Exception { - - Element element = Mockito.mock(Element.class); - Map properties = new HashMap<>(); - - // test 1 - - properties.put(EdgePropertyEnum.STATE, "mock"); - testSubject.setEdgeProperties(element, properties); - } - - @Test - public void testGetByCriteria() throws Exception { - Map props = new HashMap<>(); - Either, TitanOperationStatus> result; - - TitanGraph tg = Mockito.mock(TitanGraph.class); - Either value = Either.left(tg); - TitanVertex value2 = Mockito.mock(TitanVertex.class); - Mockito.when(tg.addVertex()).thenReturn(value2); - Mockito.when(titanClient.getGraph()).thenReturn(value); - - // default test - result = testSubject.getByCriteria(VertexTypeEnum.ADDITIONAL_INFORMATION, props); - } - - @Test - public void testGetByCriteria_1() throws Exception { - - Map props = new HashMap<>(); - Either, TitanOperationStatus> result; - - Either value = Either.right(TitanOperationStatus.GENERAL_ERROR); - TitanVertex value2 = Mockito.mock(TitanVertex.class); - Mockito.when(titanClient.getGraph()).thenReturn(value); - - // default test - result = testSubject.getByCriteria(VertexTypeEnum.ADDITIONAL_INFORMATION, props, JsonParseFlagEnum.NoParse); - } - - @Test - public void testGetCatalogVerticies() throws Exception { - Either, TitanOperationStatus> result; - - Either value = Either.right(TitanOperationStatus.GENERAL_ERROR); - // default test - TitanVertex value2 = Mockito.mock(TitanVertex.class); - Mockito.when(titanClient.getGraph()).thenReturn(value); - - // default test - result = testSubject.getCatalogOrArchiveVerticies(true); - } - - @Test - public void testGetChildVertex() throws Exception { - - GraphVertex parentVertex = new GraphVertex(); - EdgeLabelEnum edgeLabel = null; - JsonParseFlagEnum parseFlag = null; - Either result; - - Either value = Either.right(TitanOperationStatus.GENERAL_ERROR); - TitanVertex value2 = Mockito.mock(TitanVertex.class); - Mockito.when(titanClient.getGraph()).thenReturn(value); - - // default test - result = testSubject.getChildVertex(parentVertex, EdgeLabelEnum.ADDITIONAL_INFORMATION, JsonParseFlagEnum.NoParse); - } - - @Test - public void testGetChildVertex_1() throws Exception { - - Vertex parentVertex = null; - EdgeLabelEnum edgeLabel = null; - JsonParseFlagEnum parseFlag = null; - Either result; - - Either value = Either.right(TitanOperationStatus.GENERAL_ERROR); - TitanVertex value2 = Mockito.mock(TitanVertex.class); - Mockito.when(titanClient.getGraph()).thenReturn(value); - - // default test - result = testSubject.getChildVertex(parentVertex, edgeLabel, parseFlag); - } - - - @Test - public void testGetParentVertex_1() throws Exception { - - Vertex parentVertex = null; - EdgeLabelEnum edgeLabel = null; - JsonParseFlagEnum parseFlag = null; - Either result; - - // default test - - result = testSubject.getParentVertex(parentVertex, edgeLabel, parseFlag); - } - - @Test - public void testGetParentVertecies_1() throws Exception { - - Vertex parentVertex = null; - EdgeLabelEnum edgeLabel = null; - JsonParseFlagEnum parseFlag = null; - Either, TitanOperationStatus> result; - - // default test - - result = testSubject.getParentVertecies(parentVertex, edgeLabel, parseFlag); - } - - @Test - public void testGetAdjacentVerticies() throws Exception { - - Vertex parentVertex = null; - EdgeLabelEnum edgeLabel = null; - JsonParseFlagEnum parseFlag = null; - Direction direction = null; - Either, TitanOperationStatus> result; - - Either value = Either.right(TitanOperationStatus.GENERAL_ERROR); - TitanVertex value2 = Mockito.mock(TitanVertex.class); - Mockito.when(titanClient.getGraph()).thenReturn(value); - // default test - result = Deencapsulation.invoke(testSubject, "getAdjacentVerticies", - new Object[] { Vertex.class, EdgeLabelEnum.class, JsonParseFlagEnum.class, Direction.class }); - } - - @Test - public void testGetChildrenVertecies_1() throws Exception { - - Vertex parentVertex = null; - EdgeLabelEnum edgeLabel = null; - JsonParseFlagEnum parseFlag = null; - Either, TitanOperationStatus> result; - - // default test - - result = testSubject.getChildrenVertecies(parentVertex, edgeLabel, parseFlag); - } - - - @Test - public void testDeleteBelongingEdgeByCriteria() throws Exception { - - GraphVertex vertex = null; - EdgeLabelEnum label = null; - Map properties = null; - Either result; - - // default test - - result = testSubject.deleteBelongingEdgeByCriteria(vertex, label, properties); - } - - @Test - public void testDeleteEdge() throws Exception { - - GraphVertex fromVertex = new GraphVertex(); - GraphVertex toVertex = new GraphVertex(); - Either result; - - Either value = Either.right(TitanOperationStatus.GENERAL_ERROR); - TitanVertex value2 = Mockito.mock(TitanVertex.class); - Mockito.when(titanClient.getGraph()).thenReturn(value); - - // default test - result = testSubject.deleteEdge(fromVertex, toVertex, EdgeLabelEnum.ADDITIONAL_INFORMATION); - } - - @Test - public void testDeleteEdgeByDirection() throws Exception { - GraphVertex fromVertex = new GraphVertex(); - TitanOperationStatus result; - - // default test - result = testSubject.deleteEdgeByDirection(fromVertex, Direction.BOTH, EdgeLabelEnum.ADDITIONAL_INFORMATION); - } - - @Test - public void testDeleteEdgeByDirectionMock() throws Exception { - GraphVertex fromVertex = Mockito.mock(GraphVertex.class); - TitanOperationStatus result; - - TitanVertex value = Mockito.mock(TitanVertex.class);; - Mockito.when(fromVertex.getVertex()).thenReturn(value); - Iterator value2 = Mockito.mock(Iterator.class);; - Mockito.when(value.edges(Mockito.any(), Mockito.any())).thenReturn(value2); - Mockito.when(value2.hasNext()).thenReturn(true, false); - Edge value3 = Mockito.mock(Edge.class);; - Mockito.when(value2.next()).thenReturn(value3); - // default test - result = testSubject.deleteEdgeByDirection(fromVertex, Direction.BOTH, EdgeLabelEnum.ADDITIONAL_INFORMATION); - } - - @Test - public void testUpdateVertex() throws Exception { - - GraphVertex graphVertex = new GraphVertex(); - Either result; - - // default test - - result = testSubject.updateVertex(graphVertex); - } - - @Test - public void testGetVerticesByUniqueIdAndParseFlag() throws Exception { - - Map> verticesToGet = new HashMap<>(); - Either, TitanOperationStatus> result; - - // default test - result = testSubject.getVerticesByUniqueIdAndParseFlag(verticesToGet); - ImmutablePair value3 = ImmutablePair.of(GraphPropertyEnum.COMPONENT_TYPE, JsonParseFlagEnum.NoParse); - verticesToGet.put("mock", value3); - try { - result = testSubject.getVerticesByUniqueIdAndParseFlag(verticesToGet); - } catch (Exception e) { - // TODO Auto-generated catch block - e.printStackTrace(); - } - } - - @Test - public void testCreateEdge_2() throws Exception { - - Vertex from = null; - Vertex to = null; - EdgeLabelEnum label = null; - Edge edgeToCopy = null; - TitanOperationStatus result; - - // default test - - result = testSubject.createEdge(from, to, label, edgeToCopy); - } - - - @Test - public void testReplaceEdgeLabel() throws Exception { - - Vertex fromVertex = null; - Vertex toVertex = null; - Edge prevEdge = null; - EdgeLabelEnum prevLabel = null; - EdgeLabelEnum newLabel = null; - TitanOperationStatus result; - - // default test - - result = testSubject.replaceEdgeLabel(fromVertex, toVertex, prevEdge, prevLabel, newLabel); - } - - @Test - public void testUpdateVertexMetadataPropertiesWithJson() throws Exception { - - Vertex vertex = Mockito.mock(Vertex.class);; - Map properties = new HashMap<>(); - properties.put(GraphPropertyEnum.COMPONENT_TYPE, "mock"); - TitanOperationStatus result; - - // default test - - result = testSubject.updateVertexMetadataPropertiesWithJson(vertex, properties); - } - - //TODO Last - @Test - public void testDisassociateAndDeleteLast() throws Exception { - - GraphVertex vertex = Mockito.mock(GraphVertex.class); - TitanOperationStatus result; - - TitanVertex value = Mockito.mock(TitanVertex.class); - Iterator mockiter = Mockito.mock(Iterator.class); - Edge nextmock = Mockito.mock(Edge.class); - Mockito.when(vertex.getVertex()).thenReturn(value); - Mockito.when(value.edges(Mockito.any(), Mockito.any())).thenReturn(mockiter); - Mockito.when(mockiter.hasNext()).thenReturn(true, false); - Mockito.when(mockiter.next()).thenReturn(nextmock); - Vertex secondVertex = Mockito.mock(Vertex.class); - Mockito.when(nextmock.outVertex()).thenReturn(secondVertex); - Mockito.when(nextmock.inVertex()).thenReturn(secondVertex); - Iterator restOfEdges = Mockito.mock(Iterator.class); - Mockito.when(secondVertex.edges(Mockito.any(), Mockito.any())).thenReturn(restOfEdges); - Mockito.when(restOfEdges.hasNext()).thenReturn(false); - - // default test - result = testSubject.disassociateAndDeleteLast(vertex, Direction.OUT, EdgeLabelEnum.ADDITIONAL_INFORMATION); - } - - @Test - public void testDisassociateAndDeleteLastOut() throws Exception { - - GraphVertex vertex = Mockito.mock(GraphVertex.class); - TitanOperationStatus result; - - TitanVertex value = Mockito.mock(TitanVertex.class); - Iterator mockiter = Mockito.mock(Iterator.class); - Edge nextmock = Mockito.mock(Edge.class); - Mockito.when(vertex.getVertex()).thenReturn(value); - Mockito.when(value.edges(Mockito.any(), Mockito.any())).thenReturn(mockiter); - Mockito.when(mockiter.hasNext()).thenReturn(true, false); - Mockito.when(mockiter.next()).thenReturn(nextmock); - Vertex secondVertex = Mockito.mock(Vertex.class); - Mockito.when(nextmock.outVertex()).thenReturn(secondVertex); - Mockito.when(nextmock.inVertex()).thenReturn(secondVertex); - Iterator restOfEdges = Mockito.mock(Iterator.class); - Mockito.when(secondVertex.edges(Mockito.any(), Mockito.any())).thenReturn(restOfEdges); - Mockito.when(restOfEdges.hasNext()).thenReturn(false); - - // default test - result = testSubject.disassociateAndDeleteLast(vertex, Direction.IN, EdgeLabelEnum.ADDITIONAL_INFORMATION); - } - - @Test - public void testDisassociateAndDeleteLastException() throws Exception { - - GraphVertex vertex = Mockito.mock(GraphVertex.class); - TitanOperationStatus result; - - Mockito.when(vertex.getVertex()).thenThrow(RuntimeException.class); - - // default test - result = testSubject.disassociateAndDeleteLast(vertex, Direction.OUT, EdgeLabelEnum.ADDITIONAL_INFORMATION); - } - - @Test - public void testMoveEdge() throws Exception { - - GraphVertex vertexA = new GraphVertex(); - GraphVertex vertexB = new GraphVertex(); - TitanOperationStatus result; - - // default test - - result = testSubject.moveEdge(vertexA, vertexB, EdgeLabelEnum.ADDITIONAL_INFORMATION, Direction.BOTH); - } -} \ No newline at end of file diff --git a/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/jsongraph/TitanDaoTest.java b/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/jsongraph/TitanDaoTest.java deleted file mode 100644 index 2c4b868ff2..0000000000 --- a/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/jsongraph/TitanDaoTest.java +++ /dev/null @@ -1,312 +0,0 @@ -package org.openecomp.sdc.be.dao.jsongraph; - -import com.thinkaurelius.titan.core.TitanGraph; -import fj.data.Either; -import org.apache.tinkerpop.gremlin.structure.Edge; -import org.apache.tinkerpop.gremlin.structure.Element; -import org.apache.tinkerpop.gremlin.structure.Property; -import org.apache.tinkerpop.gremlin.structure.Vertex; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; -import org.mockito.Mockito; -import org.openecomp.sdc.be.dao.DAOTitanStrategy; -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.JsonParseFlagEnum; -import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; -import org.openecomp.sdc.be.dao.titan.TitanGraphClient; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; -import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; -import org.openecomp.sdc.be.utils.DAOConfDependentTest; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -import java.util.Iterator; -import java.util.List; -import java.util.Map; - -public class TitanDaoTest extends DAOConfDependentTest{ - - - private static Logger logger = LoggerFactory.getLogger(TitanDaoTest.class); - private TitanDao dao = new TitanDao(new TitanGraphClient(new DAOTitanStrategy())); - - @Before - public void init(){ - dao.titanClient.createGraph(); - } - - @After - public void end(){ - dao.titanClient.cleanupGraph(); - } - - @Test - public void testCreateVertex() throws Exception { - Either result; - - // default test - GraphVertex graphVertex = new GraphVertex(VertexTypeEnum.REQUIREMENTS); - result = dao.createVertex(graphVertex); - - graphVertex = new GraphVertex(); - result = dao.createVertex(graphVertex); - } - - @Test - public void testGetVertexByLabel() throws Exception { - Either result; - - // default test - result = dao.getVertexByLabel(VertexTypeEnum.ADDITIONAL_INFORMATION); - } - - @Test - public void testCommit() throws Exception { - TitanOperationStatus result; - - // default test - - result = dao.commit(); - } - - - @Test - public void testRollback() throws Exception { - - TitanOperationStatus result; - - // default test - - result = dao.rollback(); - } - - @Test - public void testGetGraph() throws Exception { - - Either result; - - // default test - - result = dao.getGraph(); - } - - @Test - public void testGetVertexByPropertyAndLabel() throws Exception { - - GraphPropertyEnum name = null; - Object value = null; - VertexTypeEnum label = null; - Either result; - - // default test - - result = dao.getVertexByPropertyAndLabel(name, value, label); - - result = dao.getVertexByPropertyAndLabel(GraphPropertyEnum.COMPONENT_TYPE, new Object(), VertexTypeEnum.ADDITIONAL_INFORMATION); - } - - @Test - public void testGetVertexByPropertyAndLabel_1() throws Exception { - - GraphPropertyEnum name = null; - Object value = null; - VertexTypeEnum label = null; - JsonParseFlagEnum parseFlag = null; - Either result; - - // default test - - result = dao.getVertexByPropertyAndLabel(name, value, label, parseFlag); - } - - - @Test - public void testGetVertexById() throws Exception { - - String id = ""; - Either result; - - // default test - - result = dao.getVertexById(id); - } - - @Test - public void testGetVertexById_1() throws Exception { - - String id = ""; - JsonParseFlagEnum parseFlag = null; - Either result; - - // test 1 - - id = null; - result = dao.getVertexById(id, parseFlag); - - // test 2 - - id = ""; - result = dao.getVertexById(id, parseFlag); - } - - @Test - public void testGetVertexProperties() throws Exception { - - Element element = null; - Map result; - - // test 1 - - element = null; - result = dao.getVertexProperties(element); - } - - - @Test - public void testGetEdgeProperties() throws Exception { - - Element element = null; - Map result; - - // test 1 - - element = null; - result = dao.getEdgeProperties(element); - } - - @Test - public void testGetByCriteria() throws Exception { - - VertexTypeEnum type = null; - Map props = null; - Either, TitanOperationStatus> result; - - // default test - - result = dao.getByCriteria(type, props); - } - - @Test - public void testGetByCriteria_1() throws Exception { - - VertexTypeEnum type = null; - Map props = null; - JsonParseFlagEnum parseFlag = null; - Either, TitanOperationStatus> result; - - // default test - - result = dao.getByCriteria(type, props, parseFlag); - } - - - @Test - public void testGetByCriteria_2() throws Exception { - - VertexTypeEnum type = null; - Map props = null; - Map hasNotProps = null; - JsonParseFlagEnum parseFlag = null; - Either, TitanOperationStatus> result; - - // default test - - result = dao.getByCriteria(type, props, hasNotProps, parseFlag); - } - - @Test - public void testGetCatalogVerticies() throws Exception { - - Either, TitanOperationStatus> result; - - // default test - - result = dao.getCatalogOrArchiveVerticies(true); - } - - @Test - public void testGetParentVertecies_1() throws Exception { - - Vertex parentVertex = null; - EdgeLabelEnum edgeLabel = null; - JsonParseFlagEnum parseFlag = null; - Either, TitanOperationStatus> result; - - // default test - - result = dao.getParentVertecies(parentVertex, edgeLabel, parseFlag); - } - - @Test - public void testGetChildrenVertecies_1() throws Exception { - - Vertex parentVertex = null; - EdgeLabelEnum edgeLabel = null; - JsonParseFlagEnum parseFlag = null; - Either, TitanOperationStatus> result; - - // default test - - result = dao.getChildrenVertecies(parentVertex, edgeLabel, parseFlag); - } - - @Test - public void testUpdateVertexMetadataPropertiesWithJson() throws Exception { - - Vertex vertex = null; - Map properties = null; - TitanOperationStatus result; - - // default test - - result = dao.updateVertexMetadataPropertiesWithJson(vertex, properties); - } - - @Test - public void testGetProperty() throws Exception { - Edge edge = Mockito.mock(Edge.class);; - Object result; - - Property value = Mockito.mock(Property.class); - Mockito.when(edge.property(Mockito.any())).thenReturn(value); - - // default test - result = dao.getProperty(edge, EdgePropertyEnum.STATE); - } - - @Test - public void testGetProperty_1() throws Exception { - Edge edge = Mockito.mock(Edge.class);; - Object result; - - // default test - result = dao.getProperty(edge, EdgePropertyEnum.STATE); - } - - @Test - public void testGetPropertyexception() throws Exception { - Edge edge = Mockito.mock(Edge.class);; - Object result; - - Property value = Mockito.mock(Property.class); - Mockito.when(edge.property(Mockito.any())).thenThrow(RuntimeException.class); - - // default test - result = dao.getProperty(edge, EdgePropertyEnum.STATE); - } - - @Test - public void testGetBelongingEdgeByCriteria_1() throws Exception { - - String parentId = ""; - EdgeLabelEnum label = null; - Map properties = null; - Either result; - - // default test - - result = dao.getBelongingEdgeByCriteria(parentId, label, properties); - } -} \ No newline at end of file diff --git a/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/titan/TitanUtilsTest.java b/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/titan/TitanUtilsTest.java deleted file mode 100644 index 641eec5773..0000000000 --- a/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/titan/TitanUtilsTest.java +++ /dev/null @@ -1,21 +0,0 @@ -package org.openecomp.sdc.be.dao.titan; - -import com.thinkaurelius.titan.graphdb.query.TitanPredicate; -import org.apache.tinkerpop.gremlin.structure.T; -import org.junit.Test; - -import java.util.Collection; -import java.util.Map; -import java.util.Map.Entry; -public class TitanUtilsTest { - - @Test - public void testBuildNotInPredicate() throws Exception { - String propKey = ""; - Collection notInCollection = null; - Map> result; - - // default test - result = TitanUtils.buildNotInPredicate(propKey, notInCollection); - } -} \ No newline at end of file diff --git a/catalog-dao/src/test/java/org/openecomp/sdc/be/resources/JanusGraphGenericDaoTest.java b/catalog-dao/src/test/java/org/openecomp/sdc/be/resources/JanusGraphGenericDaoTest.java new file mode 100644 index 0000000000..09ab6a1745 --- /dev/null +++ b/catalog-dao/src/test/java/org/openecomp/sdc/be/resources/JanusGraphGenericDaoTest.java @@ -0,0 +1,630 @@ +/*- + * ============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.resources; + +import com.google.gson.Gson; +import org.janusgraph.core.PropertyKey; +import org.janusgraph.core.JanusGraphEdge; +import org.janusgraph.core.JanusGraphFactory; +import org.janusgraph.core.JanusGraph; +import org.janusgraph.core.JanusGraphVertex; +import org.janusgraph.core.attribute.Text; +import org.janusgraph.core.schema.JanusGraphManagement; +import fj.data.Either; +import org.apache.commons.configuration.BaseConfiguration; +import org.apache.commons.lang3.tuple.ImmutablePair; +import org.apache.tinkerpop.gremlin.structure.Direction; +import org.apache.tinkerpop.gremlin.structure.Edge; +import org.apache.tinkerpop.gremlin.structure.Vertex; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.openecomp.sdc.be.config.ConfigurationManager; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; +import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels; +import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary; +import org.openecomp.sdc.be.dao.utils.UserStatusEnum; +import org.openecomp.sdc.be.datatypes.components.ResourceMetadataDataDefinition; +import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; +import org.openecomp.sdc.be.resources.data.*; +import org.openecomp.sdc.common.api.ConfigurationSource; +import org.openecomp.sdc.common.api.UserRoleEnum; +import org.openecomp.sdc.common.impl.ExternalConfiguration; +import org.openecomp.sdc.common.impl.FSConfigurationSource; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.TestExecutionListeners; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; +import org.springframework.test.context.support.DependencyInjectionTestExecutionListener; +import org.springframework.test.context.support.DirtiesContextTestExecutionListener; +import org.springframework.test.context.transaction.TransactionalTestExecutionListener; + +import javax.annotation.Resource; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration("classpath:application-context-test.xml") +@TestExecutionListeners(listeners = { DependencyInjectionTestExecutionListener.class, + DirtiesContextTestExecutionListener.class, TransactionalTestExecutionListener.class }) +public class JanusGraphGenericDaoTest { + private static Logger log = LoggerFactory.getLogger(JanusGraphGenericDaoTest.class.getName()); + private static ConfigurationManager configurationManager; + + @Resource(name = "janusgraph-generic-dao") + private JanusGraphGenericDao janusGraphDao; + + @BeforeClass + public static void setupBeforeClass() { + ExternalConfiguration.setAppName("catalog-dao"); + String appConfigDir = "src/test/resources/config/catalog-dao"; + ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), + appConfigDir); + configurationManager = new ConfigurationManager(configurationSource); + configurationManager.getConfiguration().setJanusGraphCfgFile("../catalog-be/src/main/resources/config/janusgraph.properties"); + configurationManager.getConfiguration().setJanusGraphInMemoryGraph(true); + } + + // @Test + public void testcheckEdgeProps() { + JanusGraph graph = janusGraphDao.getGraph().left().value(); + JanusGraphVertex v1 = graph.addVertex(); + v1.property("prop1", 123); + JanusGraphVertex v2 = graph.addVertex(); + v2.property("prop1", 456); + JanusGraphEdge addEdge = v1.addEdge("label11", v2); + addEdge.property("edgeProp", "my prop edge"); + graph.tx().commit(); + + Either v11 = janusGraphDao.getVertexByProperty("prop1", 123); + Iterator edges = v11.left().value().edges(Direction.OUT, "label11"); + Edge edge = edges.next(); + // String value = (String)edge.value("edgeProp"); + String value = (String) janusGraphDao.getProperty(edge, "edgeProp"); + log.debug(value); + + } + + @Test + public void testCrudNode() { + + String id = "userId12345abc"; + UserData userData = new UserData("Myname123", "Mylastname", id, "email123", "Tester", + UserStatusEnum.ACTIVE.name(), null); + + Either newNode = janusGraphDao.createNode(userData, UserData.class); + + assertTrue(newNode.isLeft()); + + log.debug("{}", newNode.left().value()); + + janusGraphDao.commit(); + + ImmutablePair keyValueId = userData.getKeyValueId(); + Either node = janusGraphDao.getNode(keyValueId.getKey(), keyValueId.getValue(), + UserData.class); + janusGraphDao.commit(); + assertTrue(node.isLeft()); + log.debug("{}", node.left().value()); + + userData.setRole("Designer"); + node = janusGraphDao.updateNode(userData, UserData.class); + assertTrue(node.isLeft()); + log.debug("{}", node.left().value()); + assertEquals(null, "Designer", node.left().value().getRole()); + janusGraphDao.commit(); + + node = janusGraphDao.deleteNode(userData, UserData.class); + assertTrue(node.isLeft()); + log.debug("{}", node.left().value()); + janusGraphDao.commit(); + + node = janusGraphDao.getNode(keyValueId.getKey(), keyValueId.getValue(), UserData.class); + assertTrue(node.isRight()); + log.debug("{}", node.right().value()); + + } + + @Test + public void testGetByCategoryAndAll() { + + // create 2 nodes + String id = "userId12345abc"; + UserData userData1 = new UserData("Myname123", "Mylastname", id, "email123", "Tester", + UserStatusEnum.ACTIVE.name(), null); + + Either node1 = janusGraphDao.createNode(userData1, UserData.class); + assertTrue(node1.isLeft()); + log.debug("{}", node1.left().value()); + + id = "userIddfkoer45abc"; + UserData userData2 = new UserData("Mynadyhme123", "Mylasghtname", id, "emaighdl123", "Designer", + UserStatusEnum.ACTIVE.name(), null); + Either node2 = janusGraphDao.createNode(userData2, UserData.class); + assertTrue(node2.isLeft()); + log.debug("{}", node2.left().value()); + + janusGraphDao.commit(); + + ImmutablePair keyValueId1 = userData1.getKeyValueId(); + // get first node + Either node = janusGraphDao.getNode(keyValueId1.getKey(), keyValueId1.getValue(), + UserData.class); + assertTrue(node.isLeft()); + log.debug("{}", node.left().value()); + janusGraphDao.commit(); + + // get all must be 2 + 1 default user = 3 + Either, JanusGraphOperationStatus> all = janusGraphDao.getAll(NodeTypeEnum.User, UserData.class); + assertTrue(all.isLeft()); + assertTrue(all.left().value().size() > 0); + + log.debug("{}", all.left().value()); + + Map props = new HashMap<>(); + + props.put(keyValueId1.getKey(), keyValueId1.getValue()); + + // get by criteria. must be 1 + Either, JanusGraphOperationStatus> byCriteria = janusGraphDao.getByCriteria(NodeTypeEnum.User, props, + UserData.class); + assertTrue(byCriteria.isLeft()); + assertEquals(1, byCriteria.left().value().size()); + + log.debug("{}", byCriteria.left().value()); + + // delete all nodes + node = janusGraphDao.deleteNode(userData1, UserData.class); + assertTrue(node.isLeft()); + node = janusGraphDao.deleteNode(userData2, UserData.class); + assertTrue(node.isLeft()); + } + + @Test + public void testGetEdgesForNode() { + String id = "userId12345abc"; + UserData userData = new UserData("Myname123", "Mylastname", id, "email123", UserRoleEnum.ADMIN.name(), + UserStatusEnum.ACTIVE.name(), null); + janusGraphDao.createNode(userData, UserData.class); + ResourceMetadataData resourceData = new ResourceMetadataData(); + resourceData.getMetadataDataDefinition().setName("resourceForLock"); + resourceData.getMetadataDataDefinition().setVersion("0.1"); + resourceData.getMetadataDataDefinition().setState("newState"); + resourceData.getMetadataDataDefinition().setUniqueId(resourceData.getMetadataDataDefinition().getName() + "." + + resourceData.getMetadataDataDefinition().getVersion()); + + janusGraphDao.createNode(resourceData, ResourceMetadataData.class); + janusGraphDao.createRelation(userData, resourceData, GraphEdgeLabels.LAST_MODIFIER, null); + janusGraphDao.commit(); + + Either, JanusGraphOperationStatus> eitherEdges = janusGraphDao.getEdgesForNode(userData, Direction.OUT); + assertTrue(eitherEdges.isLeft()); + assertEquals(1, eitherEdges.left().value().size()); + + eitherEdges = janusGraphDao.getEdgesForNode(userData, Direction.IN); + assertTrue(eitherEdges.isLeft()); + assertEquals(0, eitherEdges.left().value().size()); + + eitherEdges = janusGraphDao.getEdgesForNode(resourceData, Direction.OUT); + assertTrue(eitherEdges.isLeft()); + assertEquals(0, eitherEdges.left().value().size()); + + eitherEdges = janusGraphDao.getEdgesForNode(resourceData, Direction.IN); + assertTrue(eitherEdges.isLeft()); + assertEquals(1, eitherEdges.left().value().size()); + + eitherEdges = janusGraphDao.getEdgesForNode(resourceData, Direction.BOTH); + assertTrue(eitherEdges.isLeft()); + assertEquals(1, eitherEdges.left().value().size()); + + eitherEdges = janusGraphDao.getEdgesForNode(userData, Direction.BOTH); + assertTrue(eitherEdges.isLeft()); + assertEquals(1, eitherEdges.left().value().size()); + + janusGraphDao.deleteNode(userData, UserData.class); + janusGraphDao.deleteNode(resourceData, ResourceMetadataData.class); + janusGraphDao.commit(); + } + + @Test + public void testLockElement() { + + ResourceMetadataData resourceData = new ResourceMetadataData(); + + resourceData.getMetadataDataDefinition().setName("resourceForLock"); + resourceData.getMetadataDataDefinition().setVersion("0.1"); + resourceData.getMetadataDataDefinition().setState("newState"); + resourceData.getMetadataDataDefinition().setUniqueId(resourceData.getMetadataDataDefinition().getName() + "." + + resourceData.getMetadataDataDefinition().getVersion()); + + Either resource1 = janusGraphDao.createNode(resourceData, + ResourceMetadataData.class); + assertTrue(resource1.isLeft()); + janusGraphDao.commit(); + String lockId = "lock_" + resourceData.getLabel() + "_" + resource1.left().value().getUniqueId(); + + Either nodeLock = janusGraphDao + .getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class); + assertTrue(nodeLock.isRight()); + assertEquals(JanusGraphOperationStatus.NOT_FOUND, nodeLock.right().value()); + + JanusGraphOperationStatus status = janusGraphDao.lockElement(resourceData); + assertEquals(JanusGraphOperationStatus.OK, status); + + nodeLock = janusGraphDao.getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class); + assertTrue(nodeLock.isLeft()); + assertEquals(lockId, nodeLock.left().value().getUniqueId()); + + janusGraphDao.commit(); + + status = janusGraphDao.lockElement(resourceData); + assertEquals(JanusGraphOperationStatus.ALREADY_LOCKED, status); + + status = janusGraphDao.releaseElement(resourceData); + assertEquals(JanusGraphOperationStatus.OK, status); + + nodeLock = janusGraphDao.getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class); + assertTrue(nodeLock.isRight()); + assertEquals(JanusGraphOperationStatus.NOT_FOUND, nodeLock.right().value()); + janusGraphDao.deleteNode(resourceData, ResourceMetadataData.class); + janusGraphDao.commit(); + + } + + @Test + public void testReLockElement() throws InterruptedException { + + ResourceMetadataData resourceData = new ResourceMetadataData(); + + resourceData.getMetadataDataDefinition().setName("resourceForReLock"); + resourceData.getMetadataDataDefinition().setVersion("0.1"); + resourceData.getMetadataDataDefinition().setState("newState"); + resourceData.getMetadataDataDefinition().setUniqueId(resourceData.getMetadataDataDefinition().getName() + "." + + resourceData.getMetadataDataDefinition().getVersion()); + + Either resource1 = janusGraphDao.createNode(resourceData, + ResourceMetadataData.class); + assertTrue(resource1.isLeft()); + janusGraphDao.commit(); + String lockId = "lock_" + resourceData.getLabel() + "_" + resource1.left().value().getUniqueId(); + + Either nodeLock = janusGraphDao + .getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class); + assertTrue(nodeLock.isRight()); + assertEquals(JanusGraphOperationStatus.NOT_FOUND, nodeLock.right().value()); + + // lock + JanusGraphOperationStatus status = janusGraphDao.lockElement(resourceData); + assertEquals(JanusGraphOperationStatus.OK, status); + + nodeLock = janusGraphDao.getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class); + assertTrue(nodeLock.isLeft()); + assertEquals(lockId, nodeLock.left().value().getUniqueId()); + long time1 = nodeLock.left().value().getTime(); + + janusGraphDao.commit(); + + // timeout + configurationManager.getConfiguration().setJanusGraphLockTimeout(2L); + Thread.sleep(5001); + + // relock + status = janusGraphDao.lockElement(resourceData); + assertEquals(JanusGraphOperationStatus.OK, status); + + nodeLock = janusGraphDao.getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class); + assertTrue(nodeLock.isLeft()); + assertEquals(lockId, nodeLock.left().value().getUniqueId()); + + long time2 = nodeLock.left().value().getTime(); + + assertTrue(time2 > time1); + + status = janusGraphDao.releaseElement(resourceData); + assertEquals(JanusGraphOperationStatus.OK, status); + + nodeLock = janusGraphDao.getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class); + assertTrue(nodeLock.isRight()); + assertEquals(JanusGraphOperationStatus.NOT_FOUND, nodeLock.right().value()); + + janusGraphDao.deleteNode(resourceData, ResourceMetadataData.class); + janusGraphDao.commit(); + + } + + @Test + public void testBoolean() { + ResourceMetadataData resourceData = new ResourceMetadataData(); + + resourceData.getMetadataDataDefinition().setName("resourceForLock"); + resourceData.getMetadataDataDefinition().setVersion("0.1"); + resourceData.getMetadataDataDefinition().setState("NOT_CERTIFIED_CHECKOUT"); + resourceData.getMetadataDataDefinition().setHighestVersion(true); + resourceData.getMetadataDataDefinition().setUniqueId(resourceData.getMetadataDataDefinition().getName() + "." + + resourceData.getMetadataDataDefinition().getVersion()); + + Either resource1 = janusGraphDao.createNode(resourceData, + ResourceMetadataData.class); + assertTrue(resource1.isLeft()); + + resourceData = new ResourceMetadataData(); + + resourceData.getMetadataDataDefinition().setName("resourceForLock"); + resourceData.getMetadataDataDefinition().setVersion("0.2"); + resourceData.getMetadataDataDefinition().setState("NOT_CERTIFIED_CHECKOUT"); + resourceData.getMetadataDataDefinition().setHighestVersion(false); + resourceData.getMetadataDataDefinition().setUniqueId(resourceData.getMetadataDataDefinition().getName() + "." + + resourceData.getMetadataDataDefinition().getVersion()); + + Either resource2 = janusGraphDao.createNode(resourceData, + ResourceMetadataData.class); + janusGraphDao.commit(); + + Map props = new HashMap<>(); + + props.put(GraphPropertiesDictionary.STATE.getProperty(), "NOT_CERTIFIED_CHECKOUT"); + props.put("name", "resourceForLock"); + props.put(GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty(), false); + + // get by criteria. must be 1 + Either, JanusGraphOperationStatus> byCriteria = janusGraphDao + .getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class); + assertTrue(byCriteria.isLeft()); + + janusGraphDao.deleteNode(resource1.left().value(), ResourceMetadataData.class); + + janusGraphDao.deleteNode(resource2.left().value(), ResourceMetadataData.class); + janusGraphDao.commit(); + } + + // @Test + public void testStringSearch() { + JanusGraph graph; + + BaseConfiguration conf = new BaseConfiguration(); + conf.setProperty("storage.backend", "inmemory"); + graph = JanusGraphFactory.open(conf); + + // JanusGraphManagement graphMgt = graph.getManagementSystem(); + JanusGraphManagement graphMgt = graph.openManagement(); + PropertyKey propKey = graphMgt.makePropertyKey("string1").dataType(String.class).make(); + graphMgt.buildIndex("string1", Vertex.class).addKey(propKey).unique().buildCompositeIndex(); + + propKey = graphMgt.makePropertyKey("string2").dataType(String.class).make(); + + graphMgt.buildIndex("string2", Vertex.class).addKey(propKey).unique().buildCompositeIndex(); + graphMgt.commit(); + + + log.debug("**** predicat index search non case"); + Iterable vertices = graph.query().has("string1", Text.REGEX, "my new string 1").vertices(); + Iterator iter = vertices.iterator(); + while (iter.hasNext()) { + Vertex ver = iter.next(); + // System.out.println(com.tinkerpop.blueprints.util.ElementHelper.getProperties(ver)); + log.debug("{}", janusGraphDao.getProperties(ver)); + } + + } + + @Test + public void testDuplicateResultDueToJanusGraphBug() { + + ResourceMetadataData resourceData1 = new ResourceMetadataData(); + resourceData1.getMetadataDataDefinition().setUniqueId("A"); + ((ResourceMetadataDataDefinition) resourceData1.getMetadataDataDefinition()).setAbstract(true); + resourceData1.getMetadataDataDefinition().setName("aaaa"); + + Either newNode1 = janusGraphDao.createNode(resourceData1, + ResourceMetadataData.class); + assertTrue(newNode1.isLeft()); + log.debug("{}", newNode1.left().value()); + // janusGraphDao.commit(); + + Map props = new HashMap<>(); + props.put(GraphPropertiesDictionary.IS_ABSTRACT.getProperty(), true); + Either, JanusGraphOperationStatus> byCriteria = janusGraphDao + .getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class); + assertTrue(byCriteria.isLeft()); + assertEquals("check one result returned", 1, byCriteria.left().value().size()); + // janusGraphDao.commit(); + + ResourceMetadataData resourceToUpdate = new ResourceMetadataData(); + ((ResourceMetadataDataDefinition) resourceToUpdate.getMetadataDataDefinition()).setAbstract(false); + resourceToUpdate.getMetadataDataDefinition().setUniqueId("A"); + Either updateNode = janusGraphDao.updateNode(resourceToUpdate, + ResourceMetadataData.class); + assertTrue(updateNode.isLeft()); + // janusGraphDao.commit(); + + byCriteria = janusGraphDao.getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class); + assertTrue(byCriteria.isRight()); + assertEquals("check one result returned due to janusgraph bug", JanusGraphOperationStatus.NOT_FOUND, + byCriteria.right().value()); + + AdditionalInfoParameterData infoParameterData = new AdditionalInfoParameterData(); + infoParameterData.getAdditionalInfoParameterDataDefinition().setUniqueId("123"); + Map idToKey = new HashMap<>(); + idToKey.put("key1", "value1"); + infoParameterData.setIdToKey(idToKey); + + Either newNode2 = janusGraphDao.createNode(infoParameterData, + AdditionalInfoParameterData.class); + assertTrue(newNode2.isLeft()); + log.debug("{}", newNode2.left().value()); + // janusGraphDao.commit(); + + Map idToKey2 = new HashMap<>(); + idToKey2.put("key1", "value2"); + + Map props2 = new HashMap<>(); + props2.put(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), "123"); + Gson gson = new Gson(); + props2.put(GraphPropertiesDictionary.ADDITIONAL_INFO_ID_TO_KEY.getProperty(), gson.toJson(idToKey2)); + // props2.put(GraphPropertiesDictionary.ADDITIONAL_INFO_ID_TO_KEY.getProperty(), + // idToKey2); + + Either, JanusGraphOperationStatus> byCriteria2 = janusGraphDao + .getByCriteria(NodeTypeEnum.AdditionalInfoParameters, props2, AdditionalInfoParameterData.class); + assertTrue(byCriteria2.isRight()); + assertEquals("check one result returned due to janusgraph bug", JanusGraphOperationStatus.NOT_FOUND, + byCriteria2.right().value()); + + infoParameterData.setIdToKey(idToKey2); + + Either updateNode2 = janusGraphDao.updateNode(infoParameterData, + AdditionalInfoParameterData.class); + assertTrue(updateNode2.isLeft()); + // janusGraphDao.commit(); + + props2.put(GraphPropertiesDictionary.ADDITIONAL_INFO_ID_TO_KEY.getProperty(), idToKey); + byCriteria2 = janusGraphDao.getByCriteria(NodeTypeEnum.AdditionalInfoParameters, props2, + AdditionalInfoParameterData.class); + assertTrue(byCriteria2.isRight()); + assertEquals("check one result returned due to janusgraph bug", JanusGraphOperationStatus.NOT_FOUND, + byCriteria2.right().value()); + + ComponentInstanceData resourceInstanceData = new ComponentInstanceData(); + resourceInstanceData.getComponentInstDataDefinition().setUniqueId("ri123"); + resourceInstanceData.getComponentInstDataDefinition().setPosX("22"); + resourceInstanceData.getComponentInstDataDefinition().setName("myresource_1"); + + Either newNode3 = janusGraphDao.createNode(resourceInstanceData, + ComponentInstanceData.class); + assertTrue(newNode3.isLeft()); + log.debug("{}", newNode3.left().value()); + // janusGraphDao.commit(); + + resourceInstanceData.getComponentInstDataDefinition().setPosX("50"); + Either updateNode3 = janusGraphDao.updateNode(resourceInstanceData, + ComponentInstanceData.class); + assertTrue(updateNode3.isLeft()); + // janusGraphDao.commit(); + + resourceInstanceData.getComponentInstDataDefinition().setName("myresource_2"); + updateNode3 = janusGraphDao.updateNode(resourceInstanceData, ComponentInstanceData.class); + assertTrue(updateNode3.isLeft()); + // janusGraphDao.commit(); + + Map props3 = new HashMap<>(); + props3.put("positionX", "22"); + Either, JanusGraphOperationStatus> byCriteria3 = janusGraphDao + .getByCriteria(NodeTypeEnum.ResourceInstance, props3, ComponentInstanceData.class); + assertTrue(byCriteria3.isRight()); + assertEquals("check one result returned due to janusgraph bug", JanusGraphOperationStatus.NOT_FOUND, + byCriteria3.right().value()); + + props3.put("positionX", "50"); + byCriteria3 = janusGraphDao.getByCriteria(NodeTypeEnum.ResourceInstance, props3, ComponentInstanceData.class); + assertTrue(byCriteria3.isLeft()); + + /////////////////////////// check integer //////////////////////// + + ArtifactData artifactData = new ArtifactData(); + artifactData.getArtifactDataDefinition().setUniqueId("ad234"); + artifactData.getArtifactDataDefinition().setTimeout(100); + + Either newNode4 = janusGraphDao.createNode(artifactData, ArtifactData.class); + assertTrue(newNode4.isLeft()); + log.debug("{}", newNode4.left().value()); + // janusGraphDao.commit(); + + artifactData.getArtifactDataDefinition().setTimeout(50); + Either updateNode4 = janusGraphDao.updateNode(artifactData, ArtifactData.class); + assertTrue(updateNode4.isLeft()); + // janusGraphDao.commit(); + + Map props4 = new HashMap<>(); + props4.put("timeout", 100); + Either, JanusGraphOperationStatus> byCriteria4 = janusGraphDao.getByCriteria(NodeTypeEnum.ArtifactRef, + props4, ArtifactData.class); + assertTrue(byCriteria4.isRight()); + assertEquals("check one result returned due to janusgraph bug", JanusGraphOperationStatus.NOT_FOUND, + byCriteria4.right().value()); + + props4.put("timeout", 50); + byCriteria4 = janusGraphDao.getByCriteria(NodeTypeEnum.ArtifactRef, props4, ArtifactData.class); + assertTrue(byCriteria4.isLeft()); + + janusGraphDao.rollback(); + } + + @Test + public void testDuplicateResultUSeHasNotQueryDueToJanusGraphBug() { + + String name = "bbbb"; + + ResourceMetadataData resourceData1 = new ResourceMetadataData(); + resourceData1.getMetadataDataDefinition().setUniqueId("A"); + ((ResourceMetadataDataDefinition) resourceData1.getMetadataDataDefinition()).setAbstract(true); + resourceData1.getMetadataDataDefinition().setName(name); + + Either newNode1 = janusGraphDao.createNode(resourceData1, + ResourceMetadataData.class); + assertTrue(newNode1.isLeft()); + log.debug("{}", newNode1.left().value()); + // janusGraphDao.commit(); + + Map props = new HashMap<>(); + props.put(GraphPropertiesDictionary.IS_ABSTRACT.getProperty(), true); + Either, JanusGraphOperationStatus> byCriteria = janusGraphDao + .getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class); + assertTrue(byCriteria.isLeft()); + assertEquals("check one result returned", 1, byCriteria.left().value().size()); + // janusGraphDao.commit(); + + ResourceMetadataData resourceToUpdate = new ResourceMetadataData(); + ((ResourceMetadataDataDefinition) resourceToUpdate.getMetadataDataDefinition()).setAbstract(false); + resourceToUpdate.getMetadataDataDefinition().setUniqueId("A"); + Either updateNode = janusGraphDao.updateNode(resourceToUpdate, + ResourceMetadataData.class); + assertTrue(updateNode.isLeft()); + // janusGraphDao.commit(); + + // no result where isAbstract = true + byCriteria = janusGraphDao.getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class); + assertTrue(byCriteria.isRight()); + assertEquals("check one result returned due to janusgraph bug", JanusGraphOperationStatus.NOT_FOUND, + byCriteria.right().value()); + + // one result where isAbstract != true + byCriteria = janusGraphDao.getByCriteria(NodeTypeEnum.Resource, null, props, ResourceMetadataData.class); + assertTrue(byCriteria.isLeft()); + assertEquals("check one result returned", 1, byCriteria.left().value().size()); + + props.put(GraphPropertiesDictionary.IS_ABSTRACT.getProperty(), false); + byCriteria = janusGraphDao.getByCriteria(NodeTypeEnum.Resource, null, props, ResourceMetadataData.class); + assertTrue(byCriteria.isRight()); + assertEquals("check one result returned due to janusgraph bug", JanusGraphOperationStatus.NOT_FOUND, + byCriteria.right().value()); + + janusGraphDao.rollback(); + + } + +} diff --git a/catalog-dao/src/test/java/org/openecomp/sdc/be/resources/TitanGenericDaoTest.java b/catalog-dao/src/test/java/org/openecomp/sdc/be/resources/TitanGenericDaoTest.java deleted file mode 100644 index e8c6b3cdd1..0000000000 --- a/catalog-dao/src/test/java/org/openecomp/sdc/be/resources/TitanGenericDaoTest.java +++ /dev/null @@ -1,631 +0,0 @@ -/*- - * ============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.resources; - -import com.google.gson.Gson; -import com.thinkaurelius.titan.core.PropertyKey; -import com.thinkaurelius.titan.core.TitanEdge; -import com.thinkaurelius.titan.core.TitanFactory; -import com.thinkaurelius.titan.core.TitanGraph; -import com.thinkaurelius.titan.core.TitanVertex; -import com.thinkaurelius.titan.core.attribute.Text; -import com.thinkaurelius.titan.core.schema.TitanManagement; -import fj.data.Either; -import org.apache.commons.configuration.BaseConfiguration; -import org.apache.commons.lang3.tuple.ImmutablePair; -import org.apache.tinkerpop.gremlin.structure.Direction; -import org.apache.tinkerpop.gremlin.structure.Edge; -import org.apache.tinkerpop.gremlin.structure.Vertex; -import org.junit.BeforeClass; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.openecomp.sdc.be.config.ConfigurationManager; -import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels; -import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary; -import org.openecomp.sdc.be.dao.titan.TitanGenericDao; -import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; -import org.openecomp.sdc.be.dao.utils.UserStatusEnum; -import org.openecomp.sdc.be.datatypes.components.ResourceMetadataDataDefinition; -import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; -import org.openecomp.sdc.be.resources.data.*; -import org.openecomp.sdc.common.api.ConfigurationSource; -import org.openecomp.sdc.common.api.UserRoleEnum; -import org.openecomp.sdc.common.impl.ExternalConfiguration; -import org.openecomp.sdc.common.impl.FSConfigurationSource; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; -import org.springframework.test.context.ContextConfiguration; -import org.springframework.test.context.TestExecutionListeners; -import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; -import org.springframework.test.context.support.DependencyInjectionTestExecutionListener; -import org.springframework.test.context.support.DirtiesContextTestExecutionListener; -import org.springframework.test.context.transaction.TransactionalTestExecutionListener; - -import javax.annotation.Resource; -import java.util.HashMap; -import java.util.Iterator; -import java.util.List; -import java.util.Map; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; - -@RunWith(SpringJUnit4ClassRunner.class) -@ContextConfiguration("classpath:application-context-test.xml") -@TestExecutionListeners(listeners = { DependencyInjectionTestExecutionListener.class, - DirtiesContextTestExecutionListener.class, TransactionalTestExecutionListener.class }) -public class TitanGenericDaoTest { - private static Logger log = LoggerFactory.getLogger(TitanGenericDaoTest.class.getName()); - private static ConfigurationManager configurationManager; - - @Resource(name = "titan-generic-dao") - private TitanGenericDao titanDao; - - @BeforeClass - public static void setupBeforeClass() { - ExternalConfiguration.setAppName("catalog-dao"); - String appConfigDir = "src/test/resources/config/catalog-dao"; - ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), - appConfigDir); - configurationManager = new ConfigurationManager(configurationSource); - configurationManager.getConfiguration() - .setTitanCfgFile("../catalog-be/src/main/resources/config/titan.properties"); - configurationManager.getConfiguration().setTitanInMemoryGraph(true); - } - - // @Test - public void testcheckEdgeProps() { - TitanGraph graph = titanDao.getGraph().left().value(); - TitanVertex v1 = graph.addVertex(); - v1.property("prop1", 123); - TitanVertex v2 = graph.addVertex(); - v2.property("prop1", 456); - TitanEdge addEdge = v1.addEdge("label11", v2); - addEdge.property("edgeProp", "my prop edge"); - graph.tx().commit(); - - Either v11 = titanDao.getVertexByProperty("prop1", 123); - Iterator edges = v11.left().value().edges(Direction.OUT, "label11"); - Edge edge = edges.next(); - // String value = (String)edge.value("edgeProp"); - String value = (String) titanDao.getProperty(edge, "edgeProp"); - log.debug(value); - - } - - @Test - public void testCrudNode() { - - String id = "userId12345abc"; - UserData userData = new UserData("Myname123", "Mylastname", id, "email123", "Tester", - UserStatusEnum.ACTIVE.name(), null); - - Either newNode = titanDao.createNode(userData, UserData.class); - - assertTrue(newNode.isLeft()); - - log.debug("{}", newNode.left().value()); - - titanDao.commit(); - - ImmutablePair keyValueId = userData.getKeyValueId(); - Either node = titanDao.getNode(keyValueId.getKey(), keyValueId.getValue(), - UserData.class); - titanDao.commit(); - assertTrue(node.isLeft()); - log.debug("{}", node.left().value()); - - userData.setRole("Designer"); - node = titanDao.updateNode(userData, UserData.class); - assertTrue(node.isLeft()); - log.debug("{}", node.left().value()); - assertEquals(null, "Designer", node.left().value().getRole()); - titanDao.commit(); - - node = titanDao.deleteNode(userData, UserData.class); - assertTrue(node.isLeft()); - log.debug("{}", node.left().value()); - titanDao.commit(); - - node = titanDao.getNode(keyValueId.getKey(), keyValueId.getValue(), UserData.class); - assertTrue(node.isRight()); - log.debug("{}", node.right().value()); - - } - - @Test - public void testGetByCategoryAndAll() { - - // create 2 nodes - String id = "userId12345abc"; - UserData userData1 = new UserData("Myname123", "Mylastname", id, "email123", "Tester", - UserStatusEnum.ACTIVE.name(), null); - - Either node1 = titanDao.createNode(userData1, UserData.class); - assertTrue(node1.isLeft()); - log.debug("{}", node1.left().value()); - - id = "userIddfkoer45abc"; - UserData userData2 = new UserData("Mynadyhme123", "Mylasghtname", id, "emaighdl123", "Designer", - UserStatusEnum.ACTIVE.name(), null); - Either node2 = titanDao.createNode(userData2, UserData.class); - assertTrue(node2.isLeft()); - log.debug("{}", node2.left().value()); - - titanDao.commit(); - - ImmutablePair keyValueId1 = userData1.getKeyValueId(); - // get first node - Either node = titanDao.getNode(keyValueId1.getKey(), keyValueId1.getValue(), - UserData.class); - assertTrue(node.isLeft()); - log.debug("{}", node.left().value()); - titanDao.commit(); - - // get all must be 2 + 1 default user = 3 - Either, TitanOperationStatus> all = titanDao.getAll(NodeTypeEnum.User, UserData.class); - assertTrue(all.isLeft()); - assertTrue(all.left().value().size() > 0); - - log.debug("{}", all.left().value()); - - Map props = new HashMap<>(); - - props.put(keyValueId1.getKey(), keyValueId1.getValue()); - - // get by criteria. must be 1 - Either, TitanOperationStatus> byCriteria = titanDao.getByCriteria(NodeTypeEnum.User, props, - UserData.class); - assertTrue(byCriteria.isLeft()); - assertEquals(1, byCriteria.left().value().size()); - - log.debug("{}", byCriteria.left().value()); - - // delete all nodes - node = titanDao.deleteNode(userData1, UserData.class); - assertTrue(node.isLeft()); - node = titanDao.deleteNode(userData2, UserData.class); - assertTrue(node.isLeft()); - } - - @Test - public void testGetEdgesForNode() { - String id = "userId12345abc"; - UserData userData = new UserData("Myname123", "Mylastname", id, "email123", UserRoleEnum.ADMIN.name(), - UserStatusEnum.ACTIVE.name(), null); - titanDao.createNode(userData, UserData.class); - ResourceMetadataData resourceData = new ResourceMetadataData(); - resourceData.getMetadataDataDefinition().setName("resourceForLock"); - resourceData.getMetadataDataDefinition().setVersion("0.1"); - resourceData.getMetadataDataDefinition().setState("newState"); - resourceData.getMetadataDataDefinition().setUniqueId(resourceData.getMetadataDataDefinition().getName() + "." - + resourceData.getMetadataDataDefinition().getVersion()); - - titanDao.createNode(resourceData, ResourceMetadataData.class); - titanDao.createRelation(userData, resourceData, GraphEdgeLabels.LAST_MODIFIER, null); - titanDao.commit(); - - Either, TitanOperationStatus> eitherEdges = titanDao.getEdgesForNode(userData, Direction.OUT); - assertTrue(eitherEdges.isLeft()); - assertEquals(1, eitherEdges.left().value().size()); - - eitherEdges = titanDao.getEdgesForNode(userData, Direction.IN); - assertTrue(eitherEdges.isLeft()); - assertEquals(0, eitherEdges.left().value().size()); - - eitherEdges = titanDao.getEdgesForNode(resourceData, Direction.OUT); - assertTrue(eitherEdges.isLeft()); - assertEquals(0, eitherEdges.left().value().size()); - - eitherEdges = titanDao.getEdgesForNode(resourceData, Direction.IN); - assertTrue(eitherEdges.isLeft()); - assertEquals(1, eitherEdges.left().value().size()); - - eitherEdges = titanDao.getEdgesForNode(resourceData, Direction.BOTH); - assertTrue(eitherEdges.isLeft()); - assertEquals(1, eitherEdges.left().value().size()); - - eitherEdges = titanDao.getEdgesForNode(userData, Direction.BOTH); - assertTrue(eitherEdges.isLeft()); - assertEquals(1, eitherEdges.left().value().size()); - - titanDao.deleteNode(userData, UserData.class); - titanDao.deleteNode(resourceData, ResourceMetadataData.class); - titanDao.commit(); - } - - @Test - public void testLockElement() { - - ResourceMetadataData resourceData = new ResourceMetadataData(); - - resourceData.getMetadataDataDefinition().setName("resourceForLock"); - resourceData.getMetadataDataDefinition().setVersion("0.1"); - resourceData.getMetadataDataDefinition().setState("newState"); - resourceData.getMetadataDataDefinition().setUniqueId(resourceData.getMetadataDataDefinition().getName() + "." - + resourceData.getMetadataDataDefinition().getVersion()); - - Either resource1 = titanDao.createNode(resourceData, - ResourceMetadataData.class); - assertTrue(resource1.isLeft()); - titanDao.commit(); - String lockId = "lock_" + resourceData.getLabel() + "_" + resource1.left().value().getUniqueId(); - - Either nodeLock = titanDao - .getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class); - assertTrue(nodeLock.isRight()); - assertEquals(TitanOperationStatus.NOT_FOUND, nodeLock.right().value()); - - TitanOperationStatus status = titanDao.lockElement(resourceData); - assertEquals(TitanOperationStatus.OK, status); - - nodeLock = titanDao.getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class); - assertTrue(nodeLock.isLeft()); - assertEquals(lockId, nodeLock.left().value().getUniqueId()); - - titanDao.commit(); - - status = titanDao.lockElement(resourceData); - assertEquals(TitanOperationStatus.ALREADY_LOCKED, status); - - status = titanDao.releaseElement(resourceData); - assertEquals(TitanOperationStatus.OK, status); - - nodeLock = titanDao.getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class); - assertTrue(nodeLock.isRight()); - assertEquals(TitanOperationStatus.NOT_FOUND, nodeLock.right().value()); - titanDao.deleteNode(resourceData, ResourceMetadataData.class); - titanDao.commit(); - - } - - @Test - public void testReLockElement() throws InterruptedException { - - ResourceMetadataData resourceData = new ResourceMetadataData(); - - resourceData.getMetadataDataDefinition().setName("resourceForReLock"); - resourceData.getMetadataDataDefinition().setVersion("0.1"); - resourceData.getMetadataDataDefinition().setState("newState"); - resourceData.getMetadataDataDefinition().setUniqueId(resourceData.getMetadataDataDefinition().getName() + "." - + resourceData.getMetadataDataDefinition().getVersion()); - - Either resource1 = titanDao.createNode(resourceData, - ResourceMetadataData.class); - assertTrue(resource1.isLeft()); - titanDao.commit(); - String lockId = "lock_" + resourceData.getLabel() + "_" + resource1.left().value().getUniqueId(); - - Either nodeLock = titanDao - .getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class); - assertTrue(nodeLock.isRight()); - assertEquals(TitanOperationStatus.NOT_FOUND, nodeLock.right().value()); - - // lock - TitanOperationStatus status = titanDao.lockElement(resourceData); - assertEquals(TitanOperationStatus.OK, status); - - nodeLock = titanDao.getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class); - assertTrue(nodeLock.isLeft()); - assertEquals(lockId, nodeLock.left().value().getUniqueId()); - long time1 = nodeLock.left().value().getTime(); - - titanDao.commit(); - - // timeout - configurationManager.getConfiguration().setTitanLockTimeout(2L); - Thread.sleep(5001); - - // relock - status = titanDao.lockElement(resourceData); - assertEquals(TitanOperationStatus.OK, status); - - nodeLock = titanDao.getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class); - assertTrue(nodeLock.isLeft()); - assertEquals(lockId, nodeLock.left().value().getUniqueId()); - - long time2 = nodeLock.left().value().getTime(); - - assertTrue(time2 > time1); - - status = titanDao.releaseElement(resourceData); - assertEquals(TitanOperationStatus.OK, status); - - nodeLock = titanDao.getNode(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), lockId, GraphNodeLock.class); - assertTrue(nodeLock.isRight()); - assertEquals(TitanOperationStatus.NOT_FOUND, nodeLock.right().value()); - - titanDao.deleteNode(resourceData, ResourceMetadataData.class); - titanDao.commit(); - - } - - @Test - public void testBoolean() { - ResourceMetadataData resourceData = new ResourceMetadataData(); - - resourceData.getMetadataDataDefinition().setName("resourceForLock"); - resourceData.getMetadataDataDefinition().setVersion("0.1"); - resourceData.getMetadataDataDefinition().setState("NOT_CERTIFIED_CHECKOUT"); - resourceData.getMetadataDataDefinition().setHighestVersion(true); - resourceData.getMetadataDataDefinition().setUniqueId(resourceData.getMetadataDataDefinition().getName() + "." - + resourceData.getMetadataDataDefinition().getVersion()); - - Either resource1 = titanDao.createNode(resourceData, - ResourceMetadataData.class); - assertTrue(resource1.isLeft()); - - resourceData = new ResourceMetadataData(); - - resourceData.getMetadataDataDefinition().setName("resourceForLock"); - resourceData.getMetadataDataDefinition().setVersion("0.2"); - resourceData.getMetadataDataDefinition().setState("NOT_CERTIFIED_CHECKOUT"); - resourceData.getMetadataDataDefinition().setHighestVersion(false); - resourceData.getMetadataDataDefinition().setUniqueId(resourceData.getMetadataDataDefinition().getName() + "." - + resourceData.getMetadataDataDefinition().getVersion()); - - Either resource2 = titanDao.createNode(resourceData, - ResourceMetadataData.class); - titanDao.commit(); - - Map props = new HashMap<>(); - - props.put(GraphPropertiesDictionary.STATE.getProperty(), "NOT_CERTIFIED_CHECKOUT"); - props.put("name", "resourceForLock"); - props.put(GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty(), false); - - // get by criteria. must be 1 - Either, TitanOperationStatus> byCriteria = titanDao - .getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class); - assertTrue(byCriteria.isLeft()); - - titanDao.deleteNode(resource1.left().value(), ResourceMetadataData.class); - - titanDao.deleteNode(resource2.left().value(), ResourceMetadataData.class); - titanDao.commit(); - } - - // @Test - public void testStringSearch() { - TitanGraph graph; - - BaseConfiguration conf = new BaseConfiguration(); - conf.setProperty("storage.backend", "inmemory"); - graph = TitanFactory.open(conf); - - // TitanManagement graphMgt = graph.getManagementSystem(); - TitanManagement graphMgt = graph.openManagement(); - PropertyKey propKey = graphMgt.makePropertyKey("string1").dataType(String.class).make(); - graphMgt.buildIndex("string1", Vertex.class).addKey(propKey).unique().buildCompositeIndex(); - - propKey = graphMgt.makePropertyKey("string2").dataType(String.class).make(); - - graphMgt.buildIndex("string2", Vertex.class).addKey(propKey).unique().buildCompositeIndex(); - graphMgt.commit(); - - - log.debug("**** predicat index search non case"); - Iterable vertices = graph.query().has("string1", Text.REGEX, "my new string 1").vertices(); - Iterator iter = vertices.iterator(); - while (iter.hasNext()) { - Vertex ver = iter.next(); - // System.out.println(com.tinkerpop.blueprints.util.ElementHelper.getProperties(ver)); - log.debug("{}", titanDao.getProperties(ver)); - } - - } - - @Test - public void testDuplicateResultDueToTitanBug() { - - ResourceMetadataData resourceData1 = new ResourceMetadataData(); - resourceData1.getMetadataDataDefinition().setUniqueId("A"); - ((ResourceMetadataDataDefinition) resourceData1.getMetadataDataDefinition()).setAbstract(true); - resourceData1.getMetadataDataDefinition().setName("aaaa"); - - Either newNode1 = titanDao.createNode(resourceData1, - ResourceMetadataData.class); - assertTrue(newNode1.isLeft()); - log.debug("{}", newNode1.left().value()); - // titanDao.commit(); - - Map props = new HashMap<>(); - props.put(GraphPropertiesDictionary.IS_ABSTRACT.getProperty(), true); - Either, TitanOperationStatus> byCriteria = titanDao - .getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class); - assertTrue(byCriteria.isLeft()); - assertEquals("check one result returned", 1, byCriteria.left().value().size()); - // titanDao.commit(); - - ResourceMetadataData resourceToUpdate = new ResourceMetadataData(); - ((ResourceMetadataDataDefinition) resourceToUpdate.getMetadataDataDefinition()).setAbstract(false); - resourceToUpdate.getMetadataDataDefinition().setUniqueId("A"); - Either updateNode = titanDao.updateNode(resourceToUpdate, - ResourceMetadataData.class); - assertTrue(updateNode.isLeft()); - // titanDao.commit(); - - byCriteria = titanDao.getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class); - assertTrue(byCriteria.isRight()); - assertEquals("check one result returned due to titan bug", TitanOperationStatus.NOT_FOUND, - byCriteria.right().value()); - - AdditionalInfoParameterData infoParameterData = new AdditionalInfoParameterData(); - infoParameterData.getAdditionalInfoParameterDataDefinition().setUniqueId("123"); - Map idToKey = new HashMap<>(); - idToKey.put("key1", "value1"); - infoParameterData.setIdToKey(idToKey); - - Either newNode2 = titanDao.createNode(infoParameterData, - AdditionalInfoParameterData.class); - assertTrue(newNode2.isLeft()); - log.debug("{}", newNode2.left().value()); - // titanDao.commit(); - - Map idToKey2 = new HashMap<>(); - idToKey2.put("key1", "value2"); - - Map props2 = new HashMap<>(); - props2.put(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), "123"); - Gson gson = new Gson(); - props2.put(GraphPropertiesDictionary.ADDITIONAL_INFO_ID_TO_KEY.getProperty(), gson.toJson(idToKey2)); - // props2.put(GraphPropertiesDictionary.ADDITIONAL_INFO_ID_TO_KEY.getProperty(), - // idToKey2); - - Either, TitanOperationStatus> byCriteria2 = titanDao - .getByCriteria(NodeTypeEnum.AdditionalInfoParameters, props2, AdditionalInfoParameterData.class); - assertTrue(byCriteria2.isRight()); - assertEquals("check one result returned due to titan bug", TitanOperationStatus.NOT_FOUND, - byCriteria2.right().value()); - - infoParameterData.setIdToKey(idToKey2); - - Either updateNode2 = titanDao.updateNode(infoParameterData, - AdditionalInfoParameterData.class); - assertTrue(updateNode2.isLeft()); - // titanDao.commit(); - - props2.put(GraphPropertiesDictionary.ADDITIONAL_INFO_ID_TO_KEY.getProperty(), idToKey); - byCriteria2 = titanDao.getByCriteria(NodeTypeEnum.AdditionalInfoParameters, props2, - AdditionalInfoParameterData.class); - assertTrue(byCriteria2.isRight()); - assertEquals("check one result returned due to titan bug", TitanOperationStatus.NOT_FOUND, - byCriteria2.right().value()); - - ComponentInstanceData resourceInstanceData = new ComponentInstanceData(); - resourceInstanceData.getComponentInstDataDefinition().setUniqueId("ri123"); - resourceInstanceData.getComponentInstDataDefinition().setPosX("22"); - resourceInstanceData.getComponentInstDataDefinition().setName("myresource_1"); - - Either newNode3 = titanDao.createNode(resourceInstanceData, - ComponentInstanceData.class); - assertTrue(newNode3.isLeft()); - log.debug("{}", newNode3.left().value()); - // titanDao.commit(); - - resourceInstanceData.getComponentInstDataDefinition().setPosX("50"); - Either updateNode3 = titanDao.updateNode(resourceInstanceData, - ComponentInstanceData.class); - assertTrue(updateNode3.isLeft()); - // titanDao.commit(); - - resourceInstanceData.getComponentInstDataDefinition().setName("myresource_2"); - updateNode3 = titanDao.updateNode(resourceInstanceData, ComponentInstanceData.class); - assertTrue(updateNode3.isLeft()); - // titanDao.commit(); - - Map props3 = new HashMap<>(); - props3.put("positionX", "22"); - Either, TitanOperationStatus> byCriteria3 = titanDao - .getByCriteria(NodeTypeEnum.ResourceInstance, props3, ComponentInstanceData.class); - assertTrue(byCriteria3.isRight()); - assertEquals("check one result returned due to titan bug", TitanOperationStatus.NOT_FOUND, - byCriteria3.right().value()); - - props3.put("positionX", "50"); - byCriteria3 = titanDao.getByCriteria(NodeTypeEnum.ResourceInstance, props3, ComponentInstanceData.class); - assertTrue(byCriteria3.isLeft()); - - /////////////////////////// check integer //////////////////////// - - ArtifactData artifactData = new ArtifactData(); - artifactData.getArtifactDataDefinition().setUniqueId("ad234"); - artifactData.getArtifactDataDefinition().setTimeout(100); - - Either newNode4 = titanDao.createNode(artifactData, ArtifactData.class); - assertTrue(newNode4.isLeft()); - log.debug("{}", newNode4.left().value()); - // titanDao.commit(); - - artifactData.getArtifactDataDefinition().setTimeout(50); - Either updateNode4 = titanDao.updateNode(artifactData, ArtifactData.class); - assertTrue(updateNode4.isLeft()); - // titanDao.commit(); - - Map props4 = new HashMap<>(); - props4.put("timeout", 100); - Either, TitanOperationStatus> byCriteria4 = titanDao.getByCriteria(NodeTypeEnum.ArtifactRef, - props4, ArtifactData.class); - assertTrue(byCriteria4.isRight()); - assertEquals("check one result returned due to titan bug", TitanOperationStatus.NOT_FOUND, - byCriteria4.right().value()); - - props4.put("timeout", 50); - byCriteria4 = titanDao.getByCriteria(NodeTypeEnum.ArtifactRef, props4, ArtifactData.class); - assertTrue(byCriteria4.isLeft()); - - titanDao.rollback(); - } - - @Test - public void testDuplicateResultUSeHasNotQueryDueToTitanBug() { - - String name = "bbbb"; - - ResourceMetadataData resourceData1 = new ResourceMetadataData(); - resourceData1.getMetadataDataDefinition().setUniqueId("A"); - ((ResourceMetadataDataDefinition) resourceData1.getMetadataDataDefinition()).setAbstract(true); - resourceData1.getMetadataDataDefinition().setName(name); - - Either newNode1 = titanDao.createNode(resourceData1, - ResourceMetadataData.class); - assertTrue(newNode1.isLeft()); - log.debug("{}", newNode1.left().value()); - // titanDao.commit(); - - Map props = new HashMap<>(); - props.put(GraphPropertiesDictionary.IS_ABSTRACT.getProperty(), true); - Either, TitanOperationStatus> byCriteria = titanDao - .getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class); - assertTrue(byCriteria.isLeft()); - assertEquals("check one result returned", 1, byCriteria.left().value().size()); - // titanDao.commit(); - - ResourceMetadataData resourceToUpdate = new ResourceMetadataData(); - ((ResourceMetadataDataDefinition) resourceToUpdate.getMetadataDataDefinition()).setAbstract(false); - resourceToUpdate.getMetadataDataDefinition().setUniqueId("A"); - Either updateNode = titanDao.updateNode(resourceToUpdate, - ResourceMetadataData.class); - assertTrue(updateNode.isLeft()); - // titanDao.commit(); - - // no result where isAbstract = true - byCriteria = titanDao.getByCriteria(NodeTypeEnum.Resource, props, ResourceMetadataData.class); - assertTrue(byCriteria.isRight()); - assertEquals("check one result returned due to titan bug", TitanOperationStatus.NOT_FOUND, - byCriteria.right().value()); - - // one result where isAbstract != true - byCriteria = titanDao.getByCriteria(NodeTypeEnum.Resource, null, props, ResourceMetadataData.class); - assertTrue(byCriteria.isLeft()); - assertEquals("check one result returned", 1, byCriteria.left().value().size()); - - props.put(GraphPropertiesDictionary.IS_ABSTRACT.getProperty(), false); - byCriteria = titanDao.getByCriteria(NodeTypeEnum.Resource, null, props, ResourceMetadataData.class); - assertTrue(byCriteria.isRight()); - assertEquals("check one result returned due to titan bug", TitanOperationStatus.NOT_FOUND, - byCriteria.right().value()); - - titanDao.rollback(); - - } - -} -- cgit 1.2.3-korg