2 * ============LICENSE_START=======================================================
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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=========================================================
20 package org.onap.aai.query.builder;
22 import org.apache.tinkerpop.gremlin.process.traversal.Path;
23 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
24 import org.apache.tinkerpop.gremlin.process.traversal.step.util.BulkSet;
25 import org.apache.tinkerpop.gremlin.process.traversal.step.util.Tree;
26 import org.apache.tinkerpop.gremlin.structure.Edge;
27 import org.apache.tinkerpop.gremlin.structure.Graph;
28 import org.apache.tinkerpop.gremlin.structure.Vertex;
29 import org.janusgraph.core.JanusGraphFactory;
31 import org.junit.runner.RunWith;
32 import org.onap.aai.config.ConfigConfiguration;
33 import org.onap.aai.config.IntrospectionConfig;
34 import org.onap.aai.config.SpringContextAware;
35 import org.onap.aai.exceptions.AAIException;
36 import org.onap.aai.introspection.Loader;
37 import org.onap.aai.introspection.LoaderFactory;
38 import org.onap.aai.introspection.ModelType;
39 import org.onap.aai.nodes.NodeIngestor;
40 import org.onap.aai.serialization.db.EdgeSerializer;
41 import org.onap.aai.edges.EdgeIngestor;
42 import org.onap.aai.edges.enums.EdgeType;
43 import org.onap.aai.serialization.db.exceptions.NoEdgeRuleFoundException;
44 import org.onap.aai.serialization.queryformats.QueryFormatTestHelper;
45 import org.onap.aai.setup.SchemaLocationsBean;
46 import org.onap.aai.setup.SchemaVersions;
47 import org.onap.aai.util.AAIConstants;
48 import org.springframework.beans.factory.annotation.Autowired;
49 import org.springframework.test.annotation.DirtiesContext;
50 import org.springframework.test.context.ContextConfiguration;
51 import org.springframework.test.context.TestPropertySource;
52 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
53 import org.onap.aai.db.props.AAIProperties;
56 import java.util.ArrayList;
57 import java.util.Arrays;
58 import java.util.Collections;
59 import java.util.List;
61 import static org.hamcrest.CoreMatchers.is;
62 import static org.hamcrest.collection.IsIterableContainingInOrder.contains;
63 import static org.junit.Assert.*;
65 @RunWith(SpringJUnit4ClassRunner.class)
66 @ContextConfiguration(classes = {
67 ConfigConfiguration.class,
68 QueryTestsConfigTranslator.class,
72 SpringContextAware.class,
73 IntrospectionConfig.class
75 @DirtiesContext(classMode = DirtiesContext.ClassMode.AFTER_CLASS)
76 @TestPropertySource(properties = {
77 "schema.translator.list = config",
78 "schema.nodes.location=src/test/resources/onap/oxm",
79 "schema.edges.location=src/test/resources/onap/dbedgerules"
81 public abstract class QueryBuilderTestAbstraction {
83 protected Loader loader;
84 protected static Graph graph;
85 protected GraphTraversalSource g;
88 protected EdgeSerializer testEdgeSer;
91 protected SchemaVersions schemaVersions;
94 protected LoaderFactory loaderFactory;
98 public static void setup() throws Exception {
99 System.setProperty("AJSC_HOME", ".");
100 System.setProperty("BUNDLECONFIG_DIR", "src/test/resources/bundleconfig-local");
101 QueryFormatTestHelper.setFinalStatic(AAIConstants.class.getField("AAI_HOME_ETC_OXM"), "src/test/resources/bundleconfig-local/etc/oxm/");
102 graph = JanusGraphFactory.build().set("storage.backend", "inmemory").open();
106 public void configure() throws Exception {
107 loader = loaderFactory.createLoaderForVersion(ModelType.MOXY, schemaVersions.getDefaultVersion());
110 g = graph.traversal();
114 public void deConfigure() throws Exception {
119 public static void teardown() throws Exception {
124 public void createEdgeGVnfToVnfcTraversal() throws AAIException {
126 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","myvnf").next();
127 Vertex vnfc = g.addV("aai-node-type","vnfc","vnfc-name","a-name").next();
128 testEdgeSer.addEdge(g, gvnf, vnfc, "uses");
130 QueryBuilder<Vertex> tQ = getNewVertexTraversalWithTestEdgeRules(gvnf);
131 tQ.createEdgeTraversal(EdgeType.COUSIN, "generic-vnf", "vnfc");
133 assertEquals(vnfc, tQ.next());
139 public void createEdgeLinterfaceToLogicalLinkTraversal() throws AAIException {
141 Vertex lInterface = g.addV("aai-node-type","l-interface","interface-name","l-interface-a").next();
142 Vertex logicalLink = g.addV("aai-node-type","logical-link","link-name","logical-link-a").next();
143 testEdgeSer.addEdge(g, lInterface, logicalLink, "sourceLInterface");
145 QueryBuilder<Vertex> tQ = getNewVertexTraversalWithTestEdgeRules(lInterface);
146 tQ.createEdgeTraversal(EdgeType.COUSIN, "l-interface", "logical-link");
148 Vertex next = tQ.next();
150 assertEquals(logicalLink, next);
155 @SuppressWarnings("rawtypes")
157 public void createEdgeLinterfaceToLogicalLinkTraversal_tree() throws AAIException {
158 Vertex lInterface = g.addV("aai-node-type","l-interface","interface-name","l-interface-a").next();
159 Vertex logicalLink = g.addV("aai-node-type","logical-link","link-name","logical-link-a").next();
160 testEdgeSer.addEdge(g, lInterface, logicalLink, "sourceLInterface");
162 QueryBuilder<Tree> tQ = getNewTreeTraversalWithTestEdgeRules(lInterface).createEdgeTraversal(EdgeType.COUSIN,
163 loader.introspectorFromName("l-interface" ), loader.introspectorFromName("logical-link")).tree();
165 Vertex lInterfaceExpected = graph.traversal().V().has("aai-node-type","l-interface").has("interface-name","l-interface-a").next();
166 Vertex logicalLinkExpected = graph.traversal().V().has("aai-node-type", "logical-link").has("link-name","logical-link-a").next();
167 Tree tree = tQ.next();
168 assertTrue(tree.containsKey(lInterfaceExpected));
169 assertTrue(((Tree) tree.get(lInterfaceExpected)).containsKey(logicalLinkExpected));
172 @SuppressWarnings("rawtypes")
174 public void createEdgeLinterfaceToLogicalLinkTraversal_Path() throws AAIException {
175 Vertex pInterface = g.addV("aai-node-type","p-interface","interface-name","p-interface-a").next();
176 Vertex lInterface = g.addV("aai-node-type","l-interface","interface-name","l-interface-a").next();
177 Vertex logicalLink = g.addV("aai-node-type","logical-link","link-name","logical-link-a").next();
178 testEdgeSer.addEdge(g, lInterface, logicalLink);
179 testEdgeSer.addTreeEdge(g, pInterface, lInterface);
181 QueryBuilder<Path> tQ = getNewPathTraversalWithTestEdgeRules(pInterface).createEdgeTraversal(EdgeType.TREE,
182 loader.introspectorFromName("p-interface" ), loader.introspectorFromName("l-interface")).createEdgeTraversal(EdgeType.COUSIN,
183 loader.introspectorFromName("l-interface" ), loader.introspectorFromName("logical-link")).path();
185 Path path = tQ.next();
186 assertThat(path.objects(), contains(pInterface, lInterface, logicalLink));
189 @SuppressWarnings("rawtypes")
191 public void parentVertexTest() throws AAIException {
192 Vertex pInterface = g.addV("aai-node-type","p-interface","interface-name","p-interface-a").next();
193 Vertex lInterface = g.addV("aai-node-type","l-interface","interface-name","l-interface-a").next();
195 testEdgeSer.addTreeEdge(g, pInterface, lInterface);
197 QueryBuilder<Vertex> tQ = getNewEdgeTraversalWithTestEdgeRules(lInterface).getParentVertex();
199 Vertex parent = tQ.next();
200 assertThat(parent, is(pInterface));
205 public void createEdgeLinterfaceToLogicalLinkIntrospectorTraversal() throws AAIException {
207 Vertex lInterface = g.addV("aai-node-type","l-interface","interface-name","l-interface-a").next();
208 Vertex logicalLink = g.addV("aai-node-type","logical-link","link-name","logical-link-a").next();
209 testEdgeSer.addEdge(g, lInterface, logicalLink, "sourceLInterface");
211 QueryBuilder<Vertex> tQ = getNewVertexTraversalWithTestEdgeRules(lInterface);
212 tQ.createEdgeTraversal(EdgeType.COUSIN, loader.introspectorFromName("l-interface"), loader.introspectorFromName("logical-link"));
214 Vertex next = tQ.next();
216 assertEquals(logicalLink, next);
222 public void createEdgeLinterfaceToLogicalLinkVertexToIntrospectorTraversal() throws AAIException {
224 Vertex lInterface = g.addV("aai-node-type","l-interface","interface-name","l-interface-a").next();
225 Vertex logicalLink = g.addV("aai-node-type","logical-link","link-name","logical-link-a").next();
226 testEdgeSer.addEdge(g, lInterface, logicalLink, "sourceLInterface");
228 QueryBuilder<Vertex> tQ = getNewVertexTraversalWithTestEdgeRules(lInterface);
229 tQ.createEdgeTraversal(EdgeType.COUSIN, lInterface, loader.introspectorFromName("logical-link"));
231 Vertex next = tQ.next();
233 assertEquals(logicalLink, next);
239 public void edgeToVertexTraversalTest() throws AAIException {
241 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
242 Vertex vnfc1 = g.addV("aai-node-type","vnfc","vnfc-name","a-name").next();
244 testEdgeSer.addEdge(g, gvnf, vnfc1);
246 QueryBuilder<Vertex> tQ = getNewVertexTraversalWithTestEdgeRules(gvnf);
247 tQ.createEdgeTraversal(EdgeType.COUSIN, "generic-vnf", "vnfc");
249 List<Vertex> list = tQ.toList();
251 assertEquals("Has 1 vertexes ", 1, list.size());
252 assertTrue("Has vertex on the default edge ", list.contains(vnfc1));
258 public void edgeToVertexTraversalSingleOutRuleTest() throws AAIException {
260 Vertex vce = g.addV("aai-node-type","vce","vnf-id","vce").next();
261 Vertex vnfc1 = g.addV("aai-node-type","vnfc","vnfc-name","a-name").next();
263 testEdgeSer.addEdge(g, vce, vnfc1);
265 QueryBuilder<Vertex> tQ1 = getNewVertexTraversalWithTestEdgeRules(vce);
266 tQ1.createEdgeTraversal(EdgeType.COUSIN, "vce", "vnfc");
268 QueryBuilder<Vertex> tQ2 = getNewVertexTraversalWithTestEdgeRules(vnfc1);
269 tQ2.createEdgeTraversal(EdgeType.COUSIN, "vnfc", "vce");
271 List<Vertex> list1 = tQ1.toList();
272 List<Vertex> list2 = tQ2.toList();
274 assertEquals("1 - Has 1 vertexes ", 1, list1.size());
275 assertTrue("1 - traversal results in vnfc ", list1.contains(vnfc1));
276 assertEquals("2 - Has 1 vertexes ", 1, list2.size());
277 assertTrue("2 - traversal results in vce ", list2.contains(vce));
283 public void edgeToVertexTraversalSingleInRuleTest() throws AAIException {
285 Vertex vce = g.addV("aai-node-type","vce","vnf-id","vce").next();
286 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
288 testEdgeSer.addEdge(g, vce, pserver);
290 QueryBuilder<Vertex> tQ1 = getNewVertexTraversalWithTestEdgeRules(vce);
291 tQ1.createEdgeTraversal(EdgeType.COUSIN, "vce", "pserver");
293 List<Vertex> list = tQ1.toList();
295 assertEquals("1 - Has 1 vertexes ", 1, list.size());
296 assertTrue("1 - traversal results in vnfc ", list.contains(pserver));
302 public void edgeToVertexMultiRuleTraversalTest() throws AAIException {
304 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
305 Vertex vnfc1 = g.addV("aai-node-type","vnfc","vnfc-name","a-name").next();
306 Vertex vnfc2 = g.addV("aai-node-type","vnfc","vnfc-name","b-name").next();
308 testEdgeSer.addEdge(g, gvnf, vnfc1);
309 testEdgeSer.addEdge(g, gvnf, vnfc2, "re-uses");
311 QueryBuilder<Vertex> tQ = getNewVertexTraversalWithTestEdgeRules(gvnf);
312 tQ.createEdgeTraversal(EdgeType.COUSIN, "generic-vnf", "vnfc");
314 List<Vertex> list = tQ.toList();
316 assertEquals("Has 2 vertexes ", 2, list.size());
317 assertTrue("Has vertex on the default edge ", list.contains(vnfc1));
318 assertTrue("Has vertex on the re-uses edge ", list.contains(vnfc2));
324 public void edgeToVertexMultiLabelTest() throws AAIException {
326 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
327 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
328 Vertex vnfc1 = g.addV("aai-node-type","vnfc","vnfc-name","a-name").next();
330 testEdgeSer.addEdge(g, gvnf, vnfc1);
331 testEdgeSer.addEdge(g, pserver, vnfc1);
333 QueryBuilder<Vertex> tQ = getNewVertexTraversalWithTestEdgeRules(vnfc1);
334 tQ.createEdgeTraversal(EdgeType.COUSIN, "vnfc", "generic-vnf");
336 List<Vertex> list = tQ.toList();
338 assertEquals("Has 1 vertexes ", 1, list.size());
339 assertTrue("Only returns the generic vnf vertex", list.contains(gvnf));
345 public void limitTraversalTest() throws AAIException {
347 g.addV("aai-node-type","vnfc","vnfc-name","a-name").next();
348 g.addV("aai-node-type","vnfc","vnfc-name","b-name").next();
350 QueryBuilder<Vertex> tQ = new GremlinTraversal<>(loader, g);
351 tQ.getVerticesByProperty("aai-node-type","vnfc").limit(1);
353 List<Vertex> list = tQ.toList();
355 assertEquals("Has 1 vertexes ", 1, list.size());
361 public void getVertexesByPropertiesTraversalTest() throws AAIException {
363 g.addV("aai-node-type","vnfc","vnfc-name","a-name").next();
364 g.addV("aai-node-type","vnfc","vnfc-name","b-name").next();
366 QueryBuilder<Vertex> tQ = new GremlinTraversal<>(loader, g);
367 tQ.getVerticesByProperty("vnfc-name", Arrays.asList("a-name", "b-name"));
369 List<Vertex> list = tQ.toList();
371 assertEquals("Has 2 vertexes ", 2, list.size());
377 public void getVertexesByIndexedPropertyTraversalTest() throws AAIException {
379 g.addV("aai-node-type","vnfc","vnfc-name","a-name").next();
380 g.addV("aai-node-type","vnfc","vnfc-name","b-name").next();
382 QueryBuilder<Vertex> tQ = new GremlinTraversal<>(loader, g);
383 tQ.getVerticesByIndexedProperty("aai-node-type","vnfc");
385 List<Vertex> list = tQ.toList();
387 assertEquals("Has 2 vertexes ", 2, list.size());
393 public void dedupTraversalTest() throws AAIException {
395 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
396 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
398 testEdgeSer.addEdge(g, gvnf, pserver);
399 testEdgeSer.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
401 QueryBuilder<Vertex> tQ = getNewVertexTraversalWithTestEdgeRules(gvnf);
402 tQ.createEdgeTraversal(EdgeType.COUSIN, "generic-vnf", "pserver").dedup();
404 List<Vertex> list = tQ.toList();
406 assertEquals("Has 2 vertexes ", 1, list.size());
407 assertTrue("result has pserver ", list.contains(pserver));
413 public void storeCapTraversalTest() throws AAIException {
415 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
416 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
418 testEdgeSer.addEdge(g, gvnf, pserver);
419 testEdgeSer.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
421 GremlinTraversal<BulkSet<Vertex>> tQ = new GremlinTraversal<>(loader, g, gvnf);
422 tQ.createEdgeTraversal(EdgeType.COUSIN, "generic-vnf", "pserver").store("x").cap("x");
424 List<BulkSet<Vertex>> list = tQ.toList();
426 assertEquals("Has 2 vertexes ", 1, list.size());
427 assertEquals("result has pserver ",pserver, list.get(0).iterator().next());
433 public void storeCapUnfoldTraversalTest() throws AAIException {
435 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
436 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
438 testEdgeSer.addEdge(g, gvnf, pserver);
439 testEdgeSer.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
441 QueryBuilder<Vertex> tQ = getNewVertexTraversalWithTestEdgeRules(gvnf);
442 tQ.createEdgeTraversal(EdgeType.COUSIN, "generic-vnf", "pserver").store("x").cap("x").unfold();
444 List<Vertex> list = tQ.toList();
446 assertEquals("Has 2 vertexes ", 2, list.size());
447 assertTrue("result has pserver ", list.contains(pserver));
453 public void nextAndHasNextTraversalTest() throws AAIException {
455 Vertex v1 = g.addV("aai-node-type","vnfc","vnfc-name","a-name").next();
456 Vertex v2 = g.addV("aai-node-type","vnfc","vnfc-name","b-name").next();
458 QueryBuilder<Vertex> tQ = new GremlinTraversal<>(loader, g);
459 tQ.getVerticesByProperty("aai-node-type","vnfc");
461 List<Vertex> list = new ArrayList<>();
463 assertTrue("Has next 1 ",tQ.hasNext());
465 assertTrue("Has next 2 ",tQ.hasNext());
467 assertFalse("Has next 3 ",tQ.hasNext());
468 assertTrue("Has all the vertexes", list.contains(v1) && list.remove(v2));
473 public void edgeToVertexMultiRuleOutTraversalTest() throws AAIException {
475 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
476 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
478 testEdgeSer.addEdge(g, gvnf, pserver);
479 testEdgeSer.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
481 QueryBuilder<Vertex> tQ = getNewVertexTraversalWithTestEdgeRules(gvnf);
482 tQ.createEdgeTraversal(EdgeType.COUSIN, "generic-vnf", "pserver");
484 List<Vertex> list = tQ.toList();
486 assertEquals("Has 2 vertexes ", 2, list.size());
487 assertTrue("result has pserver ", list.contains(pserver));
493 public void edgeToVertexMultiRuleInTraversalTest() throws AAIException {
495 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
496 Vertex complex = g.addV("aai-node-type","complex","physical-location-id","a-name").next();
498 testEdgeSer.addEdge(g, gvnf, complex);
499 testEdgeSer.addEdge(g, gvnf, complex, "complex-generic-vnf-B");
501 QueryBuilder<Vertex> tQ = getNewVertexTraversalWithTestEdgeRules(gvnf);
502 tQ.createEdgeTraversal(EdgeType.COUSIN, "generic-vnf", "complex");
504 List<Vertex> list = tQ.toList();
506 assertEquals("Has 2 vertexes ", 2, list.size());
507 assertTrue("result has pserver ", list.contains(complex));
513 public void edgeTraversalSingleInRuleTest() throws AAIException {
515 Vertex vce = g.addV("aai-node-type","vce","vnf-id","vce").next();
516 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
518 Edge e = testEdgeSer.addEdge(g, vce, pserver);
520 QueryBuilder<Edge> tQ1 = getNewEdgeTraversalWithTestEdgeRules(vce);
521 tQ1.getEdgesBetween(EdgeType.COUSIN, "vce", "pserver");
523 List<Edge> list = tQ1.toList();
525 assertEquals("1 - Has 1 edge ", 1, list.size());
526 assertTrue("1 - traversal results in edge ", list.contains(e));
532 public void edgeTraversalSingleOutRuleTest() throws AAIException {
534 Vertex vce = g.addV("aai-node-type","vce","vnf-id","vce").next();
535 Vertex vnfc1 = g.addV("aai-node-type","vnfc","vnfc-name","a-name").next();
537 Edge e = testEdgeSer.addEdge(g, vce, vnfc1);
539 QueryBuilder<Edge> tQ1 = getNewEdgeTraversalWithTestEdgeRules(vce);
540 tQ1.getEdgesBetween(EdgeType.COUSIN, "vce", "vnfc");
542 List<Edge> list1 = tQ1.toList();
544 assertEquals("1 - Has 1 edge ", 1, list1.size());
545 assertTrue("1 - traversal results in edge ", list1.contains(e));
551 public void edgeTraversalMultiRuleOutTraversalTest() throws AAIException {
553 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
554 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
556 Edge e1 = testEdgeSer.addEdge(g, gvnf, pserver);
557 Edge e2 = testEdgeSer.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
559 QueryBuilder<Edge> tQ = getNewEdgeTraversalWithTestEdgeRules(gvnf);
560 tQ.getEdgesBetween(EdgeType.COUSIN, "generic-vnf", "pserver");
562 List<Edge> list = tQ.toList();
564 assertEquals("Has 2 edges ", 2, list.size());
565 assertTrue("result has default edge ", list.contains(e1));
566 assertTrue("result has other edge ", list.contains(e2));
572 public void edgeTraversalMultiRuleInTraversalTest() throws AAIException {
574 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
575 Vertex complex = g.addV("aai-node-type","complex","physical-location-id","a-name").next();
577 Edge e1 = testEdgeSer.addEdge(g, gvnf, complex);
578 Edge e2 = testEdgeSer.addEdge(g, gvnf, complex, "complex-generic-vnf-B");
580 QueryBuilder<Edge> tQ = getNewEdgeTraversalWithTestEdgeRules(gvnf);
581 tQ.getEdgesBetween(EdgeType.COUSIN, "generic-vnf", "complex");
583 List<Edge> list = tQ.toList();
585 assertEquals("Has 2 edges ", 2, list.size());
586 assertTrue("result has default edge ", list.contains(e1));
587 assertTrue("result has other edge ", list.contains(e2));
593 public void edgeTraversalMultiRuleTraversalTest() throws AAIException {
595 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
596 Vertex vnfc1 = g.addV("aai-node-type","vnfc","vnfc-name","a-name").next();
597 Vertex vnfc2 = g.addV("aai-node-type","vnfc","vnfc-name","b-name").next();
599 Edge e1 = testEdgeSer.addEdge(g, gvnf, vnfc1);
600 Edge e2 = testEdgeSer.addEdge(g, gvnf, vnfc2, "re-uses");
602 QueryBuilder<Edge> tQ = getNewEdgeTraversalWithTestEdgeRules(gvnf);
603 tQ.getEdgesBetween(EdgeType.COUSIN, "generic-vnf", "vnfc");
605 List<Edge> list = tQ.toList();
607 assertEquals("Has 2 edges ", 2, list.size());
608 assertTrue("result has default edge ", list.contains(e1));
609 assertTrue("result has other edge ", list.contains(e2));
614 @Ignore("This test is failing for TraversalQueryTest and Optimized but it passes for GremlinQueryTest")
615 @Test (expected = NoEdgeRuleFoundException.class)
616 public void getEdgesBetweenWithLabelsEmptyListTest() throws AAIException {
618 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
619 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
621 testEdgeSer.addEdge(g, gvnf, pserver);
622 testEdgeSer.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
624 QueryBuilder<Edge> tQ = getNewEdgeTraversalWithTestEdgeRules(gvnf);
625 tQ.getEdgesBetweenWithLabels(EdgeType.COUSIN, "generic-vnf", "pserver", Collections.emptyList());
630 public void getEdgesBetweenWithLabelsSingleItemTest() throws AAIException {
632 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
633 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
635 Edge e1 = testEdgeSer.addEdge(g, gvnf, pserver);
636 Edge e2 = testEdgeSer.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
638 QueryBuilder<Edge> tQ = getNewEdgeTraversalWithTestEdgeRules(gvnf);
639 tQ.getEdgesBetweenWithLabels(EdgeType.COUSIN, "generic-vnf", "pserver", Collections.singletonList("generic-vnf-pserver-B"));
641 List<Edge> list = tQ.toList();
643 assertEquals("Has 1 edges ", 1, list.size());
644 assertFalse("result does not have default edge ", list.contains(e1));
645 assertTrue("result has other edge ", list.contains(e2));
650 public void getEdgesBetweenWithLabelsMultipleItemTest() throws AAIException {
652 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
653 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
655 Edge e1 = testEdgeSer.addEdge(g, gvnf, pserver);
656 Edge e2 = testEdgeSer.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
658 QueryBuilder<Edge> tQ = getNewEdgeTraversalWithTestEdgeRules(gvnf);
659 tQ.getEdgesBetweenWithLabels(EdgeType.COUSIN, "generic-vnf", "pserver", Arrays.asList("generic-vnf-pserver-B", "generic-vnf-pserver-A"));
661 List<Edge> list = tQ.toList();
663 assertEquals("Has 2 edges ", 2, list.size());
664 assertTrue("result has generic-vnf-pserver-A edge ", list.contains(e1));
665 assertTrue("result has generic-vnf-pserver-B edge ", list.contains(e2));
669 @Ignore("This test is failing for TraversalQueryTest and Optimized but it passes for GremlinQueryTest")
670 @Test (expected = NoEdgeRuleFoundException.class)
671 public void createEdgeTraversalWithLabelsEmptyListTest() throws AAIException {
673 Vertex gvnf = getVertex();
675 QueryBuilder<Edge> tQ = getNewEdgeTraversalWithTestEdgeRules(gvnf);
676 tQ.getEdgesBetweenWithLabels(EdgeType.COUSIN, "generic-vnf", "pserver", Collections.emptyList());
683 private Vertex getVertex() throws AAIException {
684 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
685 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
687 testEdgeSer.addEdge(g, gvnf, pserver);
688 testEdgeSer.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
693 public void createEdgeTraversalWithLabelsSingleItemTest() throws AAIException {
695 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
696 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
698 Edge e1 = testEdgeSer.addEdge(g, gvnf, pserver);
699 Edge e2 = testEdgeSer.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
701 QueryBuilder<Edge> tQ = getNewEdgeTraversalWithTestEdgeRules(gvnf);
702 tQ.getEdgesBetweenWithLabels(EdgeType.COUSIN, "generic-vnf", "pserver", Collections.singletonList("generic-vnf-pserver-B"));
704 List<Edge> list = tQ.toList();
706 assertEquals("Has 1 edges ", 1, list.size());
707 assertFalse("result does not have default edge ", list.contains(e1));
708 assertTrue("result has other edge ", list.contains(e2));
713 public void createEdgeTraversalWithLabelsMultipleItemTest() throws AAIException {
715 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
716 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
718 Edge e1 = testEdgeSer.addEdge(g, gvnf, pserver);
719 Edge e2 = testEdgeSer.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
721 QueryBuilder<Edge> tQ = getNewEdgeTraversalWithTestEdgeRules(gvnf);
722 tQ.getEdgesBetweenWithLabels(EdgeType.COUSIN, "generic-vnf", "pserver", Arrays.asList("generic-vnf-pserver-B", "generic-vnf-pserver-A"));
724 List<Edge> list = tQ.toList();
726 assertEquals("Has 2 edges ", 2, list.size());
727 assertTrue("result has generic-vnf-pserver-A edge ", list.contains(e1));
728 assertTrue("result has generic-vnf-pserver-B edge ", list.contains(e2));
732 protected abstract QueryBuilder<Edge> getNewEdgeTraversalWithTestEdgeRules(Vertex v);
734 protected abstract QueryBuilder<Edge> getNewEdgeTraversalWithTestEdgeRules();
736 protected abstract QueryBuilder<Vertex> getNewVertexTraversalWithTestEdgeRules(Vertex v);
738 protected abstract QueryBuilder<Vertex> getNewVertexTraversalWithTestEdgeRules();
740 protected abstract QueryBuilder<Tree> getNewTreeTraversalWithTestEdgeRules(Vertex v);
742 protected abstract QueryBuilder<Tree> getNewTreeTraversalWithTestEdgeRules();
744 protected abstract QueryBuilder<Path> getNewPathTraversalWithTestEdgeRules(Vertex v);
746 protected abstract QueryBuilder<Path> getNewPathTraversalWithTestEdgeRules();