1 package org.openecomp.sdc.be.model.jsonjanusgraph.operations;
3 import static org.assertj.core.api.Assertions.assertThat;
4 import static org.junit.Assert.assertEquals;
5 import static org.junit.Assert.assertNotNull;
6 import static org.junit.Assert.assertTrue;
8 import org.janusgraph.core.JanusGraph;
9 import org.janusgraph.core.JanusGraphVertex;
10 import fj.data.Either;
11 import java.io.BufferedOutputStream;
13 import java.io.FileOutputStream;
14 import java.io.OutputStream;
15 import java.util.ArrayList;
16 import java.util.HashMap;
17 import java.util.Iterator;
18 import java.util.List;
20 import javax.annotation.Resource;
21 import org.apache.tinkerpop.gremlin.structure.Direction;
22 import org.apache.tinkerpop.gremlin.structure.Edge;
23 import org.apache.tinkerpop.gremlin.structure.Vertex;
24 import org.apache.tinkerpop.gremlin.structure.io.IoCore;
25 import org.junit.After;
26 import org.junit.Before;
27 import org.junit.BeforeClass;
28 import org.junit.Test;
29 import org.junit.runner.RunWith;
30 import org.openecomp.sdc.be.dao.config.JanusGraphSpringConfig;
31 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
32 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
33 import org.openecomp.sdc.be.dao.jsongraph.HealingJanusGraphDao;
34 import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
35 import org.openecomp.sdc.be.dao.jsongraph.types.EdgePropertyEnum;
36 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
37 import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition;
38 import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
39 import org.openecomp.sdc.be.model.ModelTestBase;
40 import org.openecomp.sdc.be.model.config.ModelOperationsSpringConfig;
41 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
42 import org.springframework.test.context.ContextConfiguration;
43 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
45 @RunWith(SpringJUnit4ClassRunner.class)
46 @ContextConfiguration(classes = {JanusGraphSpringConfig.class, ModelOperationsSpringConfig.class})
47 public class NodeTemplateOperationGraphTest extends ModelTestBase{
49 private HealingJanusGraphDao janusGraphDao;
51 private NodeTemplateOperation nodeTemplateOperation;
53 private JanusGraph graphT;
54 private GraphVertex containerVertex;
55 private String containeId;
58 public static void setupBeforeClass() {
65 Either<JanusGraph, JanusGraphOperationStatus> graph = janusGraphDao.getGraph();
66 graphT = graph.left().value();
68 containerVertex = new GraphVertex(VertexTypeEnum.TOPOLOGY_TEMPLATE);
69 containeId = "containerId";
70 containerVertex.setUniqueId(containeId);
71 Either<GraphVertex, JanusGraphOperationStatus> createVertex = janusGraphDao.createVertex(containerVertex);
72 assertTrue(createVertex.isLeft());
77 janusGraphDao.rollback();
82 String outputDirectory = "C:\\Output";
85 public void testCreateInstanceEdge(){
87 Map<String, List<String>> mapOriginToInstId = new HashMap<>();
88 createIntancesFromSameResource(mapOriginToInstId, 1, 3);
89 createIntancesFromSameResource(mapOriginToInstId, 2, 4);
90 createIntancesFromSameResource(mapOriginToInstId, 3, 1);
92 // exportGraphMl(graphT);
94 validateOnGraph(mapOriginToInstId, 3);
98 public void testRemoveInstanceEdge(){
99 //create 3 instances from same resource orig1
100 Map<String, List<String>> mapOriginToInstId = new HashMap<>();
101 String originId = createIntancesFromSameResource(mapOriginToInstId, 1, 3);
102 validateOnGraph(mapOriginToInstId, 1);
105 String instanceId = removeInstanceEdge(containerVertex, originId, 1, 1);
106 mapOriginToInstId.get(originId).remove(instanceId);
107 validateOnGraph(mapOriginToInstId, 1);
109 //create new instance from orig1
110 instanceId = createInstanceEdge(containerVertex, originId, 1, 4, false, null);
111 mapOriginToInstId.get(originId).add(instanceId);
112 validateOnGraph(mapOriginToInstId, 1);
114 //create 1 instance from same resource orig2
115 originId = createIntancesFromSameResource(mapOriginToInstId, 2, 1);
116 validateOnGraph(mapOriginToInstId, 2);
118 //remove instance of orig 2
119 instanceId = removeInstanceEdge(containerVertex, originId, 2, 1);
120 mapOriginToInstId.get(originId).remove(instanceId);
121 validateOnGraph(mapOriginToInstId, 1);
126 public void testProxyInstanceEdge(){
127 Map<String, List<String>> mapOriginToInstId = new HashMap<>();
128 String proxyId = createOrigin(2);
129 createIntancesFromSameResource(mapOriginToInstId, 1, 1, true, proxyId);
131 validateOnGraph(mapOriginToInstId, 1);
133 private void validateOnGraph(Map<String, List<String>> mapOriginToInstId, int expectedEdgeCount) {
134 validateOnGraph(mapOriginToInstId, expectedEdgeCount, false);
136 private void validateOnGraph(Map<String, List<String>> mapOriginToInstId, int expectedEdgeCount, boolean validateProxy) {
137 Iterable vertices = graphT.query().has(GraphPropertyEnum.UNIQUE_ID.getProperty(), containeId).vertices();
138 assertNotNull(vertices);
139 Iterator<JanusGraphVertex> iterator = vertices.iterator();
140 assertTrue(iterator.hasNext());
141 Vertex containerV = iterator.next();
142 validatePerEdgeType(mapOriginToInstId, expectedEdgeCount, containerV, EdgeLabelEnum.INSTANCE_OF);
143 if ( validateProxy ){
144 validatePerEdgeType(mapOriginToInstId, expectedEdgeCount, containerV, EdgeLabelEnum.PROXY_OF);
147 private void validatePerEdgeType(Map<String, List<String>> mapOriginToInstId, int expectedEdgeCount, Vertex containerV, EdgeLabelEnum edgeLabel) {
148 Iterator<Edge> edges = containerV.edges(Direction.OUT, edgeLabel.name());
149 assertNotNull(edges);
152 while (edges.hasNext()){
153 Edge edge = edges.next();
155 validateEdge(edge, mapOriginToInstId);
157 assertEquals("check edge size", expectedEdgeCount, counter);
161 private String createIntancesFromSameResource(Map<String, List<String>> mapOriginToInstId, int originIndex, int countInstances) {
162 return createIntancesFromSameResource(mapOriginToInstId, originIndex, countInstances, false, null);
165 private String createIntancesFromSameResource(Map<String, List<String>> mapOriginToInstId, int originIndex, int countInstances, boolean isProxy, String proxyId) {
167 List<String> exp = new ArrayList();
168 String originId = createOrigin(originIndex);
170 for ( int i = 0; i < countInstances; i++){
171 String instanceId = createInstanceEdge(containerVertex, originId, originIndex, i+1, isProxy, proxyId);
174 mapOriginToInstId.put(originId, exp);
176 mapOriginToInstId.put(proxyId, exp);
181 private String createInstanceEdge(GraphVertex containerVertex, String originId, int originIndex, int insIndex, boolean isProxy, String proxyId) {
182 ComponentInstanceDataDefinition componentInstance = new ComponentInstanceDataDefinition();
183 componentInstance.setComponentUid(originId);
184 String instanceId = buildInstanceId(originIndex, insIndex);
185 componentInstance.setUniqueId(instanceId);
186 componentInstance.setIsProxy(isProxy);
187 componentInstance.setSourceModelUid(proxyId);
188 StorageOperationStatus edgeStatus = nodeTemplateOperation.createInstanceEdge(containerVertex, componentInstance);
189 assertEquals("assertion createInstanceEdge", StorageOperationStatus.OK, edgeStatus);
193 private String buildInstanceId(int originIndex, int insIndex) {
194 StringBuffer sb = new StringBuffer("instanceId_");
195 sb.append(originIndex).append("-").append(insIndex);
196 return sb.toString();
198 private String removeInstanceEdge(GraphVertex containerVertex, String originId, int originIndex, int insIndex) {
199 ComponentInstanceDataDefinition componentInstance = new ComponentInstanceDataDefinition();
200 componentInstance.setComponentUid(originId);
201 String instanceId = buildInstanceId(originIndex, insIndex);
202 componentInstance.setUniqueId(instanceId);
203 StorageOperationStatus edgeStatus = nodeTemplateOperation.removeInstanceEdge(containerVertex, componentInstance);
204 assertEquals("assertion removeInstanceEdge", StorageOperationStatus.OK, edgeStatus);
209 private String createOrigin(int index) {
210 Either<GraphVertex, JanusGraphOperationStatus> createVertex;
211 GraphVertex originVertex = new GraphVertex(VertexTypeEnum.NODE_TYPE);
212 String originId = "originId_" + index;
213 originVertex.setUniqueId(originId);
214 createVertex = janusGraphDao.createVertex(originVertex);
215 assertTrue(createVertex.isLeft());
218 private void validateEdge(Edge edge, Map<String, List<String>> mapOriginToInstId) {
219 List<String> expextedInList;
221 Vertex originV = edge.inVertex();
222 String id = (String) janusGraphDao.getProperty((JanusGraphVertex)originV, GraphPropertyEnum.UNIQUE_ID.getProperty());
223 expextedInList = mapOriginToInstId.get(id);
225 List<String> list = (List<String>) janusGraphDao.getProperty(edge, EdgePropertyEnum.INSTANCES);
226 assertThat(list).hasSameSizeAs(expextedInList);
227 assertThat(list).containsOnlyElementsOf(expextedInList);
230 private String exportGraphMl(JanusGraph graph) {
231 String result = null;
232 String outputFile = outputDirectory + File.separator + "exportGraph." + System.currentTimeMillis() + ".graphml";
234 try (final OutputStream os = new BufferedOutputStream(new FileOutputStream(outputFile))) {
235 graph.io(IoCore.graphml()).writer().normalize(true).create().writeGraph(os, graph);
238 } catch (Exception e) {