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 com.thinkaurelius.titan.core.TitanFactory;
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;
30 import org.onap.aai.AAISetup;
31 import org.onap.aai.db.props.AAIProperties;
32 import org.onap.aai.exceptions.AAIException;
33 import org.onap.aai.introspection.Loader;
34 import org.onap.aai.introspection.LoaderFactory;
35 import org.onap.aai.introspection.ModelType;
36 import org.onap.aai.serialization.db.EdgeRules;
37 import org.onap.aai.serialization.db.EdgeType;
38 import org.onap.aai.serialization.db.exceptions.NoEdgeRuleFoundException;
40 import java.util.ArrayList;
41 import java.util.Arrays;
42 import java.util.Collections;
43 import java.util.List;
45 import static org.junit.Assert.*;
47 public abstract class QueryBuilderTestAbstraction extends AAISetup {
49 protected static Loader loader;
50 protected static Graph graph;
51 protected GraphTraversalSource g;
53 protected EdgeRules testEdgeRules = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_TraversalQueryTest.json");
57 public static void setup() throws Exception {
58 loader = LoaderFactory.createLoaderForVersion(ModelType.MOXY, AAIProperties.LATEST);
59 graph = TitanFactory.build().set("storage.backend", "inmemory").open();
63 public void configure() throws Exception {
64 g = graph.traversal();
68 public void deConfigure() throws Exception {
73 public static void teardown() throws Exception {
78 public void createEdgeGVnfToVnfcTraversal() throws AAIException {
80 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","myvnf").next();
81 Vertex vnfc = g.addV("aai-node-type","vnfc","vnfc-name","a-name").next();
82 testEdgeRules.addEdge(g, gvnf, vnfc, "uses");
84 QueryBuilder<Vertex> tQ = getNewVertexTraversalWithTestEdgeRules(gvnf);
85 tQ.createEdgeTraversal(EdgeType.COUSIN, "generic-vnf", "vnfc");
87 assertEquals(vnfc, tQ.next());
93 public void createEdgeLinterfaceToLogicalLinkTraversal() throws AAIException {
95 Vertex lInterface = g.addV("aai-node-type","l-interface","interface-name","l-interface-a").next();
96 Vertex logicalLink = g.addV("aai-node-type","logical-link","link-name","logical-link-a").next();
97 testEdgeRules.addEdge(g, lInterface, logicalLink, "sourceLInterface");
99 QueryBuilder<Vertex> tQ = getNewVertexTraversalWithTestEdgeRules(lInterface);
100 tQ.createEdgeTraversal(EdgeType.COUSIN, "l-interface", "logical-link");
102 Vertex next = tQ.next();
104 assertEquals(logicalLink, next);
110 public void createEdgeLinterfaceToLogicalLinkIntrospectorTraversal() throws AAIException {
112 Vertex lInterface = g.addV("aai-node-type","l-interface","interface-name","l-interface-a").next();
113 Vertex logicalLink = g.addV("aai-node-type","logical-link","link-name","logical-link-a").next();
114 testEdgeRules.addEdge(g, lInterface, logicalLink, "sourceLInterface");
116 QueryBuilder<Vertex> tQ = getNewVertexTraversalWithTestEdgeRules(lInterface);
117 tQ.createEdgeTraversal(EdgeType.COUSIN, loader.introspectorFromName("l-interface"), loader.introspectorFromName("logical-link"));
119 Vertex next = tQ.next();
121 assertEquals(logicalLink, next);
127 public void createEdgeLinterfaceToLogicalLinkVertexToIntrospectorTraversal() throws AAIException {
129 Vertex lInterface = g.addV("aai-node-type","l-interface","interface-name","l-interface-a").next();
130 Vertex logicalLink = g.addV("aai-node-type","logical-link","link-name","logical-link-a").next();
131 testEdgeRules.addEdge(g, lInterface, logicalLink, "sourceLInterface");
133 QueryBuilder<Vertex> tQ = getNewVertexTraversalWithTestEdgeRules(lInterface);
134 tQ.createEdgeTraversal(EdgeType.COUSIN, lInterface, loader.introspectorFromName("logical-link"));
136 Vertex next = tQ.next();
138 assertEquals(logicalLink, next);
144 public void edgeToVertexTraversalTest() throws AAIException {
146 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
147 Vertex vnfc1 = g.addV("aai-node-type","vnfc","vnfc-name","a-name").next();
149 testEdgeRules.addEdge(g, gvnf, vnfc1);
151 QueryBuilder<Vertex> tQ = getNewVertexTraversalWithTestEdgeRules(gvnf);
152 tQ.createEdgeTraversal(EdgeType.COUSIN, "generic-vnf", "vnfc");
154 List<Vertex> list = tQ.toList();
156 assertEquals("Has 1 vertexes ", 1, list.size());
157 assertTrue("Has vertex on the default edge ", list.contains(vnfc1));
163 public void edgeToVertexTraversalSingleOutRuleTest() throws AAIException {
165 Vertex vce = g.addV("aai-node-type","vce","vnf-id","vce").next();
166 Vertex vnfc1 = g.addV("aai-node-type","vnfc","vnfc-name","a-name").next();
168 testEdgeRules.addEdge(g, vce, vnfc1);
170 QueryBuilder<Vertex> tQ1 = getNewVertexTraversalWithTestEdgeRules(vce);
171 tQ1.createEdgeTraversal(EdgeType.COUSIN, "vce", "vnfc");
173 QueryBuilder<Vertex> tQ2 = getNewVertexTraversalWithTestEdgeRules(vnfc1);
174 tQ2.createEdgeTraversal(EdgeType.COUSIN, "vnfc", "vce");
176 List<Vertex> list1 = tQ1.toList();
177 List<Vertex> list2 = tQ2.toList();
179 assertEquals("1 - Has 1 vertexes ", 1, list1.size());
180 assertTrue("1 - traversal results in vnfc ", list1.contains(vnfc1));
181 assertEquals("2 - Has 1 vertexes ", 1, list2.size());
182 assertTrue("2 - traversal results in vce ", list2.contains(vce));
188 public void edgeToVertexTraversalSingleInRuleTest() throws AAIException {
190 Vertex vce = g.addV("aai-node-type","vce","vnf-id","vce").next();
191 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
193 testEdgeRules.addEdge(g, vce, pserver);
195 QueryBuilder<Vertex> tQ1 = getNewVertexTraversalWithTestEdgeRules(vce);
196 tQ1.createEdgeTraversal(EdgeType.COUSIN, "vce", "pserver");
198 List<Vertex> list = tQ1.toList();
200 assertEquals("1 - Has 1 vertexes ", 1, list.size());
201 assertTrue("1 - traversal results in vnfc ", list.contains(pserver));
207 public void edgeToVertexMultiRuleTraversalTest() throws AAIException {
209 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
210 Vertex vnfc1 = g.addV("aai-node-type","vnfc","vnfc-name","a-name").next();
211 Vertex vnfc2 = g.addV("aai-node-type","vnfc","vnfc-name","b-name").next();
213 testEdgeRules.addEdge(g, gvnf, vnfc1);
214 testEdgeRules.addEdge(g, gvnf, vnfc2, "re-uses");
216 QueryBuilder<Vertex> tQ = getNewVertexTraversalWithTestEdgeRules(gvnf);
217 tQ.createEdgeTraversal(EdgeType.COUSIN, "generic-vnf", "vnfc");
219 List<Vertex> list = tQ.toList();
221 assertEquals("Has 2 vertexes ", 2, list.size());
222 assertTrue("Has vertex on the default edge ", list.contains(vnfc1));
223 assertTrue("Has vertex on the re-uses edge ", list.contains(vnfc2));
229 public void edgeToVertexMultiLabelTest() throws AAIException {
231 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
232 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
233 Vertex vnfc1 = g.addV("aai-node-type","vnfc","vnfc-name","a-name").next();
235 testEdgeRules.addEdge(g, gvnf, vnfc1);
236 testEdgeRules.addEdge(g, pserver, vnfc1);
238 QueryBuilder<Vertex> tQ = getNewVertexTraversalWithTestEdgeRules(vnfc1);
239 tQ.createEdgeTraversal(EdgeType.COUSIN, "vnfc", "generic-vnf");
241 List<Vertex> list = tQ.toList();
243 assertEquals("Has 1 vertexes ", 1, list.size());
244 assertTrue("Only returns the generic vnf vertex", list.contains(gvnf));
250 public void limitTraversalTest() throws AAIException {
252 g.addV("aai-node-type","vnfc","vnfc-name","a-name").next();
253 g.addV("aai-node-type","vnfc","vnfc-name","b-name").next();
255 QueryBuilder<Vertex> tQ = new GremlinTraversal<>(loader, g, testEdgeRules);
256 tQ.getVerticesByProperty("aai-node-type","vnfc").limit(1);
258 List<Vertex> list = tQ.toList();
260 assertEquals("Has 1 vertexes ", 1, list.size());
266 public void getVertexesByPropertiesTraversalTest() throws AAIException {
268 g.addV("aai-node-type","vnfc","vnfc-name","a-name").next();
269 g.addV("aai-node-type","vnfc","vnfc-name","b-name").next();
271 QueryBuilder<Vertex> tQ = new GremlinTraversal<>(loader, g, testEdgeRules);
272 tQ.getVerticesByProperty("vnfc-name", Arrays.asList("a-name", "b-name"));
274 List<Vertex> list = tQ.toList();
276 assertEquals("Has 2 vertexes ", 2, list.size());
282 public void getVertexesByIndexedPropertyTraversalTest() throws AAIException {
284 g.addV("aai-node-type","vnfc","vnfc-name","a-name").next();
285 g.addV("aai-node-type","vnfc","vnfc-name","b-name").next();
287 QueryBuilder<Vertex> tQ = new GremlinTraversal<>(loader, g, testEdgeRules);
288 tQ.getVerticesByIndexedProperty("aai-node-type","vnfc");
290 List<Vertex> list = tQ.toList();
292 assertEquals("Has 2 vertexes ", 2, list.size());
298 public void dedupTraversalTest() throws AAIException {
300 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
301 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
303 testEdgeRules.addEdge(g, gvnf, pserver);
304 testEdgeRules.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
306 QueryBuilder<Vertex> tQ = getNewVertexTraversalWithTestEdgeRules(gvnf);
307 tQ.createEdgeTraversal(EdgeType.COUSIN, "generic-vnf", "pserver").dedup();
309 List<Vertex> list = tQ.toList();
311 assertEquals("Has 2 vertexes ", 1, list.size());
312 assertTrue("result has pserver ", list.contains(pserver));
318 public void storeCapTraversalTest() throws AAIException {
320 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
321 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
323 testEdgeRules.addEdge(g, gvnf, pserver);
324 testEdgeRules.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
326 GremlinTraversal<BulkSet<Vertex>> tQ = new GremlinTraversal<>(loader, g, gvnf, testEdgeRules);
327 tQ.createEdgeTraversal(EdgeType.COUSIN, "generic-vnf", "pserver").store("x").cap("x");
329 List<BulkSet<Vertex>> list = tQ.toList();
331 assertEquals("Has 2 vertexes ", 1, list.size());
332 assertEquals("result has pserver ",pserver, list.get(0).iterator().next());
338 public void storeCapUnfoldTraversalTest() throws AAIException {
340 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
341 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
343 testEdgeRules.addEdge(g, gvnf, pserver);
344 testEdgeRules.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
346 QueryBuilder<Vertex> tQ = getNewVertexTraversalWithTestEdgeRules(gvnf);
347 tQ.createEdgeTraversal(EdgeType.COUSIN, "generic-vnf", "pserver").store("x").cap("x").unfold();
349 List<Vertex> list = tQ.toList();
351 assertEquals("Has 2 vertexes ", 2, list.size());
352 assertTrue("result has pserver ", list.contains(pserver));
358 public void nextAndHasNextTraversalTest() throws AAIException {
360 Vertex v1 = g.addV("aai-node-type","vnfc","vnfc-name","a-name").next();
361 Vertex v2 = g.addV("aai-node-type","vnfc","vnfc-name","b-name").next();
363 QueryBuilder<Vertex> tQ = new GremlinTraversal<>(loader, g, testEdgeRules);
364 tQ.getVerticesByProperty("aai-node-type","vnfc");
366 List<Vertex> list = new ArrayList<>();
368 assertTrue("Has next 1 ",tQ.hasNext());
370 assertTrue("Has next 2 ",tQ.hasNext());
372 assertFalse("Has next 3 ",tQ.hasNext());
373 assertTrue("Has all the vertexes", list.contains(v1) && list.remove(v2));
378 public void edgeToVertexMultiRuleOutTraversalTest() throws AAIException {
380 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
381 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
383 testEdgeRules.addEdge(g, gvnf, pserver);
384 testEdgeRules.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
386 QueryBuilder<Vertex> tQ = getNewVertexTraversalWithTestEdgeRules(gvnf);
387 tQ.createEdgeTraversal(EdgeType.COUSIN, "generic-vnf", "pserver");
389 List<Vertex> list = tQ.toList();
391 assertEquals("Has 2 vertexes ", 2, list.size());
392 assertTrue("result has pserver ", list.contains(pserver));
398 public void edgeToVertexMultiRuleInTraversalTest() throws AAIException {
400 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
401 Vertex complex = g.addV("aai-node-type","complex","physical-location-id","a-name").next();
403 testEdgeRules.addEdge(g, gvnf, complex);
404 testEdgeRules.addEdge(g, gvnf, complex, "complex-generic-vnf-B");
406 QueryBuilder<Vertex> tQ = getNewVertexTraversalWithTestEdgeRules(gvnf);
407 tQ.createEdgeTraversal(EdgeType.COUSIN, "generic-vnf", "complex");
409 List<Vertex> list = tQ.toList();
411 assertEquals("Has 2 vertexes ", 2, list.size());
412 assertTrue("result has pserver ", list.contains(complex));
418 public void edgeTraversalSingleInRuleTest() throws AAIException {
420 Vertex vce = g.addV("aai-node-type","vce","vnf-id","vce").next();
421 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
423 Edge e = testEdgeRules.addEdge(g, vce, pserver);
425 QueryBuilder<Edge> tQ1 = getNewEdgeTraversalWithTestEdgeRules(vce);
426 tQ1.getEdgesBetween(EdgeType.COUSIN, "vce", "pserver");
428 List<Edge> list = tQ1.toList();
430 assertEquals("1 - Has 1 edge ", 1, list.size());
431 assertTrue("1 - traversal results in edge ", list.contains(e));
437 public void edgeTraversalSingleOutRuleTest() throws AAIException {
439 Vertex vce = g.addV("aai-node-type","vce","vnf-id","vce").next();
440 Vertex vnfc1 = g.addV("aai-node-type","vnfc","vnfc-name","a-name").next();
442 Edge e = testEdgeRules.addEdge(g, vce, vnfc1);
444 QueryBuilder<Edge> tQ1 = getNewEdgeTraversalWithTestEdgeRules(vce);
445 tQ1.getEdgesBetween(EdgeType.COUSIN, "vce", "vnfc");
447 List<Edge> list1 = tQ1.toList();
449 assertEquals("1 - Has 1 edge ", 1, list1.size());
450 assertTrue("1 - traversal results in edge ", list1.contains(e));
456 public void edgeTraversalMultiRuleOutTraversalTest() throws AAIException {
458 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
459 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
461 Edge e1 = testEdgeRules.addEdge(g, gvnf, pserver);
462 Edge e2 = testEdgeRules.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
464 QueryBuilder<Edge> tQ = getNewEdgeTraversalWithTestEdgeRules(gvnf);
465 tQ.getEdgesBetween(EdgeType.COUSIN, "generic-vnf", "pserver");
467 List<Edge> list = tQ.toList();
469 assertEquals("Has 2 edges ", 2, list.size());
470 assertTrue("result has default edge ", list.contains(e1));
471 assertTrue("result has other edge ", list.contains(e2));
477 public void edgeTraversalMultiRuleInTraversalTest() throws AAIException {
479 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
480 Vertex complex = g.addV("aai-node-type","complex","physical-location-id","a-name").next();
482 Edge e1 = testEdgeRules.addEdge(g, gvnf, complex);
483 Edge e2 = testEdgeRules.addEdge(g, gvnf, complex, "complex-generic-vnf-B");
485 QueryBuilder<Edge> tQ = getNewEdgeTraversalWithTestEdgeRules(gvnf);
486 tQ.getEdgesBetween(EdgeType.COUSIN, "generic-vnf", "complex");
488 List<Edge> list = tQ.toList();
490 assertEquals("Has 2 edges ", 2, list.size());
491 assertTrue("result has default edge ", list.contains(e1));
492 assertTrue("result has other edge ", list.contains(e2));
498 public void edgeTraversalMultiRuleTraversalTest() throws AAIException {
500 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
501 Vertex vnfc1 = g.addV("aai-node-type","vnfc","vnfc-name","a-name").next();
502 Vertex vnfc2 = g.addV("aai-node-type","vnfc","vnfc-name","b-name").next();
504 Edge e1 = testEdgeRules.addEdge(g, gvnf, vnfc1);
505 Edge e2 = testEdgeRules.addEdge(g, gvnf, vnfc2, "re-uses");
507 QueryBuilder<Edge> tQ = getNewEdgeTraversalWithTestEdgeRules(gvnf);
508 tQ.getEdgesBetween(EdgeType.COUSIN, "generic-vnf", "vnfc");
510 List<Edge> list = tQ.toList();
512 assertEquals("Has 2 edges ", 2, list.size());
513 assertTrue("result has default edge ", list.contains(e1));
514 assertTrue("result has other edge ", list.contains(e2));
519 @Test (expected = NoEdgeRuleFoundException.class)
520 public void getEdgesBetweenWithLabelsEmptyListTest() throws AAIException {
522 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
523 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
525 testEdgeRules.addEdge(g, gvnf, pserver);
526 testEdgeRules.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
528 QueryBuilder<Edge> tQ = getNewEdgeTraversalWithTestEdgeRules(gvnf);
529 tQ.getEdgesBetweenWithLabels(EdgeType.COUSIN, "generic-vnf", "pserver", Collections.emptyList());
534 public void getEdgesBetweenWithLabelsSingleItemTest() throws AAIException {
536 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
537 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
539 Edge e1 = testEdgeRules.addEdge(g, gvnf, pserver);
540 Edge e2 = testEdgeRules.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
542 QueryBuilder<Edge> tQ = getNewEdgeTraversalWithTestEdgeRules(gvnf);
543 tQ.getEdgesBetweenWithLabels(EdgeType.COUSIN, "generic-vnf", "pserver", Collections.singletonList("generic-vnf-pserver-B"));
545 List<Edge> list = tQ.toList();
547 assertEquals("Has 1 edges ", 1, list.size());
548 assertFalse("result does not have default edge ", list.contains(e1));
549 assertTrue("result has other edge ", list.contains(e2));
554 public void getEdgesBetweenWithLabelsMultipleItemTest() throws AAIException {
556 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
557 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
559 Edge e1 = testEdgeRules.addEdge(g, gvnf, pserver);
560 Edge e2 = testEdgeRules.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
562 QueryBuilder<Edge> tQ = getNewEdgeTraversalWithTestEdgeRules(gvnf);
563 tQ.getEdgesBetweenWithLabels(EdgeType.COUSIN, "generic-vnf", "pserver", Arrays.asList("generic-vnf-pserver-B", "generic-vnf-pserver-A"));
565 List<Edge> list = tQ.toList();
567 assertEquals("Has 2 edges ", 2, list.size());
568 assertTrue("result has generic-vnf-pserver-A edge ", list.contains(e1));
569 assertTrue("result has generic-vnf-pserver-B edge ", list.contains(e2));
573 @Test (expected = NoEdgeRuleFoundException.class)
574 public void createEdgeTraversalWithLabelsEmptyListTest() throws AAIException {
576 Vertex gvnf = getVertex();
578 QueryBuilder<Edge> tQ = getNewEdgeTraversalWithTestEdgeRules(gvnf);
579 tQ.getEdgesBetweenWithLabels(EdgeType.COUSIN, "generic-vnf", "pserver", Collections.emptyList());
586 private Vertex getVertex() throws AAIException {
587 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
588 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
590 testEdgeRules.addEdge(g, gvnf, pserver);
591 testEdgeRules.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
596 public void createEdgeTraversalWithLabelsSingleItemTest() throws AAIException {
598 Vertex gvnf = g.addV("aai-node-type","generic-vnf","vnf-id","gvnf").next();
599 Vertex pserver = g.addV("aai-node-type","pserver","hostname","a-name").next();
601 Edge e1 = testEdgeRules.addEdge(g, gvnf, pserver);
602 Edge e2 = testEdgeRules.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
604 QueryBuilder<Edge> tQ = getNewEdgeTraversalWithTestEdgeRules(gvnf);
605 tQ.getEdgesBetweenWithLabels(EdgeType.COUSIN, "generic-vnf", "pserver", Collections.singletonList("generic-vnf-pserver-B"));
607 List<Edge> list = tQ.toList();
609 assertEquals("Has 1 edges ", 1, list.size());
610 assertFalse("result does not have default edge ", list.contains(e1));
611 assertTrue("result has other edge ", list.contains(e2));
616 public void createEdgeTraversalWithLabelsMultipleItemTest() 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 Edge e1 = testEdgeRules.addEdge(g, gvnf, pserver);
622 Edge e2 = testEdgeRules.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
624 QueryBuilder<Edge> tQ = getNewEdgeTraversalWithTestEdgeRules(gvnf);
625 tQ.getEdgesBetweenWithLabels(EdgeType.COUSIN, "generic-vnf", "pserver", Arrays.asList("generic-vnf-pserver-B", "generic-vnf-pserver-A"));
627 List<Edge> list = tQ.toList();
629 assertEquals("Has 2 edges ", 2, list.size());
630 assertTrue("result has generic-vnf-pserver-A edge ", list.contains(e1));
631 assertTrue("result has generic-vnf-pserver-B edge ", list.contains(e2));
635 protected abstract QueryBuilder<Edge> getNewEdgeTraversalWithTestEdgeRules(Vertex v);
637 protected abstract QueryBuilder<Edge> getNewEdgeTraversalWithTestEdgeRules();
639 protected abstract QueryBuilder<Vertex> getNewVertexTraversalWithTestEdgeRules(Vertex v);
641 protected abstract QueryBuilder<Vertex> getNewVertexTraversalWithTestEdgeRules();
643 protected abstract QueryBuilder<Tree> getNewTreeTraversalWithTestEdgeRules(Vertex v);
645 protected abstract QueryBuilder<Tree> getNewTreeTraversalWithTestEdgeRules();