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