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