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