aai-core/src/test/java/org/onap/aai/query/builder/TraversalQueryTest.java

   1 /**
   2  * ============LICENSE_START=======================================================
   3  * org.onap.aai
   4  * ================================================================================
   5  * Copyright © 2017-2018 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Modifications Copyright © 2024 DEUTSCHE TELEKOM AG.
   8  * ================================================================================
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *    http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  * ============LICENSE_END=========================================================
  21  */
  22
  23 package org.onap.aai.query.builder;
  24
  25 import static org.junit.Assert.assertEquals;
  26 import static org.junit.Assert.assertTrue;
  27
  28 import java.io.UnsupportedEncodingException;
  29 import java.net.URI;
  30 import java.net.URISyntaxException;
  31 import java.util.List;
  32
  33 import org.apache.tinkerpop.gremlin.process.traversal.Path;
  34 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
  35 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
  36 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
  37 import org.apache.tinkerpop.gremlin.process.traversal.step.util.Tree;
  38 import org.apache.tinkerpop.gremlin.structure.Edge;
  39 import org.apache.tinkerpop.gremlin.structure.Vertex;
  40 import org.janusgraph.core.JanusGraph;
  41 import org.janusgraph.core.JanusGraphFactory;
  42 import org.junit.Ignore;
  43 import org.junit.Test;
  44 import org.junit.experimental.categories.Category;
  45 import org.onap.aai.TinkerpopUpgrade;
  46 import org.onap.aai.db.props.AAIProperties;
  47 import org.onap.aai.edges.enums.EdgeType;
  48 import org.onap.aai.exceptions.AAIException;
  49 import org.onap.aai.introspection.Introspector;
  50 import org.onap.aai.introspection.Loader;
  51 import org.onap.aai.introspection.LoaderUtil;
  52 import org.onap.aai.introspection.exceptions.AAIUnknownObjectException;
  53
  54 @Category(TinkerpopUpgrade.class)
  55 public class TraversalQueryTest extends QueryBuilderTestAbstraction {
  56
  57     @Override
  58     protected QueryBuilder<Edge> getNewEdgeTraversalWithTestEdgeRules(Vertex v) {
  59         return new TraversalQuery<>(loader, g, v);
  60     }
  61
  62     @Override
  63     protected QueryBuilder<Edge> getNewEdgeTraversalWithTestEdgeRules() {
  64         return new TraversalQuery<>(loader, g);
  65     }
  66
  67     @Override
  68     protected QueryBuilder<Vertex> getNewVertexTraversalWithTestEdgeRules(Vertex v) {
  69         return new TraversalQuery<>(loader, g, v);
  70     }
  71
  72     @Override
  73     protected QueryBuilder<Vertex> getNewVertexTraversalWithTestEdgeRules() {
  74         return new TraversalQuery<>(loader, g);
  75     }
  76
  77     protected QueryBuilder<Vertex> getNewVertexTraversal() {
  78         return new TraversalQuery<>(loader, g);
  79     }
  80
  81     @Override
  82     protected QueryBuilder<Tree> getNewTreeTraversalWithTestEdgeRules(Vertex v) {
  83         return new TraversalQuery<>(loader, g, v);
  84     }
  85
  86     @Override
  87     protected QueryBuilder<Tree> getNewTreeTraversalWithTestEdgeRules() {
  88         return new TraversalQuery<>(loader, g);
  89     }
  90
  91     @Override
  92     protected QueryBuilder<Path> getNewPathTraversalWithTestEdgeRules(Vertex v) {
  93         return new TraversalQuery<>(loader, g, v);
  94     }
  95
  96     @Override
  97     protected QueryBuilder<Path> getNewPathTraversalWithTestEdgeRules() {
  98         return new TraversalQuery<>(loader, g);
  99     }
 100
 101     @Test
 102     public void unionQuery() {
 103         QueryBuilder<Vertex> tQ = getNewVertexTraversal();
 104         QueryBuilder<Vertex> tQ2 = getNewVertexTraversal();
 105         QueryBuilder<Vertex> tQ3 = getNewVertexTraversal();
 106         tQ.union(tQ2.getVerticesByProperty("test1", "value1"), tQ3.getVerticesByIndexedProperty("test2", "value2"));
 107
 108         GraphTraversal<Vertex, Vertex> expected =
 109                 __.<Vertex>start().union(__.has("test1", "value1"), __.has("test2", "value2"));
 110
 111         assertEquals("they are equal", expected, tQ.getQuery());
 112
 113     }
 114
 115     @Test
 116     public void traversalClones() throws UnsupportedEncodingException, AAIException, URISyntaxException {
 117         QueryBuilder<Vertex> tQ = getNewVertexTraversal();
 118         QueryBuilder<Vertex> builder =
 119                 tQ.createQueryFromURI(new URI("network/generic-vnfs/generic-vnf/key1")).getQueryBuilder();
 120         GraphTraversal<Vertex, Vertex> expected =
 121                 __.<Vertex>start().has("vnf-id", "key1").has("aai-node-type", "generic-vnf");
 122         GraphTraversal<Vertex, Vertex> containerExpected = __.<Vertex>start().has("aai-node-type", "generic-vnf");
 123
 124         assertEquals("query object", expected.toString(), builder.getQuery().toString());
 125         assertEquals("container query object", containerExpected.toString(),
 126                 builder.getContainerQuery().getQuery().toString());
 127
 128     }
 129
 130     // TODO - Identify why this unit test is failing and if this
 131     // is going to cause any problems
 132     @Test
 133     @Ignore("Not working ever since the change to using model driven development")
 134     public void nestedTraversalClones() throws UnsupportedEncodingException, AAIException, URISyntaxException {
 135
 136         QueryBuilder<Vertex> tQ = getNewVertexTraversal();
 137         QueryBuilder<Vertex> builder =
 138                 tQ.createQueryFromURI(new URI("network/generic-vnfs/generic-vnf/key1/l-interfaces/l-interface/key2"))
 139                         .getQueryBuilder();
 140         GraphTraversal<Vertex, Vertex> expected = __.<Vertex>start().has("vnf-id", "key1")
 141                 .has("aai-node-type", "generic-vnf").in("org.onap.relationships.inventory.BelongsTo")
 142                 .has(AAIProperties.NODE_TYPE, "l-interface").has("interface-name", "key2");
 143         GraphTraversal<Vertex, Vertex> containerExpected =
 144                 __.<Vertex>start().has("vnf-id", "key1").has("aai-node-type", "generic-vnf")
 145                         .in("org.onap.relationships.inventory.BelongsTo").has(AAIProperties.NODE_TYPE, "l-interface");
 146
 147         assertEquals("query object", expected.toString(), builder.getQuery().toString());
 148         assertEquals("container query object", containerExpected.toString(),
 149                 builder.getContainerQuery().getQuery().toString());
 150
 151     }
 152
 153     @Test
 154     public void abstractEdgeToVertexTraversalTest() throws AAIException {
 155
 156         Vertex gvnf = this.addVHelper(g, "vertex", "aai-node-type", "generic-vnf", "vnf-id", "gvnf").next();
 157         Vertex vnfc1 = this.addVHelper(g, "vertex", "aai-node-type", "vnfc", "vnfc-name", "a-name").next();
 158
 159         testEdgeSer.addEdge(g, gvnf, vnfc1);
 160
 161         QueryBuilder<Vertex> tQ = getNewVertexTraversalWithTestEdgeRules(gvnf);
 162         tQ.createEdgeTraversal(EdgeType.COUSIN, "vnf", "vnfc");
 163
 164         List<Vertex> list = tQ.toList();
 165
 166         assertEquals("Has 1 vertexes ", 1, list.size());
 167         assertTrue("Has vertex on the default edge ", list.contains(vnfc1));
 168
 169     }
 170
 171     @Test
 172     public void abstractEdgeToVertexTraversalSingleOutRuleTest() throws AAIException {
 173
 174         Vertex vce = this.addVHelper(g, "vertex", "aai-node-type", "vce", "vnf-id", "vce").next();
 175         Vertex vnfc1 = this.addVHelper(g, "vertex", "aai-node-type", "vnfc", "vnfc-name", "a-name").next();
 176
 177         testEdgeSer.addEdge(g, vce, vnfc1);
 178
 179         QueryBuilder<Vertex> tQ1 = getNewVertexTraversalWithTestEdgeRules(vce);
 180         tQ1.createEdgeTraversal(EdgeType.COUSIN, "vnf", "vnfc");
 181
 182         QueryBuilder<Vertex> tQ2 = getNewVertexTraversalWithTestEdgeRules(vnfc1);
 183         tQ2.createEdgeTraversal(EdgeType.COUSIN, "vnfc", "vnf");
 184
 185         List<Vertex> list1 = tQ1.toList();
 186         List<Vertex> list2 = tQ2.toList();
 187
 188         assertEquals("1 - Has 1 vertexes ", 1, list1.size());
 189         assertTrue("1 - traversal results in vnfc ", list1.contains(vnfc1));
 190         assertEquals("2 - Has 1 vertexes ", 1, list2.size());
 191         assertTrue("2 - traversal results in vce ", list2.contains(vce));
 192
 193     }
 194
 195     @Test
 196     public void abstractEdgeToVertexTraversalSingleInRuleTest() throws AAIException {
 197
 198         Vertex vce = this.addVHelper(g, "vertex", "aai-node-type", "vce", "vnf-id", "vce").next();
 199         Vertex pserver = this.addVHelper(g, "vertex", "aai-node-type", "pserver", "hostname", "a-name").next();
 200
 201         testEdgeSer.addEdge(g, vce, pserver);
 202
 203         QueryBuilder<Vertex> tQ1 = getNewVertexTraversalWithTestEdgeRules(vce);
 204         tQ1.createEdgeTraversal(EdgeType.COUSIN, "vnf", "pserver");
 205
 206         List<Vertex> list = tQ1.toList();
 207
 208         assertEquals("1 - Has 1 vertexes ", 1, list.size());
 209         assertTrue("1 - traversal results in vnfc ", list.contains(pserver));
 210
 211     }
 212
 213     @Test
 214     public void abstractEdgeToVertexMultiRuleTraversalTest() throws AAIException {
 215
 216         Vertex gvnf = this.addVHelper(g, "vertex", "aai-node-type", "generic-vnf", "vnf-id", "gvnf").next();
 217         Vertex vnfc1 = this.addVHelper(g, "vertex", "aai-node-type", "vnfc", "vnfc-name", "a-name").next();
 218         Vertex vnfc2 = this.addVHelper(g, "vertex", "aai-node-type", "vnfc", "vnfc-name", "b-name").next();
 219
 220         testEdgeSer.addEdge(g, gvnf, vnfc1);
 221         testEdgeSer.addEdge(g, gvnf, vnfc2, "re-uses");
 222
 223         QueryBuilder<Vertex> tQ = getNewVertexTraversalWithTestEdgeRules(gvnf);
 224         tQ.createEdgeTraversal(EdgeType.COUSIN, "vnf", "vnfc");
 225
 226         List<Vertex> list = tQ.toList();
 227
 228         assertEquals("Has 2 vertexes ", 2, list.size());
 229         assertTrue("Has vertex on the default edge ", list.contains(vnfc1));
 230         assertTrue("Has vertex on the re-uses edge ", list.contains(vnfc2));
 231
 232     }
 233
 234     @Test
 235     public void abstractEdgeToVertexMultiRuleOutTraversalTest() throws AAIException {
 236
 237         Vertex gvnf = this.addVHelper(g, "vertex", "aai-node-type", "generic-vnf", "vnf-id", "gvnf").next();
 238         Vertex pserver = this.addVHelper(g, "vertex", "aai-node-type", "pserver", "hostname", "a-name").next();
 239
 240         testEdgeSer.addEdge(g, gvnf, pserver);
 241         testEdgeSer.addEdge(g, gvnf, pserver, "generic-vnf-pserver-B");
 242
 243         QueryBuilder<Vertex> tQ = getNewVertexTraversalWithTestEdgeRules(gvnf);
 244         tQ.createEdgeTraversal(EdgeType.COUSIN, "vnf", "pserver");
 245
 246         List<Vertex> list = tQ.toList();
 247
 248         assertEquals("Has 2 vertexes ", 2, list.size());
 249         assertTrue("result has pserver ", list.contains(pserver));
 250
 251     }
 252
 253     @Test
 254     public void abstractEdgeToVertexMultiRuleInTraversalTest() throws AAIException {
 255
 256         Vertex gvnf = this.addVHelper(g, "vertex", "aai-node-type", "generic-vnf", "vnf-id", "gvnf").next();
 257         Vertex complex =
 258                 this.addVHelper(g, "vertex", "aai-node-type", "complex", "physical-location-id", "a-name").next();
 259
 260         testEdgeSer.addEdge(g, gvnf, complex);
 261         testEdgeSer.addEdge(g, gvnf, complex, "complex-generic-vnf-B");
 262
 263         QueryBuilder<Vertex> tQ = getNewVertexTraversalWithTestEdgeRules(gvnf);
 264         tQ.createEdgeTraversal(EdgeType.COUSIN, "vnf", "complex");
 265
 266         List<Vertex> list = tQ.toList();
 267
 268         assertEquals("Has 2 vertexes ", 2, list.size());
 269         assertTrue("result has pserver ", list.contains(complex));
 270
 271     }
 272
 273     @Test
 274     public void createDBQueryTest() throws AAIUnknownObjectException {
 275         JanusGraph graph = JanusGraphFactory.build().set("storage.backend", "inmemory").open();
 276         GraphTraversalSource source = graph.newTransaction().traversal();
 277         final Loader loader = LoaderUtil.getLatestVersion();
 278         GraphTraversal<Vertex, Vertex> traversal = __.<Vertex>start();
 279         TraversalQuery traversalQuery = new TraversalQuery<>(loader, source, traversal);
 280         Introspector obj = loader.introspectorFromName("vpn-binding");
 281         obj.setValue("vpn-id", "modifyKey");
 282
 283         traversalQuery.createKeyQuery(obj);
 284         assertEquals(1, traversal.asAdmin().getSteps().size());
 285         assertEquals("HasStep([vpn-id.eq(modifyKey)])", traversal.asAdmin().getSteps().get(0).toString());
 286         traversalQuery.createContainerQuery(obj);
 287         assertEquals(1, traversal.asAdmin().getSteps().size());
 288         assertEquals("HasStep([vpn-id.eq(modifyKey), aai-node-type.eq(vpn-binding)])", traversal.asAdmin().getSteps().get(0).toString());
 289     }
 290
 291     @Test
 292     public void removeQueryStepsBetweenTest() throws AAIUnknownObjectException {
 293         JanusGraph graph = JanusGraphFactory.build().set("storage.backend", "inmemory").open();
 294         GraphTraversalSource source = graph.newTransaction().traversal();
 295         final Loader loader = LoaderUtil.getLatestVersion();
 296         TraversalQuery traversalQuery = new TraversalQuery<>(loader, source);
 297         traversalQuery.has("propertyKey", "value");
 298
 299         QueryBuilder clonedQuery = traversalQuery.removeQueryStepsBetween(0, 1);
 300         String query = clonedQuery.getQuery().toString();
 301         assertEquals("[HasStep([propertyKey.eq(value)])]", query);
 302     }
 303
 304     @Test
 305     public void removeQueryStepsBetweenTest02() throws AAIUnknownObjectException {
 306         JanusGraph graph = JanusGraphFactory.build().set("storage.backend", "inmemory").open();
 307         GraphTraversalSource source = graph.newTransaction().traversal();
 308         final Loader loader = LoaderUtil.getLatestVersion();
 309         TraversalQuery traversalQuery = new TraversalQuery<>(loader, source);
 310         traversalQuery.has("propertyKey", "value");
 311
 312         QueryBuilder clonedQuery = traversalQuery.removeQueryStepsBetween(0, 2);
 313         String query = clonedQuery.getQuery().toString();
 314         assertEquals("[]", query);
 315     }
 316
 317     @Test
 318     public void removeQueryStepsBetweenTest07() throws AAIUnknownObjectException {
 319         JanusGraph graph = JanusGraphFactory.build().set("storage.backend", "inmemory").open();
 320         GraphTraversalSource source = graph.newTransaction().traversal();
 321         final Loader loader = LoaderUtil.getLatestVersion();
 322         TraversalQuery traversalQuery = new TraversalQuery<>(loader, source);
 323         traversalQuery.limit(1);
 324         traversalQuery.has("propertyKey", "value");
 325         traversalQuery.has("propertyKey2", "value2");
 326         traversalQuery.limit(2);
 327         traversalQuery.has("propertyKey3", "value3");
 328         traversalQuery.has("propertyKey4", "value4");
 329         traversalQuery.has("propertyKey5", "value5");
 330         traversalQuery.limit(3);
 331         traversalQuery.limit(4);
 332
 333         QueryBuilder clonedQuery = traversalQuery.removeQueryStepsBetween(0, 7);
 334         String query = clonedQuery.getQuery().toString();
 335         assertEquals("[HasStep([propertyKey5.eq(value5)]), RangeGlobalStep(0,3), RangeGlobalStep(0,4)]", query);
 336     }
 337
 338     @Test
 339     @Ignore("Enable once removeQueryStepsBetween supports a start index > 0")
 340     public void removeQueryStepsBetweenTest27() throws AAIUnknownObjectException {
 341         JanusGraph graph = JanusGraphFactory.build().set("storage.backend", "inmemory").open();
 342         GraphTraversalSource source = graph.newTransaction().traversal();
 343         final Loader loader = LoaderUtil.getLatestVersion();
 344         TraversalQuery traversalQuery = new TraversalQuery<>(loader, source);
 345         traversalQuery.limit(1);
 346         traversalQuery.has("propertyKey", "value");
 347         traversalQuery.has("propertyKey2", "value2");
 348         traversalQuery.limit(2);
 349         traversalQuery.has("propertyKey3", "value3");
 350         traversalQuery.has("propertyKey4", "value4");
 351         traversalQuery.has("propertyKey5", "value5");
 352         traversalQuery.limit(3);
 353         traversalQuery.limit(4);
 354
 355         QueryBuilder clonedQuery = traversalQuery.removeQueryStepsBetween(2, 7);
 356         String query = clonedQuery.getQuery().toString();
 357         assertEquals("[RangeGlobalStep(0,1), HasStep([propertyKey.eq(value)]), HasStep([propertyKey5.eq(value5)]), RangeGlobalStep(0,3), RangeGlobalStep(0,4)]", query);
 358     }
 359
 360 }