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