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=========================================================
21 package org.onap.aai.query.builder;
23 import static org.hamcrest.CoreMatchers.is;
24 import static org.hamcrest.collection.IsIterableContainingInOrder.contains;
25 import static org.junit.Assert.*;
27 import java.util.ArrayList;
28 import java.util.Arrays;
29 import java.util.Collections;
30 import java.util.List;
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;
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;
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)
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 {
75 protected Loader loader;
76 protected static Graph graph;
77 protected GraphTraversalSource g;
80 protected EdgeSerializer testEdgeSer;
83 protected SchemaVersions schemaVersions;
86 protected LoaderFactory loaderFactory;
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();
98 public void configure() throws Exception {
99 loader = loaderFactory.createLoaderForVersion(ModelType.MOXY, schemaVersions.getDefaultVersion());
101 g = graph.traversal();
105 public void deConfigure() throws Exception {
110 public static void teardown() throws Exception {
115 public void createEdgeGVnfToVnfcTraversal() throws AAIException {
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");
121 QueryBuilder<Vertex> tQ = getNewVertexTraversalWithTestEdgeRules(gvnf);
122 tQ.createEdgeTraversal(EdgeType.COUSIN, "generic-vnf", "vnfc");
124 assertEquals(vnfc, tQ.next());
129 public void createEdgeLinterfaceToLogicalLinkTraversal() throws AAIException {
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");
135 QueryBuilder<Vertex> tQ = getNewVertexTraversalWithTestEdgeRules(lInterface);
136 tQ.createEdgeTraversal(EdgeType.COUSIN, "l-interface", "logical-link");
138 Vertex next = tQ.next();
140 assertEquals(logicalLink, next);
144 @SuppressWarnings("rawtypes")
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");
151 QueryBuilder<Tree> tQ = getNewTreeTraversalWithTestEdgeRules(lInterface).createEdgeTraversal(EdgeType.COUSIN,
152 loader.introspectorFromName("l-interface"), loader.introspectorFromName("logical-link")).tree();
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));
163 @SuppressWarnings("rawtypes")
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);
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"))
179 Path path = tQ.next();
180 assertThat(path.objects(), contains(pInterface, lInterface, logicalLink));
183 @SuppressWarnings("rawtypes")
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();
189 testEdgeSer.addTreeEdge(g, pInterface, lInterface);
191 QueryBuilder<Vertex> tQ = getNewEdgeTraversalWithTestEdgeRules(lInterface).getParentVertex();
193 Vertex parent = tQ.next();
194 assertThat(parent, is(pInterface));
198 public void createEdgeLinterfaceToLogicalLinkIntrospectorTraversal() throws AAIException {
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");
204 QueryBuilder<Vertex> tQ = getNewVertexTraversalWithTestEdgeRules(lInterface);
205 tQ.createEdgeTraversal(EdgeType.COUSIN, loader.introspectorFromName("l-interface"),
206 loader.introspectorFromName("logical-link"));
208 Vertex next = tQ.next();
210 assertEquals(logicalLink, next);
215 public void createEdgeLinterfaceToLogicalLinkVertexToIntrospectorTraversal() throws AAIException {
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");
221 QueryBuilder<Vertex> tQ = getNewVertexTraversalWithTestEdgeRules(lInterface);
222 tQ.createEdgeTraversal(EdgeType.COUSIN, lInterface, loader.introspectorFromName("logical-link"));
224 Vertex next = tQ.next();
226 assertEquals(logicalLink, next);
231 public void edgeToVertexTraversalTest() throws AAIException {
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();
236 testEdgeSer.addEdge(g, gvnf, vnfc1);
238 QueryBuilder<Vertex> tQ = getNewVertexTraversalWithTestEdgeRules(gvnf);
239 tQ.createEdgeTraversal(EdgeType.COUSIN, "generic-vnf", "vnfc");
241 List<Vertex> list = tQ.toList();
243 assertEquals("Has 1 vertexes ", 1, list.size());
244 assertTrue("Has vertex on the default edge ", list.contains(vnfc1));
249 public void edgeToVertexTraversalSingleOutRuleTest() throws AAIException {
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();
254 testEdgeSer.addEdge(g, vce, vnfc1);
256 QueryBuilder<Vertex> tQ1 = getNewVertexTraversalWithTestEdgeRules(vce);
257 tQ1.createEdgeTraversal(EdgeType.COUSIN, "vce", "vnfc");
259 QueryBuilder<Vertex> tQ2 = getNewVertexTraversalWithTestEdgeRules(vnfc1);
260 tQ2.createEdgeTraversal(EdgeType.COUSIN, "vnfc", "vce");
262 List<Vertex> list1 = tQ1.toList();
263 List<Vertex> list2 = tQ2.toList();
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));
273 public void edgeToVertexTraversalSingleInRuleTest() throws AAIException {
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();
278 testEdgeSer.addEdge(g, vce, pserver);
280 QueryBuilder<Vertex> tQ1 = getNewVertexTraversalWithTestEdgeRules(vce);
281 tQ1.createEdgeTraversal(EdgeType.COUSIN, "vce", "pserver");
283 List<Vertex> list = tQ1.toList();
285 assertEquals("1 - Has 1 vertexes ", 1, list.size());
286 assertTrue("1 - traversal results in vnfc ", list.contains(pserver));
291 public void edgeToVertexMultiRuleTraversalTest() throws AAIException {
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();
297 testEdgeSer.addEdge(g, gvnf, vnfc1);
298 testEdgeSer.addEdge(g, gvnf, vnfc2, "re-uses");
300 QueryBuilder<Vertex> tQ = getNewVertexTraversalWithTestEdgeRules(gvnf);
301 tQ.createEdgeTraversal(EdgeType.COUSIN, "generic-vnf", "vnfc");
303 List<Vertex> list = tQ.toList();
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));
312 public void edgeToVertexMultiLabelTest() throws AAIException {
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();
318 testEdgeSer.addEdge(g, gvnf, vnfc1);
319 testEdgeSer.addEdge(g, pserver, vnfc1);
321 QueryBuilder<Vertex> tQ = getNewVertexTraversalWithTestEdgeRules(vnfc1);
322 tQ.createEdgeTraversal(EdgeType.COUSIN, "vnfc", "generic-vnf");
324 List<Vertex> list = tQ.toList();
326 assertEquals("Has 1 vertexes ", 1, list.size());
327 assertTrue("Only returns the generic vnf vertex", list.contains(gvnf));
332 public void limitTraversalTest() throws AAIException {
334 g.addV("aai-node-type", "vnfc", "vnfc-name", "a-name").next();
335 g.addV("aai-node-type", "vnfc", "vnfc-name", "b-name").next();
337 QueryBuilder<Vertex> tQ = new GremlinTraversal<>(loader, g);
338 tQ.getVerticesByProperty("aai-node-type", "vnfc").limit(1);
340 List<Vertex> list = tQ.toList();
342 assertEquals("Has 1 vertexes ", 1, list.size());
347 public void getVertexesByPropertiesTraversalTest() throws AAIException {
349 g.addV("aai-node-type", "vnfc", "vnfc-name", "a-name").next();
350 g.addV("aai-node-type", "vnfc", "vnfc-name", "b-name").next();
352 QueryBuilder<Vertex> tQ = new GremlinTraversal<>(loader, g);
353 tQ.getVerticesByProperty("vnfc-name", Arrays.asList("a-name", "b-name"));
355 List<Vertex> list = tQ.toList();
357 assertEquals("Has 2 vertexes ", 2, list.size());
362 public void getVertexesByIndexedPropertyTraversalTest() throws AAIException {
364 g.addV("aai-node-type", "vnfc", "vnfc-name", "a-name").next();
365 g.addV("aai-node-type", "vnfc", "vnfc-name", "b-name").next();
367 QueryBuilder<Vertex> tQ = new GremlinTraversal<>(loader, g);
368 tQ.getVerticesByIndexedProperty("aai-node-type", "vnfc");
370 List<Vertex> list = tQ.toList();
372 assertEquals("Has 2 vertexes ", 2, list.size());
377 public void dedupTraversalTest() throws AAIException {
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();
382 testEdgeSer.addEdge(g, gvnf, pserver);
383 testEdgeSer.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
385 QueryBuilder<Vertex> tQ = getNewVertexTraversalWithTestEdgeRules(gvnf);
386 tQ.createEdgeTraversal(EdgeType.COUSIN, "generic-vnf", "pserver").dedup();
388 List<Vertex> list = tQ.toList();
390 assertEquals("Has 2 vertexes ", 1, list.size());
391 assertTrue("result has pserver ", list.contains(pserver));
396 public void storeCapTraversalTest() throws AAIException {
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();
401 testEdgeSer.addEdge(g, gvnf, pserver);
402 testEdgeSer.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
404 GremlinTraversal<BulkSet<Vertex>> tQ = new GremlinTraversal<>(loader, g, gvnf);
405 tQ.createEdgeTraversal(EdgeType.COUSIN, "generic-vnf", "pserver").store("x").cap("x");
407 List<BulkSet<Vertex>> list = tQ.toList();
409 assertEquals("Has 2 vertexes ", 1, list.size());
410 assertEquals("result has pserver ", pserver, list.get(0).iterator().next());
415 public void storeCapUnfoldTraversalTest() throws AAIException {
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();
420 testEdgeSer.addEdge(g, gvnf, pserver);
421 testEdgeSer.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
423 QueryBuilder<Vertex> tQ = getNewVertexTraversalWithTestEdgeRules(gvnf);
424 tQ.createEdgeTraversal(EdgeType.COUSIN, "generic-vnf", "pserver").store("x").cap("x").unfold();
426 List<Vertex> list = tQ.toList();
428 assertEquals("Has 2 vertexes ", 2, list.size());
429 assertTrue("result has pserver ", list.contains(pserver));
434 public void nextAndHasNextTraversalTest() throws AAIException {
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();
439 QueryBuilder<Vertex> tQ = new GremlinTraversal<>(loader, g);
440 tQ.getVerticesByProperty("aai-node-type", "vnfc");
442 List<Vertex> list = new ArrayList<>();
444 assertTrue("Has next 1 ", tQ.hasNext());
446 assertTrue("Has next 2 ", tQ.hasNext());
448 assertFalse("Has next 3 ", tQ.hasNext());
449 assertTrue("Has all the vertexes", list.contains(v1) && list.remove(v2));
454 public void edgeToVertexMultiRuleOutTraversalTest() throws AAIException {
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();
459 testEdgeSer.addEdge(g, gvnf, pserver);
460 testEdgeSer.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
462 QueryBuilder<Vertex> tQ = getNewVertexTraversalWithTestEdgeRules(gvnf);
463 tQ.createEdgeTraversal(EdgeType.COUSIN, "generic-vnf", "pserver");
465 List<Vertex> list = tQ.toList();
467 assertEquals("Has 2 vertexes ", 2, list.size());
468 assertTrue("result has pserver ", list.contains(pserver));
473 public void edgeToVertexMultiRuleInTraversalTest() throws AAIException {
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();
478 testEdgeSer.addEdge(g, gvnf, complex);
479 testEdgeSer.addEdge(g, gvnf, complex, "complex-generic-vnf-B");
481 QueryBuilder<Vertex> tQ = getNewVertexTraversalWithTestEdgeRules(gvnf);
482 tQ.createEdgeTraversal(EdgeType.COUSIN, "generic-vnf", "complex");
484 List<Vertex> list = tQ.toList();
486 assertEquals("Has 2 vertexes ", 2, list.size());
487 assertTrue("result has pserver ", list.contains(complex));
492 public void edgeTraversalSingleInRuleTest() throws AAIException {
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();
497 Edge e = testEdgeSer.addEdge(g, vce, pserver);
499 QueryBuilder<Edge> tQ1 = getNewEdgeTraversalWithTestEdgeRules(vce);
500 tQ1.getEdgesBetween(EdgeType.COUSIN, "vce", "pserver");
502 List<Edge> list = tQ1.toList();
504 assertEquals("1 - Has 1 edge ", 1, list.size());
505 assertTrue("1 - traversal results in edge ", list.contains(e));
510 public void edgeTraversalSingleOutRuleTest() throws AAIException {
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();
515 Edge e = testEdgeSer.addEdge(g, vce, vnfc1);
517 QueryBuilder<Edge> tQ1 = getNewEdgeTraversalWithTestEdgeRules(vce);
518 tQ1.getEdgesBetween(EdgeType.COUSIN, "vce", "vnfc");
520 List<Edge> list1 = tQ1.toList();
522 assertEquals("1 - Has 1 edge ", 1, list1.size());
523 assertTrue("1 - traversal results in edge ", list1.contains(e));
528 public void edgeTraversalMultiRuleOutTraversalTest() throws AAIException {
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();
533 Edge e1 = testEdgeSer.addEdge(g, gvnf, pserver);
534 Edge e2 = testEdgeSer.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
536 QueryBuilder<Edge> tQ = getNewEdgeTraversalWithTestEdgeRules(gvnf);
537 tQ.getEdgesBetween(EdgeType.COUSIN, "generic-vnf", "pserver");
539 List<Edge> list = tQ.toList();
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));
548 public void edgeTraversalMultiRuleInTraversalTest() throws AAIException {
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();
553 Edge e1 = testEdgeSer.addEdge(g, gvnf, complex);
554 Edge e2 = testEdgeSer.addEdge(g, gvnf, complex, "complex-generic-vnf-B");
556 QueryBuilder<Edge> tQ = getNewEdgeTraversalWithTestEdgeRules(gvnf);
557 tQ.getEdgesBetween(EdgeType.COUSIN, "generic-vnf", "complex");
559 List<Edge> list = tQ.toList();
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));
568 public void edgeTraversalMultiRuleTraversalTest() throws AAIException {
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();
574 Edge e1 = testEdgeSer.addEdge(g, gvnf, vnfc1);
575 Edge e2 = testEdgeSer.addEdge(g, gvnf, vnfc2, "re-uses");
577 QueryBuilder<Edge> tQ = getNewEdgeTraversalWithTestEdgeRules(gvnf);
578 tQ.getEdgesBetween(EdgeType.COUSIN, "generic-vnf", "vnfc");
580 List<Edge> list = tQ.toList();
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));
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 {
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();
595 testEdgeSer.addEdge(g, gvnf, pserver);
596 testEdgeSer.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
598 QueryBuilder<Edge> tQ = getNewEdgeTraversalWithTestEdgeRules(gvnf);
599 tQ.getEdgesBetweenWithLabels(EdgeType.COUSIN, "generic-vnf", "pserver", Collections.emptyList());
604 public void getEdgesBetweenWithLabelsSingleItemTest() throws AAIException {
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();
609 Edge e1 = testEdgeSer.addEdge(g, gvnf, pserver);
610 Edge e2 = testEdgeSer.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
612 QueryBuilder<Edge> tQ = getNewEdgeTraversalWithTestEdgeRules(gvnf);
613 tQ.getEdgesBetweenWithLabels(EdgeType.COUSIN, "generic-vnf", "pserver",
614 Collections.singletonList("generic-vnf-pserver-B"));
616 List<Edge> list = tQ.toList();
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));
625 public void getEdgesBetweenWithLabelsMultipleItemTest() throws AAIException {
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();
630 Edge e1 = testEdgeSer.addEdge(g, gvnf, pserver);
631 Edge e2 = testEdgeSer.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
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"));
637 List<Edge> list = tQ.toList();
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));
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 {
649 Vertex gvnf = getVertex();
651 QueryBuilder<Edge> tQ = getNewEdgeTraversalWithTestEdgeRules(gvnf);
652 tQ.getEdgesBetweenWithLabels(EdgeType.COUSIN, "generic-vnf", "pserver", Collections.emptyList());
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();
662 testEdgeSer.addEdge(g, gvnf, pserver);
663 testEdgeSer.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
668 public void createEdgeTraversalWithLabelsSingleItemTest() throws AAIException {
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();
673 Edge e1 = testEdgeSer.addEdge(g, gvnf, pserver);
674 Edge e2 = testEdgeSer.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
676 QueryBuilder<Edge> tQ = getNewEdgeTraversalWithTestEdgeRules(gvnf);
677 tQ.getEdgesBetweenWithLabels(EdgeType.COUSIN, "generic-vnf", "pserver",
678 Collections.singletonList("generic-vnf-pserver-B"));
680 List<Edge> list = tQ.toList();
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));
689 public void createEdgeTraversalWithLabelsMultipleItemTest() throws AAIException {
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();
694 Edge e1 = testEdgeSer.addEdge(g, gvnf, pserver);
695 Edge e2 = testEdgeSer.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
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"));
701 List<Edge> list = tQ.toList();
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));
709 protected abstract QueryBuilder<Edge> getNewEdgeTraversalWithTestEdgeRules(Vertex v);
711 protected abstract QueryBuilder<Edge> getNewEdgeTraversalWithTestEdgeRules();
713 protected abstract QueryBuilder<Vertex> getNewVertexTraversalWithTestEdgeRules(Vertex v);
715 protected abstract QueryBuilder<Vertex> getNewVertexTraversalWithTestEdgeRules();
717 protected abstract QueryBuilder<Tree> getNewTreeTraversalWithTestEdgeRules(Vertex v);
719 protected abstract QueryBuilder<Tree> getNewTreeTraversalWithTestEdgeRules();
721 protected abstract QueryBuilder<Path> getNewPathTraversalWithTestEdgeRules(Vertex v);
723 protected abstract QueryBuilder<Path> getNewPathTraversalWithTestEdgeRules();