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