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

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