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