catalog-model/src/test/java/org/openecomp/sdc/be/model/jsonjanusgraph/operations/NodeTemplateOperationGraphTest.java

   1 package org.openecomp.sdc.be.model.jsonjanusgraph.operations;
   2
   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;
   7
   8 import org.janusgraph.core.JanusGraph;
   9 import org.janusgraph.core.JanusGraphVertex;
  10 import fj.data.Either;
  11 import java.io.BufferedOutputStream;
  12 import java.io.File;
  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;
  19 import java.util.Map;
  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;
  44
  45 @RunWith(SpringJUnit4ClassRunner.class)
  46 @ContextConfiguration(classes = {JanusGraphSpringConfig.class, ModelOperationsSpringConfig.class})
  47 public class NodeTemplateOperationGraphTest extends ModelTestBase{
  48     @Resource
  49     private HealingJanusGraphDao janusGraphDao;
  50     @Resource
  51     private NodeTemplateOperation nodeTemplateOperation;
  52
  53     private JanusGraph graphT;
  54     private GraphVertex containerVertex;
  55     private String containeId;
  56
  57     @BeforeClass
  58     public static void setupBeforeClass() {
  59
  60         ModelTestBase.init();
  61     }
  62     @Before
  63     public void before(){
  64
  65         Either<JanusGraph, JanusGraphOperationStatus> graph = janusGraphDao.getGraph();
  66         graphT = graph.left().value();
  67
  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());
  73     }
  74
  75     @After
  76     public void after(){
  77         janusGraphDao.rollback();
  78
  79     }
  80
  81
  82     String outputDirectory = "C:\\Output";
  83
  84     @Test
  85     public void testCreateInstanceEdge(){
  86
  87         Map<String, List<String>> mapOriginToInstId = new HashMap<>();
  88         createIntancesFromSameResource(mapOriginToInstId, 1, 3);
  89         createIntancesFromSameResource(mapOriginToInstId, 2, 4);
  90         createIntancesFromSameResource(mapOriginToInstId, 3, 1);
  91
  92 //        exportGraphMl(graphT);
  93
  94         validateOnGraph(mapOriginToInstId, 3);
  95     }
  96
  97     @Test
  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);
 103
 104         //remove instance 2
 105         String instanceId = removeInstanceEdge(containerVertex, originId, 1, 1);
 106         mapOriginToInstId.get(originId).remove(instanceId);
 107         validateOnGraph(mapOriginToInstId, 1);
 108
 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);
 113
 114         //create 1 instance from same resource orig2
 115         originId = createIntancesFromSameResource(mapOriginToInstId, 2, 1);
 116         validateOnGraph(mapOriginToInstId, 2);
 117
 118         //remove instance of orig 2
 119         instanceId = removeInstanceEdge(containerVertex, originId, 2, 1);
 120         mapOriginToInstId.get(originId).remove(instanceId);
 121         validateOnGraph(mapOriginToInstId, 1);
 122
 123     }
 124
 125     @Test
 126     public void testProxyInstanceEdge(){
 127         Map<String, List<String>> mapOriginToInstId = new HashMap<>();
 128         String proxyId  = createOrigin(2);
 129         createIntancesFromSameResource(mapOriginToInstId, 1, 1, true, proxyId);
 130
 131         validateOnGraph(mapOriginToInstId, 1);
 132     }
 133     private void validateOnGraph(Map<String, List<String>> mapOriginToInstId, int expectedEdgeCount) {
 134         validateOnGraph(mapOriginToInstId, expectedEdgeCount, false);
 135     }
 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);
 145         }
 146     }
 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);
 150
 151         int counter = 0;
 152         while (edges.hasNext()){
 153             Edge edge = edges.next();
 154             counter++;
 155             validateEdge(edge, mapOriginToInstId);
 156         }
 157         assertEquals("check edge size", expectedEdgeCount, counter);
 158     }
 159
 160
 161     private String createIntancesFromSameResource(Map<String, List<String>> mapOriginToInstId, int originIndex, int countInstances) {
 162         return createIntancesFromSameResource(mapOriginToInstId,  originIndex,  countInstances, false, null);
 163     }
 164
 165     private String createIntancesFromSameResource(Map<String, List<String>> mapOriginToInstId, int originIndex, int countInstances, boolean isProxy, String proxyId) {
 166
 167         List<String> exp = new ArrayList();
 168         String originId = createOrigin(originIndex);
 169
 170         for ( int i = 0; i < countInstances; i++){
 171             String instanceId = createInstanceEdge(containerVertex, originId, originIndex, i+1, isProxy, proxyId);
 172             exp.add(instanceId);
 173         }
 174         mapOriginToInstId.put(originId, exp);
 175         if ( isProxy ){
 176             mapOriginToInstId.put(proxyId, exp);
 177         }
 178         return originId;
 179     }
 180
 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);
 190         return instanceId;
 191     }
 192
 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();
 197     }
 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);
 205         return instanceId;
 206     }
 207
 208
 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());
 216         return originId;
 217     }
 218     private void validateEdge(Edge edge, Map<String, List<String>> mapOriginToInstId) {
 219         List<String> expextedInList;
 220
 221         Vertex originV = edge.inVertex();
 222         String id = (String) janusGraphDao.getProperty((JanusGraphVertex)originV, GraphPropertyEnum.UNIQUE_ID.getProperty());
 223         expextedInList = mapOriginToInstId.get(id);
 224
 225         List<String> list = (List<String>) janusGraphDao.getProperty(edge, EdgePropertyEnum.INSTANCES);
 226         assertThat(list).hasSameSizeAs(expextedInList);
 227         assertThat(list).containsOnlyElementsOf(expextedInList);
 228     }
 229
 230     private String exportGraphMl(JanusGraph graph) {
 231         String result = null;
 232         String outputFile = outputDirectory + File.separator + "exportGraph." + System.currentTimeMillis() + ".graphml";
 233         try {
 234             try (final OutputStream os = new BufferedOutputStream(new FileOutputStream(outputFile))) {
 235                 graph.io(IoCore.graphml()).writer().normalize(true).create().writeGraph(os, graph);
 236             }
 237             result = outputFile;
 238         } catch (Exception e) {
 239             e.printStackTrace();
 240         }
 241         return result;
 242
 243     }
 244 }