aai-core/src/test/java/org/onap/aai/serialization/engines/query/GraphTraversalQueryEngineTest.java

   1 /**
   2  * ============LICENSE_START=======================================================
   3  * org.onap.aai
   4  * ================================================================================
   5  * Copyright © 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *    http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  *
  20  * ECOMP is a trademark and service mark of AT&T Intellectual Property.
  21  */
  22
  23 package org.onap.aai.serialization.engines.query;
  24
  25 import static org.junit.Assert.*;
  26
  27 import java.util.ArrayList;
  28 import java.util.Arrays;
  29 import java.util.HashSet;
  30 import java.util.Iterator;
  31 import java.util.List;
  32 import java.util.Set;
  33
  34 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
  35 import org.apache.tinkerpop.gremlin.process.traversal.step.util.Tree;
  36 import org.apache.tinkerpop.gremlin.structure.Direction;
  37 import org.apache.tinkerpop.gremlin.structure.Edge;
  38 import org.apache.tinkerpop.gremlin.structure.Element;
  39 import org.apache.tinkerpop.gremlin.structure.Graph;
  40 import org.apache.tinkerpop.gremlin.structure.T;
  41 import org.apache.tinkerpop.gremlin.structure.Vertex;
  42 import org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerGraph;
  43 import org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerVertex;
  44 import org.junit.Test;
  45 import org.onap.aai.AAISetup;
  46 import org.onap.aai.exceptions.AAIException;
  47 import org.onap.aai.introspection.Loader;
  48 import org.onap.aai.introspection.LoaderFactory;
  49 import org.onap.aai.introspection.ModelType;
  50 import org.onap.aai.introspection.Version;
  51 import org.onap.aai.serialization.db.EdgeRules;
  52
  53 public class GraphTraversalQueryEngineTest extends AAISetup {
  54
  55         @Test
  56         public void testFindParents() throws AAIException {
  57                 //setup
  58                 EdgeRules rules = EdgeRules.getInstance();
  59                 Graph graph = TinkerGraph.open();
  60
  61                 Vertex cloudreg = graph.addVertex(T.id, "00", "aai-node-type", "cloud-region");
  62                 Vertex tenant = graph.addVertex(T.id, "10", "aai-node-type", "tenant");
  63                 Vertex vserver = graph.addVertex(T.id, "20", "aai-node-type", "vserver");
  64
  65                 GraphTraversalSource g = graph.traversal();
  66
  67                 rules.addTreeEdge(g, cloudreg, tenant);
  68                 rules.addTreeEdge(g, tenant, vserver);
  69
  70                 //expect start vertex back plus any parents
  71                 List<Vertex> crExpected = new ArrayList<>(Arrays.asList(cloudreg)); //no parents
  72                 List<Vertex> tenExpected = new ArrayList<>(Arrays.asList(tenant, cloudreg)); //only has the immediate parent
  73                 List<Vertex> vsExpected = new ArrayList<>(Arrays.asList(vserver, tenant, cloudreg)); //parent & grandparent
  74
  75                 GraphTraversalQueryEngine engine = new GraphTraversalQueryEngine(g);
  76
  77                 //test
  78                 List<Vertex> crRes = engine.findParents(cloudreg);
  79                 assertTrue(crRes.containsAll(crExpected) && crExpected.containsAll(crRes));
  80
  81                 List<Vertex> tenRes = engine.findParents(tenant);
  82                 assertTrue(tenRes.containsAll(tenExpected) && tenExpected.containsAll(tenRes));
  83
  84                 List<Vertex> vsRes = engine.findParents(vserver);
  85                 assertTrue(vsRes.containsAll(vsExpected) && vsExpected.containsAll(vsRes));
  86                 //verify expected ordering - start, parent, grandparent
  87                 assertTrue(vsRes.get(0).equals(vserver));
  88                 assertTrue(vsRes.get(1).equals(tenant));
  89                 assertTrue(vsRes.get(2).equals(cloudreg));
  90         }
  91
  92         @Test
  93         public void testFindAllChildren() throws AAIException {
  94                 //setup
  95                 EdgeRules rules = EdgeRules.getInstance();
  96                 Graph graph = TinkerGraph.open();
  97
  98                 Vertex cloudreg = graph.addVertex(T.id, "00", "aai-node-type", "cloud-region");
  99                 Vertex tenant = graph.addVertex(T.id, "10", "aai-node-type", "tenant");
 100                 Vertex vserver = graph.addVertex(T.id, "20", "aai-node-type", "vserver");
 101                 Vertex vserver2 = graph.addVertex(T.id, "21", "aai-node-type", "vserver");
 102                 Vertex oam = graph.addVertex(T.id, "30", "aai-node-type", "oam-network");
 103
 104                 GraphTraversalSource g = graph.traversal();
 105
 106                 rules.addTreeEdge(g, cloudreg, tenant);
 107                 rules.addTreeEdge(g, tenant, vserver);
 108                 rules.addTreeEdge(g, tenant, vserver2);
 109                 rules.addTreeEdge(g, cloudreg, oam);
 110
 111                 List<Vertex> crExpected = new ArrayList<>(Arrays.asList(cloudreg, tenant, vserver, vserver2, oam));
 112                 List<Vertex> vsExpected = new ArrayList<>(Arrays.asList(vserver));
 113
 114                 GraphTraversalQueryEngine engine = new GraphTraversalQueryEngine(g);
 115
 116                 //test
 117                 List<Vertex> crRes = engine.findAllChildren(cloudreg);
 118                 assertTrue(crRes.containsAll(crExpected) && crExpected.containsAll(crRes));
 119
 120                 List<Vertex> vsRes = engine.findAllChildren(vserver);
 121                 assertTrue(vsRes.containsAll(vsExpected) && vsExpected.containsAll(vsRes));
 122         }
 123
 124         @Test
 125         public void testFindChildrenOfType() throws AAIException {
 126                 //setup
 127                 EdgeRules rules = EdgeRules.getInstance();
 128                 Graph graph = TinkerGraph.open();
 129
 130                 Vertex gv = graph.addVertex(T.id, "00", "aai-node-type", "generic-vnf");
 131                 Vertex lint1 = graph.addVertex(T.id, "10", "aai-node-type", "l-interface");
 132                 Vertex lint2 = graph.addVertex(T.id, "11", "aai-node-type", "l-interface");
 133                 Vertex lag = graph.addVertex(T.id, "20", "aai-node-type", "lag-interface");
 134                 Vertex lint3 = graph.addVertex(T.id, "12", "aai-node-type", "l-interface");
 135
 136                 GraphTraversalSource g = graph.traversal();
 137
 138                 rules.addTreeEdge(g, gv, lint1);
 139                 rules.addTreeEdge(g, gv, lint2);
 140                 rules.addTreeEdge(g, gv, lag);
 141                 rules.addTreeEdge(g, lag, lint3);
 142
 143                 List<Vertex> expected = new ArrayList<>(Arrays.asList(lint1, lint2));
 144
 145                 GraphTraversalQueryEngine engine = new GraphTraversalQueryEngine(g);
 146
 147                 //test
 148                 List<Vertex> results = engine.findChildrenOfType(gv, "l-interface");
 149                 assertTrue(results.containsAll(expected) && expected.containsAll(results));
 150         }
 151
 152         @Test
 153         public void testFindChildren() throws AAIException {
 154                 //setup
 155                 EdgeRules rules = EdgeRules.getInstance();
 156                 Graph graph = TinkerGraph.open();
 157
 158                 Vertex gv = graph.addVertex(T.id, "00", "aai-node-type", "generic-vnf");
 159                 Vertex lint1 = graph.addVertex(T.id, "10", "aai-node-type", "l-interface");
 160                 Vertex lint2 = graph.addVertex(T.id, "11", "aai-node-type", "l-interface");
 161                 Vertex lag = graph.addVertex(T.id, "20", "aai-node-type", "lag-interface");
 162                 Vertex lint3 = graph.addVertex(T.id, "12", "aai-node-type", "l-interface");
 163
 164                 GraphTraversalSource g = graph.traversal();
 165
 166                 rules.addTreeEdge(g, gv, lint1);
 167                 rules.addTreeEdge(g, gv, lint2);
 168                 rules.addTreeEdge(g, gv, lag);
 169                 rules.addTreeEdge(g, lag, lint3);
 170
 171                 List<Vertex> expected = new ArrayList<>(Arrays.asList(lint1, lint2, lag));
 172
 173                 GraphTraversalQueryEngine engine = new GraphTraversalQueryEngine(g);
 174
 175                 //test
 176                 List<Vertex> results = engine.findChildren(gv);
 177                 assertTrue(results.containsAll(expected) && expected.containsAll(results));
 178         }
 179
 180         @Test
 181         public void testFindDeletable() throws AAIException {
 182                 //setup
 183                 EdgeRules rules = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
 184
 185                 Graph graph = TinkerGraph.open();
 186                 Vertex parent = graph.addVertex(T.id, "00", "aai-node-type", "test-parent");
 187                 Vertex child = graph.addVertex(T.id, "10", "aai-node-type", "test-child");
 188                 Vertex cousin = graph.addVertex(T.id, "20", "aai-node-type", "test-cousin");
 189                 Vertex grandchild = graph.addVertex(T.id, "30", "aai-node-type", "test-grandchild");
 190
 191                 GraphTraversalSource g = graph.traversal();
 192
 193                 rules.addTreeEdge(g, parent, child); //delete-other-v=none, no cascade
 194                 rules.addTreeEdge(g, child, grandchild); //d-o-v=out, yes from child
 195                 rules.addEdge(g, cousin, child); //d-o-v=out, yes from cousin
 196
 197                 List<Vertex> parentExpected = new ArrayList<>(Arrays.asList(parent));
 198                 List<Vertex> childExpected = new ArrayList<>(Arrays.asList(child, grandchild));
 199                 List<Vertex> cousinExpected = new ArrayList<>(Arrays.asList(cousin, child, grandchild));
 200
 201                 GraphTraversalQueryEngine engine = new GraphTraversalQueryEngine(g);
 202
 203                 //tests
 204                 List<Vertex> parentDeletes = engine.findDeletable(parent);
 205                 assertTrue(parentExpected.containsAll(parentDeletes) && parentDeletes.containsAll(parentExpected));
 206
 207                 List<Vertex> childDeletes = engine.findDeletable(child);
 208                 assertTrue(childExpected.containsAll(childDeletes) && childDeletes.containsAll(childExpected));
 209
 210                 List<Vertex> cousinDeletes = engine.findDeletable(cousin);
 211                 assertTrue(cousinExpected.containsAll(cousinDeletes) && cousinDeletes.containsAll(cousinExpected));
 212         }
 213
 214         @Test
 215         public void testFindRelatedVertices() throws AAIException {
 216                 //setup
 217                 EdgeRules rules = EdgeRules.getInstance();
 218
 219                 Graph graph = TinkerGraph.open();
 220
 221                 Vertex gv = graph.addVertex(T.id, "00", "aai-node-type", "generic-vnf");
 222                 Vertex lint = graph.addVertex(T.id, "10", "aai-node-type", "l-interface");
 223                 Vertex lint2 = graph.addVertex(T.id, "11", "aai-node-type", "l-interface");
 224                 Vertex log = graph.addVertex(T.id, "20", "aai-node-type", "logical-link");
 225
 226                 GraphTraversalSource g = graph.traversal();
 227
 228                 rules.addTreeEdge(g, gv, lint);
 229                 rules.addEdge(g, lint, log);
 230                 rules.addEdge(g, log, lint2);
 231
 232                 List<Vertex> outExpected = new ArrayList<>(Arrays.asList(lint));
 233                 List<Vertex> inExpected = new ArrayList<>(Arrays.asList(lint, lint2));
 234                 List<Vertex> bothExpected = new ArrayList<>(Arrays.asList(log));
 235
 236                 GraphTraversalQueryEngine engine = new GraphTraversalQueryEngine(g);
 237
 238                 //test
 239                 List<Vertex> outRes = engine.findRelatedVertices(gv, Direction.OUT, "hasLInterface", "l-interface");
 240                 assertTrue(outRes.containsAll(outExpected) && outExpected.containsAll(outRes));
 241
 242                 List<Vertex> inRes = engine.findRelatedVertices(log, Direction.IN, "usesLogicalLink", "l-interface");
 243                 assertTrue(inRes.containsAll(inExpected) && inExpected.containsAll(inRes));
 244
 245                 List<Vertex> bothRes = engine.findRelatedVertices(lint, Direction.BOTH, "usesLogicalLink", "logical-link");
 246                 assertTrue(bothRes.containsAll(bothExpected) && bothExpected.containsAll(bothRes));
 247         }
 248
 249         @Test
 250         public void testFindSubGraph() throws AAIException {
 251                 //setup
 252                 EdgeRules rules = EdgeRules.getInstance();
 253                 Graph graph = TinkerGraph.open();
 254
 255                 Vertex cr = graph.addVertex(T.id, "00", "aai-node-type", "cloud-region");
 256                 Vertex ten = graph.addVertex(T.id, "10", "aai-node-type", "tenant");
 257                 Vertex ten2 = graph.addVertex(T.id, "11", "aai-node-type", "tenant");
 258                 Vertex vs = graph.addVertex(T.id, "20", "aai-node-type", "vserver");
 259                 Vertex vs2 = graph.addVertex(T.id, "21", "aai-node-type", "vserver");
 260                 Vertex lint = graph.addVertex(T.id, "30", "aai-node-type", "l-interface");
 261                 Vertex comp = graph.addVertex(T.id, "40", "aai-node-type", "complex");
 262                 Vertex ctag = graph.addVertex(T.id, "50", "aai-node-type", "ctag-pool");
 263                 Vertex gv = graph.addVertex(T.id, "60", "aai-node-type", "generic-vnf");
 264                 Vertex lag = graph.addVertex(T.id, "70", "aai-node-type", "lag-interface");
 265                 Vertex lint2 = graph.addVertex(T.id, "31", "aai-node-type", "l-interface");
 266                 Vertex log = graph.addVertex(T.id, "80", "aai-node-type", "logical-link");
 267                 Vertex vnfc = graph.addVertex(T.id, "90", "aai-node-type", "vnfc");
 268
 269                 GraphTraversalSource g = graph.traversal();
 270
 271                 Edge crTen = rules.addTreeEdge(g, cr, ten);
 272                 Edge crTen2 = rules.addTreeEdge(g, cr, ten2);
 273                 Edge tenVs = rules.addTreeEdge(g, ten, vs);
 274                 Edge tenVs2 = rules.addTreeEdge(g, ten, vs2);
 275                 Edge vsLInt = rules.addTreeEdge(g, vs, lint);
 276                 Edge lintLog = rules.addEdge(g, lint, log);
 277                 Edge vsGv = rules.addEdge(g, vs, gv);
 278                 rules.addEdge(g, gv, vnfc);
 279
 280                 rules.addTreeEdge(g, gv, lag);
 281                 rules.addTreeEdge(g, lag, lint2);
 282
 283                 rules.addTreeEdge(g, comp, ctag);
 284                 Edge crComp = rules.addEdge(g, cr, comp);
 285
 286                 //findSubGraph(cr, 0, true)
 287                 List<Element> expected1 = new ArrayList<>(Arrays.asList(cr));
 288                 //findSubGraph(cr, 2, true)
 289                 List<Element> expected2 = new ArrayList<>(Arrays.asList(cr, ten, ten2, vs, vs2,
 290                                                                                                                                         crTen, crTen2, tenVs, tenVs2));
 291                 //findSubGraph(cr)
 292                 List<Element> expected3 = new ArrayList<>(Arrays.asList(cr, ten, ten2, comp, vs, vs2, lint, gv, log,
 293                                                                                                                                 crTen, crTen2, crComp, tenVs, tenVs2, vsLInt,
 294                                                                                                                                 vsGv, lintLog));
 295
 296                 GraphTraversalQueryEngine engine = new GraphTraversalQueryEngine(g);
 297
 298                 //test
 299                 Tree<Element> res1 = engine.findSubGraph(cr, 0, true);
 300                 Set<Element> resList1 = treeToList(res1);
 301                 assertTrue(resList1.containsAll(expected1) && expected1.containsAll(resList1));
 302
 303                 Tree<Element> res2 = engine.findSubGraph(cr, 2, true);
 304                 Set<Element> resList2 = treeToList(res2);
 305                 assertTrue(resList2.containsAll(expected2) && expected2.containsAll(resList2));
 306
 307                 Tree<Element> res3 = engine.findSubGraph(cr);
 308                 Set<Element> resList3 = treeToList(res3);
 309                 assertTrue(resList3.containsAll(expected3) && expected3.containsAll(resList3));
 310         }
 311
 312         /**
 313          * convenience helper method to make it easier to check the contents of the tree against
 314          * a list of expected results
 315          * @param tree - the tree whose contents you want in collection form
 316          * @return set of the contents of the tree
 317          */
 318         private Set<Element> treeToList(Tree<Element> tree) {
 319                 Set<Element> ret = new HashSet<>();
 320
 321                 for (Element key : tree.keySet()) {
 322                         ret.add(key);
 323                         ret.addAll(treeToList(tree.get(key)));
 324                 }
 325
 326                 return ret;
 327         }
 328
 329         @Test
 330         public void testFindEdgesForVersion() throws AAIException {
 331                 //setup
 332                 EdgeRules rules = EdgeRules.getInstance();
 333                 Graph graph = TinkerGraph.open();
 334
 335                 Vertex gv = graph.addVertex(T.id, "00", "aai-node-type", "generic-vnf");
 336                 Vertex vnfc = graph.addVertex(T.id, "10", "aai-node-type", "vnfc");
 337                 Vertex lob = graph.addVertex(T.id, "20", "aai-node-type", "line-of-business");
 338                 Vertex lint = graph.addVertex(T.id, "30", "aai-node-type", "l-interface");
 339
 340                 GraphTraversalSource g = graph.traversal();
 341
 342                 rules.addTreeEdge(g, gv, lint); //tree edge so shouldn't appear in results
 343                 Edge gvVnfc = rules.addEdge(g, gv, vnfc);
 344                 rules.addEdge(g, gv, lob); //v11/12 not v10
 345
 346                 List<Edge> expected = new ArrayList<>(Arrays.asList(gvVnfc));
 347
 348                 GraphTraversalQueryEngine engine = new GraphTraversalQueryEngine(g);
 349
 350                 //test
 351                 Loader loader = LoaderFactory.createLoaderForVersion(ModelType.MOXY, Version.v10);
 352                 List<Edge> results = engine.findEdgesForVersion(gv, loader);
 353                 assertTrue(results.containsAll(expected) && expected.containsAll(results));
 354         }
 355
 356         @Test
 357         public void testFindCousinVertices() throws AAIException {
 358                 //setup
 359                 EdgeRules rules = EdgeRules.getInstance();
 360                 Graph graph = TinkerGraph.open();
 361
 362                 Vertex gv = graph.addVertex(T.id, "00", "aai-node-type", "generic-vnf");
 363                 Vertex vnfc = graph.addVertex(T.id, "10", "aai-node-type", "vnfc");
 364                 Vertex lob = graph.addVertex(T.id, "20", "aai-node-type", "line-of-business");
 365                 Vertex lint = graph.addVertex(T.id, "30", "aai-node-type", "l-interface");
 366
 367                 GraphTraversalSource g = graph.traversal();
 368
 369                 rules.addTreeEdge(g, gv, lint); //tree edge so shouldn't appear in results
 370                 rules.addEdge(g, gv, vnfc);
 371                 rules.addEdge(g, gv, lob);
 372
 373                 List<Vertex> expected = new ArrayList<>(Arrays.asList(vnfc, lob));
 374
 375                 GraphTraversalQueryEngine engine = new GraphTraversalQueryEngine(g);
 376
 377                 //test
 378                 List<Vertex> results = engine.findCousinVertices(gv);
 379                 assertTrue(results.containsAll(expected) && expected.containsAll(results));
 380         }
 381 }