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