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