2 * ============LICENSE_START=======================================================
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
13 * http://www.apache.org/licenses/LICENSE-2.0
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=========================================================
22 package org.onap.policy.xacml.test.std.pap;
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;
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;
52 public class StdEngineTest {
54 private Path repository;
55 Properties properties = new Properties();
56 StdEngine stdEngine = null;
59 public ExpectedException expectedException = ExpectedException.none();
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);
74 public void setUp() throws PAPException, IOException {
76 repository = Paths.get("target/test/resources/pdps");
77 stdEngine = new StdEngine(repository);
81 public void testGetDefaultGroup() throws PAPException {
82 assertTrue(stdEngine.getDefaultGroup() != null);
86 public void testGetGroup() throws PAPException {
87 assertTrue(stdEngine.getGroup("1") == null);
91 public void testGetOnapPDPGroups() throws PAPException {
92 assertTrue(stdEngine.getOnapPDPGroups() != null);
96 public void testGetPDP() throws PAPException {
97 assertTrue(stdEngine.getPDP("1") == null);
101 public void testGetPDPGroup() throws PAPException {
102 assertTrue(stdEngine.getPDPGroup(null) == null);
106 public void testNoRepository() throws PAPException, IOException {
107 expectedException.expect(PAPException.class);
108 expectedException.expectMessage("No repository specified.");
109 new StdEngine((Path) null);
113 public void testRepositoryDoesNotExist() throws PAPException, IOException {
114 repository = Paths.get("target/test/resources/nonExisting");
115 new StdEngine(repository);
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());
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);
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")));
136 .exists(Paths.get("target/test/resources/emptyPapGroupsDefault/xacml.properties")));
140 public void testNewGroupAndRemoveGroup()
141 throws NullPointerException, PAPException, IOException {
142 OnapPDPGroup newGroup = createGroup("newGroup", "Description of new group");
143 assertNotNull(newGroup);
145 stdEngine.removeGroup(stdEngine.getGroup("newGroup"), null);
146 assertNull(stdEngine.getGroup("newGroup"));
150 public void testRemoveGroupNull() throws NullPointerException, PAPException, IOException {
151 expectedException.expect(NullPointerException.class);
152 stdEngine.removeGroup(null, null);
153 assertNull(stdEngine.getGroup("newGroup"));
157 public void testRemoveGroupUnknown() throws NullPointerException, PAPException, IOException {
158 OnapPDPGroup unknownGroup = new StdPDPGroup("unknownId", null);
160 expectedException.expect(PAPException.class);
161 expectedException.expectMessage("The group 'unknownId' does not exist");
162 stdEngine.removeGroup(unknownGroup, null);
166 public void testRemoveGroupDefault() throws NullPointerException, PAPException, IOException {
167 OnapPDPGroup defaultGroup = stdEngine.getDefaultGroup();
169 expectedException.expect(PAPException.class);
170 expectedException.expectMessage("You cannot delete the default group.");
171 stdEngine.removeGroup(defaultGroup, null);
175 public void testSetDefaultGroup() throws NullPointerException, PAPException, IOException {
176 OnapPDPGroup newGroup = createGroup("newGroup", "Description of new group");
177 assertNotNull(newGroup);
179 OnapPDPGroup defaultGroup = stdEngine.getDefaultGroup();
180 assertEquals("default", defaultGroup.getName());
181 stdEngine.setDefaultGroup(newGroup);
182 assertEquals(newGroup, stdEngine.getDefaultGroup());
184 stdEngine.setDefaultGroup(defaultGroup);
185 stdEngine.removeGroup(stdEngine.getGroup("newGroup"), null);
189 public void testPdps() throws NullPointerException, PAPException {
190 OnapPDPGroup group1 = createGroup("newGroup", "Description of new group");
191 assertEquals(0, group1.getPdps().size());
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());
199 OnapPDPGroup group2 = createGroup("anotherNewGroup", "Description of new group");
200 assertEquals(0, group2.getPdps().size());
202 stdEngine.movePDP(group1.getOnapPdps().iterator().next(), group2);
203 assertEquals(0, group1.getPdps().size());
204 assertEquals(1, group2.getPdps().size());
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());
213 stdEngine.removePDP(group2.getOnapPdps().iterator().next());
214 assertEquals(0, group1.getPdps().size());
215 assertEquals(0, group2.getPdps().size());
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);
226 public void testNewPdpUnknownGroup() throws NullPointerException, PAPException {
227 OnapPDPGroup unknownGroup = new StdPDPGroup("unknownId", null);
229 expectedException.expect(PAPException.class);
230 expectedException.expectMessage("Unknown group, not in our list.");
231 stdEngine.newPDP("newPdp", unknownGroup, "newPdpName", "A new pdp", 1);
235 public void testNewPdpAlreadyExistingPdp() throws NullPointerException, PAPException {
236 OnapPDPGroup group1 = createGroup("newGroup", "Description of new group");
237 assertEquals(0, group1.getPdps().size());
239 stdEngine.newPDP("newPdp", group1, "newPdpName", "A new pdp", 1);
240 assertEquals(1, group1.getPdps().size());
242 expectedException.expect(PAPException.class);
243 expectedException.expectMessage("A PDP with this ID exists.");
244 stdEngine.newPDP("newPdp", group1, "newPdpName", "A new pdp", 1);
248 public void testRemoveGroupWithPdps() throws NullPointerException, PAPException {
249 OnapPDPGroup group1 = createGroup("newGroup", "Description of new group");
251 stdEngine.newPDP("newPdp", group1, "newPdpName", "A new pdp", 1);
252 assertEquals(1, group1.getPdps().size());
254 OnapPDPGroup group2 = createGroup("anotherNewGroup", "Description of new group");
255 assertEquals(0, group2.getPdps().size());
257 stdEngine.removeGroup(group1, group2);
258 assertNull(stdEngine.getGroup("newGroup"));
259 assertEquals(1, group2.getPdps().size());
263 public void testRemoveGroupWithPdpsNoTarget() throws NullPointerException, PAPException {
264 OnapPDPGroup group1 = createGroup("newGroup", "Description of new group");
266 stdEngine.newPDP("newPdp", group1, "newPdpName", "A new pdp", 1);
267 assertEquals(1, group1.getPdps().size());
269 OnapPDPGroup group2 = createGroup("anotherNewGroup", "Description of new group");
270 assertEquals(0, group2.getPdps().size());
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);
279 public void testUpdateGroupName() throws NullPointerException, PAPException, IOException {
280 OnapPDPGroup newGroup = createGroup("newGroup", "Description of new group");
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());
293 public void testUpdateGroupDescription()
294 throws NullPointerException, PAPException, IOException {
295 OnapPDPGroup newGroup = createGroup("newGroup", "Description of new group");
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());
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);
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);
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);
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);
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);
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);
356 stdEngine.removePolicy(policy, newGroup);
357 assertNull(newGroup.getPolicy("com.Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml"));
361 public void testPublishPolicyNull()
362 throws NullPointerException, PAPException, FileNotFoundException {
363 expectedException.expect(NullPointerException.class);
364 stdEngine.publishPolicy(null, null, true, null, null);
368 public void testPublishPolicyUnknownGroup()
369 throws NullPointerException, PAPException, FileNotFoundException {
370 OnapPDPGroup unknownGroup = new StdPDPGroup("unknownId", null);
372 expectedException.expect(PAPException.class);
373 expectedException.expectMessage("Unknown PDP Group: unknownId");
374 stdEngine.publishPolicy(null, null, true, null, unknownGroup);
378 public void testRemovePolicyNull()
379 throws NullPointerException, PAPException, FileNotFoundException {
380 expectedException.expect(NullPointerException.class);
381 stdEngine.removePolicy(null, null);
385 public void testRemovePolicyUnknownGroup()
386 throws NullPointerException, PAPException, FileNotFoundException {
387 OnapPDPGroup unknownGroup = new StdPDPGroup("unknownId", null);
389 expectedException.expect(PAPException.class);
390 expectedException.expectMessage("Unknown PDP Group: unknownId");
391 stdEngine.removePolicy(null, unknownGroup);
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);
402 public void tearDown() throws PAPException {
403 ensureGroupDoesntExist("newGroup");
404 ensureGroupDoesntExist("anotherNewGroup");
405 ensureGroupDoesntExist("AnUpdatedName");
408 private void ensureGroupDoesntExist(final String groupName) throws PAPException {
409 OnapPDPGroup group = stdEngine.getGroup(groupName);
411 for (OnapPDP pdp : group.getOnapPdps()) {
412 stdEngine.removePDP(pdp);
414 stdEngine.removeGroup(group, null);