aai-core/src/test/java/org/onap/aai/serialization/db/EdgeRulesTest.java

   1 /**
   2  * ============LICENSE_START=======================================================
   3  * org.onap.aai
   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
  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 package org.onap.aai.serialization.db;
  21
  22
  23 import org.apache.tinkerpop.gremlin.structure.*;
  24 import org.junit.Test;
  25 import org.onap.aai.AAISetup;
  26
  27 import static org.junit.Assert.assertEquals;
  28 import static org.junit.Assert.assertTrue;
  29
  30 import java.util.Arrays;
  31 import java.util.List;
  32 import java.util.Map;
  33 import java.util.Set;
  34
  35 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
  36 import org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerGraph;
  37 import org.junit.Rule;
  38 import org.junit.rules.ExpectedException;
  39
  40 import org.onap.aai.db.props.AAIProperties;
  41 import org.onap.aai.exceptions.AAIException;
  42 import org.onap.aai.introspection.Version;
  43 import org.onap.aai.serialization.db.exceptions.EdgeMultiplicityException;
  44 import org.onap.aai.serialization.db.exceptions.MultipleEdgeRuleFoundException;
  45 import org.onap.aai.serialization.db.exceptions.NoEdgeRuleFoundException;
  46
  47 import com.google.common.collect.Multimap;
  48
  49 public class EdgeRulesTest extends AAISetup {
  50
  51         //set thrown.expect to whatever a specific test needs
  52         //this establishes a default of expecting no exceptions to be thrown
  53         @Rule
  54         public ExpectedException thrown = ExpectedException.none();
  55
  56         @Test
  57         public void verifyOutDirection() throws AAIException, NoEdgeRuleFoundException {
  58                 EdgeRules rules = EdgeRules.getInstance();
  59                 EdgeRule rule = rules.getEdgeRule(EdgeType.TREE, "cloud-region", "flavor");
  60
  61                 assertEquals("out direction", rule.getDirection(), Direction.IN);
  62         }
  63
  64         @Test
  65         public void verifyOutFlippedDirection() throws AAIException, NoEdgeRuleFoundException {
  66                 EdgeRules rules = EdgeRules.getInstance();
  67                 EdgeRule rule = rules.getEdgeRule(EdgeType.TREE, "flavor", "cloud-region");
  68
  69                 assertEquals("in direction", rule.getDirection(), Direction.OUT);
  70         }
  71
  72         @Test
  73         public void verifyInDirection() throws AAIException, NoEdgeRuleFoundException {
  74                 EdgeRules rules = EdgeRules.getInstance();
  75                 EdgeRule rule = rules.getEdgeRule(EdgeType.COUSIN, "model-ver", "model-element");
  76
  77                 assertEquals("in direction", Direction.IN, rule.getDirection());
  78         }
  79
  80         @Test
  81         public void verifyInFlippedDirection() throws AAIException, NoEdgeRuleFoundException {
  82                 EdgeRules rules = EdgeRules.getInstance();
  83                 EdgeRule rule = rules.getEdgeRule(EdgeType.COUSIN, "model-element", "model-ver");
  84
  85                 assertEquals("out direction", Direction.OUT, rule.getDirection());
  86         }
  87         @Test
  88         public void verifyMultipleGet() throws AAIException {
  89                 EdgeRules rules = EdgeRules.getInstance();
  90                 Map<String, EdgeRule> ruleMap = rules.getEdgeRules("model-element", "model-ver");
  91                 assertEquals("has isA rule", "org.onap.relationships.inventory.IsA",
  92                                 ruleMap.get("org.onap.relationships.inventory.IsA").getLabel());
  93                 assertEquals("has startsWith rule", "org.onap.relationships.inventory.BelongsTo",
  94                                 ruleMap.get("org.onap.relationships.inventory.BelongsTo").getLabel());
  95         }
  96
  97         @Test
  98         public void verifyMultipleGetSingleRule() throws AAIException {
  99                 EdgeRules rules = EdgeRules.getInstance();
 100                 Map<String, EdgeRule> ruleMap = rules.getEdgeRules("availability-zone", "complex");
 101
 102                 assertEquals("has org.onap.relationships.inventory.LocatedIn rule", "org.onap.relationships.inventory.LocatedIn",
 103                                 ruleMap.get("org.onap.relationships.inventory.LocatedIn").getLabel());
 104         }
 105
 106         @Test
 107         public void verifyOldEdgeRule() throws AAIException, ClassNotFoundException, IllegalArgumentException, IllegalAccessException, NoSuchFieldException, SecurityException {
 108                 assertEquals(true, EdgeRules.getInstance().hasEdgeRule("model-element", "model-ver"));
 109                 assertEquals(true, EdgeRules.getInstance(Version.v8).hasEdgeRule("pserver", "complex"));
 110                 assertEquals(false, EdgeRules.getInstance(Version.v8).hasEdgeRule("model-element", "model-ver"));
 111         }
 112
 113         @Test
 114         public void hasEdgeRuleTest() {
 115                 assertEquals("true: cloud-region | tenant", true, EdgeRules.getInstance().hasEdgeRule("cloud-region", "tenant"));
 116                 assertEquals("true: tenant | cloud-region", true, EdgeRules.getInstance().hasEdgeRule("tenant", "cloud-region"));
 117                 assertEquals("true: pserver | complex", true, EdgeRules.getInstance().hasEdgeRule("pserver", "complex"));
 118                 assertEquals("false: pserver | service", false, EdgeRules.getInstance().hasEdgeRule("pserver", "service"));
 119         }
 120
 121         @Test
 122         public void hasTreeEdgeRuleTest() {
 123                 assertEquals("true: cloud-region | tenant", true, EdgeRules.getInstance().hasTreeEdgeRule("cloud-region", "tenant"));
 124                 assertEquals("true: tenant | cloud-region", true, EdgeRules.getInstance().hasTreeEdgeRule("tenant", "cloud-region"));
 125                 assertEquals("false: pserver | complex", false, EdgeRules.getInstance().hasTreeEdgeRule("pserver", "complex"));
 126                 assertEquals("true: service-instance | allotted-resource", true, EdgeRules.getInstance().hasTreeEdgeRule("service-instance", "allotted-resource"));
 127
 128         }
 129
 130         @Test
 131         public void hasCousinEdgeRuleTest() {
 132                 assertEquals("false: cloud-region | tenant", false, EdgeRules.getInstance().hasCousinEdgeRule("cloud-region", "tenant", null));
 133                 assertEquals("false: tenant | cloud-region", false, EdgeRules.getInstance().hasCousinEdgeRule("tenant", "cloud-region", null));
 134                 assertEquals("true: pserver | complex", true, EdgeRules.getInstance().hasCousinEdgeRule("pserver", "complex", null));
 135                 assertEquals("true: service-instance | allotted-resource", true, EdgeRules.getInstance().hasCousinEdgeRule("service-instance", "allotted-resource", null));
 136                 assertEquals("true: logical-link | l-interface", true, EdgeRules.getInstance().hasCousinEdgeRule("logical-link", "l-interface", null));
 137                 assertEquals("true: logical-link | l-interface : sourceLInterface", true, EdgeRules.getInstance().hasCousinEdgeRule("logical-link", "l-interface", "org.onap.relationships.inventory.Source"));
 138                 assertEquals("true: logical-link | l-interface : targetLInterface", true, EdgeRules.getInstance().hasCousinEdgeRule("logical-link", "l-interface", "org.onap.relationships.inventory.Destination"));
 139                 assertEquals("false: logical-link | l-interface : blah", false, EdgeRules.getInstance().hasCousinEdgeRule("logical-link", "l-interface", "blah"));
 140         }
 141
 142         @Test
 143         public void hasEdgeRuleVertexTest() {
 144                 Graph graph = TinkerGraph.open();
 145                 Vertex v1 = graph.addVertex("aai-node-type", "cloud-region");
 146                 Vertex v2 = graph.addVertex("aai-node-type", "tenant");
 147                 assertEquals(true, EdgeRules.getInstance().hasEdgeRule(v1, v2));
 148         }
 149
 150         @Test
 151         public void getEdgeRuleByTypeAndVertices() throws AAIException {
 152                 Graph graph = TinkerGraph.open();
 153                 Vertex v1 = graph.addVertex("aai-node-type", "cloud-region");
 154                 Vertex v2 = graph.addVertex("aai-node-type", "tenant");
 155                 EdgeRules rules = EdgeRules.getInstance();
 156                 EdgeRule rule = rules.getEdgeRule(EdgeType.TREE, v1, v2);
 157                 assertEquals(true, "IN".equalsIgnoreCase(rule.getContains()));
 158                 assertEquals(true, "NONE".equalsIgnoreCase(rule.getDeleteOtherV()));
 159                 assertEquals(true, MultiplicityRule.MANY2ONE.equals(rule.getMultiplicityRule()));
 160                 assertEquals(true,  "OUT".equalsIgnoreCase(rule.getServiceInfrastructure()));
 161                 assertEquals(true, "IN".equalsIgnoreCase(rule.getPreventDelete()));
 162         }
 163
 164         @Test
 165         public void addTreeEdgeTest() throws AAIException {
 166                 Graph graph = TinkerGraph.open();
 167                 Vertex v1 = graph.addVertex(T.id, "1", "aai-node-type", "cloud-region");
 168                 Vertex v2 = graph.addVertex(T.id, "10", "aai-node-type", "tenant");
 169                 EdgeRules rules = EdgeRules.getInstance();
 170                 GraphTraversalSource g = graph.traversal();
 171                 rules.addTreeEdge(g, v1, v2);
 172                 assertEquals(true, g.V(v1).in("org.onap.relationships.inventory.BelongsTo").has("aai-node-type", "tenant").hasNext());
 173
 174                 Vertex v3 = graph.addVertex(T.id, "2", "aai-node-type", "cloud-region");
 175                 assertEquals(null, rules.addTreeEdgeIfPossible(g, v3, v2));
 176         }
 177
 178         @Test
 179         public void addCousinEdgeTest() throws AAIException {
 180                 Graph graph = TinkerGraph.open();
 181                 Vertex v1 = graph.addVertex(T.id, "1", "aai-node-type", "flavor");
 182                 Vertex v2 = graph.addVertex(T.id, "10", "aai-node-type", "vserver");
 183                 EdgeRules rules = EdgeRules.getInstance(Version.getLatest());
 184                 GraphTraversalSource g = graph.traversal();
 185                 rules.addEdge(g, v1, v2);
 186                 assertEquals(true, g.V(v2).out("org.onap.relationships.inventory.Uses").has("aai-node-type", "flavor").hasNext());
 187
 188                 Vertex v3 = graph.addVertex(T.id, "2", "aai-node-type", "flavor");
 189                 assertEquals(null, rules.addEdgeIfPossible(g, v3, v2));
 190         }
 191
 192         @Test
 193         public void multiplicityViolationTest() throws AAIException {
 194                 thrown.expect(EdgeMultiplicityException.class);
 195                 thrown.expectMessage("multiplicity rule violated: only one edge can exist with label: org.onap.relationships.inventory.Uses between vf-module and volume-group");
 196
 197                 Graph graph = TinkerGraph.open();
 198                 Vertex v1 = graph.addVertex(T.id, "1", "aai-node-type", "vf-module");
 199                 Vertex v2 = graph.addVertex(T.id, "10", "aai-node-type", "volume-group");
 200                 EdgeRules rules = EdgeRules.getInstance(Version.getLatest());
 201                 GraphTraversalSource g = graph.traversal();
 202
 203                 rules.addEdge(g, v2, v1);
 204                 Vertex v3 = graph.addVertex(T.id, "3", "aai-node-type", "vf-module");
 205                 rules.addEdge(g, v2, v3);
 206         }
 207
 208         @Test
 209         public void getChildrenTest() {
 210                 EdgeRules rules = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
 211                 Set<EdgeRule> children = rules.getChildren("foo");
 212                 assertEquals(2, children.size());
 213                 boolean sawBazRule = false;
 214                 boolean sawQuuxRule = false;
 215                 for (EdgeRule r : children) {
 216                         if ("isVeryHappyAbout".equals(r.getLabel())) {
 217                                 sawBazRule = true;
 218                         } else if ("dancesWith".equals(r.getLabel())) {
 219                                 sawQuuxRule = true;
 220                         }
 221                 }
 222                 assertEquals(true, sawBazRule && sawQuuxRule);
 223         }
 224
 225         @Test
 226         public void getAllRulesTest() {
 227                 EdgeRules rules = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
 228                 Multimap<String, EdgeRule> allRules = rules.getAllRules();
 229                 assertEquals(16, allRules.size());
 230                 assertEquals(true, allRules.containsKey("foo|bar"));
 231                 assertEquals(true, allRules.containsKey("foo|bar"));
 232                 assertEquals(true, allRules.containsKey("quux|foo"));
 233         }
 234
 235         @Test
 236         public void getAllRulesMissingPropertyTest() {
 237                 EdgeRules rules = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test_broken.json");
 238
 239                 thrown.expect(RuntimeException.class);
 240                 thrown.expectMessage("org.onap.aai.exceptions.AAIException: Rule between foo and bar is missing property delete-other-v.");
 241                 rules.getAllRules();
 242         }
 243
 244         @Test
 245         public void getChildrenMissingPropertyTest() {
 246                 EdgeRules rules = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test_broken.json");
 247
 248                 thrown.expect(RuntimeException.class);
 249                 thrown.expectMessage("org.onap.aai.exceptions.AAIException: Rule between quux and foo is missing property SVC-INFRA.");
 250                 rules.getChildren("foo");
 251         }
 252
 253         @Test
 254         public void getEdgeRuleMissingPropertyTest() throws AAIException {
 255                 EdgeRules rules = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test_broken.json");
 256
 257                 thrown.expect(RuntimeException.class);
 258                 rules.getEdgeRules("foo", "quux");
 259         }
 260
 261         @Test
 262         public void verifyAllRules() {
 263                 // This will cause every rule in the real json files to be verified
 264                 // so if any required properties are missing, the verification builds
 265                 // will catch it and incorrect rules can't get merged in.
 266                 for (Version v : Version.values()) {
 267                         // NOt adding descriptions prior to v12
 268                         switch (v.toString()) {
 269                         case "v7":
 270                         case "v8":
 271                         case "v9":
 272                         case "v10":
 273                         case "v11":
 274                                 continue;
 275                         }
 276                         EdgeRules rules = EdgeRules.getInstance(v);
 277                         rules.getAllRules();
 278                 }
 279         }
 280
 281     @Test(expected = NoEdgeRuleFoundException.class)
 282     public void noEdgeRuleFoundTest() throws AAIException {
 283         EdgeRules rules = EdgeRules.getInstance();
 284         rules.getEdgeRule(EdgeType.TREE, "a", "b");
 285     }
 286
 287     @Test
 288     public void verifyOutDirectionUsingLabel() throws AAIException, NoEdgeRuleFoundException {
 289         EdgeRules rules = EdgeRules.getInstance();
 290         EdgeRule rule = rules.getEdgeRule(EdgeType.COUSIN, "generic-vnf", "l3-network", "org.onap.relationships.inventory.Uses");
 291
 292         assertEquals("out direction", rule.getDirection(), Direction.OUT);
 293     }
 294
 295     @Test
 296     public void verifyInDirectionLinterfaceToLinterfaceUsingLabel() throws AAIException, NoEdgeRuleFoundException {
 297         EdgeRules rules = EdgeRules.getInstance();
 298         EdgeRule rule = rules.getEdgeRule(EdgeType.TREE, "l-interface", "l-interface");
 299
 300         assertEquals("in direction", rule.getDirection(), Direction.IN);
 301     }
 302
 303     @Test
 304     public void verifyOutFlippedDirectionUsingLabel() throws AAIException, NoEdgeRuleFoundException {
 305         EdgeRules rules = EdgeRules.getInstance();
 306         EdgeRule rule = rules.getEdgeRule(EdgeType.COUSIN, "l3-network", "generic-vnf", "org.onap.relationships.inventory.Uses");
 307
 308         assertEquals("in direction", rule.getDirection(), Direction.IN);
 309     }
 310
 311     @Test(expected = MultipleEdgeRuleFoundException.class)
 312     public void multipleEdgeRulesVerifyMultipleEdgeRuleException() throws AAIException {
 313         EdgeRules rules = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
 314         rules.getEdgeRule(EdgeType.COUSIN, "foo", "bar");
 315     }
 316
 317     @Test
 318     public void multipleEdgeRulesVerifyGetRuleWithLabel() throws AAIException {
 319         EdgeRules rules = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
 320         EdgeRule rule = rules.getEdgeRule(EdgeType.COUSIN, "foo", "bar", "eatz");
 321         assertEquals("in direction", rule.getDirection(), Direction.IN);
 322     }
 323
 324     @Test
 325     public void multipleEdgeRulesVerifyGetRuleWithOutLabelDefaults() throws AAIException {
 326         EdgeRules rules = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
 327         EdgeRule rule = rules.getEdgeRule(EdgeType.COUSIN, "a", "b");
 328         assertEquals("in direction", rule.getLabel(), "d");
 329     }
 330
 331     @Test
 332     public void multipleEdgeRulesRevVerifyGetRuleWithOutLabelDefaults() throws AAIException {
 333         EdgeRules rules = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
 334         EdgeRule rule = rules.getEdgeRule(EdgeType.COUSIN, "z", "y");
 335         assertEquals("in direction", rule.getLabel(), "w");
 336     }
 337
 338     @Test
 339     public void multipleEdgeRulesRevRevVerifyGetRuleWithOutLabelDefaults() throws AAIException {
 340         EdgeRules rules = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
 341         EdgeRule rule = rules.getEdgeRule(EdgeType.COUSIN, "y", "z");
 342         assertEquals("in direction", rule.getLabel(), "w");
 343     }
 344
 345         @Test
 346         public void getEdgeRulesWithLabelsTest() throws AAIException {
 347                 EdgeRules rules = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
 348                 List<String> labels = Arrays.asList("uses","re-uses","over-uses");
 349                 Map<String, EdgeRule> edgeRules = rules.getEdgeRulesWithLabels(EdgeType.COUSIN, "generic-vnf", "vnfc", labels);
 350                 assertEquals("Found 3 edge rules", 3, edgeRules.size());
 351                 assertTrue("Rules for each edge label found", edgeRules.keySet().containsAll(labels));
 352         }
 353
 354         @Test(expected = NoEdgeRuleFoundException.class)
 355         public void getEdgeRulesWithLabelsBadLabelTest() throws AAIException {
 356                 EdgeRules rules = EdgeRules.getInstance("/dbedgerules/DbEdgeRules_test.json");
 357                 List<String> labels = Arrays.asList("bad","re-uses","over-uses");
 358                 Map<String, EdgeRule> edgeRules = rules.getEdgeRulesWithLabels(EdgeType.COUSIN, "generic-vnf", "vnfc", labels);
 359         }
 360
 361         @Test
 362         public void addEdgeVerifyAAIUUIDCousinTest() throws AAIException {
 363                 Graph graph = TinkerGraph.open();
 364                 Vertex v1 = graph.addVertex(T.id, "1", "aai-node-type", "flavor");
 365                 Vertex v2 = graph.addVertex(T.id, "10", "aai-node-type", "vserver");
 366                 EdgeRules rules = EdgeRules.getInstance(Version.getLatest());
 367                 GraphTraversalSource g = graph.traversal();
 368                 Edge e = rules.addEdge(g, v1, v2);
 369                 assertTrue(e.property(AAIProperties.AAI_UUID).isPresent());
 370                 //assertTrue(e.property(AAIProperties.AAI_UUID).value().toString().matches("^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"));
 371         }
 372
 373         @Test
 374         public void addEdgeVerifyAAIUUIDTreeTest() throws AAIException {
 375                 Graph graph = TinkerGraph.open();
 376                 Vertex v1 = graph.addVertex(T.id, "1", "aai-node-type", "tenant");
 377                 Vertex v2 = graph.addVertex(T.id, "10", "aai-node-type", "vserver");
 378                 EdgeRules rules = EdgeRules.getInstance(Version.getLatest());
 379                 GraphTraversalSource g = graph.traversal();
 380                 Edge e = rules.addTreeEdge(g, v1, v2);
 381                 assertTrue(e.property(AAIProperties.AAI_UUID).isPresent());
 382                 //assertTrue(e.property(AAIProperties.AAI_UUID).value().toString().matches("^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"));
 383         }
 384
 385 }