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