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