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