2 * ============LICENSE_START=======================================================
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
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=========================================================
23 package org.onap.policy.xacml.test.std.pap;
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;
30 import com.att.research.xacml.api.pap.PAPException;
31 import com.att.research.xacml.api.pap.PDPPolicy;
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;
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;
56 public class StdEngineTest {
58 private Path repository;
59 Properties properties = new Properties();
60 StdEngine stdEngine = null;
63 public ExpectedException expectedException = ExpectedException.none();
68 * @throws IOException IOException
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);
84 * @throws PAPException PAPException
85 * @throws IOException IOException
88 public void setUp() throws PAPException, IOException {
90 repository = Paths.get("target/test/resources/pdps");
91 stdEngine = new StdEngine(repository);
95 public void testGetDefaultGroup() throws PAPException {
96 assertTrue(stdEngine.getDefaultGroup() != null);
100 public void testGetGroup() throws PAPException {
101 assertTrue(stdEngine.getGroup("1") == null);
105 public void testGetOnapPDPGroups() throws PAPException {
106 assertTrue(stdEngine.getOnapPDPGroups() != null);
110 public void testGetPDP() throws PAPException {
111 assertTrue(stdEngine.getPDP("1") == null);
115 public void testGetPDPGroup() throws PAPException {
116 assertTrue(stdEngine.getPDPGroup(null) == null);
120 public void testNoRepository() throws PAPException, IOException {
121 expectedException.expect(PAPException.class);
122 expectedException.expectMessage("No repository specified.");
123 new StdEngine((Path) null);
127 public void testRepositoryDoesNotExist() throws PAPException, IOException {
128 repository = Paths.get("target/test/resources/nonExisting");
129 new StdEngine(repository);
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());
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);
143 assertTrue(Files.exists(Paths.get("target/test/resources/emptyPapGroupsDefault/default/xacml.pip.properties")));
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")));
150 public void testNewGroupAndRemoveGroup() throws NullPointerException, PAPException, IOException {
151 OnapPDPGroup newGroup = createGroup("newGroup", "Description of new group");
152 assertNotNull(newGroup);
154 stdEngine.removeGroup(stdEngine.getGroup("newGroup"), null);
155 assertNull(stdEngine.getGroup("newGroup"));
159 public void testRemoveGroupNull() throws NullPointerException, PAPException, IOException {
160 expectedException.expect(NullPointerException.class);
161 stdEngine.removeGroup(null, null);
162 assertNull(stdEngine.getGroup("newGroup"));
166 public void testRemoveGroupUnknown() throws NullPointerException, PAPException, IOException {
167 OnapPDPGroup unknownGroup = new StdPDPGroup("unknownId", null);
169 expectedException.expect(PAPException.class);
170 expectedException.expectMessage("The group 'unknownId' does not exist");
171 stdEngine.removeGroup(unknownGroup, null);
175 public void testRemoveGroupDefault() throws NullPointerException, PAPException, IOException {
176 OnapPDPGroup defaultGroup = stdEngine.getDefaultGroup();
178 expectedException.expect(PAPException.class);
179 expectedException.expectMessage("You cannot delete the default group.");
180 stdEngine.removeGroup(defaultGroup, null);
184 public void testSetDefaultGroup() throws NullPointerException, PAPException, IOException {
185 OnapPDPGroup newGroup = createGroup("newGroup", "Description of new group");
186 assertNotNull(newGroup);
188 OnapPDPGroup defaultGroup = stdEngine.getDefaultGroup();
189 assertEquals("default", defaultGroup.getName());
190 stdEngine.setDefaultGroup(newGroup);
191 assertEquals(newGroup, stdEngine.getDefaultGroup());
193 stdEngine.setDefaultGroup(defaultGroup);
194 stdEngine.removeGroup(stdEngine.getGroup("newGroup"), null);
198 public void testPdps() throws NullPointerException, PAPException {
199 OnapPDPGroup group1 = createGroup("newGroup", "Description of new group");
200 assertEquals(0, group1.getPdps().size());
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());
208 OnapPDPGroup group2 = createGroup("anotherNewGroup", "Description of new group");
209 assertEquals(0, group2.getPdps().size());
211 stdEngine.movePDP(group1.getOnapPdps().iterator().next(), group2);
212 assertEquals(0, group1.getPdps().size());
213 assertEquals(1, group2.getPdps().size());
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());
222 stdEngine.removePDP(group2.getOnapPdps().iterator().next());
223 assertEquals(0, group1.getPdps().size());
224 assertEquals(0, group2.getPdps().size());
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);
235 public void testNewPdpUnknownGroup() throws NullPointerException, PAPException {
236 OnapPDPGroup unknownGroup = new StdPDPGroup("unknownId", null);
238 expectedException.expect(PAPException.class);
239 expectedException.expectMessage("Unknown group, not in our list.");
240 stdEngine.newPDP("newPdp", unknownGroup, "newPdpName", "A new pdp", 1);
244 public void testNewPdpAlreadyExistingPdp() throws NullPointerException, PAPException {
245 OnapPDPGroup group1 = createGroup("newGroup", "Description of new group");
246 assertEquals(0, group1.getPdps().size());
248 stdEngine.newPDP("newPdp", group1, "newPdpName", "A new pdp", 1);
249 assertEquals(1, group1.getPdps().size());
251 expectedException.expect(PAPException.class);
252 expectedException.expectMessage("A PDP with this ID exists.");
253 stdEngine.newPDP("newPdp", group1, "newPdpName", "A new pdp", 1);
257 public void testRemoveGroupWithPdps() throws NullPointerException, PAPException {
258 OnapPDPGroup group1 = createGroup("newGroup", "Description of new group");
260 stdEngine.newPDP("newPdp", group1, "newPdpName", "A new pdp", 1);
261 assertEquals(1, group1.getPdps().size());
263 OnapPDPGroup group2 = createGroup("anotherNewGroup", "Description of new group");
264 assertEquals(0, group2.getPdps().size());
266 stdEngine.removeGroup(group1, group2);
267 assertNull(stdEngine.getGroup("newGroup"));
268 assertEquals(1, group2.getPdps().size());
272 public void testRemoveGroupWithPdpsNoTarget() throws NullPointerException, PAPException {
273 OnapPDPGroup group1 = createGroup("newGroup", "Description of new group");
275 stdEngine.newPDP("newPdp", group1, "newPdpName", "A new pdp", 1);
276 assertEquals(1, group1.getPdps().size());
278 OnapPDPGroup group2 = createGroup("anotherNewGroup", "Description of new group");
279 assertEquals(0, group2.getPdps().size());
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);
287 public void testUpdateGroupName() throws NullPointerException, PAPException, IOException {
288 OnapPDPGroup newGroup = createGroup("newGroup", "Description of new group");
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());
300 public void testUpdateGroupDescription() throws NullPointerException, PAPException, IOException {
301 OnapPDPGroup newGroup = createGroup("newGroup", "Description of new group");
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());
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);
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);
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);
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);
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);
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);
360 stdEngine.removePolicy(policy, newGroup);
361 assertNull(newGroup.getPolicy("com.Config_BRMS_Param_BRMSParamvFWDemoPolicy.1.xml"));
365 public void testPublishPolicyNull() throws NullPointerException, PAPException, FileNotFoundException {
366 expectedException.expect(NullPointerException.class);
367 stdEngine.publishPolicy(null, null, true, null, null);
371 public void testPublishPolicyUnknownGroup() throws NullPointerException, PAPException, FileNotFoundException {
372 OnapPDPGroup unknownGroup = new StdPDPGroup("unknownId", null);
374 expectedException.expect(PAPException.class);
375 expectedException.expectMessage("Unknown PDP Group: unknownId");
376 stdEngine.publishPolicy(null, null, true, null, unknownGroup);
380 public void testRemovePolicyNull() throws NullPointerException, PAPException, FileNotFoundException {
381 expectedException.expect(NullPointerException.class);
382 stdEngine.removePolicy(null, null);
386 public void testRemovePolicyUnknownGroup() 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);