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

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