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