diff options
Diffstat (limited to 'catalog-dao/src/test')
14 files changed, 1499 insertions, 168 deletions
diff --git a/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/es/ElasticSearchClientTest.java b/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/es/ElasticSearchClientTest.java index b5c971496b..e9661e9605 100644 --- a/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/es/ElasticSearchClientTest.java +++ b/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/es/ElasticSearchClientTest.java @@ -1,18 +1,30 @@ package org.openecomp.sdc.be.dao.es; -import javax.annotation.Generated; - import org.elasticsearch.client.Client; import org.junit.Test; +import org.openecomp.sdc.be.utils.DAOConfDependentTest; -@Generated(value = "org.junit-tools-1.0.6") -public class ElasticSearchClientTest { +public class ElasticSearchClientTest extends DAOConfDependentTest{ private ElasticSearchClient createTestSubject() { return new ElasticSearchClient(); } @Test + public void testInitialize() throws Exception { + ElasticSearchClient testSubject; + + // default test + testSubject = createTestSubject(); + testSubject.setTransportClient("true"); + testSubject.setLocal("true"); + testSubject.initialize(); + testSubject.setTransportClient("false"); + testSubject.setClusterName("false"); + testSubject.initialize(); + } + + @Test public void testClose() throws Exception { ElasticSearchClient testSubject; @@ -80,6 +92,9 @@ public class ElasticSearchClientTest { testSubject = createTestSubject(); strIsLocal = ""; testSubject.setLocal(strIsLocal); + + strIsLocal = "true"; + testSubject.setLocal(strIsLocal); } @@ -106,7 +121,7 @@ public class ElasticSearchClientTest { // test 2 testSubject = createTestSubject(); - strIsTransportclient = ""; + strIsTransportclient = "true"; testSubject.setTransportClient(strIsTransportclient); } }
\ No newline at end of file diff --git a/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/graph/GraphElementFactoryTest.java b/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/graph/GraphElementFactoryTest.java new file mode 100644 index 0000000000..588eb046a5 --- /dev/null +++ b/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/graph/GraphElementFactoryTest.java @@ -0,0 +1,76 @@ +package org.openecomp.sdc.be.dao.graph; + +import java.util.HashMap; +import java.util.Map; + +import org.apache.tinkerpop.gremlin.structure.T; +import org.junit.Test; +import org.mockito.Mockito; +import org.openecomp.sdc.be.dao.graph.datatype.GraphElementTypeEnum; +import org.openecomp.sdc.be.dao.graph.datatype.GraphNode; +import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation; +import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; + +import mockit.Deencapsulation; + +public class GraphElementFactoryTest { + + @Test + public void testCreateElement() throws Exception { + String label = "mock"; + Map<String, Object> properties = new HashMap<>(); + Class<GraphNode> clazz = (Class<GraphNode>) (Mockito.mock(GraphNode.class)).getClass(); + + // default test + GraphElementFactory.createElement(label, GraphElementTypeEnum.Node, properties, clazz); + } + + @Test + public void testCreateElement_1() throws Exception { + String label = "mock"; + GraphElementTypeEnum type = null; + Map<String, Object> properties = new HashMap<>(); + GraphNode result; + + // default test + result = GraphElementFactory.createElement(label, GraphElementTypeEnum.Node, properties); + } + + @Test + public void testCreateRelation() throws Exception { + String type = ""; + Map<String, Object> properties = new HashMap<>(); + GraphNode from = Mockito.mock(GraphNode.class); + GraphNode to = Mockito.mock(GraphNode.class); + ; + GraphRelation result; + + // default test + result = GraphElementFactory.createRelation(type, properties, from, to); + } + + @Test + public void testCreateNode() throws Exception { + Map<String, Object> properties = new HashMap<>(); + GraphNode result; + + result = Deencapsulation.invoke(GraphElementFactory.class, "createNode", NodeTypeEnum.User.getName(), + properties); + result = Deencapsulation.invoke(GraphElementFactory.class, "createNode", + NodeTypeEnum.ResourceCategory.getName(), properties); + result = Deencapsulation.invoke(GraphElementFactory.class, "createNode", NodeTypeEnum.ServiceCategory.getName(), + properties); + result = Deencapsulation.invoke(GraphElementFactory.class, "createNode", NodeTypeEnum.Tag.getName(), + properties); + result = Deencapsulation.invoke(GraphElementFactory.class, "createNode", NodeTypeEnum.Service.getName(), + properties); + // result = Deencapsulation.invoke(GraphElementFactory.class, "createNode", + // NodeTypeEnum.Resource.getName(), properties); + result = Deencapsulation.invoke(GraphElementFactory.class, "createNode", NodeTypeEnum.Property.getName(), + properties); + result = Deencapsulation.invoke(GraphElementFactory.class, "createNode", NodeTypeEnum.HeatParameter.getName(), + properties); + result = Deencapsulation.invoke(GraphElementFactory.class, "createNode", + NodeTypeEnum.HeatParameterValue.getName(), properties); + } +}
\ No newline at end of file diff --git a/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/graph/datatype/GraphEdgeTest.java b/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/graph/datatype/GraphEdgeTest.java new file mode 100644 index 0000000000..fba04bb55c --- /dev/null +++ b/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/graph/datatype/GraphEdgeTest.java @@ -0,0 +1,102 @@ +package org.openecomp.sdc.be.dao.graph.datatype; + +import java.util.HashMap; +import java.util.Map; + +import org.junit.Assert; +import org.junit.Test; +import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels; + +public class GraphEdgeTest { + + private GraphEdge createTestSubject() { + return new GraphEdge(); + } + + @Test + public void testCtor() throws Exception { + new GraphEdge(GraphEdgeLabels.ADDITIONAL_INFORMATION, new HashMap<>()); + } + + @Test + public void testGetEdgeType() throws Exception { + GraphEdge testSubject; + GraphEdgeLabels result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getEdgeType(); + } + + @Test + public void testSetEdgeType() throws Exception { + GraphEdge testSubject; + GraphEdgeLabels edgeType = null; + + // default test + testSubject = createTestSubject(); + testSubject.setEdgeType(edgeType); + } + + @Test + public void testGetProperties() throws Exception { + GraphEdge testSubject; + Map<String, Object> result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getProperties(); + } + + @Test + public void testSetProperties() throws Exception { + GraphEdge testSubject; + Map<String, Object> properties = null; + + // default test + testSubject = createTestSubject(); + testSubject.setProperties(properties); + } + + @Test + public void testHashCode() throws Exception { + GraphEdge testSubject; + int result; + + // default test + testSubject = createTestSubject(); + result = testSubject.hashCode(); + } + + @Test + public void testEquals() throws Exception { + GraphEdge testSubject; + Object obj = null; + boolean result; + + // test 1 + testSubject = createTestSubject(); + obj = null; + result = testSubject.equals(obj); + Assert.assertEquals(false, result); + + result = testSubject.equals(testSubject); + Assert.assertEquals(true, result); + + result = testSubject.equals(createTestSubject()); + Assert.assertEquals(true, result); + + result = testSubject.equals(new Object()); + Assert.assertEquals(false, result); + } + + @Test + public void testToString() throws Exception { + GraphEdge testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.toString(); + } +}
\ No newline at end of file diff --git a/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/graph/datatype/GraphRelationTest.java b/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/graph/datatype/GraphRelationTest.java new file mode 100644 index 0000000000..5d47f5d735 --- /dev/null +++ b/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/graph/datatype/GraphRelationTest.java @@ -0,0 +1,171 @@ +package org.openecomp.sdc.be.dao.graph.datatype; + +import java.util.HashMap; +import java.util.Map; + +import org.junit.Test; + +public class GraphRelationTest { + + private GraphRelation createTestSubject() { + return new GraphRelation(); + } + + @Test + public void testCtor() throws Exception { + new GraphRelation("mock"); + } + + @Test + public void testGetFrom() throws Exception { + GraphRelation testSubject; + RelationEndPoint result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getFrom(); + } + + @Test + public void testSetFrom() throws Exception { + GraphRelation testSubject; + RelationEndPoint from = null; + + // default test + testSubject = createTestSubject(); + testSubject.setFrom(from); + } + + @Test + public void testGetTo() throws Exception { + GraphRelation testSubject; + RelationEndPoint result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getTo(); + } + + @Test + public void testSetTo() throws Exception { + GraphRelation testSubject; + RelationEndPoint to = null; + + // default test + testSubject = createTestSubject(); + testSubject.setTo(to); + } + + @Test + public void testGetType() throws Exception { + GraphRelation testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getType(); + } + + @Test + public void testSetType() throws Exception { + GraphRelation testSubject; + String type = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setType(type); + } + + @Test + public void testAddProperty() throws Exception { + GraphRelation testSubject; + String property = ""; + Object value = null; + + // test 1 + testSubject = createTestSubject(); + property = null; + value = null; + testSubject.addProperty(property, value); + + // test 2 + testSubject = createTestSubject(); + property = ""; + value = null; + testSubject.addProperty(property, value); + + // test 3 + testSubject = createTestSubject(); + value = null; + property = null; + testSubject.addProperty(property, value); + + testSubject = createTestSubject(); + value = new Object(); + property = "mock"; + testSubject.addProperty(property, value); + } + + @Test + public void testAddPropertis() throws Exception { + GraphRelation testSubject; + Map<String, Object> props = null; + + // default test + testSubject = createTestSubject(); + testSubject.addPropertis(props); + props = new HashMap<>(); + testSubject.addPropertis(props); + } + + @Test + public void testOverwritePropertis() throws Exception { + GraphRelation testSubject; + Map<String, Object> props = null; + + // default test + testSubject = createTestSubject(); + testSubject.overwritePropertis(props); + } + + @Test + public void testGetProperty() throws Exception { + GraphRelation testSubject; + String property = ""; + Object result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getProperty(property); + } + + @Test + public void testToGraphMap() throws Exception { + GraphRelation testSubject; + Map<String, Object> result; + + // default test + testSubject = createTestSubject(); + result = testSubject.toGraphMap(); + } + + @Test + public void testToString() throws Exception { + GraphRelation testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.toString(); + } + + @Test + public void testHashCode() throws Exception { + GraphRelation testSubject; + int result; + + // default test + testSubject = createTestSubject(); + result = testSubject.hashCode(); + } +}
\ No newline at end of file diff --git a/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/graph/datatype/RelationEndPointTest.java b/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/graph/datatype/RelationEndPointTest.java new file mode 100644 index 0000000000..7e1a8358cf --- /dev/null +++ b/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/graph/datatype/RelationEndPointTest.java @@ -0,0 +1,114 @@ +package org.openecomp.sdc.be.dao.graph.datatype; + +import org.junit.Assert; +import org.junit.Test; +import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; + +public class RelationEndPointTest { + + private RelationEndPoint createTestSubject() { + return new RelationEndPoint(NodeTypeEnum.AdditionalInfoParameters, "", null); + } + + @Test + public void testGetLabel() throws Exception { + RelationEndPoint testSubject; + NodeTypeEnum result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getLabel(); + } + + @Test + public void testSetLabel() throws Exception { + RelationEndPoint testSubject; + NodeTypeEnum label = null; + + // default test + testSubject = createTestSubject(); + testSubject.setLabel(label); + } + + @Test + public void testGetIdName() throws Exception { + RelationEndPoint testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getIdName(); + } + + @Test + public void testSetIdName() throws Exception { + RelationEndPoint testSubject; + String idName = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setIdName(idName); + } + + @Test + public void testGetIdValue() throws Exception { + RelationEndPoint testSubject; + Object result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getIdValue(); + } + + @Test + public void testSetIdValue() throws Exception { + RelationEndPoint testSubject; + Object idValue = null; + + // default test + testSubject = createTestSubject(); + testSubject.setIdValue(idValue); + } + + @Test + public void testToString() throws Exception { + RelationEndPoint testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.toString(); + } + + @Test + public void testHashCode() throws Exception { + RelationEndPoint testSubject; + int result; + + // default test + testSubject = createTestSubject(); + result = testSubject.hashCode(); + } + + @Test + public void testEquals() throws Exception { + RelationEndPoint testSubject; + Object obj = null; + boolean result; + + // test 1 + testSubject = createTestSubject(); + obj = null; + result = testSubject.equals(obj); + Assert.assertEquals(false, result); + + result = testSubject.equals(testSubject); + Assert.assertEquals(true, result); + + result = testSubject.equals(createTestSubject()); + Assert.assertEquals(true, result); + + result = testSubject.equals(new Object()); + Assert.assertEquals(false, result); + } +}
\ 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 ae51f64d05..e09257d1f9 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,9 +1,11 @@ package org.openecomp.sdc.be.dao.jsongraph; +import java.util.HashMap; import java.util.Map; import org.junit.Test; import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum; +import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum; import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition; @@ -16,7 +18,11 @@ public class GraphVertexTest { private GraphVertex createTestSubject() { return new GraphVertex(); } - + + @Test + public void testCtor() throws Exception { + new GraphVertex(VertexTypeEnum.ADDITIONAL_INFORMATION); + } @Test public void testGetUniqueId() throws Exception { @@ -181,12 +187,14 @@ public class GraphVertexTest { @Test public void testGetJsonMetadataField() throws Exception { GraphVertex testSubject; - JsonPresentationFields field = null; Object result; // default test testSubject = createTestSubject(); - result = testSubject.getJsonMetadataField(field); + result = testSubject.getJsonMetadataField(JsonPresentationFields.API_URL); + testSubject = createTestSubject(); + testSubject.setType(ComponentTypeEnum.RESOURCE); + result = testSubject.getJsonMetadataField(JsonPresentationFields.API_URL); } @@ -197,5 +205,38 @@ public class GraphVertexTest { // default test testSubject = createTestSubject(); testSubject.updateMetadataJsonWithCurrentMetadataProperties(); + Map<GraphPropertyEnum, Object> metadataProperties = new HashMap<>(); + metadataProperties.put(GraphPropertyEnum.COMPONENT_TYPE, "mock"); + testSubject.setMetadataProperties(metadataProperties ); + testSubject.updateMetadataJsonWithCurrentMetadataProperties(); + } + + @Test + public void testGetType() throws Exception { + GraphVertex testSubject; + + // default test + testSubject = createTestSubject(); + testSubject.setType(ComponentTypeEnum.RESOURCE); + testSubject.getType(); + } + + @Test + public void testCloneData() throws Exception { + GraphVertex testSubject; + + // default test + testSubject = createTestSubject(); + testSubject.cloneData(new GraphVertex()); + } + + @Test + public void testSetJsonMetadataField() throws Exception { + GraphVertex testSubject; + + // default test + testSubject = createTestSubject(); + testSubject.setJsonMetadataField(JsonPresentationFields.API_URL, "mock"); } + }
\ 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 new file mode 100644 index 0000000000..f31e08e2fb --- /dev/null +++ b/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/jsongraph/TitanDaoMockTest.java @@ -0,0 +1,584 @@ +package org.openecomp.sdc.be.dao.jsongraph; + +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; + +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 com.thinkaurelius.titan.core.TitanGraph; +import com.thinkaurelius.titan.core.TitanVertex; + +import fj.data.Either; +import mockit.Deencapsulation; + +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<TitanGraph, TitanOperationStatus> result; + + // default test + + result = testSubject.getGraph(); + } + + @Test + public void testCreateVertex() throws Exception { + + GraphVertex graphVertex = new GraphVertex(); + graphVertex.setLabel(VertexTypeEnum.ADDITIONAL_INFORMATION); + Either<GraphVertex, TitanOperationStatus> result; + + TitanGraph tg = Mockito.mock(TitanGraph.class); + Either<TitanGraph, TitanOperationStatus> 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<GraphVertex, TitanOperationStatus> result; + + Either<TitanGraph, TitanOperationStatus> 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<GraphVertex, TitanOperationStatus> result; + + TitanGraph tg = Mockito.mock(TitanGraph.class); + Either<TitanGraph, TitanOperationStatus> 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<GraphVertex, TitanOperationStatus> 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<TitanVertex> vertices = Mockito.mock(Iterable.class); + Either<GraphVertex, TitanOperationStatus> result; + + Iterator<TitanVertex> 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<TitanVertex> vertices = Mockito.mock(Iterable.class); + Either<GraphVertex, TitanOperationStatus> result; + + Iterator<TitanVertex> 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<GraphVertex, TitanOperationStatus> result; + + TitanGraph tg = Mockito.mock(TitanGraph.class); + Either<TitanGraph, TitanOperationStatus> 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<GraphVertex, TitanOperationStatus> result; + + Object b; + Either<TitanGraph, TitanOperationStatus> 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<String, Object> 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<EdgePropertyEnum, Object> 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<EdgePropertyEnum, Object> properties = new HashMap<>(); + + // test 1 + + properties.put(EdgePropertyEnum.STATE, "mock"); + testSubject.setEdgeProperties(element, properties); + } + + @Test + public void testGetByCriteria() throws Exception { + Map<GraphPropertyEnum, Object> props = new HashMap<>(); + Either<List<GraphVertex>, TitanOperationStatus> result; + + TitanGraph tg = Mockito.mock(TitanGraph.class); + Either<TitanGraph, TitanOperationStatus> 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<GraphPropertyEnum, Object> props = new HashMap<>(); + Either<List<GraphVertex>, TitanOperationStatus> result; + + Either<TitanGraph, TitanOperationStatus> 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<Iterator<Vertex>, TitanOperationStatus> result; + + Either<TitanGraph, TitanOperationStatus> value = Either.right(TitanOperationStatus.GENERAL_ERROR); + // default test + TitanVertex value2 = Mockito.mock(TitanVertex.class); + Mockito.when(titanClient.getGraph()).thenReturn(value); + + // default test + result = testSubject.getCatalogVerticies(); + } + + @Test + public void testGetChildVertex() throws Exception { + + GraphVertex parentVertex = new GraphVertex(); + EdgeLabelEnum edgeLabel = null; + JsonParseFlagEnum parseFlag = null; + Either<GraphVertex, TitanOperationStatus> result; + + Either<TitanGraph, TitanOperationStatus> 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<Vertex, TitanOperationStatus> result; + + Either<TitanGraph, TitanOperationStatus> 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<Vertex, TitanOperationStatus> 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<List<Vertex>, 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<List<Vertex>, TitanOperationStatus> result; + + Either<TitanGraph, TitanOperationStatus> 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<List<Vertex>, TitanOperationStatus> result; + + // default test + + result = testSubject.getChildrenVertecies(parentVertex, edgeLabel, parseFlag); + } + + @Test + public void testDeleteBelongingEdgeByCriteria() throws Exception { + + GraphVertex vertex = null; + EdgeLabelEnum label = null; + Map<GraphPropertyEnum, Object> properties = null; + Either<Edge, TitanOperationStatus> result; + + // default test + + result = testSubject.deleteBelongingEdgeByCriteria(vertex, label, properties); + } + + @Test + public void testDeleteEdge() throws Exception { + + GraphVertex fromVertex = new GraphVertex(); + GraphVertex toVertex = new GraphVertex(); + Either<Edge, TitanOperationStatus> result; + + Either<TitanGraph, TitanOperationStatus> 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<Edge> 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<GraphVertex, TitanOperationStatus> result; + + // default test + + result = testSubject.updateVertex(graphVertex); + } + + @Test + public void testGetVerticesByUniqueIdAndParseFlag() throws Exception { + + Map<String, ImmutablePair<GraphPropertyEnum, JsonParseFlagEnum>> verticesToGet = new HashMap<>(); + Either<Map<String, GraphVertex>, TitanOperationStatus> result; + + // default test + result = testSubject.getVerticesByUniqueIdAndParseFlag(verticesToGet); + ImmutablePair<GraphPropertyEnum, JsonParseFlagEnum> 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<GraphPropertyEnum, Object> 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<Edge> 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<Edge> 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<Edge> 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<Edge> 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 index cede79d7c8..4f962ba9b2 100644 --- 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 @@ -6,11 +6,12 @@ import java.util.Map; 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.openecomp.sdc.be.config.ConfigurationManager; +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; @@ -19,9 +20,7 @@ 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.common.api.ConfigurationSource; -import org.openecomp.sdc.common.impl.ExternalConfiguration; -import org.openecomp.sdc.common.impl.FSConfigurationSource; +import org.openecomp.sdc.be.utils.DAOConfDependentTest; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -29,18 +28,12 @@ import com.thinkaurelius.titan.core.TitanGraph; import fj.data.Either; -public class TitanDaoTest { +public class TitanDaoTest extends DAOConfDependentTest{ private static Logger logger = LoggerFactory.getLogger(TitanDaoTest.class); private TitanDao dao = new TitanDao(new TitanGraphClient(new DAOTitanStrategy())); - static { - String appConfigDir = "src/test/resources/config/catalog-dao"; - ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), appConfigDir); - ConfigurationManager configurationManager = new ConfigurationManager(configurationSource); - } - @Before public void init(){ dao.titanClient.createGraph(); @@ -51,6 +44,25 @@ public class TitanDaoTest { dao.titanClient.cleanupGraph(); } + @Test + public void testCreateVertex() throws Exception { + Either<GraphVertex, TitanOperationStatus> 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<GraphVertex, TitanOperationStatus> result; + + // default test + result = dao.getVertexByLabel(VertexTypeEnum.ADDITIONAL_INFORMATION); + } @Test public void testCommit() throws Exception { @@ -72,7 +84,6 @@ public class TitanDaoTest { result = dao.rollback(); } - @Test public void testGetGraph() throws Exception { @@ -83,10 +94,6 @@ public class TitanDaoTest { result = dao.getGraph(); } - - - - @Test public void testGetVertexByPropertyAndLabel() throws Exception { @@ -98,13 +105,10 @@ public class TitanDaoTest { // 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 { @@ -131,7 +135,6 @@ public class TitanDaoTest { result = dao.getVertexById(id); } - @Test public void testGetVertexById_1() throws Exception { @@ -150,19 +153,6 @@ public class TitanDaoTest { result = dao.getVertexById(id, parseFlag); } - - - - - - - - - - - - - @Test public void testGetVertexProperties() throws Exception { @@ -188,10 +178,6 @@ public class TitanDaoTest { result = dao.getEdgeProperties(element); } - - - - @Test public void testGetByCriteria() throws Exception { @@ -204,7 +190,6 @@ public class TitanDaoTest { result = dao.getByCriteria(type, props); } - @Test public void testGetByCriteria_1() throws Exception { @@ -233,7 +218,6 @@ public class TitanDaoTest { result = dao.getByCriteria(type, props, hasNotProps, parseFlag); } - @Test public void testGetCatalogVerticies() throws Exception { @@ -243,21 +227,6 @@ public class TitanDaoTest { result = dao.getCatalogVerticies(); } - - - - - - - - - - - - - - - @Test public void testGetParentVertecies_1() throws Exception { @@ -272,9 +241,6 @@ public class TitanDaoTest { result = dao.getParentVertecies(parentVertex, edgeLabel, parseFlag); } - - - @Test public void testGetChildrenVertecies_1() throws Exception { @@ -288,34 +254,6 @@ public class TitanDaoTest { result = dao.getChildrenVertecies(parentVertex, edgeLabel, parseFlag); } - - - - - - - - - - - - - - - - - - - - - - - - - - - - @Test public void testUpdateVertexMetadataPropertiesWithJson() throws Exception { @@ -328,26 +266,38 @@ public class TitanDaoTest { result = dao.updateVertexMetadataPropertiesWithJson(vertex, properties); } - - - - + @Test + public void testGetProperty() throws Exception { + Edge edge = Mockito.mock(Edge.class);; + Object result; + + Property<Object> 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 = null; - EdgePropertyEnum key = null; + Edge edge = Mockito.mock(Edge.class);; Object result; // default test - - result = dao.getProperty(edge, key); + result = dao.getProperty(edge, EdgePropertyEnum.STATE); } - - - + @Test + public void testGetPropertyexception() throws Exception { + Edge edge = Mockito.mock(Edge.class);; + Object result; + + Property<Object> 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 { diff --git a/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/model/GetMultipleDataResultTest.java b/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/model/GetMultipleDataResultTest.java new file mode 100644 index 0000000000..a3304517f6 --- /dev/null +++ b/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/model/GetMultipleDataResultTest.java @@ -0,0 +1,137 @@ +package org.openecomp.sdc.be.dao.model; + +import org.apache.tinkerpop.gremlin.structure.T; +import org.junit.Test; + +public class GetMultipleDataResultTest { + + private GetMultipleDataResult createTestSubject() { + return new GetMultipleDataResult<>(); + } + + @Test + public void testCtor() throws Exception { + new GetMultipleDataResult<>(new String [1], new Object[1]); + new GetMultipleDataResult<>(new String [1], new String [1], 0L, 0L, 1, 1); + } + + @Test + public void testGetTypes() throws Exception { + GetMultipleDataResult testSubject; + String[] result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getTypes(); + } + + @Test + public void testGetData() throws Exception { + GetMultipleDataResult testSubject; + Object[] result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getData(); + } + + @Test + public void testSetTypes() throws Exception { + GetMultipleDataResult testSubject; + String[] types = new String[] { "" }; + + // default test + testSubject = createTestSubject(); + testSubject.setTypes(types); + } + + @Test + public void testSetData() throws Exception { + GetMultipleDataResult testSubject; + T[] data = new T[] { null }; + + // default test + testSubject = createTestSubject(); + testSubject.setData(data); + } + + @Test + public void testSetQueryDuration() throws Exception { + GetMultipleDataResult testSubject; + long queryDuration = 0L; + + // default test + testSubject = createTestSubject(); + testSubject.setQueryDuration(queryDuration); + } + + @Test + public void testSetTotalResults() throws Exception { + GetMultipleDataResult testSubject; + long totalResults = 0L; + + // default test + testSubject = createTestSubject(); + testSubject.setTotalResults(totalResults); + } + + @Test + public void testSetFrom() throws Exception { + GetMultipleDataResult testSubject; + int from = 0; + + // default test + testSubject = createTestSubject(); + testSubject.setFrom(from); + } + + @Test + public void testSetTo() throws Exception { + GetMultipleDataResult testSubject; + int to = 0; + + // default test + testSubject = createTestSubject(); + testSubject.setTo(to); + } + + @Test + public void testGetQueryDuration() throws Exception { + GetMultipleDataResult testSubject; + long result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getQueryDuration(); + } + + @Test + public void testGetTotalResults() throws Exception { + GetMultipleDataResult testSubject; + long result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getTotalResults(); + } + + @Test + public void testGetFrom() throws Exception { + GetMultipleDataResult testSubject; + int result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getFrom(); + } + + @Test + public void testGetTo() throws Exception { + GetMultipleDataResult testSubject; + int result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getTo(); + } +}
\ No newline at end of file diff --git a/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/neo4j/GraphEdgeLabelsTest.java b/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/neo4j/GraphEdgeLabelsTest.java new file mode 100644 index 0000000000..40800f70e2 --- /dev/null +++ b/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/neo4j/GraphEdgeLabelsTest.java @@ -0,0 +1,50 @@ +package org.openecomp.sdc.be.dao.neo4j; + +import java.util.List; + +import org.junit.Test; + +public class GraphEdgeLabelsTest { + + private GraphEdgeLabels createTestSubject() { + return GraphEdgeLabels.ADDITIONAL_INFORMATION; + } + + @Test + public void testGetProperty() throws Exception { + GraphEdgeLabels testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getProperty(); + } + + @Test + public void testSetProperty() throws Exception { + GraphEdgeLabels testSubject; + String property = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setProperty(property); + } + + @Test + public void testGetAllProperties() throws Exception { + List<String> result; + + // default test + result = GraphEdgeLabels.getAllProperties(); + } + + @Test + public void testGetByName() throws Exception { + String property = ""; + GraphEdgeLabels result; + + // default test + result = GraphEdgeLabels.getByName(property); + result = GraphEdgeLabels.getByName("mock"); + } +}
\ No newline at end of file diff --git a/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/neo4j/GraphEdgePropertiesDictionaryTest.java b/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/neo4j/GraphEdgePropertiesDictionaryTest.java new file mode 100644 index 0000000000..9a1514ec4f --- /dev/null +++ b/catalog-dao/src/test/java/org/openecomp/sdc/be/dao/neo4j/GraphEdgePropertiesDictionaryTest.java @@ -0,0 +1,70 @@ +package org.openecomp.sdc.be.dao.neo4j; + +import java.util.List; + +import org.junit.Test; + +public class GraphEdgePropertiesDictionaryTest { + + private GraphEdgePropertiesDictionary createTestSubject() { + return GraphEdgePropertiesDictionary.GET_INPUT_INDEX; + } + + @Test + public void testGetProperty() throws Exception { + GraphEdgePropertiesDictionary testSubject; + String result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getProperty(); + } + + @Test + public void testSetProperty() throws Exception { + GraphEdgePropertiesDictionary testSubject; + String property = ""; + + // default test + testSubject = createTestSubject(); + testSubject.setProperty(property); + } + + @Test + public void testGetClazz() throws Exception { + GraphEdgePropertiesDictionary testSubject; + Class result; + + // default test + testSubject = createTestSubject(); + result = testSubject.getClazz(); + } + + @Test + public void testSetClazz() throws Exception { + GraphEdgePropertiesDictionary testSubject; + Class clazz = null; + + // default test + testSubject = createTestSubject(); + testSubject.setClazz(clazz); + } + + @Test + public void testGetAllProperties() throws Exception { + List<String> result; + + // default test + result = GraphEdgePropertiesDictionary.getAllProperties(); + } + + @Test + public void testGetByName() throws Exception { + String property = ""; + GraphEdgePropertiesDictionary result; + + // default test + result = GraphEdgePropertiesDictionary.getByName(property); + result = GraphEdgePropertiesDictionary.getByName("mock"); + } +}
\ No newline at end of file diff --git a/catalog-dao/src/test/java/org/openecomp/sdc/be/resources/ArtifactDaoTest.java b/catalog-dao/src/test/java/org/openecomp/sdc/be/resources/ArtifactDaoTest.java index 292ae08f0a..29d5d60870 100644 --- a/catalog-dao/src/test/java/org/openecomp/sdc/be/resources/ArtifactDaoTest.java +++ b/catalog-dao/src/test/java/org/openecomp/sdc/be/resources/ArtifactDaoTest.java @@ -29,7 +29,6 @@ import javax.annotation.Resource; import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest; import org.elasticsearch.action.admin.indices.delete.DeleteIndexResponse; import org.junit.Before; -import org.junit.BeforeClass; import org.junit.Test; import org.junit.runner.RunWith; import org.openecomp.sdc.be.config.ConfigurationManager; @@ -38,9 +37,7 @@ import org.openecomp.sdc.be.dao.api.ResourceUploadStatus; import org.openecomp.sdc.be.dao.es.ElasticSearchClient; import org.openecomp.sdc.be.resources.api.IResourceUploader; import org.openecomp.sdc.be.resources.data.ESArtifactData; -import org.openecomp.sdc.common.api.ConfigurationSource; -import org.openecomp.sdc.common.impl.ExternalConfiguration; -import org.openecomp.sdc.common.impl.FSConfigurationSource; +import org.openecomp.sdc.be.utils.DAOConfDependentTest; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.TestExecutionListeners; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; @@ -56,7 +53,7 @@ import fj.data.Either; DirtiesContextTestExecutionListener.class, TransactionalTestExecutionListener.class }) // , // CassandraUnitTestExecutionListener.class}) // @EmbeddedCassandra(host ="localhost", port=9042) -public class ArtifactDaoTest { +public class ArtifactDaoTest extends DAOConfDependentTest { private static final String TEST_IMAGES_DIRECTORY = "src/test/resources/images"; @Resource @@ -73,23 +70,8 @@ public class ArtifactDaoTest { @Resource(name = "resource-dao") private IGenericSearchDAO resourceDAO; - private String nodeType = "NodeType1"; private String nodeTypeVersion = "1.0.0"; - private String nodeType2 = "NodeType2"; - private String nodeTypeVersion2 = "1.0.1"; - - private String nodeType3 = "NodeType3"; - private String nodeNypeVersion3 = "1.1.1"; - - private String topologyId = "topology"; - private String topologyTemplateName = "topologyTemplate"; - private String topologyTemplateVersion = "1.1.1"; - - private String nodeTypeTemplate1 = "NodeTypeTemplate1"; - private String nodeTypeTemplate2 = "NodeTypeTemplate2"; - private String nodeTypeTemplate3 = "NodeTypeTemplate3"; - private static ConfigurationManager configurationManager; @Before @@ -103,14 +85,14 @@ public class ArtifactDaoTest { } - @BeforeClass + /*@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); - } + }*/ // @Before // public void createSchema(){ diff --git a/catalog-dao/src/test/java/org/openecomp/sdc/be/resources/AuditingDaoTest.java b/catalog-dao/src/test/java/org/openecomp/sdc/be/resources/AuditingDaoTest.java index 1d0c9e0a89..10e2c9ea86 100644 --- a/catalog-dao/src/test/java/org/openecomp/sdc/be/resources/AuditingDaoTest.java +++ b/catalog-dao/src/test/java/org/openecomp/sdc/be/resources/AuditingDaoTest.java @@ -42,6 +42,7 @@ import org.junit.Before; import org.junit.BeforeClass; import org.junit.Test; import org.junit.runner.RunWith; +import org.mockito.Mockito; import org.openecomp.sdc.be.config.Configuration; import org.openecomp.sdc.be.config.Configuration.ElasticSearchConfig.IndicesTimeFrequencyEntry; import org.openecomp.sdc.be.config.ConfigurationManager; @@ -231,6 +232,22 @@ public class AuditingDaoTest { testCreationPeriodScenario(params, creationPeriod, expectedIndexName, ResourceAdminEvent.class); } + @Test + public void testGetFilteredResourceAdminAuditingEvents() { + Map<AuditingFieldsKeysEnum, Object> filterMap = new HashMap<>(); + filterMap.put(AuditingFieldsKeysEnum.AUDIT_ACTION, new Object()); + Either<List<ESTimeBasedEvent>, ActionStatus> filteredResourceAdminAuditingEvents = auditingDao + .getFilteredResourceAdminAuditingEvents(filterMap); + } + + @Test + public void testGetListOfDistributionByAction() { + Either<List<ESTimeBasedEvent>, ActionStatus> filteredResourceAdminAuditingEvents = auditingDao + .getListOfDistributionByAction("mock", "mock", "mock", AuditingGenericEvent.class); + filteredResourceAdminAuditingEvents = auditingDao + .getListOfDistributionByAction("mock", "mock", null, AuditingGenericEvent.class); + } + private SearchResponse testCreationPeriodScenario(Map<AuditingFieldsKeysEnum, Object> params, String creationPeriod, String expectedIndexName, Class<? extends AuditingGenericEvent> clazz) { diff --git a/catalog-dao/src/test/java/org/openecomp/sdc/be/resources/JsonParserUtilsTests.java b/catalog-dao/src/test/java/org/openecomp/sdc/be/resources/JsonParserUtilsTests.java index 508fb0c2cc..d92d8dee16 100644 --- a/catalog-dao/src/test/java/org/openecomp/sdc/be/resources/JsonParserUtilsTests.java +++ b/catalog-dao/src/test/java/org/openecomp/sdc/be/resources/JsonParserUtilsTests.java @@ -25,6 +25,7 @@ import static org.assertj.core.api.Assertions.assertThatCode; import static org.openecomp.sdc.be.utils.FixtureHelpers.fixture; import static org.openecomp.sdc.be.utils.JsonTester.testJsonMap; +import java.io.IOException; import java.util.HashMap; import java.util.List; import java.util.Map; @@ -33,6 +34,7 @@ import org.junit.Test; import org.openecomp.sdc.be.dao.jsongraph.utils.JsonParserUtils; import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition; import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition; +import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition; import com.fasterxml.jackson.databind.DeserializationFeature; import com.fasterxml.jackson.databind.ObjectMapper; @@ -41,49 +43,69 @@ import com.google.common.collect.ImmutableList; public class JsonParserUtilsTests { - private static final String FIXTURE_PATH = "fixtures/ListCapabilityDataDefinition.json"; + private static final String FIXTURE_PATH = "fixtures/ListCapabilityDataDefinition.json"; - @Test - public void testToMap() { - String json = fixture(FIXTURE_PATH); - Map<String, ListCapabilityDataDefinition> actual = JsonParserUtils.toMap(json, ListCapabilityDataDefinition.class); - Map<String, ListCapabilityDataDefinition> expected = buildMap(); - assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected); - } + @Test + public void testToMap() { + String json = fixture(FIXTURE_PATH); + Map<String, ListCapabilityDataDefinition> actual = JsonParserUtils.toMap(json, + ListCapabilityDataDefinition.class); + Map<String, ListCapabilityDataDefinition> expected = buildMap(); + assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected); + } - @Test - public void testJacksonFasterXml() { - ObjectMapper mapper = new ObjectMapper() - .disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES) - .disable(SerializationFeature.FAIL_ON_EMPTY_BEANS); - assertThatCode(() -> testJsonMap(buildMap(), ListCapabilityDataDefinition.class, FIXTURE_PATH, mapper)) - .doesNotThrowAnyException(); - } + @Test + public void testJacksonFasterXml() { + ObjectMapper mapper = new ObjectMapper().disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES) + .disable(SerializationFeature.FAIL_ON_EMPTY_BEANS); + assertThatCode(() -> testJsonMap(buildMap(), ListCapabilityDataDefinition.class, FIXTURE_PATH, mapper)) + .doesNotThrowAnyException(); + } - private Map<String, ListCapabilityDataDefinition> buildMap() { - Map<String, ListCapabilityDataDefinition> map = new HashMap<>(); - map.put("org.openecomp.capabilities.Forwarder", buildListCapabilityDataDefinition()); - return map; - } + @Test + public void testToJson() { + try { + JsonParserUtils.toJson(new Object()); + } catch (IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } - private ListCapabilityDataDefinition buildListCapabilityDataDefinition() { - CapabilityDataDefinition dataDefinition = new CapabilityDataDefinition(); - dataDefinition.setName("forwarder"); - dataDefinition.setType("org.openecomp.capabilities.Forwarder"); - dataDefinition.setUniqueId("capability.deb142fd-95eb-48f7-99ae-81ab09466b1e.forwarder"); - dataDefinition.setOwnerId("deb142fd-95eb-48f7-99ae-81ab09466b1e"); - dataDefinition.setMinOccurrences("1"); - dataDefinition.setLeftOccurrences("UNBOUNDED"); - dataDefinition.setMaxOccurrences("UNBOUNDED"); - dataDefinition.setCapabilitySources(buildCapabilitySources()); + @Test + public void testMap() { + JsonParserUtils.toMap("{}"); + JsonParserUtils.toMap(""); + JsonParserUtils.toMap("****"); + + JsonParserUtils.toMap("{}", ToscaDataDefinition.class); + JsonParserUtils.toMap("", ToscaDataDefinition.class); + JsonParserUtils.toMap("****", ToscaDataDefinition.class); + + } - return new ListCapabilityDataDefinition(ImmutableList.of(dataDefinition)); - } + private Map<String, ListCapabilityDataDefinition> buildMap() { + Map<String, ListCapabilityDataDefinition> map = new HashMap<>(); + map.put("org.openecomp.capabilities.Forwarder", buildListCapabilityDataDefinition()); + return map; + } - private List<String> buildCapabilitySources() { - return ImmutableList.of( - "org.openecomp.resource.cp.nodes.network.Port", - "org.openecomp.resource.cp.v2.extCP", - "org.openecomp.resource.cp.v2.extContrailCP"); - } + private ListCapabilityDataDefinition buildListCapabilityDataDefinition() { + CapabilityDataDefinition dataDefinition = new CapabilityDataDefinition(); + dataDefinition.setName("forwarder"); + dataDefinition.setType("org.openecomp.capabilities.Forwarder"); + dataDefinition.setUniqueId("capability.deb142fd-95eb-48f7-99ae-81ab09466b1e.forwarder"); + dataDefinition.setOwnerId("deb142fd-95eb-48f7-99ae-81ab09466b1e"); + dataDefinition.setMinOccurrences("1"); + dataDefinition.setLeftOccurrences("UNBOUNDED"); + dataDefinition.setMaxOccurrences("UNBOUNDED"); + dataDefinition.setCapabilitySources(buildCapabilitySources()); + + return new ListCapabilityDataDefinition(ImmutableList.of(dataDefinition)); + } + + private List<String> buildCapabilitySources() { + return ImmutableList.of("org.openecomp.resource.cp.nodes.network.Port", "org.openecomp.resource.cp.v2.extCP", + "org.openecomp.resource.cp.v2.extContrailCP"); + } } |