aai-core/src/test/java/org/onap/aai/query/builder/QueryBuilderTestAbstraction.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.query.builder;
  23
  24 import static org.junit.Assert.assertEquals;
  25 import static org.junit.Assert.assertFalse;
  26 import static org.junit.Assert.assertTrue;
  27
  28 import java.util.ArrayList;
  29 import java.util.Arrays;
  30 import java.util.Collections;
  31 import java.util.List;
  32
  33 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
  34 import org.apache.tinkerpop.gremlin.process.traversal.step.util.BulkSet;
  35 import org.apache.tinkerpop.gremlin.structure.Edge;
  36 import org.apache.tinkerpop.gremlin.structure.Graph;
  37 import org.apache.tinkerpop.gremlin.structure.Vertex;
  38 import org.junit.*;
  39 import org.onap.aai.AAISetup;
  40 import org.onap.aai.db.props.AAIProperties;
  41 import org.onap.aai.exceptions.AAIException;
  42 import org.onap.aai.introspection.Loader;
  43 import org.onap.aai.introspection.LoaderFactory;
  44 import org.onap.aai.introspection.ModelType;
  45 import org.onap.aai.serialization.db.EdgeRules;
  46 import org.onap.aai.serialization.db.EdgeType;
  47
  48 import com.thinkaurelius.titan.core.TitanFactory;
  49 import org.onap.aai.serialization.db.exceptions.NoEdgeRuleFoundException;
  50
  51 public abstract class QueryBuilderTestAbstraction extends AAISetup {
  52
  53         protected static Loader loader;
  54         protected static Graph graph;
  55         protected GraphTraversalSource g;
  56
  57         protected EdgeRules testEdgeRules = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_TraversalQueryTest.json");
  58
  59
  60         @BeforeClass
  61         public static void setup() throws Exception {
  62                 loader = LoaderFactory.createLoaderForVersion(ModelType.MOXY, AAIProperties.LATEST);
  63                 graph = TitanFactory.build().set("storage.backend", "inmemory").open();
  64         }
  65
  66         @Before
  67         public void configure() throws Exception {
  68                 g = graph.traversal();
  69         }
  70
  71         @After
  72         public void deConfigure() throws Exception {
  73                 g.tx().rollback();
  74         }
  75
  76         @AfterClass
  77         public static void teardown() throws Exception {
  78                 graph.close();
  79         }
  80
  81         @Test
  82         public void createEdgeGVnfToVnfcTraversal() throws AAIException {
  83
  84                 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","myvnf").next();
  85                 Vertex vnfc = g.addV("aai-node-type","vnfc","vnfc-name","a-name").next();
  86                 testEdgeRules.addEdge(g, gvnf, vnfc, "uses");
  87
  88                 QueryBuilder<Vertex> tQ = getNewVertexTraversal(gvnf);
  89                 tQ.createEdgeTraversal(EdgeType.COUSIN, "generic-vnf", "vnfc");
  90
  91                 assertEquals(vnfc, tQ.next());
  92
  93
  94         }
  95
  96         @Test
  97         public void createEdgeLinterfaceToLogicalLinkTraversal() throws AAIException {
  98
  99                 Vertex lInterface = g.addV("aai-node-type","l-interface","interface-name","l-interface-a").next();
 100                 Vertex logicalLink = g.addV("aai-node-type","logical-link","link-name","logical-link-a").next();
 101                 testEdgeRules.addEdge(g, lInterface, logicalLink, "sourceLInterface");
 102
 103                 QueryBuilder<Vertex> tQ = getNewVertexTraversal(lInterface);
 104                 tQ.createEdgeTraversal(EdgeType.COUSIN, "l-interface", "logical-link");
 105
 106                 Vertex next = tQ.next();
 107
 108                 assertEquals(logicalLink, next);
 109
 110
 111         }
 112
 113         @Test
 114         public void createEdgeLinterfaceToLogicalLinkIntrospectorTraversal() throws AAIException {
 115
 116                 Vertex lInterface = g.addV("aai-node-type","l-interface","interface-name","l-interface-a").next();
 117                 Vertex logicalLink = g.addV("aai-node-type","logical-link","link-name","logical-link-a").next();
 118                 testEdgeRules.addEdge(g, lInterface, logicalLink, "sourceLInterface");
 119
 120                 QueryBuilder<Vertex> tQ = getNewVertexTraversal(lInterface);
 121                 tQ.createEdgeTraversal(EdgeType.COUSIN, loader.introspectorFromName("l-interface"), loader.introspectorFromName("logical-link"));
 122
 123                 Vertex next = tQ.next();
 124
 125                 assertEquals(logicalLink, next);
 126
 127
 128         }
 129
 130         @Test
 131         public void createEdgeLinterfaceToLogicalLinkVertexToIntrospectorTraversal() throws AAIException {
 132
 133                 Vertex lInterface = g.addV("aai-node-type","l-interface","interface-name","l-interface-a").next();
 134                 Vertex logicalLink = g.addV("aai-node-type","logical-link","link-name","logical-link-a").next();
 135                 testEdgeRules.addEdge(g, lInterface, logicalLink, "sourceLInterface");
 136
 137                 QueryBuilder<Vertex> tQ = getNewVertexTraversal(lInterface);
 138                 tQ.createEdgeTraversal(EdgeType.COUSIN, lInterface, loader.introspectorFromName("logical-link"));
 139
 140                 Vertex next = tQ.next();
 141
 142                 assertEquals(logicalLink, next);
 143
 144
 145         }
 146
 147         @Test
 148         public void edgeToVertexTraversalTest() throws AAIException {
 149
 150                 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
 151                 Vertex vnfc1 = g.addV("aai-node-type","vnfc","vnfc-name","a-name").next();
 152
 153                 testEdgeRules.addEdge(g, gvnf, vnfc1);
 154
 155                 QueryBuilder<Vertex> tQ = getNewVertexTraversal(gvnf);
 156                 tQ.createEdgeTraversal(EdgeType.COUSIN, "generic-vnf", "vnfc");
 157
 158                 List<Vertex> list = tQ.toList();
 159
 160                 assertEquals("Has 1 vertexes ", 1, list.size());
 161                 assertTrue("Has vertex on the default edge ", list.contains(vnfc1));
 162
 163
 164         }
 165
 166         @Test
 167         public void edgeToVertexTraversalSingleOutRuleTest() throws AAIException {
 168
 169                 Vertex vce = g.addV("aai-node-type","vce","vnf-id","vce").next();
 170                 Vertex vnfc1 = g.addV("aai-node-type","vnfc","vnfc-name","a-name").next();
 171
 172                 testEdgeRules.addEdge(g, vce, vnfc1);
 173
 174                 QueryBuilder<Vertex> tQ1 = getNewVertexTraversal(vce);
 175                 tQ1.createEdgeTraversal(EdgeType.COUSIN, "vce", "vnfc");
 176
 177                 QueryBuilder<Vertex> tQ2 = getNewVertexTraversal(vnfc1);
 178                 tQ2.createEdgeTraversal(EdgeType.COUSIN, "vnfc", "vce");
 179
 180                 List<Vertex> list1 = tQ1.toList();
 181                 List<Vertex> list2 = tQ2.toList();
 182
 183                 assertEquals("1 - Has 1 vertexes ", 1, list1.size());
 184                 assertTrue("1 - traversal results in vnfc ", list1.contains(vnfc1));
 185                 assertEquals("2 - Has 1 vertexes ", 1, list2.size());
 186                 assertTrue("2 - traversal results in vce ", list2.contains(vce));
 187
 188
 189         }
 190
 191         @Test
 192         public void edgeToVertexTraversalSingleInRuleTest() throws AAIException {
 193
 194                 Vertex vce = g.addV("aai-node-type","vce","vnf-id","vce").next();
 195                 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
 196
 197                 testEdgeRules.addEdge(g, vce, pserver);
 198
 199                 QueryBuilder<Vertex> tQ1 = getNewVertexTraversal(vce);
 200                 tQ1.createEdgeTraversal(EdgeType.COUSIN, "vce", "pserver");
 201
 202                 List<Vertex> list = tQ1.toList();
 203
 204                 assertEquals("1 - Has 1 vertexes ", 1, list.size());
 205                 assertTrue("1 - traversal results in vnfc ", list.contains(pserver));
 206
 207
 208         }
 209
 210         @Test
 211         public void edgeToVertexMultiRuleTraversalTest() throws AAIException {
 212
 213                 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
 214                 Vertex vnfc1 = g.addV("aai-node-type","vnfc","vnfc-name","a-name").next();
 215                 Vertex vnfc2 = g.addV("aai-node-type","vnfc","vnfc-name","b-name").next();
 216
 217                 testEdgeRules.addEdge(g, gvnf, vnfc1);
 218                 testEdgeRules.addEdge(g, gvnf, vnfc2, "re-uses");
 219
 220                 QueryBuilder<Vertex> tQ = getNewVertexTraversal(gvnf);
 221                 tQ.createEdgeTraversal(EdgeType.COUSIN, "generic-vnf", "vnfc");
 222
 223                 List<Vertex> list = tQ.toList();
 224
 225                 assertEquals("Has 2 vertexes ", 2, list.size());
 226                 assertTrue("Has vertex on the default edge ", list.contains(vnfc1));
 227                 assertTrue("Has vertex on the re-uses edge ", list.contains(vnfc2));
 228
 229
 230         }
 231
 232         @Test
 233         public void edgeToVertexMultiLabelTest() throws AAIException {
 234
 235                 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
 236                 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
 237                 Vertex vnfc1 = g.addV("aai-node-type","vnfc","vnfc-name","a-name").next();
 238
 239                 testEdgeRules.addEdge(g, gvnf, vnfc1);
 240                 testEdgeRules.addEdge(g, pserver, vnfc1);
 241
 242                 QueryBuilder<Vertex> tQ = getNewVertexTraversal(vnfc1);
 243                 tQ.createEdgeTraversal(EdgeType.COUSIN, "vnfc", "generic-vnf");
 244
 245                 List<Vertex> list = tQ.toList();
 246
 247                 assertEquals("Has 1 vertexes ", 1, list.size());
 248                 assertTrue("Only returns the generic vnf vertex", list.contains(gvnf));
 249
 250
 251         }
 252
 253         @Test
 254         public void limitTraversalTest() throws AAIException {
 255
 256                 g.addV("aai-node-type","vnfc","vnfc-name","a-name").next();
 257                 g.addV("aai-node-type","vnfc","vnfc-name","b-name").next();
 258
 259                 QueryBuilder<Vertex> tQ = new GremlinTraversal<>(loader, g, testEdgeRules);
 260                 tQ.getVerticesByProperty("aai-node-type","vnfc").limit(1);
 261
 262                 List<Vertex> list = tQ.toList();
 263
 264                 assertEquals("Has 1 vertexes ", 1, list.size());
 265
 266
 267         }
 268
 269         @Test
 270         public void getVertexesByPropertiesTraversalTest() throws AAIException {
 271
 272                 g.addV("aai-node-type","vnfc","vnfc-name","a-name").next();
 273                 g.addV("aai-node-type","vnfc","vnfc-name","b-name").next();
 274
 275                 QueryBuilder<Vertex> tQ = new GremlinTraversal<>(loader, g, testEdgeRules);
 276                 tQ.getVerticesByProperty("vnfc-name", Arrays.asList("a-name", "b-name"));
 277
 278                 List<Vertex> list = tQ.toList();
 279
 280                 assertEquals("Has 2 vertexes ", 2, list.size());
 281
 282
 283         }
 284
 285         @Test
 286         public void getVertexesByIndexedPropertyTraversalTest() throws AAIException {
 287
 288                 g.addV("aai-node-type","vnfc","vnfc-name","a-name").next();
 289                 g.addV("aai-node-type","vnfc","vnfc-name","b-name").next();
 290
 291                 QueryBuilder<Vertex> tQ = new GremlinTraversal<>(loader, g, testEdgeRules);
 292                 tQ.getVerticesByIndexedProperty("aai-node-type","vnfc");
 293
 294                 List<Vertex> list = tQ.toList();
 295
 296                 assertEquals("Has 2 vertexes ", 2, list.size());
 297
 298
 299         }
 300
 301         @Test
 302         public void dedupTraversalTest() throws AAIException {
 303
 304                 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
 305                 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
 306
 307                 testEdgeRules.addEdge(g, gvnf, pserver);
 308                 testEdgeRules.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
 309
 310                 QueryBuilder<Vertex> tQ = getNewVertexTraversal(gvnf);
 311                 tQ.createEdgeTraversal(EdgeType.COUSIN, "generic-vnf", "pserver").dedup();
 312
 313                 List<Vertex> list = tQ.toList();
 314
 315                 assertEquals("Has 2 vertexes ", 1, list.size());
 316                 assertTrue("result has pserver ", list.contains(pserver));
 317
 318
 319         }
 320
 321         @Test
 322         public void storeCapTraversalTest() throws AAIException {
 323
 324                 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
 325                 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
 326
 327                 testEdgeRules.addEdge(g, gvnf, pserver);
 328                 testEdgeRules.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
 329
 330                 GremlinTraversal<BulkSet<Vertex>> tQ = new GremlinTraversal<>(loader, g, gvnf, testEdgeRules);
 331                 tQ.createEdgeTraversal(EdgeType.COUSIN, "generic-vnf", "pserver").store("x").cap("x");
 332
 333                 List<BulkSet<Vertex>> list = tQ.toList();
 334
 335                 assertEquals("Has 2 vertexes ", 1, list.size());
 336                 assertEquals("result has pserver ",pserver, list.get(0).iterator().next());
 337
 338
 339         }
 340
 341         @Test
 342         public void storeCapUnfoldTraversalTest() throws AAIException {
 343
 344                 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
 345                 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
 346
 347                 testEdgeRules.addEdge(g, gvnf, pserver);
 348                 testEdgeRules.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
 349
 350                 QueryBuilder<Vertex> tQ = getNewVertexTraversal(gvnf);
 351                 tQ.createEdgeTraversal(EdgeType.COUSIN, "generic-vnf", "pserver").store("x").cap("x").unfold();
 352
 353                 List<Vertex> list = tQ.toList();
 354
 355                 assertEquals("Has 2 vertexes ", 2, list.size());
 356                 assertTrue("result has pserver ", list.contains(pserver));
 357
 358
 359         }
 360
 361         @Test
 362         public void nextAndHasNextTraversalTest() throws AAIException {
 363
 364                 Vertex v1 = g.addV("aai-node-type","vnfc","vnfc-name","a-name").next();
 365                 Vertex v2 = g.addV("aai-node-type","vnfc","vnfc-name","b-name").next();
 366
 367                 QueryBuilder<Vertex> tQ = new GremlinTraversal<>(loader, g, testEdgeRules);
 368                 tQ.getVerticesByProperty("aai-node-type","vnfc");
 369
 370                 List<Vertex> list = new ArrayList<>();
 371
 372                 assertTrue("Has next 1 ",tQ.hasNext());
 373                 list.add(tQ.next());
 374                 assertTrue("Has next 2 ",tQ.hasNext());
 375                 list.add(tQ.next());
 376                 assertFalse("Has next 3 ",tQ.hasNext());
 377                 assertTrue("Has all the vertexes", list.contains(v1) && list.remove(v2));
 378
 379         }
 380
 381         @Test
 382         public void edgeToVertexMultiRuleOutTraversalTest() throws AAIException {
 383
 384                 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
 385                 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
 386
 387                 testEdgeRules.addEdge(g, gvnf, pserver);
 388                 testEdgeRules.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
 389
 390                 QueryBuilder<Vertex> tQ = getNewVertexTraversal(gvnf);
 391                 tQ.createEdgeTraversal(EdgeType.COUSIN, "generic-vnf", "pserver");
 392
 393                 List<Vertex> list = tQ.toList();
 394
 395                 assertEquals("Has 2 vertexes ", 2, list.size());
 396                 assertTrue("result has pserver ", list.contains(pserver));
 397
 398
 399         }
 400
 401         @Test
 402         public void edgeToVertexMultiRuleInTraversalTest() throws AAIException {
 403
 404                 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
 405                 Vertex complex = g.addV("aai-node-type","complex","physical-location-id","a-name").next();
 406
 407                 testEdgeRules.addEdge(g, gvnf, complex);
 408                 testEdgeRules.addEdge(g, gvnf, complex, "complex-generic-vnf-B");
 409
 410                 QueryBuilder<Vertex> tQ = getNewVertexTraversal(gvnf);
 411                 tQ.createEdgeTraversal(EdgeType.COUSIN, "generic-vnf", "complex");
 412
 413                 List<Vertex> list = tQ.toList();
 414
 415                 assertEquals("Has 2 vertexes ", 2, list.size());
 416                 assertTrue("result has pserver ", list.contains(complex));
 417
 418
 419         }
 420
 421         @Test
 422         public void edgeTraversalSingleInRuleTest() throws AAIException {
 423
 424                 Vertex vce = g.addV("aai-node-type","vce","vnf-id","vce").next();
 425                 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
 426
 427                 Edge e = testEdgeRules.addEdge(g, vce, pserver);
 428
 429                 QueryBuilder<Edge> tQ1 = getNewEdgeTraversal(vce);
 430                 tQ1.getEdgesBetween(EdgeType.COUSIN, "vce", "pserver");
 431
 432                 List<Edge> list = tQ1.toList();
 433
 434                 assertEquals("1 - Has 1 edge ", 1, list.size());
 435                 assertTrue("1 - traversal results in edge ", list.contains(e));
 436
 437
 438         }
 439
 440         @Test
 441         public void edgeTraversalSingleOutRuleTest() throws AAIException {
 442
 443                 Vertex vce = g.addV("aai-node-type","vce","vnf-id","vce").next();
 444                 Vertex vnfc1 = g.addV("aai-node-type","vnfc","vnfc-name","a-name").next();
 445
 446                 Edge e = testEdgeRules.addEdge(g, vce, vnfc1);
 447
 448                 QueryBuilder<Edge> tQ1 = getNewEdgeTraversal(vce);
 449                 tQ1.getEdgesBetween(EdgeType.COUSIN, "vce", "vnfc");
 450
 451                 List<Edge> list1 = tQ1.toList();
 452
 453                 assertEquals("1 - Has 1 edge ", 1, list1.size());
 454                 assertTrue("1 - traversal results in edge ", list1.contains(e));
 455
 456
 457         }
 458
 459         @Test
 460         public void edgeTraversalMultiRuleOutTraversalTest() throws AAIException {
 461
 462                 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
 463                 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
 464
 465                 Edge e1 = testEdgeRules.addEdge(g, gvnf, pserver);
 466                 Edge e2 = testEdgeRules.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
 467
 468                 QueryBuilder<Edge> tQ = getNewEdgeTraversal(gvnf);
 469                 tQ.getEdgesBetween(EdgeType.COUSIN, "generic-vnf", "pserver");
 470
 471                 List<Edge> list = tQ.toList();
 472
 473                 assertEquals("Has 2 edges ", 2, list.size());
 474                 assertTrue("result has default edge ", list.contains(e1));
 475                 assertTrue("result has other edge ", list.contains(e2));
 476
 477
 478         }
 479
 480         @Test
 481         public void edgeTraversalMultiRuleInTraversalTest() throws AAIException {
 482
 483                 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
 484                 Vertex complex = g.addV("aai-node-type","complex","physical-location-id","a-name").next();
 485
 486                 Edge e1 = testEdgeRules.addEdge(g, gvnf, complex);
 487                 Edge e2 = testEdgeRules.addEdge(g, gvnf, complex, "complex-generic-vnf-B");
 488
 489                 QueryBuilder<Edge> tQ = getNewEdgeTraversal(gvnf);
 490                 tQ.getEdgesBetween(EdgeType.COUSIN, "generic-vnf", "complex");
 491
 492                 List<Edge> list = tQ.toList();
 493
 494                 assertEquals("Has 2 edges ", 2, list.size());
 495                 assertTrue("result has default edge ", list.contains(e1));
 496                 assertTrue("result has other edge ", list.contains(e2));
 497
 498
 499         }
 500
 501         @Test
 502         public void edgeTraversalMultiRuleTraversalTest() throws AAIException {
 503
 504                 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
 505                 Vertex vnfc1 = g.addV("aai-node-type","vnfc","vnfc-name","a-name").next();
 506                 Vertex vnfc2 = g.addV("aai-node-type","vnfc","vnfc-name","b-name").next();
 507
 508                 Edge e1 = testEdgeRules.addEdge(g, gvnf, vnfc1);
 509                 Edge e2 = testEdgeRules.addEdge(g, gvnf, vnfc2, "re-uses");
 510
 511                 QueryBuilder<Edge> tQ = getNewEdgeTraversal(gvnf);
 512                 tQ.getEdgesBetween(EdgeType.COUSIN, "generic-vnf", "vnfc");
 513
 514                 List<Edge> list = tQ.toList();
 515
 516                 assertEquals("Has 2 edges ", 2, list.size());
 517                 assertTrue("result has default edge ", list.contains(e1));
 518                 assertTrue("result has other edge ", list.contains(e2));
 519
 520
 521         }
 522
 523         @Test (expected = NoEdgeRuleFoundException.class)
 524         public void getEdgesBetweenWithLabelsEmptyListTest() throws AAIException {
 525
 526                 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
 527                 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
 528
 529                 Edge e1 = testEdgeRules.addEdge(g, gvnf, pserver);
 530                 Edge e2 = testEdgeRules.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
 531
 532                 QueryBuilder<Edge> tQ = getNewEdgeTraversal(gvnf);
 533                 tQ.getEdgesBetweenWithLabels(EdgeType.COUSIN, "generic-vnf", "pserver", Collections.emptyList());
 534
 535         }
 536
 537         @Test
 538         public void getEdgesBetweenWithLabelsSingleItemTest() throws AAIException {
 539
 540                 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
 541                 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
 542
 543                 Edge e1 = testEdgeRules.addEdge(g, gvnf, pserver);
 544                 Edge e2 = testEdgeRules.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
 545
 546                 QueryBuilder<Edge> tQ = getNewEdgeTraversal(gvnf);
 547                 tQ.getEdgesBetweenWithLabels(EdgeType.COUSIN, "generic-vnf", "pserver", Collections.singletonList("generic-vnf-pserver-B"));
 548
 549                 List<Edge> list = tQ.toList();
 550
 551                 assertEquals("Has 1 edges ", 1, list.size());
 552                 assertFalse("result does not have default edge ", list.contains(e1));
 553                 assertTrue("result has other edge ", list.contains(e2));
 554
 555         }
 556
 557         @Test
 558         public void getEdgesBetweenWithLabelsMultipleItemTest() throws AAIException {
 559
 560                 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
 561                 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
 562
 563                 Edge e1 = testEdgeRules.addEdge(g, gvnf, pserver);
 564                 Edge e2 = testEdgeRules.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
 565
 566                 QueryBuilder<Edge> tQ = getNewEdgeTraversal(gvnf);
 567                 tQ.getEdgesBetweenWithLabels(EdgeType.COUSIN, "generic-vnf", "pserver", Arrays.asList("generic-vnf-pserver-B", "generic-vnf-pserver-A"));
 568
 569                 List<Edge> list = tQ.toList();
 570
 571                 assertEquals("Has 2 edges ", 2, list.size());
 572                 assertTrue("result has generic-vnf-pserver-A edge ", list.contains(e1));
 573                 assertTrue("result has generic-vnf-pserver-B edge ", list.contains(e2));
 574
 575         }
 576
 577         @Test (expected = NoEdgeRuleFoundException.class)
 578         public void createEdgeTraversalWithLabelsEmptyListTest() throws AAIException {
 579
 580                 Vertex gvnf = getVertex();
 581
 582                 QueryBuilder<Edge> tQ = getNewEdgeTraversal(gvnf);
 583                 tQ.getEdgesBetweenWithLabels(EdgeType.COUSIN, "generic-vnf", "pserver", Collections.emptyList());
 584
 585                 List<Edge> list = tQ.toList();
 586
 587
 588         }
 589
 590         private Vertex getVertex() throws AAIException {
 591                 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
 592                 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
 593
 594                 Edge e1 = testEdgeRules.addEdge(g, gvnf, pserver);
 595                 Edge e2 = testEdgeRules.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
 596                 return gvnf;
 597         }
 598
 599         @Test
 600         public void createEdgeTraversalWithLabelsSingleItemTest() throws AAIException {
 601
 602                 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
 603                 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
 604
 605                 Edge e1 = testEdgeRules.addEdge(g, gvnf, pserver);
 606                 Edge e2 = testEdgeRules.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
 607
 608                 QueryBuilder<Edge> tQ = getNewEdgeTraversal(gvnf);
 609                 tQ.getEdgesBetweenWithLabels(EdgeType.COUSIN, "generic-vnf", "pserver", Collections.singletonList("generic-vnf-pserver-B"));
 610
 611                 List<Edge> list = tQ.toList();
 612
 613                 assertEquals("Has 1 edges ", 1, list.size());
 614                 assertFalse("result does not have default edge ", list.contains(e1));
 615                 assertTrue("result has other edge ", list.contains(e2));
 616
 617         }
 618
 619         @Test
 620         public void createEdgeTraversalWithLabelsMultipleItemTest() throws AAIException {
 621
 622                 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
 623                 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
 624
 625                 Edge e1 = testEdgeRules.addEdge(g, gvnf, pserver);
 626                 Edge e2 = testEdgeRules.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
 627
 628                 QueryBuilder<Edge> tQ = getNewEdgeTraversal(gvnf);
 629                 tQ.getEdgesBetweenWithLabels(EdgeType.COUSIN, "generic-vnf", "pserver", Arrays.asList("generic-vnf-pserver-B", "generic-vnf-pserver-A"));
 630
 631                 List<Edge> list = tQ.toList();
 632
 633                 assertEquals("Has 2 edges ", 2, list.size());
 634                 assertTrue("result has generic-vnf-pserver-A edge ", list.contains(e1));
 635                 assertTrue("result has generic-vnf-pserver-B edge ", list.contains(e2));
 636
 637         }
 638
 639         protected abstract QueryBuilder<Edge> getNewEdgeTraversal(Vertex v);
 640
 641         protected abstract QueryBuilder<Edge> getNewEdgeTraversal();
 642
 643         protected abstract QueryBuilder<Vertex> getNewVertexTraversal(Vertex v);
 644
 645         protected abstract QueryBuilder<Vertex> getNewVertexTraversal();
 646
 647
 648 }