2 * ============LICENSE_START=======================================================
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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=========================================================
20 package org.onap.policy.xacml.test.std.pap;
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;
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;
50 public class StdEngineTest {
52 private Path repository;
53 Properties properties = new Properties();
54 StdEngine stdEngine = null;
57 public ExpectedException expectedException = ExpectedException.none();
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);
68 public void setUp() throws PAPException, IOException {
70 repository = Paths.get("target/test/resources/pdps");
71 stdEngine = new StdEngine(repository);
75 public void testGetDefaultGroup() throws PAPException {
76 assertTrue(stdEngine.getDefaultGroup() != null);
80 public void testGetGroup() throws PAPException {
81 assertTrue(stdEngine.getGroup("1") == null);
85 public void testGetOnapPDPGroups() throws PAPException {
86 assertTrue(stdEngine.getOnapPDPGroups() != null);
90 public void testGetPDP() throws PAPException {
91 assertTrue(stdEngine.getPDP("1") == null);
95 public void testGetPDPGroup() throws PAPException {
96 assertTrue(stdEngine.getPDPGroup(null) == null);
100 public void testNoRepository() throws PAPException, IOException {
101 expectedException.expect(PAPException.class);
102 expectedException.expectMessage("No repository specified.");
103 new StdEngine((Path)null);
107 public void testRepositoryDoesNotExist() throws PAPException, IOException {
108 repository = Paths.get("target/test/resources/nonExisting");
109 new StdEngine(repository);
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());
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);
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")));
129 public void testNewGroupAndRemoveGroup() throws NullPointerException, PAPException, IOException {
130 OnapPDPGroup newGroup = createGroup("newGroup", "Description of new group");
131 assertNotNull(newGroup);
133 stdEngine.removeGroup(stdEngine.getGroup("newGroup"), null);
134 assertNull(stdEngine.getGroup("newGroup"));
138 public void testRemoveGroupNull() throws NullPointerException, PAPException, IOException {
139 expectedException.expect(NullPointerException.class);
140 stdEngine.removeGroup(null, null);
141 assertNull(stdEngine.getGroup("newGroup"));
145 public void testRemoveGroupUnknown() throws NullPointerException, PAPException, IOException {
146 OnapPDPGroup unknownGroup = new StdPDPGroup("unknownId", null);
148 expectedException.expect(PAPException.class);
149 expectedException.expectMessage("The group 'unknownId' does not exist");
150 stdEngine.removeGroup(unknownGroup, null);
154 public void testRemoveGroupDefault() throws NullPointerException, PAPException, IOException {
155 OnapPDPGroup defaultGroup = stdEngine.getDefaultGroup();
157 expectedException.expect(PAPException.class);
158 expectedException.expectMessage("You cannot delete the default group.");
159 stdEngine.removeGroup(defaultGroup, null);
163 public void testSetDefaultGroup() throws NullPointerException, PAPException, IOException {
164 OnapPDPGroup newGroup = createGroup("newGroup", "Description of new group");
165 assertNotNull(newGroup);
167 OnapPDPGroup defaultGroup = stdEngine.getDefaultGroup();
168 assertEquals("default", defaultGroup.getName());
169 stdEngine.setDefaultGroup(newGroup);
170 assertEquals(newGroup, stdEngine.getDefaultGroup());
172 stdEngine.setDefaultGroup(defaultGroup);
173 stdEngine.removeGroup(stdEngine.getGroup("newGroup"), null);
177 public void testPdps() throws NullPointerException, PAPException{
178 OnapPDPGroup group1 = createGroup("newGroup", "Description of new group");
179 assertEquals(0, group1.getPdps().size());
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());
187 OnapPDPGroup group2 = createGroup("anotherNewGroup", "Description of new group");
188 assertEquals(0, group2.getPdps().size());
190 stdEngine.movePDP(group1.getOnapPdps().iterator().next(), group2);
191 assertEquals(0, group1.getPdps().size());
192 assertEquals(1, group2.getPdps().size());
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());
201 stdEngine.removePDP(group2.getOnapPdps().iterator().next());
202 assertEquals(0, group1.getPdps().size());
203 assertEquals(0, group2.getPdps().size());
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);
214 public void testNewPdpUnknownGroup() throws NullPointerException, PAPException{
215 OnapPDPGroup unknownGroup = new StdPDPGroup("unknownId", null);
217 expectedException.expect(PAPException.class);
218 expectedException.expectMessage("Unknown group, not in our list.");
219 stdEngine.newPDP("newPdp", unknownGroup, "newPdpName", "A new pdp", 1);
223 public void testNewPdpAlreadyExistingPdp() throws NullPointerException, PAPException{
224 OnapPDPGroup group1 = createGroup("newGroup", "Description of new group");
225 assertEquals(0, group1.getPdps().size());
227 stdEngine.newPDP("newPdp", group1, "newPdpName", "A new pdp", 1);
228 assertEquals(1, group1.getPdps().size());
230 expectedException.expect(PAPException.class);
231 expectedException.expectMessage("A PDP with this ID exists.");
232 stdEngine.newPDP("newPdp", group1, "newPdpName", "A new pdp", 1);
236 public void testRemoveGroupWithPdps() throws NullPointerException, PAPException{
237 OnapPDPGroup group1 = createGroup("newGroup", "Description of new group");
239 stdEngine.newPDP("newPdp", group1, "newPdpName", "A new pdp", 1);
240 assertEquals(1, group1.getPdps().size());
242 OnapPDPGroup group2 = createGroup("anotherNewGroup", "Description of new group");
243 assertEquals(0, group2.getPdps().size());
245 stdEngine.removeGroup(group1, group2);
246 assertNull(stdEngine.getGroup("newGroup"));
247 assertEquals(1, group2.getPdps().size());
251 public void testRemoveGroupWithPdpsNoTarget() throws NullPointerException, PAPException{
252 OnapPDPGroup group1 = createGroup("newGroup", "Description of new group");
254 stdEngine.newPDP("newPdp", group1, "newPdpName", "A new pdp", 1);
255 assertEquals(1, group1.getPdps().size());
257 OnapPDPGroup group2 = createGroup("anotherNewGroup", "Description of new group");
258 assertEquals(0, group2.getPdps().size());
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);
266 public void testUpdateGroupName() throws NullPointerException, PAPException, IOException {
267 OnapPDPGroup newGroup = createGroup("newGroup", "Description of new group");
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());
279 public void testUpdateGroupDescription() throws NullPointerException, PAPException, IOException {
280 OnapPDPGroup newGroup = createGroup("newGroup", "Description of new group");
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());
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);
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);
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);
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);
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);
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);
336 stdEngine.removePolicy(policy, newGroup);
337 assertNull(newGroup.getPolicy("com.Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml"));
341 public void testPublishPolicyNull() throws NullPointerException, PAPException, FileNotFoundException{
342 expectedException.expect(NullPointerException.class);
343 stdEngine.publishPolicy(null, null, true, null, null);
347 public void testPublishPolicyUnknownGroup() throws NullPointerException, PAPException, FileNotFoundException{
348 OnapPDPGroup unknownGroup = new StdPDPGroup("unknownId", null);
350 expectedException.expect(PAPException.class);
351 expectedException.expectMessage("Unknown PDP Group: unknownId");
352 stdEngine.publishPolicy(null, null, true, null, unknownGroup);
356 public void testRemovePolicyNull() throws NullPointerException, PAPException, FileNotFoundException{
357 expectedException.expect(NullPointerException.class);
358 stdEngine.removePolicy(null, null);
362 public void testRemovePolicyUnknownGroup() throws NullPointerException, PAPException, FileNotFoundException{
363 OnapPDPGroup unknownGroup = new StdPDPGroup("unknownId", null);
365 expectedException.expect(PAPException.class);
366 expectedException.expectMessage("Unknown PDP Group: unknownId");
367 stdEngine.removePolicy(null, unknownGroup);
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);
377 public void tearDown() throws PAPException{
378 ensureGroupDoesntExist("newGroup");
379 ensureGroupDoesntExist("anotherNewGroup");
380 ensureGroupDoesntExist("AnUpdatedName");
383 private void ensureGroupDoesntExist(final String groupName) throws PAPException{
384 OnapPDPGroup group = stdEngine.getGroup(groupName);
386 for (OnapPDP pdp: group.getOnapPdps()){
387 stdEngine.removePDP(pdp);
389 stdEngine.removeGroup(group, null);