2 * ============LICENSE_START=======================================================
3 * Copyright (C) 2018 Ericsson. All rights reserved.
4 * Modifications Copyright (C) 2019 Samsung
5 * Modifications Copyright (C) 2019 AT&T Intellectual Property.
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=========================================================
21 package org.onap.policy.xacml.test.std.pap;
23 import static org.junit.Assert.assertEquals;
24 import static org.junit.Assert.assertFalse;
25 import static org.junit.Assert.assertTrue;
27 import com.att.research.xacml.api.pap.PDPPIPConfig;
28 import com.att.research.xacml.api.pap.PDPPolicy;
29 import com.att.research.xacml.api.pap.PDPStatus.Status;
31 import java.util.HashSet;
34 import org.junit.Test;
35 import org.onap.policy.xacml.std.pap.StdPDPPIPConfig;
36 import org.onap.policy.xacml.std.pap.StdPDPPolicy;
37 import org.onap.policy.xacml.std.pap.StdPDPStatus;
39 public class StdPDPStatusTest {
41 StdPDPStatus stdPDPStatus = new StdPDPStatus();
44 public void testSetAndGetStatus() {
45 Status status = Status.UP_TO_DATE;
46 stdPDPStatus.setStatus(status);
47 assertEquals(status, stdPDPStatus.getStatus());
51 public void testSetAndGetLoadErrors() {
52 Set<String> errors = new HashSet<>();
53 errors.add("An error");
54 stdPDPStatus.setLoadErrors(errors);
55 assertEquals(errors, stdPDPStatus.getLoadErrors());
59 public void testSetAndGetLoadWarnings() {
60 Set<String> warnings = new HashSet<>();
61 warnings.add("An error");
62 stdPDPStatus.setLoadWarnings(warnings);
63 assertEquals(warnings, stdPDPStatus.getLoadWarnings());
67 public void testSetAndGetLoadedPolicies() {
68 Set<PDPPolicy> loadedPolicies = new HashSet<>();
69 loadedPolicies.add(new StdPDPPolicy());
70 stdPDPStatus.setLoadedPolicies(loadedPolicies);
71 assertEquals(loadedPolicies, stdPDPStatus.getLoadedPolicies());
75 public void testSetAndGetLoadedRootPolicies() {
76 Set<PDPPolicy> loadedRootPolicies = new HashSet<>();
77 loadedRootPolicies.add(new StdPDPPolicy());
78 stdPDPStatus.setLoadedRootPolicies(loadedRootPolicies);
79 assertEquals(loadedRootPolicies, stdPDPStatus.getLoadedRootPolicies());
83 public void testSetAndGetFailedPolicies() {
84 Set<PDPPolicy> failedPolicies = new HashSet<>();
85 failedPolicies.add(new StdPDPPolicy());
86 stdPDPStatus.setFailedPolicies(failedPolicies);
87 assertEquals(failedPolicies, stdPDPStatus.getFailedPolicies());
91 public void testSetAndGetLoadedPipConfigs() {
92 Set<PDPPIPConfig> loadedPipConfigs = new HashSet<>();
93 loadedPipConfigs.add(new StdPDPPIPConfig());
94 stdPDPStatus.setLoadedPipConfigs(loadedPipConfigs);
95 assertEquals(loadedPipConfigs, stdPDPStatus.getLoadedPipConfigs());
99 public void testSetAndGetFailedPipConfigs() {
100 Set<PDPPIPConfig> failedPipConfigs = new HashSet<>();
101 failedPipConfigs.add(new StdPDPPIPConfig());
102 stdPDPStatus.setFailedPipConfigs(failedPipConfigs);
103 assertEquals(failedPipConfigs, stdPDPStatus.getFailedPipConfigs());
107 public void testPoliciesOK() {
108 assertTrue(stdPDPStatus.policiesOK());
109 stdPDPStatus.addFailedPolicy(new StdPDPPolicy());
110 assertFalse(stdPDPStatus.policiesOK());
114 public void testPipConfigOK() {
115 assertTrue(stdPDPStatus.pipConfigOK());
116 stdPDPStatus.addFailedPipConfig(new StdPDPPIPConfig());
117 assertFalse(stdPDPStatus.pipConfigOK());
121 public void testIsOkFailedPolicy() {
122 stdPDPStatus.setStatus(Status.UP_TO_DATE);
123 assertTrue(stdPDPStatus.isOk());
124 stdPDPStatus.addFailedPolicy(new StdPDPPolicy());
125 assertFalse(stdPDPStatus.isOk());
129 public void testIsOkFailedPipConfig() {
130 stdPDPStatus.setStatus(Status.UP_TO_DATE);
131 assertTrue(stdPDPStatus.isOk());
132 stdPDPStatus.addFailedPipConfig(new StdPDPPIPConfig());
133 assertFalse(stdPDPStatus.isOk());
137 public void testIsOkStatusOutOfSync() {
138 stdPDPStatus.setStatus(Status.UP_TO_DATE);
139 assertTrue(stdPDPStatus.isOk());
140 stdPDPStatus.setStatus(Status.OUT_OF_SYNCH);
141 assertFalse(stdPDPStatus.isOk());
145 public void testAddLoadError() {
146 stdPDPStatus.addLoadError("An error");
147 assertEquals("An error", stdPDPStatus.getLoadErrors().iterator().next());
151 public void testAddLoadWarning() {
152 stdPDPStatus.addLoadWarning("A warning");
153 assertEquals("A warning", stdPDPStatus.getLoadWarnings().iterator().next());
157 public void testAddLoadedPolicy() {
158 PDPPolicy policy = new StdPDPPolicy();
159 stdPDPStatus.addLoadedPolicy(policy);
160 assertEquals(policy, stdPDPStatus.getLoadedPolicies().iterator().next());
164 public void testAddRootPolicy() {
165 PDPPolicy policy = new StdPDPPolicy();
166 stdPDPStatus.addRootPolicy(policy);
167 assertEquals(policy, stdPDPStatus.getLoadedRootPolicies().iterator().next());
171 public void testAddAllLoadedRootPolicy() {
172 Set<PDPPolicy> policies = new HashSet<>();
173 PDPPolicy policy = new StdPDPPolicy();
174 policies.add(policy);
175 stdPDPStatus.addAllLoadedRootPolicies(policies);
176 assertEquals(policies, stdPDPStatus.getLoadedRootPolicies());
180 public void testAddLoadedPipConfig() {
181 PDPPIPConfig pipConfig = new StdPDPPIPConfig();
182 stdPDPStatus.addLoadedPipConfig(pipConfig);
183 assertEquals(pipConfig, stdPDPStatus.getLoadedPipConfigs().iterator().next());
187 public void testSet() {
188 final Status status = Status.UP_TO_DATE;
189 Set<PDPPIPConfig> failedPipConfigs = new HashSet<>();
190 failedPipConfigs.add(new StdPDPPIPConfig());
191 Set<PDPPolicy> failedPolicies = new HashSet<>();
192 failedPolicies.add(new StdPDPPolicy());
193 Set<PDPPIPConfig> loadedPipConfigs = new HashSet<>();
194 loadedPipConfigs.add(new StdPDPPIPConfig());
195 Set<PDPPolicy> loadedPolicies = new HashSet<>();
196 loadedPolicies.add(new StdPDPPolicy());
197 Set<PDPPolicy> loadedRootPolicies = new HashSet<>();
198 loadedRootPolicies.add(new StdPDPPolicy());
199 Set<String> loadErrors = new HashSet<>();
200 loadErrors.add("An error");
201 Set<String> loadWarnings = new HashSet<>();
202 loadWarnings.add("An error");
204 stdPDPStatus.setStatus(status);
205 stdPDPStatus.setFailedPipConfigs(failedPipConfigs);
206 stdPDPStatus.setFailedPolicies(failedPolicies);
207 stdPDPStatus.setLoadedPipConfigs(loadedPipConfigs);
208 stdPDPStatus.setLoadedPolicies(loadedPolicies);
209 stdPDPStatus.setLoadedRootPolicies(loadedRootPolicies);
210 stdPDPStatus.setLoadErrors(loadErrors);
211 stdPDPStatus.setLoadWarnings(loadWarnings);
213 StdPDPStatus stdPdpStatus1 = new StdPDPStatus();
214 stdPdpStatus1.set(stdPDPStatus);
216 assertEquals(status, stdPdpStatus1.getStatus());
217 assertEquals(loadErrors, stdPdpStatus1.getLoadErrors());
218 assertEquals(loadWarnings, stdPdpStatus1.getLoadWarnings());
219 assertEquals(loadedPolicies, stdPdpStatus1.getLoadedPolicies());
220 assertEquals(loadedRootPolicies, stdPdpStatus1.getLoadedRootPolicies());
221 assertEquals(failedPolicies, stdPdpStatus1.getFailedPolicies());
222 assertEquals(loadedPipConfigs, stdPdpStatus1.getLoadedPipConfigs());
223 assertEquals(failedPipConfigs, stdPdpStatus1.getFailedPipConfigs());
225 assertTrue(stdPdpStatus1.toString().startsWith("StdPDPStatus"));
229 public void testEqualsAndHashCode() {
230 final Status status = Status.UP_TO_DATE;
231 Set<PDPPIPConfig> failedPipConfigs = new HashSet<>();
232 failedPipConfigs.add(new StdPDPPIPConfig());
233 Set<PDPPolicy> failedPolicies = new HashSet<>();
234 failedPolicies.add(new StdPDPPolicy());
235 Set<PDPPIPConfig> loadedPipConfigs = new HashSet<>();
236 loadedPipConfigs.add(new StdPDPPIPConfig());
237 Set<PDPPolicy> loadedPolicies = new HashSet<>();
238 loadedPolicies.add(new StdPDPPolicy());
239 Set<PDPPolicy> loadedRootPolicies = new HashSet<>();
240 loadedRootPolicies.add(new StdPDPPolicy());
241 Set<String> loadErrors = new HashSet<>();
242 loadErrors.add("An error");
243 Set<String> loadWarnings = new HashSet<>();
244 loadWarnings.add("An error");
246 StdPDPStatus stdPdpStatus1 = new StdPDPStatus();
248 assertTrue(stdPDPStatus.equals(stdPdpStatus1));
250 stdPDPStatus.setStatus(status);
251 assertFalse(stdPDPStatus.equals(stdPdpStatus1));
252 stdPdpStatus1.setStatus(status);
253 assertTrue(stdPDPStatus.equals(stdPdpStatus1));
254 assertEquals(stdPDPStatus.hashCode(), stdPdpStatus1.hashCode());
256 stdPDPStatus.setFailedPipConfigs(failedPipConfigs);
257 assertFalse(stdPDPStatus.equals(stdPdpStatus1));
258 stdPdpStatus1.setFailedPipConfigs(failedPipConfigs);
259 assertTrue(stdPDPStatus.equals(stdPdpStatus1));
260 assertEquals(stdPDPStatus.hashCode(), stdPdpStatus1.hashCode());
262 stdPDPStatus.setFailedPolicies(failedPolicies);
263 assertFalse(stdPDPStatus.equals(stdPdpStatus1));
264 stdPdpStatus1.setFailedPolicies(failedPolicies);
265 assertTrue(stdPDPStatus.equals(stdPdpStatus1));
266 assertEquals(stdPDPStatus.hashCode(), stdPdpStatus1.hashCode());
268 stdPDPStatus.setLoadedPipConfigs(loadedPipConfigs);
269 assertFalse(stdPDPStatus.equals(stdPdpStatus1));
270 stdPdpStatus1.setLoadedPipConfigs(loadedPipConfigs);
271 assertTrue(stdPDPStatus.equals(stdPdpStatus1));
272 assertEquals(stdPDPStatus.hashCode(), stdPdpStatus1.hashCode());
274 stdPDPStatus.setLoadedPolicies(loadedPolicies);
275 assertFalse(stdPDPStatus.equals(stdPdpStatus1));
276 stdPdpStatus1.setLoadedPolicies(loadedPolicies);
277 assertTrue(stdPDPStatus.equals(stdPdpStatus1));
278 assertEquals(stdPDPStatus.hashCode(), stdPdpStatus1.hashCode());
280 stdPDPStatus.setLoadedRootPolicies(loadedRootPolicies);
281 assertFalse(stdPDPStatus.equals(stdPdpStatus1));
282 stdPdpStatus1.setLoadedRootPolicies(loadedRootPolicies);
283 assertTrue(stdPDPStatus.equals(stdPdpStatus1));
284 assertEquals(stdPDPStatus.hashCode(), stdPdpStatus1.hashCode());
286 stdPDPStatus.setLoadErrors(loadErrors);
287 assertFalse(stdPDPStatus.equals(stdPdpStatus1));
288 stdPdpStatus1.setLoadErrors(loadErrors);
289 assertTrue(stdPDPStatus.equals(stdPdpStatus1));
290 assertEquals(stdPDPStatus.hashCode(), stdPdpStatus1.hashCode());
292 stdPDPStatus.setLoadWarnings(loadWarnings);
293 assertFalse(stdPDPStatus.equals(stdPdpStatus1));
294 stdPdpStatus1.setLoadWarnings(loadWarnings);
295 assertTrue(stdPDPStatus.equals(stdPdpStatus1));
296 assertEquals(stdPDPStatus.hashCode(), stdPdpStatus1.hashCode());
300 public void testEqualsSameObject() {
301 assertTrue(stdPDPStatus.equals(stdPDPStatus));
305 public void testEqualsNull() {
306 assertFalse(stdPDPStatus.equals(null));
310 public void testEqualsInstanceOfDiffClass() {
311 assertFalse(stdPDPStatus.equals(""));