aai-schema-ingest/src/test/java/org/onap/aai/edges/EdgeIngestorTest.java

   1 /**
   2  * ============LICENSE_START=======================================================
   3  * org.onap.aai
   4  * ================================================================================
   5  * Copyright © 2017-18 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
  21 package org.onap.aai.edges;
  22
  23 import static org.junit.Assert.*;
  24
  25 import java.util.Collection;
  26
  27 import org.apache.tinkerpop.gremlin.structure.Direction;
  28 import org.junit.Rule;
  29 import org.junit.Test;
  30 import org.junit.rules.ExpectedException;
  31 import org.junit.runner.RunWith;
  32 import org.onap.aai.edges.enums.AAIDirection;
  33 import org.onap.aai.edges.enums.MultiplicityRule;
  34 import org.onap.aai.edges.exceptions.AmbiguousRuleChoiceException;
  35 import org.onap.aai.edges.exceptions.EdgeRuleNotFoundException;
  36 import org.onap.aai.setup.SchemaLocationsBean;
  37 import org.onap.aai.setup.SchemaVersion;
  38 import org.onap.aai.setup.SchemaVersions;
  39 import org.onap.aai.testutils.TestUtilConfigTranslator;
  40 import org.springframework.beans.factory.annotation.Autowired;
  41 import org.springframework.boot.test.context.SpringBootTest;
  42 import org.springframework.test.context.ContextConfiguration;
  43 import org.springframework.test.context.TestPropertySource;
  44 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  45
  46 import com.google.common.collect.Multimap;
  47
  48 @RunWith(SpringJUnit4ClassRunner.class)
  49 @ContextConfiguration(classes = {SchemaLocationsBean.class, SchemaVersions.class, TestUtilConfigTranslator.class, EdgeIngestor.class})
  50 @TestPropertySource(properties = { "schema.ingest.file = src/test/resources/forWiringTests/schema-ingest-wiring-test.properties" })
  51 @SpringBootTest
  52 public class EdgeIngestorTest {
  53     @Autowired
  54     EdgeIngestor ei;
  55
  56     @Rule
  57     public ExpectedException thrown = ExpectedException.none();
  58
  59     @Test
  60     public void getRulesTest1() throws EdgeRuleNotFoundException {
  61         EdgeRuleQuery q = new EdgeRuleQuery.Builder("foo").build();
  62         Multimap<String, EdgeRule> results = ei.getRules(q);
  63         assertTrue(results.size() == 5);
  64         assertTrue(results.containsKey("bar|foo"));
  65
  66         assertTrue(2 == results.get("bar|foo").size());
  67         boolean seenLabel1 = false;
  68         boolean seenLabel2 = false;
  69         for(EdgeRule r : results.get("bar|foo")) {
  70             if ("eats".equals(r.getLabel())) {
  71                 seenLabel1 = true;
  72             }
  73             if ("eatz".equals(r.getLabel())) {
  74                 seenLabel2 = true;
  75             }
  76         }
  77         assertTrue(seenLabel1 && seenLabel2);
  78
  79         assertTrue(results.containsKey("baz|foo"));
  80         assertTrue(results.containsKey("foo|quux"));
  81         assertTrue(results.containsKey("dog|foo"));
  82     }
  83
  84     @Test
  85     public void getRulesTest2() throws EdgeRuleNotFoundException {
  86         EdgeRuleQuery q = new EdgeRuleQuery.Builder("dog", "puppy").build();
  87         Multimap<String, EdgeRule> results = ei.getRules(q);
  88         assertTrue(results.size() == 1);
  89         assertTrue(results.containsKey("dog|puppy"));
  90         Collection<EdgeRule> cr = results.get("dog|puppy");
  91         for (EdgeRule r : cr) {
  92             assertTrue("dog".equals(r.getFrom()));
  93             assertTrue("puppy".equals(r.getTo()));
  94             assertTrue("caresFor".equals(r.getLabel()));
  95             assertTrue(Direction.OUT.equals(r.getDirection()));
  96             assertTrue("One2Many".equalsIgnoreCase(r.getMultiplicityRule().toString()));
  97             assertTrue("NONE".equals(r.getContains()));
  98             assertTrue("OUT".equals(r.getDeleteOtherV()));
  99             assertTrue("NONE".equals(r.getPreventDelete()));
 100             assertTrue(r.isDefault());
 101         }
 102     }
 103
 104     @Test
 105     public void getRulesFlippedTypesTest() throws EdgeRuleNotFoundException {
 106         EdgeRuleQuery q = new EdgeRuleQuery.Builder("l-interface", "logical-link").version(new SchemaVersion("v11")).build();
 107         Multimap<String, EdgeRule> results = ei.getRules(q);
 108         assertTrue(results.size() == 3);
 109         for (EdgeRule r : results.get("l-interface|logical-link")) {
 110             if ("org.onap.relationships.inventory.Source".equals(r.getLabel()) ||
 111                 "org.onap.relationships.inventory.Destination".equals(r.getLabel())) {
 112                 //these are defined with from=logical-link, to=l-interface, so they must be flipped
 113                 assertTrue(Direction.IN.equals(r.getDirection()));
 114             } else if ("tosca.relationships.network.LinksTo".equals(r.getLabel())) {
 115                 //this is defined with from=l-interface, to=logical-link, so it shouldn't be flipped
 116                 assertTrue(Direction.OUT.equals(r.getDirection()));
 117             } else {
 118                 fail("how did you get here");
 119             }
 120         }
 121     }
 122
 123     @Test
 124     public void fromToSameFlipTests() throws EdgeRuleNotFoundException, AmbiguousRuleChoiceException {
 125         //getRules, setting from and to
 126         EdgeRuleQuery q = new EdgeRuleQuery.Builder("bloop","bloop").version(new SchemaVersion("v11")).build();
 127         Multimap<String, EdgeRule> results = ei.getRules(q);
 128         assertTrue(results.size() == 1);
 129         for (EdgeRule r : results.get("bloop|bloop")) {
 130             assertTrue(Direction.IN.equals(r.getDirection()));
 131         }
 132
 133         //getRule, setting just from
 134         EdgeRuleQuery q2 = new EdgeRuleQuery.Builder("bloop").version(new SchemaVersion("v11")).build();
 135         assertTrue(Direction.IN.equals(ei.getRule(q2).getDirection()));
 136
 137         //getChildRules
 138         Multimap<String, EdgeRule> child = ei.getChildRules("bloop", new SchemaVersion("v11"));
 139         assertTrue(child.size() == 1);
 140         for (EdgeRule r : child.get("bloop|bloop")) {
 141             assertTrue(Direction.IN.equals(r.getDirection()));
 142         }
 143     }
 144
 145     @Test
 146     public void getRulesTest3() throws EdgeRuleNotFoundException {
 147         EdgeRuleQuery q = new EdgeRuleQuery.Builder("l-interface").version(new SchemaVersion("v11")).build();
 148         Multimap<String, EdgeRule> results = ei.getRules(q);
 149         assertTrue(results.size() == 4);
 150         assertTrue(results.containsKey("lag-interface|l-interface"));
 151         assertTrue(results.containsKey("l-interface|logical-link"));
 152         assertTrue(results.get("l-interface|logical-link").size() == 3);
 153     }
 154
 155     @Test
 156     public void getRulesNoneFound() throws EdgeRuleNotFoundException {
 157         thrown.expect(EdgeRuleNotFoundException.class);
 158         thrown.expectMessage("No rules found for");
 159         EdgeRuleQuery q = new EdgeRuleQuery.Builder("l-interface").build();
 160         ei.getRules(q);
 161     }
 162
 163     @Test
 164     public void getRuleSimpleTest() throws EdgeRuleNotFoundException, AmbiguousRuleChoiceException {
 165         EdgeRuleQuery q = new EdgeRuleQuery.Builder("parent", "notation").build();
 166         EdgeRule result = ei.getRule(q);
 167         assertTrue("parent".equals(result.getFrom()));
 168         assertTrue("notation".equals(result.getTo()));
 169         assertTrue("has".equals(result.getLabel()));
 170         assertTrue(Direction.OUT.equals(result.getDirection()));
 171         assertTrue(MultiplicityRule.MANY2MANY.equals(result.getMultiplicityRule()));
 172         assertTrue(AAIDirection.OUT.toString().equals(result.getContains()));
 173         assertTrue(AAIDirection.NONE.toString().equals(result.getDeleteOtherV()));
 174         assertTrue(AAIDirection.NONE.toString().equals(result.getPreventDelete()));
 175         assertTrue("parent contains notation".equals(result.getDescription()));
 176     }
 177
 178     @Test
 179     public void getRuleFlippedTypesTest() throws EdgeRuleNotFoundException, AmbiguousRuleChoiceException {
 180         EdgeRuleQuery q = new EdgeRuleQuery.Builder("notation", "parent").build();
 181         EdgeRule result = ei.getRule(q);
 182         assertTrue("parent".equals(result.getFrom()));
 183         assertTrue("notation".equals(result.getTo()));
 184         assertTrue("has".equals(result.getLabel()));
 185         //direction flipped to match input order per old EdgeRules.java API
 186         assertTrue(Direction.IN.equals(result.getDirection()));
 187         assertTrue(MultiplicityRule.MANY2MANY.equals(result.getMultiplicityRule()));
 188         assertTrue(AAIDirection.OUT.toString().equals(result.getContains()));
 189         assertTrue(AAIDirection.NONE.toString().equals(result.getDeleteOtherV()));
 190         assertTrue(AAIDirection.NONE.toString().equals(result.getPreventDelete()));
 191         assertTrue("parent contains notation".equals(result.getDescription()));
 192     }
 193
 194     @Test
 195     public void getRuleWithDefaultTest() throws EdgeRuleNotFoundException, AmbiguousRuleChoiceException {
 196
 197         EdgeRuleQuery q = new EdgeRuleQuery.Builder("l-interface","logical-link").version(new SchemaVersion("v11")).build();
 198         EdgeRule res = ei.getRule(q);
 199         assertTrue(res.isDefault());
 200         assertTrue("tosca.relationships.network.LinksTo".equals(res.getLabel()));
 201     }
 202
 203     @Test
 204     public void getRuleWithNonDefault() throws EdgeRuleNotFoundException, AmbiguousRuleChoiceException {
 205         EdgeRuleQuery q = new EdgeRuleQuery.Builder("l-interface","logical-link").label("org.onap.relationships.inventory.Source").version(new SchemaVersion("v11")).build();
 206         EdgeRule res = ei.getRule(q);
 207         assertFalse(res.isDefault());
 208         assertTrue("org.onap.relationships.inventory.Source".equals(res.getLabel()));
 209     }
 210
 211     @Test
 212     public void getRuleNoneFoundTest() throws EdgeRuleNotFoundException, AmbiguousRuleChoiceException {
 213         thrown.expect(EdgeRuleNotFoundException.class);
 214         thrown.expectMessage("No rule found for");
 215         EdgeRuleQuery q = new EdgeRuleQuery.Builder("l-interface","nonexistent").build();
 216         ei.getRule(q);
 217     }
 218
 219     @Test
 220     public void getRuleTooManyPairsTest() throws EdgeRuleNotFoundException, AmbiguousRuleChoiceException {
 221         thrown.expect(AmbiguousRuleChoiceException.class);
 222         thrown.expectMessage("No way to select single rule from these pairs:");
 223         EdgeRuleQuery q = new EdgeRuleQuery.Builder("foo").build();
 224         ei.getRule(q);
 225     }
 226
 227     @Test
 228     public void getRuleAmbiguousDefaultTest() throws EdgeRuleNotFoundException, AmbiguousRuleChoiceException {
 229         thrown.expect(AmbiguousRuleChoiceException.class);
 230         thrown.expectMessage("Multiple defaults found.");
 231         EdgeRuleQuery q = new EdgeRuleQuery.Builder("seed","plant").version(new SchemaVersion("v11")).build();
 232         ei.getRule(q);
 233     }
 234
 235     @Test
 236     public void getRuleNoDefaultTest() throws EdgeRuleNotFoundException, AmbiguousRuleChoiceException {
 237         thrown.expect(AmbiguousRuleChoiceException.class);
 238         thrown.expectMessage("No default found.");
 239         EdgeRuleQuery q = new EdgeRuleQuery.Builder("apple", "orange").version(new SchemaVersion("v11")).build();
 240         ei.getRule(q);
 241     }
 242
 243     @Test
 244     public void hasRuleTest() {
 245         assertTrue(ei.hasRule(new EdgeRuleQuery.Builder("l-interface").version(new SchemaVersion("v11")).build()));
 246         assertFalse(ei.hasRule(new EdgeRuleQuery.Builder("l-interface").build()));
 247     }
 248
 249     @Test
 250     public void getCousinRulesTest() {
 251         Multimap<String, EdgeRule> results = ei.getCousinRules("dog");
 252         assertTrue(results.size() == 2);
 253         assertTrue(results.containsKey("dog|puppy"));
 254         assertTrue(results.containsKey("dog|foo"));
 255     }
 256
 257     @Test
 258     public void getCousinRulesWithVersionTest() {
 259         Multimap<String, EdgeRule> results = ei.getCousinRules("foo", new SchemaVersion("v10"));
 260         assertTrue(results.size() == 2);
 261         assertTrue(results.containsKey("bar|foo"));
 262         assertTrue(results.get("bar|foo").size() == 2);
 263     }
 264
 265     @Test
 266     public void getCousinsNoneInVersionTest() {
 267         Multimap<String, EdgeRule> results = ei.getCousinRules("foo", new SchemaVersion("v11"));
 268         assertTrue(results.isEmpty());
 269     }
 270
 271     @Test
 272     public void hasCousinTest() {
 273         assertTrue(ei.hasCousinRule("foo"));
 274         assertTrue(ei.hasCousinRule("foo", new SchemaVersion("v10")));
 275         assertFalse(ei.hasCousinRule("parent"));
 276         assertFalse(ei.hasCousinRule("foo", new SchemaVersion("v11")));
 277     }
 278
 279     @Test
 280     public void getChildRulesTest() {
 281         Multimap<String, EdgeRule> results = ei.getChildRules("parent");
 282         assertTrue(results.size() == 6);
 283         assertTrue(results.containsKey("notation|parent"));
 284         assertTrue(results.containsKey("not-notation|parent"));
 285         assertTrue(results.containsKey("out-out|parent"));
 286         assertTrue(results.containsKey("in-in|parent"));
 287         assertTrue(results.containsKey("in-out|parent"));
 288         assertTrue(results.containsKey("out-in|parent"));
 289     }
 290
 291     @Test
 292     public void getChildRulesWithVersionTest() {
 293         Multimap<String, EdgeRule> results = ei.getChildRules("foo", new SchemaVersion("v10"));
 294         assertTrue(results.size() == 2);
 295         assertTrue(results.containsKey("baz|foo"));
 296         assertTrue(results.containsKey("foo|quux"));
 297     }
 298
 299     @Test
 300     public void getChildRulesNoneInVersionTest() {
 301         Multimap<String, EdgeRule> results = ei.getChildRules("foo", new SchemaVersion("v11"));
 302         assertTrue(results.isEmpty());
 303     }
 304
 305     @Test
 306     public void hasChildTest() {
 307         assertTrue(ei.hasChildRule("foo"));
 308         assertTrue(ei.hasChildRule("foo", new SchemaVersion("v10")));
 309         assertFalse(ei.hasChildRule("puppy"));
 310         assertFalse(ei.hasChildRule("foo", new SchemaVersion("v11")));
 311     }
 312
 313     @Test
 314     public void getParentRulesTest() {
 315         Multimap<String, EdgeRule> results = ei.getParentRules("parent");
 316         assertTrue(results.size() == 6);
 317         assertTrue(results.containsKey("grandparent1|parent"));
 318         assertTrue(results.containsKey("grandparent2|parent"));
 319         assertTrue(results.containsKey("grandparent3|parent"));
 320         assertTrue(results.containsKey("grandparent4|parent"));
 321         assertTrue(results.containsKey("grandparent5|parent"));
 322         assertTrue(results.containsKey("grandparent6|parent"));
 323     }
 324
 325     @Test
 326     public void getParentRulesWithVersionTest() {
 327         Multimap<String, EdgeRule> results = ei.getParentRules("baz", new SchemaVersion("v10"));
 328         assertTrue(results.size() == 1);
 329         assertTrue(results.containsKey("baz|foo"));
 330     }
 331
 332     @Test
 333     public void getParentRulesNoneInVersionTest() {
 334         Multimap<String, EdgeRule> results = ei.getParentRules("baz", new SchemaVersion("v11"));
 335         assertTrue(results.isEmpty());
 336     }
 337
 338     @Test
 339     public void hasParentTest() {
 340         assertTrue(ei.hasParentRule("parent"));
 341         assertTrue(ei.hasParentRule("quux", new SchemaVersion("v10")));
 342         assertFalse(ei.hasParentRule("puppy"));
 343         assertFalse(ei.hasParentRule("foo", new SchemaVersion("v11")));
 344     }
 345
 346     @Test
 347     public void getAllCurrentRulesTest() throws EdgeRuleNotFoundException {
 348         Multimap<String, EdgeRule> res = ei.getAllCurrentRules();
 349         assertTrue(res.size() == 18);
 350     }
 351
 352     @Test
 353     public void getAllRulesTest() throws EdgeRuleNotFoundException {
 354         Multimap<String, EdgeRule> res = ei.getAllRules(new SchemaVersion("v10"));
 355         assertTrue(res.size() == 4);
 356         assertTrue(res.containsKey("bar|foo"));
 357         assertTrue(res.get("bar|foo").size() == 2);
 358         assertTrue(res.containsKey("baz|foo"));
 359         assertTrue(res.containsKey("foo|quux"));
 360
 361         thrown.expect(EdgeRuleNotFoundException.class);
 362         thrown.expectMessage("No rules found for version v9.");
 363         ei.getAllRules(new SchemaVersion("v9"));
 364     }
 365 }