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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * org.onap.aai
   4  * ================================================================================
   5  * Copyright (C) 2017 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.onap.aai.serialization.db;
  22
  23 import static org.junit.Assert.assertEquals;
  24 import static org.junit.Assert.assertFalse;
  25 import static org.junit.Assert.assertTrue;
  26 import static org.mockito.Mockito.spy;
  27 import static org.mockito.Mockito.when;
  28
  29 import java.io.UnsupportedEncodingException;
  30 import java.lang.reflect.Field;
  31 import java.net.URI;
  32 import java.net.URISyntaxException;
  33 import java.util.ArrayList;
  34 import java.util.Arrays;
  35 import java.util.Collections;
  36 import java.util.List;
  37
  38 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
  39 import org.apache.tinkerpop.gremlin.structure.Edge;
  40 import org.apache.tinkerpop.gremlin.structure.Graph;
  41 import org.apache.tinkerpop.gremlin.structure.Vertex;
  42 import org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerGraph;
  43 import org.junit.After;
  44 import org.junit.Before;
  45 import org.junit.Rule;
  46 import org.junit.Test;
  47 import org.junit.rules.ExpectedException;
  48 import org.onap.aai.AAISetup;
  49 import org.onap.aai.db.props.AAIProperties;
  50 import org.onap.aai.dbmap.DBConnectionType;
  51 import org.onap.aai.exceptions.AAIException;
  52 import org.onap.aai.introspection.Introspector;
  53 import org.onap.aai.introspection.Loader;
  54 import org.onap.aai.introspection.LoaderFactory;
  55 import org.onap.aai.introspection.ModelType;
  56 import org.onap.aai.introspection.Version;
  57 import org.onap.aai.parsers.query.QueryParser;
  58 import org.onap.aai.serialization.engines.QueryStyle;
  59 import org.onap.aai.serialization.engines.TitanDBEngine;
  60 import org.onap.aai.serialization.engines.TransactionalGraphEngine;
  61
  62 import com.thinkaurelius.titan.core.TitanFactory;
  63
  64 public class DbSerializerTest extends AAISetup {
  65
  66         //to use, set thrown.expect to whatever your test needs
  67         //this line establishes default of expecting no exception to be thrown
  68         @Rule
  69         public ExpectedException thrown = ExpectedException.none();
  70
  71         protected Graph graph;
  72         protected final EdgeRules rules = EdgeRules.getInstance();
  73
  74         private final Version version = Version.getLatest();
  75         private final ModelType introspectorFactoryType = ModelType.MOXY;
  76         private final QueryStyle queryStyle = QueryStyle.TRAVERSAL;
  77         private final DBConnectionType type = DBConnectionType.REALTIME;
  78         private Loader loader;
  79         private TransactionalGraphEngine dbEngine;
  80         private TransactionalGraphEngine engine; //for tests that aren't mocking the engine
  81         private DBSerializer dbser;
  82         TransactionalGraphEngine spy;
  83         TransactionalGraphEngine.Admin adminSpy;
  84
  85         @Before
  86         public void setup() throws Exception {
  87                 graph = TitanFactory.build().set("storage.backend", "inmemory").open();
  88                 loader = LoaderFactory.createLoaderForVersion(introspectorFactoryType, version);
  89                 dbEngine = new TitanDBEngine(queryStyle, type, loader);
  90                 spy = spy(dbEngine);
  91                 adminSpy = spy(dbEngine.asAdmin());
  92
  93                 createGraph();
  94
  95                 engine = new TitanDBEngine(queryStyle, type, loader);
  96                 dbser = new DBSerializer(version, engine, introspectorFactoryType, "AAI-TEST");
  97         }
  98
  99         public void createGraph() throws AAIException {
 100                 /*
 101                  * This setus up the test graph, For future junits , add more vertices
 102                  * and edges
 103                  */
 104
 105                 Vertex l3interipv4addresslist_1 = graph.traversal().addV("aai-node-type", "l3-interface-ipv4-address-list",
 106                                 "l3-interface-ipv4-address", "l3-interface-ipv4-address-1").next();
 107                 Vertex subnet_2 = graph.traversal().addV("aai-node-type", "subnet", "subnet-id", "subnet-id-2").next();
 108                 Vertex l3interipv6addresslist_3 = graph.traversal().addV("aai-node-type", "l3-interface-ipv6-address-list",
 109                                 "l3-interface-ipv6-address", "l3-interface-ipv6-address-3").next();
 110                 Vertex subnet_4 = graph.traversal().addV("aai-node-type", "subnet", "subnet-id", "subnet-id-4").next();
 111                 Vertex subnet_5 = graph.traversal().addV("aai-node-type", "subnet", "subnet-id", "subnet-id-5").next();
 112                 Vertex l3network_6 = graph.traversal()
 113                                 .addV("aai-node-type", "l3-network", "network-id", "network-id-6", "network-name", "network-name-6")
 114                                 .next();
 115
 116                 GraphTraversalSource g = graph.traversal();
 117                 rules.addEdge(g, l3interipv4addresslist_1, subnet_2);
 118                 rules.addEdge(g, l3interipv6addresslist_3, subnet_4);
 119                 rules.addTreeEdge(g, subnet_5, l3network_6);
 120
 121         }
 122
 123         @After
 124         public void tearDown() throws Exception {
 125                 graph.close();
 126         }
 127
 128         @Test
 129         public void subnetDelwithInEdgesIpv4Test() throws AAIException {
 130                 String expected_message = "Object is being reference by additional objects preventing it from being deleted. Please clean up references from the following types [l3-interface-ipv4-address-list]";
 131
 132                 /*
 133                  * This subnet has in-edges with l3-ipv4 and NOT ok to delete
 134                  */
 135                 Vertex subnet = graph.traversal().V().has("aai-node-type", "subnet").has("subnet-id", "subnet-id-2").next();
 136
 137                 String exceptionMessage = testDelete(subnet);
 138                 assertEquals(expected_message, exceptionMessage);
 139
 140         }
 141
 142         @Test
 143         public void subnetDelwithInEdgesIpv6Test() throws AAIException {
 144                 String expected_message = "Object is being reference by additional objects preventing it from being deleted. Please clean up references from the following types [l3-interface-ipv6-address-list]";
 145
 146                 /*
 147                  * This subnet has in-edges with l3-ipv6 and NOT ok to delete
 148                  */
 149                 Vertex subnet = graph.traversal().V().has("aai-node-type", "subnet").has("subnet-id", "subnet-id-4").next();
 150                 String exceptionMessage = testDelete(subnet);
 151                 assertEquals(expected_message, exceptionMessage);
 152
 153         }
 154
 155         @Test
 156         public void subnetDelwithInEdgesL3network() throws AAIException {
 157                 String expected_message = "";
 158
 159                 /*
 160                  * This subnet has in-edges with l3-network and ok to delete
 161                  */
 162                 Vertex subnet = graph.traversal().V().has("aai-node-type", "subnet").has("subnet-id", "subnet-id-5").next();
 163
 164                 String exceptionMessage = testDelete(subnet);
 165                 assertEquals(expected_message, exceptionMessage);
 166
 167         }
 168
 169         public String testDelete(Vertex v) throws AAIException {
 170
 171                 // Graph g_tx = graph.newTransaction();
 172                 GraphTraversalSource traversal = graph.traversal();
 173                 when(spy.asAdmin()).thenReturn(adminSpy);
 174                 when(adminSpy.getTraversalSource()).thenReturn(traversal);
 175                 when(adminSpy.getReadOnlyTraversalSource()).thenReturn(traversal);
 176
 177                 String exceptionMessage = "";
 178                 DBSerializer serializer = new DBSerializer(version, spy, introspectorFactoryType, "AAI_TEST");
 179                 try {
 180                         serializer.delete(v, "resourceVersion", false);
 181                 } catch (AAIException exception) {
 182                         exceptionMessage = exception.getMessage();
 183
 184                 }
 185                 return exceptionMessage;
 186
 187         }
 188
 189         @Test
 190         public void createNewVertexTest() throws AAIException {
 191                 engine.startTransaction();
 192
 193                 Introspector testObj = loader.introspectorFromName("generic-vnf");
 194
 195                 Vertex testVertex = dbser.createNewVertex(testObj);
 196                 Vertex fromGraph = engine.tx().traversal().V().has("aai-node-type","generic-vnf").toList().get(0);
 197                 assertEquals(testVertex.id(), fromGraph.id());
 198                 assertEquals("AAI-TEST", fromGraph.property(AAIProperties.SOURCE_OF_TRUTH.toString()).value());
 199                 engine.rollback();
 200         }
 201
 202         @Test
 203         public void touchStandardVertexPropertiesTest() throws AAIException, InterruptedException {
 204                 engine.startTransaction();
 205                 DBSerializer dbser2 = new DBSerializer(Version.getLatest(), engine, introspectorFactoryType, "AAI-TEST-2");
 206
 207                 Graph graph = TinkerGraph.open();
 208                 Vertex vert = graph.addVertex("aai-node-type", "generic-vnf");
 209
 210                 dbser.touchStandardVertexProperties(vert, true);
 211                 String resverStart = (String)vert.property(AAIProperties.RESOURCE_VERSION.toString()).value();
 212                 String lastModTimeStart = (String)vert.property(AAIProperties.LAST_MOD_TS.toString()).value();
 213
 214                 Thread.sleep(10); //bc the resource version is set based on current time in milliseconds,
 215                                                         //if this test runs through too fast the value may not change
 216                                                         //causing the test to fail. sleeping ensures a different value
 217
 218                 dbser2.touchStandardVertexProperties(vert, false);
 219                 assertFalse(resverStart.equals((String)vert.property(AAIProperties.RESOURCE_VERSION.toString()).value()));
 220                 assertFalse(lastModTimeStart.equals((String)vert.property(AAIProperties.LAST_MOD_TS.toString()).value()));
 221                 assertEquals("AAI-TEST-2", (String)vert.property(AAIProperties.LAST_MOD_SOURCE_OF_TRUTH.toString()).value());
 222                 engine.rollback();
 223         }
 224
 225         @Test
 226         public void verifyResourceVersion_SunnyDayTest() throws AAIException {
 227                 engine.startTransaction();
 228
 229                 assertTrue(dbser.verifyResourceVersion("delete", "vnfc", "abc", "abc", "vnfcs/vnfc/vnfcId"));
 230                 engine.rollback();
 231         }
 232
 233         @Test
 234         public void verifyResourceVersion_CreateWithRVTest() throws AAIException {
 235                 engine.startTransaction();
 236
 237                 thrown.expect(AAIException.class);
 238                 thrown.expectMessage("resource-version passed for create of generic-vnfs/generic-vnf/myid");
 239                 try {
 240                         dbser.verifyResourceVersion("create", "generic-vnf", null, "old-res-ver", "generic-vnfs/generic-vnf/myid");
 241                 } finally {
 242                         engine.rollback();
 243                 }
 244         }
 245
 246         @Test
 247         public void verifyResourceVersion_MissingRVTest() throws AAIException {
 248                 engine.startTransaction();
 249
 250                 thrown.expect(AAIException.class);
 251                 thrown.expectMessage("resource-version not passed for update of generic-vnfs/generic-vnf/myid");
 252                 try {
 253                         dbser.verifyResourceVersion("update", "generic-vnf", "current-res-ver", null, "generic-vnfs/generic-vnf/myid");
 254                 } finally {
 255                         engine.rollback();
 256                 }
 257         }
 258
 259         @Test
 260         public void verifyResourceVersion_MismatchRVTest() throws AAIException {
 261                 engine.startTransaction();
 262
 263                 thrown.expect(AAIException.class);
 264                 thrown.expectMessage("resource-version MISMATCH for update of generic-vnfs/generic-vnf/myid");
 265                 try {
 266                         dbser.verifyResourceVersion("update", "generic-vnf", "current-res-ver", "old-res-ver", "generic-vnfs/generic-vnf/myid");
 267                 } finally {
 268                         engine.rollback();
 269                 }
 270         }
 271
 272         @Test
 273         public void trimClassNameTest() throws AAIException {
 274                 assertEquals("GenericVnf", dbser.trimClassName("GenericVnf"));
 275                 assertEquals("GenericVnf", dbser.trimClassName("org.onap.aai.GenericVnf"));
 276         }
 277
 278         @Test
 279         public void getURIForVertexTest() throws AAIException, URISyntaxException, UnsupportedEncodingException {
 280                 engine.startTransaction();
 281
 282                 Vertex cr = engine.tx().addVertex("aai-node-type", "cloud-region", "cloud-owner", "me", "cloud-region-id", "123");
 283                 Vertex ten = engine.tx().addVertex("aai-node-type", "tenant", "tenant-id", "453");
 284                 EdgeRules rules = EdgeRules.getInstance();
 285                 rules.addTreeEdge(engine.tx().traversal(), cr, ten);
 286
 287                 URI compare = new URI("/cloud-infrastructure/cloud-regions/cloud-region/me/123/tenants/tenant/453");
 288                 assertEquals(compare, dbser.getURIForVertex(ten));
 289
 290                 cr.property("aai-node-type").remove();
 291                 URI compareFailure = new URI("/unknown-uri");
 292                 assertEquals(compareFailure, dbser.getURIForVertex(ten));
 293                 engine.rollback();
 294         }
 295
 296         @Test
 297         public void getVertexPropertiesTest() throws AAIException, UnsupportedEncodingException {
 298                 engine.startTransaction();
 299
 300                 Vertex cr = engine.tx().addVertex("aai-node-type", "cloud-region", "cloud-owner", "me", "cloud-region-id", "123");
 301
 302                 Introspector crIntro = dbser.getVertexProperties(cr);
 303                 assertEquals("cloud-region", crIntro.getDbName());
 304                 assertEquals("me", crIntro.getValue("cloud-owner"));
 305                 assertEquals("123", crIntro.getValue("cloud-region-id"));
 306                 engine.rollback();
 307         }
 308
 309         @Test
 310         public void setCachedURIsTest() throws AAIException, UnsupportedEncodingException, URISyntaxException {
 311                 engine.startTransaction();
 312
 313                 Vertex cr = engine.tx().addVertex("aai-node-type", "cloud-region", "cloud-owner", "me", "cloud-region-id", "123");
 314                 Vertex ten = engine.tx().addVertex("aai-node-type", "tenant", "tenant-id", "453");
 315                 Vertex vs = engine.tx().addVertex("aai-node-type", "vserver", "vserver-id", "vs1",
 316                                                                                                 AAIProperties.AAI_URI.toString(),
 317                                                                                                         "/cloud-infrastructure/cloud-regions/cloud-region/me/123/tenants/tenant/453/vservers/vserver/vs1");
 318                 EdgeRules rules = EdgeRules.getInstance();
 319                 rules.addTreeEdge(engine.tx().traversal(), cr, ten);
 320                 rules.addTreeEdge(engine.tx().traversal(), ten, vs);
 321
 322                 List<Vertex> vertices = new ArrayList<Vertex>(Arrays.asList(cr, ten, vs));
 323                 Introspector crIn = dbser.getVertexProperties(cr);
 324                 Introspector tenIn = dbser.getVertexProperties(ten);
 325                 Introspector vsIn = dbser.getVertexProperties(vs);
 326                 List<Introspector> intros = new ArrayList<Introspector>(Arrays.asList(crIn, tenIn, vsIn));
 327
 328                 dbser.setCachedURIs(vertices, intros);
 329
 330                 assertEquals("/cloud-infrastructure/cloud-regions/cloud-region/me/123",
 331                                         (String)cr.property(AAIProperties.AAI_URI.toString()).value());
 332                 assertEquals("/cloud-infrastructure/cloud-regions/cloud-region/me/123/tenants/tenant/453",
 333                                 (String)ten.property(AAIProperties.AAI_URI.toString()).value());
 334                 assertEquals("/cloud-infrastructure/cloud-regions/cloud-region/me/123/tenants/tenant/453/vservers/vserver/vs1",
 335                                 (String)vs.property(AAIProperties.AAI_URI.toString()).value());
 336                 engine.rollback();
 337         }
 338
 339         @Test
 340         public void getEdgeBetweenTest() throws AAIException {
 341                 engine.startTransaction();
 342
 343                 Vertex cr = engine.tx().addVertex("aai-node-type", "cloud-region", "cloud-owner", "me", "cloud-region-id", "123");
 344                 Vertex ten = engine.tx().addVertex("aai-node-type", "tenant", "tenant-id", "453");
 345                 EdgeRules rules = EdgeRules.getInstance();
 346                 rules.addTreeEdge(engine.tx().traversal(), cr, ten);
 347
 348                 Edge e = dbser.getEdgeBetween(EdgeType.TREE, ten, cr, null);
 349                 assertEquals("has", e.label());
 350                 engine.rollback();
 351         }
 352
 353         @Test
 354         public void deleteEdgeTest() throws AAIException, UnsupportedEncodingException {
 355                 engine.startTransaction();
 356
 357                 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf");
 358                 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
 359                 EdgeRules rules = EdgeRules.getInstance();
 360                 rules.addEdge(engine.tx().traversal(), gvnf, vnfc);
 361
 362                 Introspector relData = loader.introspectorFromName("relationship-data");
 363                 relData.setValue("relationship-key", "vnfc.vnfc-name");
 364                 relData.setValue("relationship-value", "a-name");
 365                 Introspector relationship = loader.introspectorFromName("relationship");
 366                 relationship.setValue("related-to", "vnfc");
 367                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 368                 relationship.setValue("relationship-data",relData);
 369
 370                 assertTrue(dbser.deleteEdge(relationship, gvnf));
 371
 372                 assertFalse(engine.tx().traversal().V(gvnf).both("uses").hasNext());
 373                 assertFalse(engine.tx().traversal().V(vnfc).both("uses").hasNext());
 374                 engine.rollback();
 375         }
 376
 377         @Test
 378         public void createEdgeTest() throws AAIException, UnsupportedEncodingException {
 379                 engine.startTransaction();
 380
 381                 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf");
 382                 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
 383
 384                 //sunny day case
 385                 Introspector relData = loader.introspectorFromName("relationship-data");
 386                 relData.setValue("relationship-key", "vnfc.vnfc-name");
 387                 relData.setValue("relationship-value", "a-name");
 388                 Introspector relationship = loader.introspectorFromName("relationship");
 389                 relationship.setValue("related-to", "vnfc");
 390                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 391                 relationship.setValue("relationship-data",relData);
 392
 393                 assertTrue(dbser.createEdge(relationship, gvnf));
 394                 assertTrue(engine.tx().traversal().V(gvnf).both("uses").hasNext());
 395                 assertTrue(engine.tx().traversal().V(vnfc).both("uses").hasNext());
 396                 engine.rollback();
 397         }
 398
 399         @Test
 400         public void createCousinEdgeThatShouldBeTreeTest() throws AAIException, UnsupportedEncodingException, URISyntaxException {
 401                 engine.startTransaction();
 402
 403                 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf");
 404                 Vertex vf = engine.tx().addVertex("aai-node-type","vf-module","vf-module-id","vf-id");
 405
 406                 EdgeRules.getInstance().addTreeEdge(engine.tx().traversal(), gvnf, vf);
 407
 408                 Introspector relationship = loader.introspectorFromName("relationship");
 409                 relationship.setValue("related-to", "vf-module");
 410                 relationship.setValue("related-link", dbser.getURIForVertex(vf).toString());
 411                 //relationship.setValue("relationship-label", "");
 412                 Introspector relationshipList = loader.introspectorFromName("relationship-list");
 413                 relationshipList.setValue("relationship", Collections.singletonList(relationship.getUnderlyingObject()));
 414
 415                 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
 416                 Vertex gvnf2 = dbser.createNewVertex(gvnfObj);
 417                 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
 418                 gvnfObj.setValue("vnf-id", "myvnf-1");
 419
 420                 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf-1"));
 421
 422                 try {
 423                         dbser.serializeToDb(gvnfObj, gvnf2, uriQuery, null, "test");
 424                 } catch (AAIException e) {
 425                         assertEquals("AAI_6145", e.getCode());
 426                 }
 427                 finally {
 428                         engine.rollback();
 429                 }
 430         }
 431
 432         @Test
 433         public void createEdgeNodeDoesNotExistExceptionTest() throws AAIException, UnsupportedEncodingException {
 434                 engine.startTransaction();
 435
 436                 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf");
 437
 438                 //rainy day case, edge to non-existent object
 439                 Introspector relData = loader.introspectorFromName("relationship-data");
 440                 relData.setValue("relationship-key", "vnfc.vnfc-name");
 441                 relData.setValue("relationship-value", "b-name");
 442                 Introspector relationship = loader.introspectorFromName("relationship");
 443                 relationship.setValue("related-to", "vnfc");
 444                 relationship.setValue("related-link", "/network/vnfcs/vnfc/b-name");
 445                 relationship.setValue("relationship-data",relData);
 446
 447                 thrown.expect(AAIException.class);
 448                 thrown.expectMessage("Node of type vnfc. Could not find object at: /network/vnfcs/vnfc/b-name");
 449                 try {
 450                         dbser.createEdge(relationship, gvnf);
 451                 } finally {
 452                         engine.rollback();
 453                 }
 454         }
 455
 456         @Test
 457         public void serializeSingleVertexTopLevelTest() throws AAIException, UnsupportedEncodingException {
 458                 engine.startTransaction();
 459
 460                 Introspector gvnf = loader.introspectorFromName("generic-vnf");
 461                 Vertex gvnfVert = dbser.createNewVertex(gvnf);
 462
 463                 gvnf.setValue("vnf-id", "myvnf");
 464                 dbser.serializeSingleVertex(gvnfVert, gvnf, "test");
 465                 assertTrue(engine.tx().traversal().V().has("aai-node-type","generic-vnf").has("vnf-id","myvnf").hasNext());
 466                 engine.rollback();
 467         }
 468
 469         @Test
 470         public void serializeSingleVertexChildTest() throws AAIException, UnsupportedEncodingException {
 471                 engine.startTransaction();
 472
 473                 Vertex cr = engine.tx().addVertex("aai-node-type", "cloud-region", "cloud-owner", "me", "cloud-region-id", "123");
 474                 Introspector tenIn = loader.introspectorFromName("tenant");
 475                 Vertex ten = dbser.createNewVertex(tenIn);
 476                 EdgeRules rules = EdgeRules.getInstance();
 477                 rules.addTreeEdge(engine.tx().traversal(), cr, ten);
 478
 479                 tenIn.setValue("tenant-id", "453");
 480                 tenIn.setValue("tenant-name", "mytenant");
 481
 482                 dbser.serializeSingleVertex(ten, tenIn, "test");
 483
 484                 assertTrue(engine.tx().traversal().V().has("aai-node-type","tenant").has("tenant-id","453").has("tenant-name","mytenant").hasNext());
 485                 engine.rollback();
 486         }
 487
 488
 489         @Test
 490         public void getVertexPropertiesRelationshipHasLabelTest() throws AAIException, UnsupportedEncodingException {
 491                 engine.startTransaction();
 492
 493                 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","vnf-123");
 494                 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","vnfc-123");
 495                 EdgeRules rules = EdgeRules.getInstance();
 496                 rules.addEdge(engine.tx().traversal(), gvnf, vnfc);
 497
 498                 Introspector obj = loader.introspectorFromName("generic-vnf");
 499                 obj = this.dbser.dbToObject(Arrays.asList(gvnf), obj, AAIProperties.MAXIMUM_DEPTH, false, "false");
 500
 501                 assertEquals("edge label between generic-vnf and vnfs is uses", "uses", obj.getWrappedValue("relationship-list").getWrappedListValue("relationship").get(0).getValue("relationship-label"));
 502
 503                 engine.rollback();
 504         }
 505
 506         @Test
 507         public void getVertexPropertiesRelationshipOldVersionNoEdgeLabelTest() throws AAIException, UnsupportedEncodingException {
 508
 509                 Version version = Version.v11;
 510                 DBSerializer dbser = new DBSerializer(version, engine, introspectorFactoryType, "AAI-TEST");
 511                 Loader loader = LoaderFactory.createLoaderForVersion(introspectorFactoryType, version);
 512
 513                 engine.startTransaction();
 514
 515                 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","vnf-123");
 516                 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","vnfc-123");
 517                 EdgeRules rules = EdgeRules.getInstance();
 518                 rules.addEdge(engine.tx().traversal(), gvnf, vnfc);
 519
 520                 Introspector obj = loader.introspectorFromName("generic-vnf");
 521                 obj = dbser.dbToObject(Arrays.asList(gvnf), obj, AAIProperties.MAXIMUM_DEPTH, false, "false");
 522
 523                 assertEquals("Relationship does not contain edge-property", false, obj.getWrappedValue("relationship-list").getWrappedListValue("relationship").get(0).hasProperty("relationship-label"));
 524
 525                 engine.rollback();
 526         }
 527
 528         @Test
 529         public void createEdgeWithValidLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
 530
 531                 EdgeRules ers = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
 532
 533                 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules(ers);
 534
 535                 engine.startTransaction();
 536
 537                 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf");
 538                 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
 539
 540                 //sunny day case
 541                 Introspector relData = loader.introspectorFromName("relationship-data");
 542                 relData.setValue("relationship-key", "vnfc.vnfc-name");
 543                 relData.setValue("relationship-value", "a-name");
 544                 Introspector relationship = loader.introspectorFromName("relationship");
 545                 relationship.setValue("related-to", "vnfc");
 546                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 547                 relationship.setValue("relationship-data",relData);
 548                 relationship.setValue("relationship-label", "over-uses");
 549
 550                 assertTrue(localDbser.createEdge(relationship, gvnf));
 551                 assertTrue(engine.tx().traversal().V(gvnf).both("over-uses").hasNext());
 552                 assertTrue(engine.tx().traversal().V(vnfc).both("over-uses").hasNext());
 553                 engine.rollback();
 554         }
 555
 556         @Test
 557         public void createEdgeWithInvalidLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
 558
 559                 engine.startTransaction();
 560
 561                 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf");
 562                 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
 563
 564                 Introspector relData = loader.introspectorFromName("relationship-data");
 565                 relData.setValue("relationship-key", "vnfc.vnfc-name");
 566                 relData.setValue("relationship-value", "a-name");
 567                 Introspector relationship = loader.introspectorFromName("relationship");
 568                 relationship.setValue("related-to", "vnfc");
 569                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 570                 relationship.setValue("relationship-data",relData);
 571                 relationship.setValue("relationship-label", "NA");
 572
 573                 thrown.expect(AAIException.class);
 574                 thrown.expectMessage("no COUSIN edge rule between generic-vnf and vnfc with label NA");
 575                 try {
 576                         dbser.createEdge(relationship, gvnf);
 577                 } finally {
 578                         engine.rollback();
 579                 }
 580         }
 581
 582         @Test
 583         public void createEdgeWithValidLabelWhenSameEdgeExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
 584
 585                 EdgeRules ers = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
 586
 587                 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules(ers);
 588
 589                 engine.startTransaction();
 590
 591                 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf");
 592                 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
 593                 ers.addEdge(graph.traversal(), gvnf, vnfc, "re-uses");
 594
 595                 Introspector relData = loader.introspectorFromName("relationship-data");
 596                 relData.setValue("relationship-key", "vnfc.vnfc-name");
 597                 relData.setValue("relationship-value", "a-name");
 598                 Introspector relationship = loader.introspectorFromName("relationship");
 599                 relationship.setValue("related-to", "vnfc");
 600                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 601                 relationship.setValue("relationship-data",relData);
 602                 relationship.setValue("relationship-label", "re-uses");
 603
 604                 assertTrue(localDbser.createEdge(relationship, gvnf));
 605                 assertTrue(engine.tx().traversal().V(gvnf).both("re-uses").hasNext());
 606                 assertTrue(engine.tx().traversal().V(vnfc).both("re-uses").hasNext());
 607                 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V(vnfc).both().count().next());
 608                 engine.rollback();
 609         }
 610
 611         @Test
 612         public void createEdgeWithValidLabelWhenDiffEdgeExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
 613
 614                 EdgeRules ers = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
 615                 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules(ers);
 616
 617                 engine.startTransaction();
 618
 619                 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf");
 620                 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
 621                 ers.addEdge(graph.traversal(), gvnf, vnfc, "uses");
 622
 623                 Introspector relData = loader.introspectorFromName("relationship-data");
 624                 relData.setValue("relationship-key", "vnfc.vnfc-name");
 625                 relData.setValue("relationship-value", "a-name");
 626                 Introspector relationship = loader.introspectorFromName("relationship");
 627                 relationship.setValue("related-to", "vnfc");
 628                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 629                 relationship.setValue("relationship-data",relData);
 630                 relationship.setValue("relationship-label", "uses");
 631                 localDbser.createEdge(relationship, gvnf);
 632
 633                 relationship.setValue("relationship-label", "re-uses");
 634
 635                 assertTrue(localDbser.createEdge(relationship, gvnf));
 636                 assertTrue(engine.tx().traversal().V(gvnf).both("re-uses").hasNext());
 637                 assertTrue(engine.tx().traversal().V(vnfc).both("re-uses").hasNext());
 638                 assertTrue(engine.tx().traversal().V(gvnf).both("uses").hasNext());
 639                 assertTrue(engine.tx().traversal().V(vnfc).both("uses").hasNext());
 640                 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(vnfc).both().count().next());
 641                 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(gvnf).both().count().next());
 642                 engine.rollback();
 643         }
 644
 645         @Test
 646         public void createEdgeWithNoLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
 647
 648                 EdgeRules ers = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
 649                 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules(ers);
 650
 651                 engine.startTransaction();
 652
 653                 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf");
 654                 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
 655
 656                 Introspector relData = loader.introspectorFromName("relationship-data");
 657                 relData.setValue("relationship-key", "vnfc.vnfc-name");
 658                 relData.setValue("relationship-value", "a-name");
 659                 Introspector relationship = loader.introspectorFromName("relationship");
 660                 relationship.setValue("related-to", "vnfc");
 661                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 662                 relationship.setValue("relationship-data",relData);
 663                 localDbser.createEdge(relationship, gvnf);
 664
 665                 assertTrue(localDbser.createEdge(relationship, gvnf));
 666                 assertTrue(engine.tx().traversal().V(gvnf).both("uses").hasNext());
 667                 assertTrue(engine.tx().traversal().V(vnfc).both("uses").hasNext());
 668                 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V(vnfc).both().count().next());
 669                 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V(gvnf).both().count().next());
 670
 671                 engine.rollback();
 672         }
 673
 674         @Test
 675         public void deleteEdgeWithNoLabelWhenMultipleExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
 676
 677                 EdgeRules ers = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
 678
 679                 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules(ers);
 680
 681                 engine.startTransaction();
 682
 683                 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf");
 684                 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
 685                 ers.addEdge(graph.traversal(), gvnf, vnfc, "uses");
 686                 ers.addEdge(graph.traversal(), gvnf, vnfc, "re-uses");
 687                 ers.addEdge(graph.traversal(), gvnf, vnfc, "over-uses");
 688
 689                 Introspector relData = loader.introspectorFromName("relationship-data");
 690                 relData.setValue("relationship-key", "vnfc.vnfc-name");
 691                 relData.setValue("relationship-value", "a-name");
 692                 Introspector relationship = loader.introspectorFromName("relationship");
 693                 relationship.setValue("related-to", "vnfc");
 694                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 695                 relationship.setValue("relationship-data",relData);
 696
 697                 assertTrue(localDbser.deleteEdge(relationship, gvnf));
 698                 assertFalse("generic-vnf has no edge uses", engine.tx().traversal().V(gvnf).both("uses").hasNext());
 699                 assertFalse("vnfc has no edge uses", engine.tx().traversal().V(vnfc).both("uses").hasNext());
 700                 assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V(gvnf).both("re-uses").hasNext());
 701                 assertTrue("vnfc has edge re-uses", engine.tx().traversal().V(vnfc).both("re-uses").hasNext());
 702                 assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V(gvnf).both("over-uses").hasNext());
 703                 assertTrue("vnfc has edge re-uses", engine.tx().traversal().V(vnfc).both("over-uses").hasNext());
 704                 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(vnfc).both().count().next());
 705                 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(gvnf).both().count().next());
 706                 engine.rollback();
 707         }
 708
 709         @Test
 710         public void deleteEdgeWithValidLabelWhenMultipleExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
 711
 712                 EdgeRules ers = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
 713                 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules(ers);
 714
 715                 engine.startTransaction();
 716
 717                 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf");
 718                 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
 719                 ers.addEdge(graph.traversal(), gvnf, vnfc, "uses");
 720                 ers.addEdge(graph.traversal(), gvnf, vnfc, "re-uses");
 721                 ers.addEdge(graph.traversal(), gvnf, vnfc, "over-uses");
 722
 723                 Introspector relData = loader.introspectorFromName("relationship-data");
 724                 relData.setValue("relationship-key", "vnfc.vnfc-name");
 725                 relData.setValue("relationship-value", "a-name");
 726                 Introspector relationship = loader.introspectorFromName("relationship");
 727                 relationship.setValue("related-to", "vnfc");
 728                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 729                 relationship.setValue("relationship-data",relData);
 730                 relationship.setValue("relationship-label", "re-uses");
 731
 732                 assertTrue(localDbser.deleteEdge(relationship, gvnf));
 733                 assertTrue("generic-vnf has edge uses", engine.tx().traversal().V(gvnf).both("uses").hasNext());
 734                 assertTrue("vnfc has edge uses", engine.tx().traversal().V(vnfc).both("uses").hasNext());
 735                 assertFalse("generic-vnf has no edge re-uses", engine.tx().traversal().V(gvnf).both("re-uses").hasNext());
 736                 assertFalse("vnfc has no edge re-uses", engine.tx().traversal().V(vnfc).both("re-uses").hasNext());
 737                 assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V(gvnf).both("over-uses").hasNext());
 738                 assertTrue("vnfc has edge re-uses", engine.tx().traversal().V(vnfc).both("over-uses").hasNext());
 739                 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(vnfc).both().count().next());
 740                 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V(gvnf).both().count().next());
 741                 engine.rollback();
 742         }
 743
 744         @Test
 745         public void deleteEdgeWithValidInvalidLabelWhenMultipleExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
 746
 747                 EdgeRules ers = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
 748                 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules(ers);
 749
 750                 engine.startTransaction();
 751
 752                 Vertex gvnf = engine.tx().addVertex("aai-node-type","generic-vnf","vnf-id","myvnf");
 753                 Vertex vnfc = engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
 754                 ers.addEdge(graph.traversal(), gvnf, vnfc, "uses");
 755                 ers.addEdge(graph.traversal(), gvnf, vnfc, "re-uses");
 756                 ers.addEdge(graph.traversal(), gvnf, vnfc, "over-uses");
 757
 758                 Introspector relData = loader.introspectorFromName("relationship-data");
 759                 relData.setValue("relationship-key", "vnfc.vnfc-name");
 760                 relData.setValue("relationship-value", "a-name");
 761                 Introspector relationship = loader.introspectorFromName("relationship");
 762                 relationship.setValue("related-to", "vnfc");
 763                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 764                 relationship.setValue("relationship-data",relData);
 765                 relationship.setValue("relationship-label", "NA");
 766
 767                 thrown.expect(AAIException.class);
 768                 thrown.expectMessage("no COUSIN edge rule between generic-vnf and vnfc with label NA");
 769                 try {
 770                         localDbser.deleteEdge(relationship, gvnf);
 771                 } finally {
 772                         engine.rollback();
 773                 }
 774         }
 775
 776         @Test
 777         public void serializeToDbWithLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
 778
 779                 EdgeRules ers = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
 780                 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules(ers);
 781
 782                 engine.startTransaction();
 783
 784                 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
 785
 786                 Introspector relationship = loader.introspectorFromName("relationship");
 787                 relationship.setValue("related-to", "vnfc");
 788                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 789                 relationship.setValue("relationship-label", "re-uses");
 790                 Introspector relationshipList = loader.introspectorFromName("relationship-list");
 791                 relationshipList.setValue("relationship", Collections.singletonList(relationship.getUnderlyingObject()));
 792
 793                 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
 794                 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
 795                 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
 796                 gvnfObj.setValue("vnf-id", "myvnf");
 797
 798                 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
 799
 800                 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
 801
 802                 assertTrue("vertex with vnf-id myvnf exists", engine.tx().traversal().V().has("vnf-id", "myvnf").hasNext());
 803                 assertTrue("vertex with vnfc-name a-name exists", engine.tx().traversal().V().has("vnfc-name", "a-name").hasNext());
 804                 assertFalse("generic-vnf has no edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("uses").hasNext());
 805                 assertFalse("vnfc has no edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("uses").hasNext());
 806                 assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("re-uses").hasNext());
 807                 assertTrue("vnfc has edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("re-uses").hasNext());
 808                 assertFalse("generic-vnf has no edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("over-uses").hasNext());
 809                 assertFalse("vnfc has no edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("over-uses").hasNext());
 810                 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnfc-name", "a-name").both().count().next());
 811                 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnf-id", "myvnf").both().count().next());
 812                 engine.rollback();
 813         }
 814
 815         @Test
 816         public void serializeToDbWithoutLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
 817
 818                 EdgeRules ers = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
 819                 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules(ers);
 820
 821                 engine.startTransaction();
 822
 823                 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
 824
 825                 Introspector relationship = loader.introspectorFromName("relationship");
 826                 relationship.setValue("related-to", "vnfc");
 827                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 828
 829                 Introspector relationshipList = loader.introspectorFromName("relationship-list");
 830                 relationshipList.setValue("relationship", Collections.singletonList(relationship.getUnderlyingObject()));
 831
 832                 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
 833                 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
 834                 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
 835                 gvnfObj.setValue("vnf-id", "myvnf");
 836
 837                 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
 838
 839                 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
 840
 841                 assertTrue("vertex with vnf-id myvnf exists", engine.tx().traversal().V().has("vnf-id", "myvnf").hasNext());
 842                 assertTrue("vertex with vnfc-name a-name exists", engine.tx().traversal().V().has("vnfc-name", "a-name").hasNext());
 843                 assertTrue("generic-vnf has edge uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("uses").hasNext());
 844                 assertTrue("vnfc has edge uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("uses").hasNext());
 845                 assertFalse("generic-vnf has no edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("re-uses").hasNext());
 846                 assertFalse("vnfc has no edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("re-uses").hasNext());
 847                 assertFalse("generic-vnf has no edge over-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("over-uses").hasNext());
 848                 assertFalse("vnfc has no edge over-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("over-uses").hasNext());
 849                 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnfc-name", "a-name").both().count().next());
 850                 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnf-id", "myvnf").both().count().next());
 851                 engine.rollback();
 852         }
 853
 854         @Test
 855         public void serializeToDbWithInvalidLabelTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
 856
 857                 EdgeRules ers = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
 858                 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules(ers);
 859
 860                 engine.startTransaction();
 861
 862                 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
 863
 864                 Introspector relationship = loader.introspectorFromName("relationship");
 865                 relationship.setValue("related-to", "vnfc");
 866                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 867                 relationship.setValue("relationship-label", "NA");
 868                 Introspector relationshipList = loader.introspectorFromName("relationship-list");
 869                 relationshipList.setValue("relationship", Collections.singletonList(relationship.getUnderlyingObject()));
 870
 871                 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
 872                 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
 873                 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
 874                 gvnfObj.setValue("vnf-id", "myvnf");
 875
 876                 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
 877
 878                 thrown.expect(AAIException.class);
 879                 thrown.expectMessage("No EdgeRule found for passed nodeTypes: generic-vnf, vnfc with label NA.");
 880                 try {
 881                         localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
 882                 } finally {
 883                         engine.rollback();
 884                 }
 885                 engine.rollback();
 886         }
 887
 888         @Test
 889         public void serializeToDbWithLabelAndEdgeExistsTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
 890
 891                 EdgeRules ers = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
 892                 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules(ers);
 893
 894                 engine.startTransaction();
 895                 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
 896
 897                 Introspector relationship;
 898                 Introspector relationshipList;
 899                 List<Object> relList = new ArrayList<>();
 900
 901                 // create generic-vnf
 902                 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
 903                 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
 904                 gvnfObj.setValue("vnf-id", "myvnf");
 905                 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
 906
 907                 // create relationship to vnfc
 908                 relationship = loader.introspectorFromName("relationship");
 909                 relationship.setValue("related-to", "vnfc");
 910                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 911                 relList.add(relationship.getUnderlyingObject());
 912                 relationshipList = loader.introspectorFromName("relationship-list");
 913                 relationshipList.setValue("relationship", relList);
 914                 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
 915
 916                 // add gvnf to graph
 917                 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
 918
 919                 // add second relationship
 920                 relationship = loader.introspectorFromName("relationship");
 921                 relationship.setValue("related-to", "vnfc");
 922                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 923                 relationship.setValue("relationship-label", "re-uses");
 924                 relList.add(relationship.getUnderlyingObject());
 925                 relationshipList = loader.introspectorFromName("relationship-list");
 926                 relationshipList.setValue("relationship", relList);
 927                 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
 928
 929                 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
 930
 931                 assertTrue("vertex with vnf-id myvnf exists", engine.tx().traversal().V().has("vnf-id", "myvnf").hasNext());
 932                 assertTrue("vertex with vnfc-name a-name exists", engine.tx().traversal().V().has("vnfc-name", "a-name").hasNext());
 933                 assertTrue("generic-vnf has  edge uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("uses").hasNext());
 934                 assertTrue("vnfc has  edge uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("uses").hasNext());
 935                 assertTrue("generic-vnf has edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("re-uses").hasNext());
 936                 assertTrue("vnfc has edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("re-uses").hasNext());
 937                 assertFalse("generic-vnf has no edge over-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("over-uses").hasNext());
 938                 assertFalse("vnfc has no edge over-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("over-uses").hasNext());
 939                 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V().has("vnfc-name", "a-name").both().count().next());
 940                 assertEquals("Number of edges between vertexes is 2", Long.valueOf(2), engine.tx().traversal().V().has("vnf-id", "myvnf").both().count().next());
 941                 engine.rollback();
 942         }
 943
 944         @Test
 945         public void serializeToDbWithLabelDroppingRelationshipTest() throws AAIException, UnsupportedEncodingException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, URISyntaxException {
 946
 947                 EdgeRules ers = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
 948                 DBSerializer localDbser = getDBSerializerWithSpecificEdgeRules(ers);
 949
 950                 engine.startTransaction();
 951                 engine.tx().addVertex("aai-node-type","vnfc","vnfc-name","a-name");
 952
 953                 Introspector relationship;
 954                 Introspector relationshipList;
 955                 List<Object> relList = new ArrayList<>();
 956
 957                 // create generic-vnf
 958                 Introspector gvnfObj = loader.introspectorFromName("generic-vnf");
 959                 Vertex gvnf = localDbser.createNewVertex(gvnfObj);
 960                 gvnfObj.setValue("vnf-id", "myvnf");
 961                 QueryParser uriQuery = dbEngine.getQueryBuilder().createQueryFromURI(new URI("/network/generic-vnfs/generic-vnf/myvnf"));
 962
 963                 // create relationship to vnfc
 964                 relationship = loader.introspectorFromName("relationship");
 965                 relationship.setValue("related-to", "vnfc");
 966                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 967                 relList.add(relationship.getUnderlyingObject());
 968                 // add second relationship
 969                 relationship = loader.introspectorFromName("relationship");
 970                 relationship.setValue("related-to", "vnfc");
 971                 relationship.setValue("related-link", "/network/vnfcs/vnfc/a-name");
 972                 relationship.setValue("relationship-label", "re-uses");
 973                 relList.add(relationship.getUnderlyingObject());
 974                 relationshipList = loader.introspectorFromName("relationship-list");
 975                 relationshipList.setValue("relationship", relList);
 976                 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
 977
 978                 // add gvnf to graph
 979                 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
 980
 981                 // drop second relationship
 982                 relList.remove(1);
 983                 relationshipList = loader.introspectorFromName("relationship-list");
 984                 relationshipList.setValue("relationship", relList);
 985                 gvnfObj.setValue("relationship-list", relationshipList.getUnderlyingObject());
 986
 987                 localDbser.serializeToDb(gvnfObj, gvnf, uriQuery, null, "test");
 988
 989                 assertTrue("vertex with vnf-id myvnf exists", engine.tx().traversal().V().has("vnf-id", "myvnf").hasNext());
 990                 assertTrue("vertex with vnfc-name a-name exists", engine.tx().traversal().V().has("vnfc-name", "a-name").hasNext());
 991                 assertTrue("generic-vnf has  edge uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("uses").hasNext());
 992                 assertTrue("vnfc has  edge uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("uses").hasNext());
 993                 assertFalse("generic-vnf no longer has edge re-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("re-uses").hasNext());
 994                 assertFalse("vnfc no longer has edge re-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("re-uses").hasNext());
 995                 assertFalse("generic-vnf has no edge over-uses", engine.tx().traversal().V().has("vnf-id", "myvnf").both("over-uses").hasNext());
 996                 assertFalse("vnfc has no edge over-uses", engine.tx().traversal().V().has("vnfc-name", "a-name").both("over-uses").hasNext());
 997                 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnfc-name", "a-name").both().count().next());
 998                 assertEquals("Number of edges between vertexes is 1", Long.valueOf(1), engine.tx().traversal().V().has("vnf-id", "myvnf").both().count().next());
 999                 engine.rollback();
1000         }
1001
1002         private DBSerializer getDBSerializerWithSpecificEdgeRules(EdgeRules ers)
1003                         throws NoSuchFieldException, AAIException, IllegalAccessException {
1004                 // reflection to set the edge rules to the test one for DBSerializer
1005                 Field reader = DBSerializer.class.getDeclaredField("edgeRules");
1006                 reader.setAccessible(true);
1007                 DBSerializer localDbser = new DBSerializer(Version.getLatest(), engine, introspectorFactoryType, "AAI-TEST");
1008                 reader.set(localDbser, ers);
1009                 return localDbser;
1010         }
1011
1012 }