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