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