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 fj.data.Either;
  29 import java.io.BufferedOutputStream;
  30 import java.io.File;
  31 import java.io.FileOutputStream;
  32 import java.io.OutputStream;
  33 import java.util.ArrayList;
  34 import java.util.HashMap;
  35 import java.util.Iterator;
  36 import java.util.List;
  37 import java.util.Map;
  38 import javax.annotation.Resource;
  39 import org.apache.tinkerpop.gremlin.structure.Direction;
  40 import org.apache.tinkerpop.gremlin.structure.Edge;
  41 import org.apache.tinkerpop.gremlin.structure.Vertex;
  42 import org.apache.tinkerpop.gremlin.structure.io.IoCore;
  43 import org.janusgraph.core.JanusGraph;
  44 import org.janusgraph.core.JanusGraphVertex;
  45 import org.junit.jupiter.api.AfterEach;
  46 import org.junit.jupiter.api.BeforeAll;
  47 import org.junit.jupiter.api.BeforeEach;
  48 import org.junit.jupiter.api.Test;
  49 import org.openecomp.sdc.be.dao.config.JanusGraphSpringConfig;
  50 import org.openecomp.sdc.be.dao.janusgraph.HealingJanusGraphDao;
  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.jsongraph.types.EdgeLabelEnum;
  54 import org.openecomp.sdc.be.dao.jsongraph.types.EdgePropertyEnum;
  55 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
  56 import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition;
  57 import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
  58 import org.openecomp.sdc.be.model.ModelTestBase;
  59 import org.openecomp.sdc.be.model.config.ModelOperationsSpringConfig;
  60 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  61 import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;
  62
  63 @SpringJUnitConfig(classes = {JanusGraphSpringConfig.class, ModelOperationsSpringConfig.class})
  64 public class NodeTemplateOperationGraphTest extends ModelTestBase {
  65
  66     String outputDirectory = "C:\\Output";
  67     @Resource
  68     private HealingJanusGraphDao janusGraphDao;
  69     @Resource
  70     private NodeTemplateOperation nodeTemplateOperation;
  71     private JanusGraph graphT;
  72     private GraphVertex containerVertex;
  73     private String containeId;
  74
  75     @BeforeAll
  76     public static void setupBeforeClass() {
  77
  78         ModelTestBase.init();
  79     }
  80
  81     @BeforeEach
  82     public void before() {
  83
  84         Either<JanusGraph, JanusGraphOperationStatus> graph = janusGraphDao.getGraph();
  85         graphT = graph.left().value();
  86
  87         containerVertex = new GraphVertex(VertexTypeEnum.TOPOLOGY_TEMPLATE);
  88         containeId = "containerId";
  89         containerVertex.setUniqueId(containeId);
  90         Either<GraphVertex, JanusGraphOperationStatus> createVertex = janusGraphDao.createVertex(containerVertex);
  91         assertTrue(createVertex.isLeft());
  92     }
  93
  94     @AfterEach
  95     public void after() {
  96         janusGraphDao.rollback();
  97
  98     }
  99
 100     @Test
 101     public void testCreateInstanceEdge() {
 102
 103         Map<String, List<String>> mapOriginToInstId = new HashMap<>();
 104         createIntancesFromSameResource(mapOriginToInstId, 1, 3);
 105         createIntancesFromSameResource(mapOriginToInstId, 2, 4);
 106         createIntancesFromSameResource(mapOriginToInstId, 3, 1);
 107
 108 //        exportGraphMl(graphT);
 109
 110         validateOnGraph(mapOriginToInstId, 3);
 111     }
 112
 113     @Test
 114     public void testRemoveInstanceEdge() {
 115         //create 3 instances from same resource orig1
 116         Map<String, List<String>> mapOriginToInstId = new HashMap<>();
 117         String originId = createIntancesFromSameResource(mapOriginToInstId, 1, 3);
 118         validateOnGraph(mapOriginToInstId, 1);
 119
 120         //remove instance 2
 121         String instanceId = removeInstanceEdge(containerVertex, originId, 1, 1);
 122         mapOriginToInstId.get(originId).remove(instanceId);
 123         validateOnGraph(mapOriginToInstId, 1);
 124
 125         //create new instance from orig1
 126         instanceId = createInstanceEdge(containerVertex, originId, 1, 4, false, null);
 127         mapOriginToInstId.get(originId).add(instanceId);
 128         validateOnGraph(mapOriginToInstId, 1);
 129
 130         //create 1 instance from same resource orig2
 131         originId = createIntancesFromSameResource(mapOriginToInstId, 2, 1);
 132         validateOnGraph(mapOriginToInstId, 2);
 133
 134         //remove instance of orig 2
 135         instanceId = removeInstanceEdge(containerVertex, originId, 2, 1);
 136         mapOriginToInstId.get(originId).remove(instanceId);
 137         validateOnGraph(mapOriginToInstId, 1);
 138
 139     }
 140
 141     @Test
 142     public void testProxyInstanceEdge() {
 143         Map<String, List<String>> mapOriginToInstId = new HashMap<>();
 144         String proxyId = createOrigin(2);
 145         createIntancesFromSameResource(mapOriginToInstId, 1, 1, true, proxyId);
 146
 147         validateOnGraph(mapOriginToInstId, 1);
 148     }
 149
 150     private void validateOnGraph(Map<String, List<String>> mapOriginToInstId, int expectedEdgeCount) {
 151         validateOnGraph(mapOriginToInstId, expectedEdgeCount, false);
 152     }
 153
 154     private void validateOnGraph(Map<String, List<String>> mapOriginToInstId, int expectedEdgeCount, boolean validateProxy) {
 155         Iterable vertices = graphT.query().has(GraphPropertyEnum.UNIQUE_ID.getProperty(), containeId).vertices();
 156         assertNotNull(vertices);
 157         Iterator<JanusGraphVertex> iterator = vertices.iterator();
 158         assertTrue(iterator.hasNext());
 159         Vertex containerV = iterator.next();
 160         validatePerEdgeType(mapOriginToInstId, expectedEdgeCount, containerV, EdgeLabelEnum.INSTANCE_OF);
 161         if (validateProxy) {
 162             validatePerEdgeType(mapOriginToInstId, expectedEdgeCount, containerV, EdgeLabelEnum.PROXY_OF);
 163         }
 164     }
 165
 166     private void validatePerEdgeType(Map<String, List<String>> mapOriginToInstId, int expectedEdgeCount, Vertex containerV, EdgeLabelEnum edgeLabel) {
 167         Iterator<Edge> edges = containerV.edges(Direction.OUT, edgeLabel.name());
 168         assertNotNull(edges);
 169
 170         int counter = 0;
 171         while (edges.hasNext()) {
 172             Edge edge = edges.next();
 173             counter++;
 174             validateEdge(edge, mapOriginToInstId);
 175         }
 176         assertEquals("check edge size", expectedEdgeCount, counter);
 177     }
 178
 179
 180     private String createIntancesFromSameResource(Map<String, List<String>> mapOriginToInstId, int originIndex, int countInstances) {
 181         return createIntancesFromSameResource(mapOriginToInstId, originIndex, countInstances, false, null);
 182     }
 183
 184     private String createIntancesFromSameResource(Map<String, List<String>> mapOriginToInstId, int originIndex, int countInstances, boolean isProxy,
 185                                                   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
 219     private String removeInstanceEdge(GraphVertex containerVertex, String originId, int originIndex, int insIndex) {
 220         ComponentInstanceDataDefinition componentInstance = new ComponentInstanceDataDefinition();
 221         componentInstance.setComponentUid(originId);
 222         String instanceId = buildInstanceId(originIndex, insIndex);
 223         componentInstance.setUniqueId(instanceId);
 224         StorageOperationStatus edgeStatus = nodeTemplateOperation.removeInstanceEdge(containerVertex, componentInstance);
 225         assertEquals("assertion removeInstanceEdge", StorageOperationStatus.OK, edgeStatus);
 226         return instanceId;
 227     }
 228
 229
 230     private String createOrigin(int index) {
 231         Either<GraphVertex, JanusGraphOperationStatus> createVertex;
 232         GraphVertex originVertex = new GraphVertex(VertexTypeEnum.NODE_TYPE);
 233         String originId = "originId_" + index;
 234         originVertex.setUniqueId(originId);
 235         createVertex = janusGraphDao.createVertex(originVertex);
 236         assertTrue(createVertex.isLeft());
 237         return originId;
 238     }
 239
 240     private void validateEdge(Edge edge, Map<String, List<String>> mapOriginToInstId) {
 241         List<String> expextedInList;
 242
 243         Vertex originV = edge.inVertex();
 244         String id = (String) janusGraphDao.getProperty((JanusGraphVertex) originV, GraphPropertyEnum.UNIQUE_ID.getProperty());
 245         expextedInList = mapOriginToInstId.get(id);
 246
 247         List<String> list = (List<String>) janusGraphDao.getProperty(edge, EdgePropertyEnum.INSTANCES);
 248         assertThat(list).hasSameSizeAs(expextedInList);
 249         assertThat(list).containsOnlyElementsOf(expextedInList);
 250     }
 251
 252     private String exportGraphMl(JanusGraph graph) {
 253         String result = null;
 254         String outputFile = outputDirectory + File.separator + "exportGraph." + System.currentTimeMillis() + ".graphml";
 255         try {
 256             try (final OutputStream os = new BufferedOutputStream(new FileOutputStream(outputFile))) {
 257                 graph.io(IoCore.graphml()).writer().normalize(true).create().writeGraph(os, graph);
 258             }
 259             result = outputFile;
 260         } catch (Exception e) {
 261             e.printStackTrace();
 262         }
 263         return result;
 264
 265     }
 266 }