aai-core/src/test/java/org/onap/aai/serialization/db/DbSerializer_needsFakeRulesTest.java

   1 /**
   2  * ============LICENSE_START=======================================================
   3  * org.onap.aai
   4  * ================================================================================
   5  * Copyright © 2017-18 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 package org.onap.aai.serialization.db;
  21
  22 import org.onap.aai.setup.SchemaVersion;
  23 import org.onap.aai.setup.SchemaVersions;
  24 import org.onap.aai.util.AAIConstants;
  25 import org.janusgraph.core.JanusGraphFactory;
  26 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
  27 import org.apache.tinkerpop.gremlin.structure.*;
  28 import org.junit.*;
  29 import org.junit.rules.ExpectedException;
  30 import org.junit.runner.RunWith;
  31 import org.onap.aai.config.IntrospectionConfig;
  32 import org.onap.aai.config.SpringContextAware;
  33 import org.onap.aai.db.props.AAIProperties;
  34 import org.onap.aai.dbmap.DBConnectionType;
  35 import org.onap.aai.edges.EdgeIngestor;
  36 import org.onap.aai.exceptions.AAIException;
  37 import org.onap.aai.introspection.*;
  38 import org.onap.aai.nodes.NodeIngestor;
  39 import org.onap.aai.parsers.query.QueryParser;
  40 import org.onap.aai.serialization.engines.QueryStyle;
  41 import org.onap.aai.serialization.engines.JanusGraphDBEngine;
  42 import org.onap.aai.serialization.engines.TransactionalGraphEngine;
  43 import org.onap.aai.serialization.queryformats.QueryFormatTestHelper;
  44 import org.onap.aai.setup.SchemaLocationsBean;
  45 import org.springframework.beans.factory.annotation.Autowired;
  46 import org.springframework.test.context.ContextConfiguration;
  47 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  48
  49 import java.io.UnsupportedEncodingException;
  50 import java.net.URI;
  51 import java.net.URISyntaxException;
  52 import java.util.*;
  53
  54 import static org.junit.Assert.*;
  55 import static org.mockito.Mockito.spy;
  56 import static org.mockito.Mockito.when;
  57
  58 //@RunWith(value = Parameterized.class) TODO replace this functionality
  59 @RunWith(SpringJUnit4ClassRunner.class)
  60 @ContextConfiguration(classes = {
  61                 SchemaLocationsBean.class,
  62         SchemaVersions.class,
  63                 AAICoreFakeEdgesConfigTranslator.class,
  64                 NodeIngestor.class,
  65                 EdgeIngestor.class,
  66                 EdgeSerializer.class,
  67                 SpringContextAware.class,
  68                 IntrospectionConfig.class
  69 })
  70 public class DbSerializer_needsFakeRulesTest {
  71
  72         //to use, set thrown.expect to whatever your test needs
  73         //this line establishes default of expecting no exception to be thrown
  74         @Rule
  75         public ExpectedException thrown = ExpectedException.none();
  76
  77         protected static Graph graph;
  78
  79         @Autowired
  80         protected EdgeSerializer edgeSer;
  81         @Autowired
  82         protected EdgeIngestor ei;
  83         @Autowired
  84         protected SchemaVersions schemaVersions;
  85
  86         private SchemaVersion version;
  87         private final ModelType introspectorFactoryType = ModelType.MOXY;
  88         private final DBConnectionType type = DBConnectionType.REALTIME;
  89         private Loader loader;
  90         private TransactionalGraphEngine dbEngine;
  91         private TransactionalGraphEngine engine; //for tests that aren't mocking the engine
  92         private DBSerializer dbser;
  93         TransactionalGraphEngine spy;
  94         TransactionalGraphEngine.Admin adminSpy;
  95
  96         //@Parameterized.Parameter(value = 0)
  97         public QueryStyle queryStyle = QueryStyle.TRAVERSAL;
  98
  99         /*@Parameterized.Parameters(name = "QueryStyle.{0}")
 100         public static Collection<Object[]> data() {
 101                 return Arrays.asList(new Object[][]{
 102                                 {QueryStyle.TRAVERSAL},
 103                                 {QueryStyle.TRAVERSAL_URI}
 104                 });
 105         }*/
 106
 107         @BeforeClass
 108         public static void init() throws Exception {
 109                 graph = JanusGraphFactory.build().set("storage.backend", "inmemory").open();
 110                 System.setProperty("AJSC_HOME", ".");
 111         System.setProperty("BUNDLECONFIG_DIR", "src/test/resources/bundleconfig-local");
 112         QueryFormatTestHelper.setFinalStatic(AAIConstants.class.getField("AAI_HOME_ETC_OXM"), "src/test/resources/bundleconfig-local/etc/oxm/");
 113
 114         }
 115
 116         @Before
 117         public void setup() throws Exception {
 118                 //createGraph();
 119         version = schemaVersions.getDefaultVersion();
 120                 loader = SpringContextAware.getBean(LoaderFactory.class).createLoaderForVersion(introspectorFactoryType, version);
 121                 dbEngine = new JanusGraphDBEngine(queryStyle, type, loader);
 122                 spy = spy(dbEngine);
 123                 adminSpy = spy(dbEngine.asAdmin());
 124
 125
 126                 engine = new JanusGraphDBEngine(queryStyle, type, loader);
 127                 dbser = new DBSerializer(version, engine, introspectorFactoryType, "AAI-TEST");
 128         }
 129
 130         @After
 131         public void tearDown() throws Exception {
 132             engine.rollback();
 133         }
 134
 135         @AfterClass
 136         public static void destroy() throws Exception {
 137                 graph.close();
 138         }
 139
 140         public void subnetSetup() throws AAIException {
 141                 /*
 142                  * This setus up the test graph, For future junits , add more vertices
 143                  * and edges
 144                  */
 145
 146                 Vertex l3interipv4addresslist_1 = graph.traversal().addV("aai-node-type", "l3-interface-ipv4-address-list",
 147                                 "l3-interface-ipv4-address", "l3-interface-ipv4-address-1").next();
 148                 Vertex subnet_2 = graph.traversal().addV("aai-node-type", "subnet", "subnet-id", "subnet-id-2").next();
 149                 Vertex l3interipv6addresslist_3 = graph.traversal().addV("aai-node-type", "l3-interface-ipv6-address-list",
 150                                 "l3-interface-ipv6-address", "l3-interface-ipv6-address-3").next();
 151                 Vertex subnet_4 = graph.traversal().addV("aai-node-type", "subnet", "subnet-id", "subnet-id-4").next();
 152                 Vertex subnet_5 = graph.traversal().addV("aai-node-type", "subnet", "subnet-id", "subnet-id-5").next();
 153                 Vertex l3network_6 = graph.traversal()
 154                                 .addV("aai-node-type", "l3-network", "network-id", "network-id-6", "network-name", "network-name-6")
 155                                 .next();
 156
 157                 GraphTraversalSource g = graph.traversal();
 158                 edgeSer.addEdge(g, l3interipv4addresslist_1, subnet_2);
 159                 edgeSer.addEdge(g, l3interipv6addresslist_3, subnet_4);
 160                 edgeSer.addTreeEdge(g, subnet_5, l3network_6);
 161         }
 162
 163         public String testDelete(Vertex v) throws AAIException {
 164
 165                 GraphTraversalSource traversal = graph.traversal();
 166                 when(spy.asAdmin()).thenReturn(adminSpy);
 167                 when(adminSpy.getTraversalSource()).thenReturn(traversal);
 168                 when(adminSpy.getReadOnlyTraversalSource()).thenReturn(traversal);
 169
 170                 String exceptionMessage = "";
 171                 DBSerializer serializer = new DBSerializer(version, spy, introspectorFactoryType, "AAI_TEST");
 172                 try {
 173                         serializer.delete(v, "resourceVersion", false);
 174                 } catch (AAIException exception) {
 175                         exceptionMessage = exception.getMessage();
 176                 }
 177                 return exceptionMessage;
 178
 179         }
 180
 181         @Test
 182         public void serializeToDbNewVertexAndEdgeAAIUUIDTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
 183                 String testName = new Object() {}.getClass().getEnclosingMethod().getName();
 184                 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 185
 186                 engine.startTransaction();
 187
 188                 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","vnfc-" + testName, AAIProperties.AAI_URI, "/network/vnfcs/vnfc/vnfc-" + testName);
 189
 190                 Introspector relationship = loader.introspectorFromName("relationship");
 191                 relationship.setValue("related-to", "vnfc");
 192                 relationship.setValue("related-link", "/network/vnfcs/vnfc/vnfc-" + testName);
 193
 194                 Introspector relationshipList = loader.introspectorFromName("relationship-list");
 195                 relationshipList.setValue("relationship", Collections.singletonList(relationship.getUnderlyingObject()));
 196
 197                 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
 198                 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
 199                 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
 200                 gvnfObj.setValue("vnf-id", "vnf-" + testName);
 201
 202                 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/vnf-" + testName));
 203
 204                 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
 205                 assertTrue("Generic-vnf has uuid ", gvnf.property(AAIProperties.AAI_UUID).isPresent());
 206                 assertTrue("Edge has uuid ", gvnf.edges(Direction.BOTH).next().property(AAIProperties.AAI_UUID).isPresent());
 207
 208         }
 209
 210         @Test
 211         public void createEdgeWithValidLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
 212
 213                 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 214
 215                 engine.startTransaction();
 216
 217                 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf", "aai-uri", "/network/generic-vnfs/generic-vnf/myvnf");
 218                 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
 219
 220                 //sunny day case
 221                 Introspector relData = loader.introspectorFromName("relationship-data");
 222                 relData.setValue("relationship-key", "vnfc.vnfc-name");
 223                 relData.setValue("relationship-value", "a-name");
 224                 Introspector relationship = loader.introspectorFromName("relationship");
 225                 relationship.setValue("related-to", "vnfc");
 226                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 227                 relationship.setValue("relationship-data",relData);
 228                 relationship.setValue("relationship-label", "over-uses");
 229
 230                 assertTrue(localDbser.createEdge(relationship, gvnf));
 231                 assertTrue(engine.tx().traversal().V(gvnf).both("over-uses").hasNext());
 232                 assertTrue(engine.tx().traversal().V(vnfc).both("over-uses").hasNext());
 233
 234         }
 235
 236         @Test
 237         public void createEdgeWithValidLabelWhenSameEdgeExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
 238
 239                 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 240                 engine.startTransaction();
 241
 242                 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf", "aai-uri", "/network/generic-vnfs/generic-vnf/myvnf");
 243                 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
 244                 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "re-uses");
 245
 246                 Introspector relData = loader.introspectorFromName("relationship-data");
 247                 relData.setValue("relationship-key", "vnfc.vnfc-name");
 248                 relData.setValue("relationship-value", "a-name");
 249                 Introspector relationship = loader.introspectorFromName("relationship");
 250                 relationship.setValue("related-to", "vnfc");
 251                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 252                 relationship.setValue("relationship-data",relData);
 253                 relationship.setValue("relationship-label", "re-uses");
 254
 255                 assertTrue(localDbser.createEdge(relationship, gvnf));
 256                 assertTrue(engine.tx().traversal().V(gvnf).both("re-uses").hasNext());
 257                 assertTrue(engine.tx().traversal().V(vnfc).both("re-uses").hasNext());
 258                 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V(vnfc).both().count().next());
 259
 260         }
 261
 262         @Test
 263         public void createEdgeWithValidLabelWhenDiffEdgeExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
 264
 265                 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 266                 engine.startTransaction();
 267
 268                 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf", "aai-uri", "/network/generic-vnfs/generic-vnf/myvnf");
 269                 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
 270                 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "uses");
 271
 272                 Introspector relData = loader.introspectorFromName("relationship-data");
 273                 relData.setValue("relationship-key", "vnfc.vnfc-name");
 274                 relData.setValue("relationship-value", "a-name");
 275                 Introspector relationship = loader.introspectorFromName("relationship");
 276                 relationship.setValue("related-to", "vnfc");
 277                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 278                 relationship.setValue("relationship-data",relData);
 279                 relationship.setValue("relationship-label", "uses");
 280                 localDbser.createEdge(relationship, gvnf);
 281
 282                 relationship.setValue("relationship-label", "re-uses");
 283
 284                 assertTrue(localDbser.createEdge(relationship, gvnf));
 285                 assertTrue(engine.tx().traversal().V(gvnf).both("re-uses").hasNext());
 286                 assertTrue(engine.tx().traversal().V(vnfc).both("re-uses").hasNext());
 287                 assertTrue(engine.tx().traversal().V(gvnf).both("uses").hasNext());
 288                 assertTrue(engine.tx().traversal().V(vnfc).both("uses").hasNext());
 289                 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(vnfc).both().count().next());
 290                 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(gvnf).both().count().next());
 291
 292         }
 293
 294         @Test
 295         public void createEdgeWithNoLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
 296
 297                 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 298                 engine.startTransaction();
 299
 300                 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf", "aai-uri", "/network/generic-vnfs/generic-vnf/myvnf");
 301                 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
 302
 303                 Introspector relData = loader.introspectorFromName("relationship-data");
 304                 relData.setValue("relationship-key", "vnfc.vnfc-name");
 305                 relData.setValue("relationship-value", "a-name");
 306                 Introspector relationship = loader.introspectorFromName("relationship");
 307                 relationship.setValue("related-to", "vnfc");
 308                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 309                 relationship.setValue("relationship-data",relData);
 310                 localDbser.createEdge(relationship, gvnf);
 311
 312                 assertTrue(localDbser.createEdge(relationship, gvnf));
 313                 assertTrue(engine.tx().traversal().V(gvnf).both("uses").hasNext());
 314                 assertTrue(engine.tx().traversal().V(vnfc).both("uses").hasNext());
 315                 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V(vnfc).both().count().next());
 316                 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V(gvnf).both().count().next());
 317
 318
 319         }
 320
 321         @Test
 322         public void deleteEdgeWithNoLabelWhenMultipleExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
 323
 324                 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 325                 engine.startTransaction();
 326
 327                 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf", "aai-uri", "/network/generic-vnfs/generic-vnf/myvnf");
 328                 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
 329                 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "uses");
 330                 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "re-uses");
 331                 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "over-uses");
 332
 333                 Introspector relData = loader.introspectorFromName("relationship-data");
 334                 relData.setValue("relationship-key", "vnfc.vnfc-name");
 335                 relData.setValue("relationship-value", "a-name");
 336                 Introspector relationship = loader.introspectorFromName("relationship");
 337                 relationship.setValue("related-to", "vnfc");
 338                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 339                 relationship.setValue("relationship-data",relData);
 340
 341                 assertTrue(localDbser.deleteEdge(relationship, gvnf));
 342                 assertFalse("generic-vnf has no edge uses", engine.tx().traversal().V(gvnf).both("uses").hasNext());
 343                 assertFalse("vnfc has no edge uses", engine.tx().traversal().V(vnfc).both("uses").hasNext());
 344                 assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V(gvnf).both("re-uses").hasNext());
 345                 assertTrue("vnfc has edge re-uses", engine.tx().traversal().V(vnfc).both("re-uses").hasNext());
 346                 assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V(gvnf).both("over-uses").hasNext());
 347                 assertTrue("vnfc has edge re-uses", engine.tx().traversal().V(vnfc).both("over-uses").hasNext());
 348                 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(vnfc).both().count().next());
 349                 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(gvnf).both().count().next());
 350
 351         }
 352
 353         @Test
 354         public void deleteEdgeWithValidLabelWhenMultipleExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
 355
 356                 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 357
 358                 engine.startTransaction();
 359
 360                 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf", "aai-uri", "/network/generic-vnfs/generic-vnf/myvnf");
 361                 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
 362                 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "uses");
 363                 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "re-uses");
 364                 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "over-uses");
 365
 366                 Introspector relData = loader.introspectorFromName("relationship-data");
 367                 relData.setValue("relationship-key", "vnfc.vnfc-name");
 368                 relData.setValue("relationship-value", "a-name");
 369                 Introspector relationship = loader.introspectorFromName("relationship");
 370                 relationship.setValue("related-to", "vnfc");
 371                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 372                 relationship.setValue("relationship-data",relData);
 373                 relationship.setValue("relationship-label", "re-uses");
 374
 375                 assertTrue(localDbser.deleteEdge(relationship, gvnf));
 376                 assertTrue("generic-vnf has edge uses", engine.tx().traversal().V(gvnf).both("uses").hasNext());
 377                 assertTrue("vnfc has edge uses", engine.tx().traversal().V(vnfc).both("uses").hasNext());
 378                 assertFalse("generic-vnf has no edge re-uses", engine.tx().traversal().V(gvnf).both("re-uses").hasNext());
 379                 assertFalse("vnfc has no edge re-uses", engine.tx().traversal().V(vnfc).both("re-uses").hasNext());
 380                 assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V(gvnf).both("over-uses").hasNext());
 381                 assertTrue("vnfc has edge re-uses", engine.tx().traversal().V(vnfc).both("over-uses").hasNext());
 382                 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(vnfc).both().count().next());
 383                 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(gvnf).both().count().next());
 384
 385         }
 386
 387         @Test
 388         public void deleteEdgeWithValidInvalidLabelWhenMultipleExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
 389
 390                 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 391
 392                 engine.startTransaction();
 393
 394                 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf", "aai-uri", "/network/generic-vnfs/generic-vnf/myvnf");
 395                 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
 396                 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "uses");
 397                 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "re-uses");
 398                 edgeSer.addEdge(graph.traversal(), gvnf, vnfc, "over-uses");
 399
 400                 Introspector relData = loader.introspectorFromName("relationship-data");
 401                 relData.setValue("relationship-key", "vnfc.vnfc-name");
 402                 relData.setValue("relationship-value", "a-name");
 403                 Introspector relationship = loader.introspectorFromName("relationship");
 404                 relationship.setValue("related-to", "vnfc");
 405                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 406                 relationship.setValue("relationship-data",relData);
 407                 relationship.setValue("relationship-label", "NA");
 408
 409                 thrown.expect(AAIException.class);
 410                 thrown.expectMessage("No rule found");
 411                 thrown.expectMessage("node type: generic-vnf, node type: vnfc, label: NA, type: COUSIN");
 412                 localDbser.deleteEdge(relationship, gvnf);
 413         }
 414
 415         @Test
 416         public void serializeToDbWithLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
 417
 418                 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 419
 420                 engine.startTransaction();
 421
 422                 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
 423
 424                 Introspector relationship = loader.introspectorFromName("relationship");
 425                 relationship.setValue("related-to", "vnfc");
 426                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 427                 relationship.setValue("relationship-label", "re-uses");
 428                 Introspector relationshipList = loader.introspectorFromName("relationship-list");
 429                 relationshipList.setValue("relationship", Collections.singletonList(relationship.getUnderlyingObject()));
 430
 431                 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
 432                 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
 433                 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
 434                 gvnfObj.setValue("vnf-id", "myvnf");
 435
 436                 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
 437
 438                 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
 439
 440                 assertTrue("vertex with vnf-id myvnf exists", engine.tx().traversal().V().has("vnf-id", "myvnf").hasNext());
 441                 assertTrue("vertex with vnfc-name a-name exists", engine.tx().traversal().V().has("vnfc-name", "a-name").hasNext());
 442                 assertFalse("generic-vnf has no edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("uses").hasNext());
 443                 assertFalse("vnfc has no edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("uses").hasNext());
 444                 assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("re-uses").hasNext());
 445                 assertTrue("vnfc has edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("re-uses").hasNext());
 446                 assertFalse("generic-vnf has no edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("over-uses").hasNext());
 447                 assertFalse("vnfc has no edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("over-uses").hasNext());
 448                 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnfc-name", "a-name").both().count().next());
 449                 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnf-id", "myvnf").both().count().next());
 450
 451         }
 452
 453         @Test
 454         public void serializeToDbWithoutLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
 455
 456                 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 457
 458                 engine.startTransaction();
 459
 460                 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
 461
 462                 Introspector relationship = loader.introspectorFromName("relationship");
 463                 relationship.setValue("related-to", "vnfc");
 464                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 465
 466                 Introspector relationshipList = loader.introspectorFromName("relationship-list");
 467                 relationshipList.setValue("relationship", Collections.singletonList(relationship.getUnderlyingObject()));
 468
 469                 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
 470                 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
 471                 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
 472                 gvnfObj.setValue("vnf-id", "myvnf");
 473
 474                 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
 475
 476                 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
 477
 478                 assertTrue("vertex with vnf-id myvnf exists", engine.tx().traversal().V().has("vnf-id", "myvnf").hasNext());
 479                 assertTrue("vertex with vnfc-name a-name exists", engine.tx().traversal().V().has("vnfc-name", "a-name").hasNext());
 480                 assertTrue("generic-vnf has edge uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("uses").hasNext());
 481                 assertTrue("vnfc has edge uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("uses").hasNext());
 482                 assertFalse("generic-vnf has no edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("re-uses").hasNext());
 483                 assertFalse("vnfc has no edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("re-uses").hasNext());
 484                 assertFalse("generic-vnf has no edge over-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("over-uses").hasNext());
 485                 assertFalse("vnfc has no edge over-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("over-uses").hasNext());
 486                 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnfc-name", "a-name").both().count().next());
 487                 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnf-id", "myvnf").both().count().next());
 488
 489         }
 490
 491         @Test
 492         public void serializeToDbWithInvalidLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
 493
 494                 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 495
 496                 engine.startTransaction();
 497
 498                 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
 499
 500                 Introspector relationship = loader.introspectorFromName("relationship");
 501                 relationship.setValue("related-to", "vnfc");
 502                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 503                 relationship.setValue("relationship-label", "NA");
 504                 Introspector relationshipList = loader.introspectorFromName("relationship-list");
 505                 relationshipList.setValue("relationship", Collections.singletonList(relationship.getUnderlyingObject()));
 506
 507                 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
 508                 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
 509                 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
 510                 gvnfObj.setValue("vnf-id", "myvnf");
 511
 512                 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
 513
 514                 thrown.expect(AAIException.class);
 515                 thrown.expectMessage("No EdgeRule found for passed nodeTypes: generic-vnf, vnfc with label NA.");
 516                 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
 517
 518         }
 519
 520         @Test
 521         public void serializeToDbWithLabelAndEdgeExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
 522
 523                 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 524
 525                 engine.startTransaction();
 526                 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
 527
 528                 Introspector relationship;
 529                 Introspector relationshipList;
 530                 List<Object> relList = new ArrayList<>();
 531
 532                 // create generic-vnf
 533                 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
 534                 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
 535                 gvnfObj.setValue("vnf-id", "myvnf");
 536                 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
 537
 538                 // create relationship to vnfc
 539                 relationship = loader.introspectorFromName("relationship");
 540                 relationship.setValue("related-to", "vnfc");
 541                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 542                 relList.add(relationship.getUnderlyingObject());
 543                 relationshipList = loader.introspectorFromName("relationship-list");
 544                 relationshipList.setValue("relationship", relList);
 545                 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
 546
 547                 // add gvnf to graph
 548                 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
 549
 550                 // add second relationship
 551                 relationship = loader.introspectorFromName("relationship");
 552                 relationship.setValue("related-to", "vnfc");
 553                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 554                 relationship.setValue("relationship-label", "re-uses");
 555                 relList.add(relationship.getUnderlyingObject());
 556                 relationshipList = loader.introspectorFromName("relationship-list");
 557                 relationshipList.setValue("relationship", relList);
 558                 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
 559
 560                 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
 561
 562                 assertTrue("vertex with vnf-id myvnf exists", engine.tx().traversal().V().has("vnf-id", "myvnf").hasNext());
 563                 assertTrue("vertex with vnfc-name a-name exists", engine.tx().traversal().V().has("vnfc-name", "a-name").hasNext());
 564                 assertTrue("generic-vnf has  edge uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("uses").hasNext());
 565                 assertTrue("vnfc has  edge uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("uses").hasNext());
 566                 assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("re-uses").hasNext());
 567                 assertTrue("vnfc has edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("re-uses").hasNext());
 568                 assertFalse("generic-vnf has no edge over-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("over-uses").hasNext());
 569                 assertFalse("vnfc has no edge over-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("over-uses").hasNext());
 570                 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V().has("vnfc-name", "a-name").both().count().next());
 571                 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V().has("vnf-id", "myvnf").both().count().next());
 572
 573         }
 574
 575         @Test
 576         public void serializeToDbWithLabelDroppingRelationshipTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
 577
 578                 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules();
 579
 580                 engine.startTransaction();
 581                 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name", "aai-uri", "/network/vnfcs/vnfc/a-name");
 582
 583
 584                 Introspector relationship;
 585                 Introspector relationshipList;
 586                 List<Object> relList = new ArrayList<>();
 587
 588                 // create generic-vnf
 589                 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
 590                 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
 591                 gvnfObj.setValue("vnf-id", "myvnf");
 592                 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
 593
 594                 // create relationship to vnfc
 595                 relationship = loader.introspectorFromName("relationship");
 596                 relationship.setValue("related-to", "vnfc");
 597                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 598                 relList.add(relationship.getUnderlyingObject());
 599                 // add second relationship
 600                 relationship = loader.introspectorFromName("relationship");
 601                 relationship.setValue("related-to", "vnfc");
 602                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 603                 relationship.setValue("relationship-label", "re-uses");
 604                 relList.add(relationship.getUnderlyingObject());
 605                 relationshipList = loader.introspectorFromName("relationship-list");
 606                 relationshipList.setValue("relationship", relList);
 607                 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
 608
 609                 // add gvnf to graph
 610                 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
 611
 612                 // drop second relationship
 613                 relList.remove(1);
 614                 relationshipList = loader.introspectorFromName("relationship-list");
 615                 relationshipList.setValue("relationship", relList);
 616                 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
 617
 618                 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
 619
 620                 assertTrue("vertex with vnf-id myvnf exists", engine.tx().traversal().V().has("vnf-id", "myvnf").hasNext());
 621                 assertTrue("vertex with vnfc-name a-name exists", engine.tx().traversal().V().has("vnfc-name", "a-name").hasNext());
 622                 assertTrue("generic-vnf has  edge uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("uses").hasNext());
 623                 assertTrue("vnfc has  edge uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("uses").hasNext());
 624                 assertFalse("generic-vnf no longer has edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("re-uses").hasNext());
 625                 assertFalse("vnfc no longer has edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("re-uses").hasNext());
 626                 assertFalse("generic-vnf has no edge over-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("over-uses").hasNext());
 627                 assertFalse("vnfc has no edge over-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("over-uses").hasNext());
 628                 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnfc-name", "a-name").both().count().next());
 629                 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnf-id", "myvnf").both().count().next());
 630
 631         }
 632
 633         private DBSerializer getDBSerializerWithSpecificEdgeRules()
 634                         throws NoSuchFieldException, AAIException, IllegalAccessException {
 635
 636
 637                 DBSerializer localDbser = new DBSerializer(version, engine, introspectorFactoryType, "AAI-TEST");
 638                 return localDbser;
 639         }
 640 }