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