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

   1 package org.openecomp.sdc.be.model.jsontitan.operations;
   2
   3 import com.thinkaurelius.titan.core.TitanGraph;
   4 import com.thinkaurelius.titan.core.TitanVertex;
   5 import fj.data.Either;
   6 import org.apache.tinkerpop.gremlin.structure.Direction;
   7 import org.apache.tinkerpop.gremlin.structure.Edge;
   8 import org.apache.tinkerpop.gremlin.structure.Vertex;
   9 import org.apache.tinkerpop.gremlin.structure.io.IoCore;
  10 import org.junit.After;
  11 import org.junit.Before;
  12 import org.junit.BeforeClass;
  13 import org.junit.Test;
  14 import org.junit.runner.RunWith;
  15 import org.openecomp.sdc.be.dao.config.TitanSpringConfig;
  16 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
  17 import org.openecomp.sdc.be.dao.jsongraph.TitanDao;
  18 import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
  19 import org.openecomp.sdc.be.dao.jsongraph.types.EdgePropertyEnum;
  20 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
  21 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
  22 import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition;
  23 import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
  24 import org.openecomp.sdc.be.model.ModelTestBase;
  25 import org.openecomp.sdc.be.model.config.ModelOperationsSpringConfig;
  26 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  27 import org.springframework.test.context.ContextConfiguration;
  28 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  29
  30 import javax.annotation.Resource;
  31 import java.io.BufferedOutputStream;
  32 import java.io.File;
  33 import java.io.FileOutputStream;
  34 import java.io.OutputStream;
  35 import java.util.*;
  36
  37 import static org.assertj.core.api.Assertions.assertThat;
  38 import static org.junit.Assert.*;
  39
  40 @RunWith(SpringJUnit4ClassRunner.class)
  41 @ContextConfiguration(classes = {TitanSpringConfig.class, ModelOperationsSpringConfig.class})
  42 public class NodeTemplateOperationGraphTest extends ModelTestBase{
  43     @Resource
  44     private TitanDao titanDao;
  45     @Resource
  46     private NodeTemplateOperation nodeTemplateOperation;
  47
  48     private TitanGraph graphT;
  49     private GraphVertex containerVertex;
  50     private String containeId;
  51
  52     @BeforeClass
  53     public static void setupBeforeClass() {
  54
  55         ModelTestBase.init();
  56     }
  57     @Before
  58     public void before(){
  59
  60         Either<TitanGraph, TitanOperationStatus> graph = titanDao.getGraph();
  61         graphT = graph.left().value();
  62
  63         containerVertex = new GraphVertex(VertexTypeEnum.TOPOLOGY_TEMPLATE);
  64         containeId = "containerId";
  65         containerVertex.setUniqueId(containeId);
  66         Either<GraphVertex, TitanOperationStatus> createVertex = titanDao.createVertex(containerVertex);
  67         assertTrue(createVertex.isLeft());
  68     }
  69
  70     @After
  71     public void after(){
  72         titanDao.rollback();
  73
  74     }
  75
  76
  77     String outputDirectory = "C:\\Output";
  78
  79     @Test
  80     public void testCreateInstanceEdge(){
  81
  82         Map<String, List<String>> mapOriginToInstId = new HashMap<>();
  83         createIntancesFromSameResource(mapOriginToInstId, 1, 3);
  84         createIntancesFromSameResource(mapOriginToInstId, 2, 4);
  85         createIntancesFromSameResource(mapOriginToInstId, 3, 1);
  86
  87 //        exportGraphMl(graphT);
  88
  89         validateOnGraph(mapOriginToInstId, 3);
  90     }
  91
  92     @Test
  93     public void testRemoveInstanceEdge(){
  94         //create 3 instances from same resource orig1
  95         Map<String, List<String>> mapOriginToInstId = new HashMap<>();
  96         String originId = createIntancesFromSameResource(mapOriginToInstId, 1, 3);
  97         validateOnGraph(mapOriginToInstId, 1);
  98
  99         //remove instance 2
 100         String instanceId = removeInstanceEdge(containerVertex, originId, 1, 1);
 101         mapOriginToInstId.get(originId).remove(instanceId);
 102         validateOnGraph(mapOriginToInstId, 1);
 103
 104         //create new instance from orig1
 105         instanceId = createInstanceEdge(containerVertex, originId, 1, 4, false, null);
 106         mapOriginToInstId.get(originId).add(instanceId);
 107         validateOnGraph(mapOriginToInstId, 1);
 108
 109         //create 1 instance from same resource orig2
 110         originId = createIntancesFromSameResource(mapOriginToInstId, 2, 1);
 111         validateOnGraph(mapOriginToInstId, 2);
 112
 113         //remove instance of orig 2
 114         instanceId = removeInstanceEdge(containerVertex, originId, 2, 1);
 115         mapOriginToInstId.get(originId).remove(instanceId);
 116         validateOnGraph(mapOriginToInstId, 1);
 117
 118     }
 119
 120     @Test
 121     public void testProxyInstanceEdge(){
 122         Map<String, List<String>> mapOriginToInstId = new HashMap<>();
 123         String proxyId  = createOrigin(2);
 124         createIntancesFromSameResource(mapOriginToInstId, 1, 1, true, proxyId);
 125
 126         validateOnGraph(mapOriginToInstId, 1);
 127     }
 128     private void validateOnGraph(Map<String, List<String>> mapOriginToInstId, int expectedEdgeCount) {
 129         validateOnGraph(mapOriginToInstId, expectedEdgeCount, false);
 130     }
 131     private void validateOnGraph(Map<String, List<String>> mapOriginToInstId, int expectedEdgeCount, boolean validateProxy) {
 132         Iterable vertices = graphT.query().has(GraphPropertyEnum.UNIQUE_ID.getProperty(), containeId).vertices();
 133         assertNotNull(vertices);
 134         Iterator<TitanVertex> iterator = vertices.iterator();
 135         assertTrue(iterator.hasNext());
 136         Vertex containerV = iterator.next();
 137         validatePerEdgeType(mapOriginToInstId, expectedEdgeCount, containerV, EdgeLabelEnum.INSTANCE_OF);
 138         if ( validateProxy ){
 139             validatePerEdgeType(mapOriginToInstId, expectedEdgeCount, containerV, EdgeLabelEnum.PROXY_OF);
 140         }
 141     }
 142     private void validatePerEdgeType(Map<String, List<String>> mapOriginToInstId, int expectedEdgeCount, Vertex containerV, EdgeLabelEnum edgeLabel) {
 143         Iterator<Edge> edges = containerV.edges(Direction.OUT, edgeLabel.name());
 144         assertNotNull(edges);
 145
 146         int counter = 0;
 147         while (edges.hasNext()){
 148             Edge edge = edges.next();
 149             counter++;
 150             validateEdge(edge, mapOriginToInstId);
 151         }
 152         assertEquals("check edge size", expectedEdgeCount, counter);
 153     }
 154
 155
 156     private String createIntancesFromSameResource(Map<String, List<String>> mapOriginToInstId, int originIndex, int countInstances) {
 157         return createIntancesFromSameResource(mapOriginToInstId,  originIndex,  countInstances, false, null);
 158     }
 159
 160     private String createIntancesFromSameResource(Map<String, List<String>> mapOriginToInstId, int originIndex, int countInstances, boolean isProxy, String proxyId) {
 161
 162         List<String> exp = new ArrayList();
 163         String originId = createOrigin(originIndex);
 164
 165         for ( int i = 0; i < countInstances; i++){
 166             String instanceId = createInstanceEdge(containerVertex, originId, originIndex, i+1, isProxy, proxyId);
 167             exp.add(instanceId);
 168         }
 169         mapOriginToInstId.put(originId, exp);
 170         if ( isProxy ){
 171             mapOriginToInstId.put(proxyId, exp);
 172         }
 173         return originId;
 174     }
 175
 176     private String createInstanceEdge(GraphVertex containerVertex, String originId, int originIndex, int insIndex, boolean isProxy, String proxyId) {
 177         ComponentInstanceDataDefinition componentInstance = new ComponentInstanceDataDefinition();
 178         componentInstance.setComponentUid(originId);
 179         String instanceId = buildInstanceId(originIndex, insIndex);
 180         componentInstance.setUniqueId(instanceId);
 181         componentInstance.setIsProxy(isProxy);
 182         componentInstance.setSourceModelUid(proxyId);
 183         StorageOperationStatus edgeStatus = nodeTemplateOperation.createInstanceEdge(containerVertex, componentInstance);
 184         assertEquals("assertion createInstanceEdge", StorageOperationStatus.OK, edgeStatus);
 185         return instanceId;
 186     }
 187
 188     private String buildInstanceId(int originIndex, int insIndex) {
 189         StringBuffer sb = new StringBuffer("instanceId_");
 190         sb.append(originIndex).append("-").append(insIndex);
 191         return  sb.toString();
 192     }
 193     private String removeInstanceEdge(GraphVertex containerVertex, String originId, int originIndex, int insIndex) {
 194         ComponentInstanceDataDefinition componentInstance = new ComponentInstanceDataDefinition();
 195         componentInstance.setComponentUid(originId);
 196         String instanceId = buildInstanceId(originIndex, insIndex);
 197         componentInstance.setUniqueId(instanceId);
 198         StorageOperationStatus edgeStatus = nodeTemplateOperation.removeInstanceEdge(containerVertex, componentInstance);
 199         assertEquals("assertion removeInstanceEdge", StorageOperationStatus.OK, edgeStatus);
 200         return instanceId;
 201     }
 202
 203
 204     private String createOrigin(int index) {
 205         Either<GraphVertex, TitanOperationStatus> createVertex;
 206         GraphVertex originVertex = new GraphVertex(VertexTypeEnum.NODE_TYPE);
 207         String originId = "originId_" + index;
 208         originVertex.setUniqueId(originId);
 209         createVertex = titanDao.createVertex(originVertex);
 210         assertTrue(createVertex.isLeft());
 211         return originId;
 212     }
 213     private void validateEdge(Edge edge, Map<String, List<String>> mapOriginToInstId) {
 214         List<String> expextedInList;
 215
 216         Vertex originV = edge.inVertex();
 217         String id = (String) titanDao.getProperty((TitanVertex)originV, GraphPropertyEnum.UNIQUE_ID.getProperty());
 218         expextedInList = mapOriginToInstId.get(id);
 219
 220         List<String> list = (List<String>) titanDao.getProperty(edge, EdgePropertyEnum.INSTANCES);
 221         assertThat(list).hasSameSizeAs(expextedInList);
 222         assertThat(list).containsOnlyElementsOf(expextedInList);
 223     }
 224
 225     private String exportGraphMl(TitanGraph graph) {
 226         String result = null;
 227         String outputFile = outputDirectory + File.separator + "exportGraph." + System.currentTimeMillis() + ".graphml";
 228         try {
 229             try (final OutputStream os = new BufferedOutputStream(new FileOutputStream(outputFile))) {
 230                 graph.io(IoCore.graphml()).writer().normalize(true).create().writeGraph(os, graph);
 231             }
 232             result = outputFile;
 233         } catch (Exception e) {
 234             e.printStackTrace();
 235         }
 236         return result;
 237
 238     }
 239 }