ONAP-XACML/src/test/java/org/onap/policy/xacml/test/std/pap/StdEngineTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP-XACML
   4  * ================================================================================
   5  * Copyright (C) 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 package org.onap.policy.xacml.test.std.pap;
  21
  22 import static org.junit.Assert.assertEquals;
  23 import static org.junit.Assert.assertNotNull;
  24 import static org.junit.Assert.assertNull;
  25 import static org.junit.Assert.assertTrue;
  26 import java.io.File;
  27 import java.io.FileInputStream;
  28 import java.io.FileNotFoundException;
  29 import java.io.IOException;
  30 import java.io.InputStream;
  31 import java.nio.file.Files;
  32 import java.nio.file.Path;
  33 import java.nio.file.Paths;
  34 import java.nio.file.StandardCopyOption;
  35 import java.util.Properties;
  36 import org.apache.commons.io.FileUtils;
  37 import org.junit.After;
  38 import org.junit.Before;
  39 import org.junit.BeforeClass;
  40 import org.junit.Rule;
  41 import org.junit.Test;
  42 import org.junit.rules.ExpectedException;
  43 import org.onap.policy.xacml.api.pap.OnapPDP;
  44 import org.onap.policy.xacml.api.pap.OnapPDPGroup;
  45 import org.onap.policy.xacml.std.pap.StdEngine;
  46 import org.onap.policy.xacml.std.pap.StdPDPGroup;
  47 import com.att.research.xacml.api.pap.PAPException;
  48 import com.att.research.xacml.api.pap.PDPPolicy;
  49
  50 public class StdEngineTest {
  51
  52     private Path repository;
  53     Properties properties = new Properties();
  54     StdEngine stdEngine = null;
  55
  56     @Rule
  57     public ExpectedException expectedException = ExpectedException.none();
  58
  59     @BeforeClass
  60     public static void setUpClass() throws IOException{
  61         new File("target/test/resources/pdps").mkdirs();
  62         new File("target/test/resources/emptyPapGroupsDefault").mkdirs();
  63         Files.copy(Paths.get("src/test/resources/pdps/xacml.properties"), Paths.get("target/test/resources/pdps/xacml.properties"), StandardCopyOption.REPLACE_EXISTING);
  64         Files.copy(Paths.get("src/test/resources/emptyPapGroupsDefault/xacml.properties"), Paths.get("target/test/resources/emptyPapGroupsDefault/xacml.properties"), StandardCopyOption.REPLACE_EXISTING);
  65     }
  66
  67     @Before
  68     public void setUp() throws PAPException, IOException {
  69
  70         repository = Paths.get("target/test/resources/pdps");
  71         stdEngine = new StdEngine(repository);
  72     }
  73
  74     @Test
  75     public void testGetDefaultGroup() throws PAPException {
  76         assertTrue(stdEngine.getDefaultGroup() != null);
  77     }
  78
  79     @Test
  80     public void testGetGroup() throws PAPException {
  81         assertTrue(stdEngine.getGroup("1") == null);
  82     }
  83
  84     @Test
  85     public void testGetOnapPDPGroups() throws PAPException {
  86         assertTrue(stdEngine.getOnapPDPGroups() != null);
  87     }
  88
  89     @Test
  90     public void testGetPDP() throws PAPException {
  91         assertTrue(stdEngine.getPDP("1") == null);
  92     }
  93
  94     @Test
  95     public void testGetPDPGroup() throws PAPException {
  96         assertTrue(stdEngine.getPDPGroup(null) == null);
  97     }
  98
  99     @Test
 100     public void testNoRepository() throws PAPException, IOException {
 101         expectedException.expect(PAPException.class);
 102         expectedException.expectMessage("No repository specified.");
 103         new StdEngine((Path)null);
 104     }
 105
 106     @Test
 107     public void testRepositoryDoesNotExist() throws PAPException, IOException {
 108         repository = Paths.get("target/test/resources/nonExisting");
 109         new StdEngine(repository);
 110
 111         assertTrue(Files.exists(Paths.get("target/test/resources/nonExisting/default/xacml.pip.properties")));
 112         assertTrue(Files.exists(Paths.get("target/test/resources/nonExisting/default/xacml.policy.properties")));
 113         assertTrue(Files.exists(Paths.get("target/test/resources/nonExisting/xacml.properties")));
 114         FileUtils.deleteDirectory(repository.toFile());
 115     }
 116
 117     @Test
 118     public void testEmptyPapGroupsDefault() throws PAPException, IOException {
 119         System.setProperty("xacml.pap.groups.default", "");
 120         repository = Paths.get("target/test/resources/emptyPapGroupsDefault");
 121         new StdEngine(repository);
 122
 123         assertTrue(Files.exists(Paths.get("target/test/resources/emptyPapGroupsDefault/default/xacml.pip.properties")));
 124         assertTrue(Files.exists(Paths.get("target/test/resources/emptyPapGroupsDefault/default/xacml.policy.properties")));
 125         assertTrue(Files.exists(Paths.get("target/test/resources/emptyPapGroupsDefault/xacml.properties")));
 126     }
 127
 128     @Test
 129     public void testNewGroupAndRemoveGroup() throws NullPointerException, PAPException, IOException {
 130         OnapPDPGroup newGroup = createGroup("newGroup", "Description of new group");
 131         assertNotNull(newGroup);
 132
 133         stdEngine.removeGroup(stdEngine.getGroup("newGroup"), null);
 134         assertNull(stdEngine.getGroup("newGroup"));
 135     }
 136
 137     @Test
 138     public void testRemoveGroupNull() throws NullPointerException, PAPException, IOException {
 139         expectedException.expect(NullPointerException.class);
 140         stdEngine.removeGroup(null, null);
 141         assertNull(stdEngine.getGroup("newGroup"));
 142     }
 143
 144     @Test
 145     public void testRemoveGroupUnknown() throws NullPointerException, PAPException, IOException {
 146         OnapPDPGroup unknownGroup = new StdPDPGroup("unknownId", null);
 147
 148         expectedException.expect(PAPException.class);
 149         expectedException.expectMessage("The group 'unknownId' does not exist");
 150         stdEngine.removeGroup(unknownGroup, null);
 151     }
 152
 153     @Test
 154     public void testRemoveGroupDefault() throws NullPointerException, PAPException, IOException {
 155         OnapPDPGroup defaultGroup = stdEngine.getDefaultGroup();
 156
 157         expectedException.expect(PAPException.class);
 158         expectedException.expectMessage("You cannot delete the default group.");
 159         stdEngine.removeGroup(defaultGroup, null);
 160     }
 161
 162     @Test
 163     public void testSetDefaultGroup() throws NullPointerException, PAPException, IOException {
 164         OnapPDPGroup newGroup = createGroup("newGroup", "Description of new group");
 165         assertNotNull(newGroup);
 166
 167         OnapPDPGroup defaultGroup = stdEngine.getDefaultGroup();
 168         assertEquals("default", defaultGroup.getName());
 169         stdEngine.setDefaultGroup(newGroup);
 170         assertEquals(newGroup, stdEngine.getDefaultGroup());
 171
 172         stdEngine.setDefaultGroup(defaultGroup);
 173         stdEngine.removeGroup(stdEngine.getGroup("newGroup"), null);
 174     }
 175
 176     @Test
 177     public void testPdps() throws NullPointerException, PAPException{
 178         OnapPDPGroup group1 = createGroup("newGroup", "Description of new group");
 179         assertEquals(0, group1.getPdps().size());
 180
 181         stdEngine.newPDP("newPdp", group1, "newPdpName", "A new pdp", 1);
 182         assertEquals(1, group1.getPdps().size());
 183         assertEquals("newPdp", group1.getPdps().iterator().next().getId());
 184         assertEquals("newPdpName", group1.getPdps().iterator().next().getName());
 185         assertEquals("A new pdp", group1.getPdps().iterator().next().getDescription());
 186
 187         OnapPDPGroup group2 = createGroup("anotherNewGroup", "Description of new group");
 188         assertEquals(0, group2.getPdps().size());
 189
 190         stdEngine.movePDP(group1.getOnapPdps().iterator().next(), group2);
 191         assertEquals(0, group1.getPdps().size());
 192         assertEquals(1, group2.getPdps().size());
 193
 194         OnapPDP pdp = group2.getOnapPdps().iterator().next();
 195         pdp.setName("AnUpdatedName");;
 196         pdp.setDescription("An updated description");
 197         stdEngine.updatePDP(pdp);
 198         assertEquals("AnUpdatedName", group2.getPdps().iterator().next().getName());
 199         assertEquals("An updated description", group2.getPdps().iterator().next().getDescription());
 200
 201         stdEngine.removePDP(group2.getOnapPdps().iterator().next());
 202         assertEquals(0, group1.getPdps().size());
 203         assertEquals(0, group2.getPdps().size());
 204     }
 205
 206     @Test
 207     public void testNewPdpNullGroup() throws NullPointerException, PAPException{
 208         expectedException.expect(PAPException.class);
 209         expectedException.expectMessage("You must specify which group the PDP will belong to.");
 210         stdEngine.newPDP("newPdp", null, "newPdpName", "A new pdp", 1);
 211     }
 212
 213     @Test
 214     public void testNewPdpUnknownGroup() throws NullPointerException, PAPException{
 215         OnapPDPGroup unknownGroup = new StdPDPGroup("unknownId", null);
 216
 217         expectedException.expect(PAPException.class);
 218         expectedException.expectMessage("Unknown group, not in our list.");
 219         stdEngine.newPDP("newPdp", unknownGroup, "newPdpName", "A new pdp", 1);
 220     }
 221
 222     @Test
 223     public void testNewPdpAlreadyExistingPdp() throws NullPointerException, PAPException{
 224         OnapPDPGroup group1 = createGroup("newGroup", "Description of new group");
 225         assertEquals(0, group1.getPdps().size());
 226
 227         stdEngine.newPDP("newPdp", group1, "newPdpName", "A new pdp", 1);
 228         assertEquals(1, group1.getPdps().size());
 229
 230         expectedException.expect(PAPException.class);
 231         expectedException.expectMessage("A PDP with this ID exists.");
 232         stdEngine.newPDP("newPdp", group1, "newPdpName", "A new pdp", 1);
 233     }
 234
 235     @Test
 236     public void testRemoveGroupWithPdps() throws NullPointerException, PAPException{
 237         OnapPDPGroup group1 = createGroup("newGroup", "Description of new group");
 238
 239         stdEngine.newPDP("newPdp", group1, "newPdpName", "A new pdp", 1);
 240         assertEquals(1, group1.getPdps().size());
 241
 242         OnapPDPGroup group2 = createGroup("anotherNewGroup", "Description of new group");
 243         assertEquals(0, group2.getPdps().size());
 244
 245         stdEngine.removeGroup(group1, group2);
 246         assertNull(stdEngine.getGroup("newGroup"));
 247         assertEquals(1, group2.getPdps().size());
 248     }
 249
 250     @Test
 251     public void testRemoveGroupWithPdpsNoTarget() throws NullPointerException, PAPException{
 252         OnapPDPGroup group1 = createGroup("newGroup", "Description of new group");
 253
 254         stdEngine.newPDP("newPdp", group1, "newPdpName", "A new pdp", 1);
 255         assertEquals(1, group1.getPdps().size());
 256
 257         OnapPDPGroup group2 = createGroup("anotherNewGroup", "Description of new group");
 258         assertEquals(0, group2.getPdps().size());
 259
 260         expectedException.expect(NullPointerException.class);
 261         expectedException.expectMessage("Group targeted for deletion has PDPs, you must provide a new group for them.");
 262         stdEngine.removeGroup(group1, null);
 263     }
 264
 265     @Test
 266     public void testUpdateGroupName() throws NullPointerException, PAPException, IOException {
 267         OnapPDPGroup newGroup = createGroup("newGroup", "Description of new group");
 268
 269         OnapPDPGroup updatedGroup = new StdPDPGroup(newGroup);
 270         updatedGroup.setName("AnUpdatedName");
 271         stdEngine.updateGroup(updatedGroup);
 272         assertNull(stdEngine.getGroup("newGroup"));
 273         assertNotNull(stdEngine.getGroup("AnUpdatedName"));
 274         assertEquals("AnUpdatedName", stdEngine.getGroup("AnUpdatedName").getName());
 275         assertEquals("Description of new group", stdEngine.getGroup("AnUpdatedName").getDescription());
 276     }
 277
 278     @Test
 279     public void testUpdateGroupDescription() throws NullPointerException, PAPException, IOException {
 280         OnapPDPGroup newGroup = createGroup("newGroup", "Description of new group");
 281
 282         OnapPDPGroup updatedGroup = new StdPDPGroup(newGroup.getId(), newGroup.getName(), "An updated description", Paths.get("target/test/resources/pdps/newGroup"));
 283         updatedGroup.setDescription("An updated description");
 284         stdEngine.updateGroup(updatedGroup);
 285         assertEquals("newGroup", stdEngine.getGroup("newGroup").getName());
 286         assertEquals("An updated description", stdEngine.getGroup("newGroup").getDescription());
 287     }
 288
 289     @Test
 290     public void testUpdateGroupNull() throws NullPointerException, PAPException, IOException {
 291         expectedException.expect(PAPException.class);
 292         expectedException.expectMessage("Group or id is null");
 293         stdEngine.updateGroup(null);
 294     }
 295
 296     @Test
 297     public void testUpdateGroupIdNull() throws NullPointerException, PAPException, IOException {
 298         StdPDPGroup group = new StdPDPGroup(null, null);
 299         expectedException.expect(PAPException.class);
 300         expectedException.expectMessage("Group or id is null");
 301         stdEngine.updateGroup(group);
 302     }
 303
 304     @Test
 305     public void testUpdateGroupNameNull() throws NullPointerException, PAPException, IOException {
 306         StdPDPGroup group = new StdPDPGroup("groupId", null);
 307         expectedException.expect(PAPException.class);
 308         expectedException.expectMessage("New name for group cannot be null or blank");
 309         stdEngine.updateGroup(group);
 310     }
 311
 312     @Test
 313     public void testUpdateGroupNameEmptyString() throws NullPointerException, PAPException, IOException {
 314         StdPDPGroup group = new StdPDPGroup("groupId", "", "description", null);
 315         expectedException.expect(PAPException.class);
 316         expectedException.expectMessage("New name for group cannot be null or blank");
 317         stdEngine.updateGroup(group);
 318     }
 319
 320     @Test
 321     public void testUpdateGroupUnknown() throws NullPointerException, PAPException, IOException {
 322         StdPDPGroup group = new StdPDPGroup("groupId", "groupName", "description", null);
 323         expectedException.expect(PAPException.class);
 324         expectedException.expectMessage("Update found no existing group with id 'groupId'");
 325         stdEngine.updateGroup(group);
 326     }
 327
 328     @Test
 329     public void testPublishAndRemovePolicy() throws NullPointerException, PAPException, FileNotFoundException{
 330         OnapPDPGroup newGroup = createGroup("newGroup", "Description of new group");
 331         InputStream inputStream = new FileInputStream("src/test/resources/pdps/default/com.Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml");
 332         stdEngine.publishPolicy("com.Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml", "Config_BRMS_Param_BRMSParamvFWDemoPolicy", true, inputStream, newGroup);
 333         PDPPolicy policy = newGroup.getPolicy("com.Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml");
 334         assertNotNull(policy);
 335
 336         stdEngine.removePolicy(policy, newGroup);
 337         assertNull(newGroup.getPolicy("com.Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml"));
 338     }
 339
 340     @Test
 341     public void testPublishPolicyNull() throws NullPointerException, PAPException, FileNotFoundException{
 342         expectedException.expect(NullPointerException.class);
 343         stdEngine.publishPolicy(null, null, true, null, null);
 344     }
 345
 346     @Test
 347     public void testPublishPolicyUnknownGroup() throws NullPointerException, PAPException, FileNotFoundException{
 348         OnapPDPGroup unknownGroup = new StdPDPGroup("unknownId", null);
 349
 350         expectedException.expect(PAPException.class);
 351         expectedException.expectMessage("Unknown PDP Group: unknownId");
 352         stdEngine.publishPolicy(null, null, true, null, unknownGroup);
 353     }
 354
 355     @Test
 356     public void testRemovePolicyNull() throws NullPointerException, PAPException, FileNotFoundException{
 357         expectedException.expect(NullPointerException.class);
 358         stdEngine.removePolicy(null, null);
 359     }
 360
 361     @Test
 362     public void testRemovePolicyUnknownGroup() throws NullPointerException, PAPException, FileNotFoundException{
 363         OnapPDPGroup unknownGroup = new StdPDPGroup("unknownId", null);
 364
 365         expectedException.expect(PAPException.class);
 366         expectedException.expectMessage("Unknown PDP Group: unknownId");
 367         stdEngine.removePolicy(null, unknownGroup);
 368     }
 369
 370     private OnapPDPGroup createGroup(final String name, final String description) throws NullPointerException, PAPException{
 371         ensureGroupDoesntExist(name);
 372         stdEngine.newGroup(name, description);
 373         return stdEngine.getGroup(name);
 374     }
 375
 376     @After
 377     public void tearDown() throws PAPException{
 378         ensureGroupDoesntExist("newGroup");
 379         ensureGroupDoesntExist("anotherNewGroup");
 380         ensureGroupDoesntExist("AnUpdatedName");
 381     }
 382
 383     private void ensureGroupDoesntExist(final String groupName) throws PAPException{
 384         OnapPDPGroup group = stdEngine.getGroup(groupName);
 385         if (group != null){
 386             for (OnapPDP pdp: group.getOnapPdps()){
 387                 stdEngine.removePDP(pdp);
 388             }
 389             stdEngine.removeGroup(group, null);
 390        }
 391     }
 392 }