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