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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.be.model.jsonjanusgraph.operations;
  22
  23 import static org.assertj.core.api.Assertions.assertThat;
  24 import static org.junit.Assert.assertEquals;
  25 import static org.junit.Assert.assertNotNull;
  26 import static org.junit.Assert.assertTrue;
  27
  28 import org.janusgraph.core.JanusGraph;
  29 import org.janusgraph.core.JanusGraphVertex;
  30 import fj.data.Either;
  31 import java.io.BufferedOutputStream;
  32 import java.io.File;
  33 import java.io.FileOutputStream;
  34 import java.io.OutputStream;
  35 import java.util.ArrayList;
  36 import java.util.HashMap;
  37 import java.util.Iterator;
  38 import java.util.List;
  39 import java.util.Map;
  40 import javax.annotation.Resource;
  41 import org.apache.tinkerpop.gremlin.structure.Direction;
  42 import org.apache.tinkerpop.gremlin.structure.Edge;
  43 import org.apache.tinkerpop.gremlin.structure.Vertex;
  44 import org.apache.tinkerpop.gremlin.structure.io.IoCore;
  45 import org.junit.After;
  46 import org.junit.Before;
  47 import org.junit.BeforeClass;
  48 import org.junit.Test;
  49 import org.junit.runner.RunWith;
  50 import org.openecomp.sdc.be.dao.config.JanusGraphSpringConfig;
  51 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  52 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
  53 import org.openecomp.sdc.be.dao.janusgraph.HealingJanusGraphDao;
  54 import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
  55 import org.openecomp.sdc.be.dao.jsongraph.types.EdgePropertyEnum;
  56 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
  57 import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition;
  58 import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
  59 import org.openecomp.sdc.be.model.ModelTestBase;
  60 import org.openecomp.sdc.be.model.config.ModelOperationsSpringConfig;
  61 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  62 import org.springframework.test.context.ContextConfiguration;
  63 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  64
  65 @RunWith(SpringJUnit4ClassRunner.class)
  66 @ContextConfiguration(classes = {JanusGraphSpringConfig.class, ModelOperationsSpringConfig.class})
  67 public class NodeTemplateOperationGraphTest extends ModelTestBase{
  68     @Resource
  69     private HealingJanusGraphDao janusGraphDao;
  70     @Resource
  71     private NodeTemplateOperation nodeTemplateOperation;
  72
  73     private JanusGraph graphT;
  74     private GraphVertex containerVertex;
  75     private String containeId;
  76
  77     @BeforeClass
  78     public static void setupBeforeClass() {
  79
  80         ModelTestBase.init();
  81     }
  82     @Before
  83     public void before(){
  84
  85         Either<JanusGraph, JanusGraphOperationStatus> graph = janusGraphDao.getGraph();
  86         graphT = graph.left().value();
  87
  88         containerVertex = new GraphVertex(VertexTypeEnum.TOPOLOGY_TEMPLATE);
  89         containeId = "containerId";
  90         containerVertex.setUniqueId(containeId);
  91         Either<GraphVertex, JanusGraphOperationStatus> createVertex = janusGraphDao.createVertex(containerVertex);
  92         assertTrue(createVertex.isLeft());
  93     }
  94
  95     @After
  96     public void after(){
  97         janusGraphDao.rollback();
  98
  99     }
 100
 101
 102     String outputDirectory = "C:\\Output";
 103
 104     @Test
 105     public void testCreateInstanceEdge(){
 106
 107         Map<String, List<String>> mapOriginToInstId = new HashMap<>();
 108         createIntancesFromSameResource(mapOriginToInstId, 1, 3);
 109         createIntancesFromSameResource(mapOriginToInstId, 2, 4);
 110         createIntancesFromSameResource(mapOriginToInstId, 3, 1);
 111
 112 //        exportGraphMl(graphT);
 113
 114         validateOnGraph(mapOriginToInstId, 3);
 115     }
 116
 117     @Test
 118     public void testRemoveInstanceEdge(){
 119         //create 3 instances from same resource orig1
 120         Map<String, List<String>> mapOriginToInstId = new HashMap<>();
 121         String originId = createIntancesFromSameResource(mapOriginToInstId, 1, 3);
 122         validateOnGraph(mapOriginToInstId, 1);
 123
 124         //remove instance 2
 125         String instanceId = removeInstanceEdge(containerVertex, originId, 1, 1);
 126         mapOriginToInstId.get(originId).remove(instanceId);
 127         validateOnGraph(mapOriginToInstId, 1);
 128
 129         //create new instance from orig1
 130         instanceId = createInstanceEdge(containerVertex, originId, 1, 4, false, null);
 131         mapOriginToInstId.get(originId).add(instanceId);
 132         validateOnGraph(mapOriginToInstId, 1);
 133
 134         //create 1 instance from same resource orig2
 135         originId = createIntancesFromSameResource(mapOriginToInstId, 2, 1);
 136         validateOnGraph(mapOriginToInstId, 2);
 137
 138         //remove instance of orig 2
 139         instanceId = removeInstanceEdge(containerVertex, originId, 2, 1);
 140         mapOriginToInstId.get(originId).remove(instanceId);
 141         validateOnGraph(mapOriginToInstId, 1);
 142
 143     }
 144
 145     @Test
 146     public void testProxyInstanceEdge(){
 147         Map<String, List<String>> mapOriginToInstId = new HashMap<>();
 148         String proxyId  = createOrigin(2);
 149         createIntancesFromSameResource(mapOriginToInstId, 1, 1, true, proxyId);
 150
 151         validateOnGraph(mapOriginToInstId, 1);
 152     }
 153     private void validateOnGraph(Map<String, List<String>> mapOriginToInstId, int expectedEdgeCount) {
 154         validateOnGraph(mapOriginToInstId, expectedEdgeCount, false);
 155     }
 156     private void validateOnGraph(Map<String, List<String>> mapOriginToInstId, int expectedEdgeCount, boolean validateProxy) {
 157         Iterable vertices = graphT.query().has(GraphPropertyEnum.UNIQUE_ID.getProperty(), containeId).vertices();
 158         assertNotNull(vertices);
 159         Iterator<JanusGraphVertex> iterator = vertices.iterator();
 160         assertTrue(iterator.hasNext());
 161         Vertex containerV = iterator.next();
 162         validatePerEdgeType(mapOriginToInstId, expectedEdgeCount, containerV, EdgeLabelEnum.INSTANCE_OF);
 163         if ( validateProxy ){
 164             validatePerEdgeType(mapOriginToInstId, expectedEdgeCount, containerV, EdgeLabelEnum.PROXY_OF);
 165         }
 166     }
 167     private void validatePerEdgeType(Map<String, List<String>> mapOriginToInstId, int expectedEdgeCount, Vertex containerV, EdgeLabelEnum edgeLabel) {
 168         Iterator<Edge> edges = containerV.edges(Direction.OUT, edgeLabel.name());
 169         assertNotNull(edges);
 170
 171         int counter = 0;
 172         while (edges.hasNext()){
 173             Edge edge = edges.next();
 174             counter++;
 175             validateEdge(edge, mapOriginToInstId);
 176         }
 177         assertEquals("check edge size", expectedEdgeCount, counter);
 178     }
 179
 180
 181     private String createIntancesFromSameResource(Map<String, List<String>> mapOriginToInstId, int originIndex, int countInstances) {
 182         return createIntancesFromSameResource(mapOriginToInstId,  originIndex,  countInstances, false, null);
 183     }
 184
 185     private String createIntancesFromSameResource(Map<String, List<String>> mapOriginToInstId, int originIndex, int countInstances, boolean isProxy, String proxyId) {
 186
 187         List<String> exp = new ArrayList();
 188         String originId = createOrigin(originIndex);
 189
 190         for ( int i = 0; i < countInstances; i++){
 191             String instanceId = createInstanceEdge(containerVertex, originId, originIndex, i+1, isProxy, proxyId);
 192             exp.add(instanceId);
 193         }
 194         mapOriginToInstId.put(originId, exp);
 195         if ( isProxy ){
 196             mapOriginToInstId.put(proxyId, exp);
 197         }
 198         return originId;
 199     }
 200
 201     private String createInstanceEdge(GraphVertex containerVertex, String originId, int originIndex, int insIndex, boolean isProxy, String proxyId) {
 202         ComponentInstanceDataDefinition componentInstance = new ComponentInstanceDataDefinition();
 203         componentInstance.setComponentUid(originId);
 204         String instanceId = buildInstanceId(originIndex, insIndex);
 205         componentInstance.setUniqueId(instanceId);
 206         componentInstance.setIsProxy(isProxy);
 207         componentInstance.setSourceModelUid(proxyId);
 208         StorageOperationStatus edgeStatus = nodeTemplateOperation.createInstanceEdge(containerVertex, componentInstance);
 209         assertEquals("assertion createInstanceEdge", StorageOperationStatus.OK, edgeStatus);
 210         return instanceId;
 211     }
 212
 213     private String buildInstanceId(int originIndex, int insIndex) {
 214         StringBuilder sb = new StringBuilder("instanceId_");
 215         sb.append(originIndex).append("-").append(insIndex);
 216         return  sb.toString();
 217     }
 218     private String removeInstanceEdge(GraphVertex containerVertex, String originId, int originIndex, int insIndex) {
 219         ComponentInstanceDataDefinition componentInstance = new ComponentInstanceDataDefinition();
 220         componentInstance.setComponentUid(originId);
 221         String instanceId = buildInstanceId(originIndex, insIndex);
 222         componentInstance.setUniqueId(instanceId);
 223         StorageOperationStatus edgeStatus = nodeTemplateOperation.removeInstanceEdge(containerVertex, componentInstance);
 224         assertEquals("assertion removeInstanceEdge", StorageOperationStatus.OK, edgeStatus);
 225         return instanceId;
 226     }
 227
 228
 229     private String createOrigin(int index) {
 230         Either<GraphVertex, JanusGraphOperationStatus> createVertex;
 231         GraphVertex originVertex = new GraphVertex(VertexTypeEnum.NODE_TYPE);
 232         String originId = "originId_" + index;
 233         originVertex.setUniqueId(originId);
 234         createVertex = janusGraphDao.createVertex(originVertex);
 235         assertTrue(createVertex.isLeft());
 236         return originId;
 237     }
 238     private void validateEdge(Edge edge, Map<String, List<String>> mapOriginToInstId) {
 239         List<String> expextedInList;
 240
 241         Vertex originV = edge.inVertex();
 242         String id = (String) janusGraphDao.getProperty((JanusGraphVertex)originV, GraphPropertyEnum.UNIQUE_ID.getProperty());
 243         expextedInList = mapOriginToInstId.get(id);
 244
 245         List<String> list = (List<String>) janusGraphDao.getProperty(edge, EdgePropertyEnum.INSTANCES);
 246         assertThat(list).hasSameSizeAs(expextedInList);
 247         assertThat(list).containsOnlyElementsOf(expextedInList);
 248     }
 249
 250     private String exportGraphMl(JanusGraph graph) {
 251         String result = null;
 252         String outputFile = outputDirectory + File.separator + "exportGraph." + System.currentTimeMillis() + ".graphml";
 253         try {
 254             try (final OutputStream os = new BufferedOutputStream(new FileOutputStream(outputFile))) {
 255                 graph.io(IoCore.graphml()).writer().normalize(true).create().writeGraph(os, graph);
 256             }
 257             result = outputFile;
 258         } catch (Exception e) {
 259             e.printStackTrace();
 260         }
 261         return result;
 262
 263     }
 264 }