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