2 * ============LICENSE_START=======================================================
3 * Copyright (C) 2018 Ericsson. All rights reserved.
4 * ================================================================================
5 * Modifications Copyright (C) 2019 Samsung
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.*;
23 import java.util.HashSet;
25 import org.junit.Test;
26 import org.onap.policy.xacml.std.pap.StdPDPPIPConfig;
27 import org.onap.policy.xacml.std.pap.StdPDPPolicy;
28 import org.onap.policy.xacml.std.pap.StdPDPStatus;
29 import com.att.research.xacml.api.pap.PDPPIPConfig;
30 import com.att.research.xacml.api.pap.PDPPolicy;
31 import com.att.research.xacml.api.pap.PDPStatus.Status;
33 public class StdPDPStatusTest {
35 StdPDPStatus stdPDPStatus = new StdPDPStatus();
38 public void testSetAndGetStatus() {
39 Status status = Status.UP_TO_DATE;
40 stdPDPStatus.setStatus(status);
41 assertEquals(status, stdPDPStatus.getStatus());
45 public void testSetAndGetLoadErrors() {
46 Set<String> errors = new HashSet<>();
47 errors.add("An error");
48 stdPDPStatus.setLoadErrors(errors);
49 assertEquals(errors, stdPDPStatus.getLoadErrors());
53 public void testSetAndGetLoadWarnings() {
54 Set<String> warnings = new HashSet<>();
55 warnings.add("An error");
56 stdPDPStatus.setLoadWarnings(warnings);
57 assertEquals(warnings, stdPDPStatus.getLoadWarnings());
61 public void testSetAndGetLoadedPolicies() {
62 Set<PDPPolicy> loadedPolicies = new HashSet<>();
63 loadedPolicies.add(new StdPDPPolicy());
64 stdPDPStatus.setLoadedPolicies(loadedPolicies);
65 assertEquals(loadedPolicies, stdPDPStatus.getLoadedPolicies());
69 public void testSetAndGetLoadedRootPolicies() {
70 Set<PDPPolicy> loadedRootPolicies = new HashSet<>();
71 loadedRootPolicies.add(new StdPDPPolicy());
72 stdPDPStatus.setLoadedRootPolicies(loadedRootPolicies);
73 assertEquals(loadedRootPolicies, stdPDPStatus.getLoadedRootPolicies());
77 public void testSetAndGetFailedPolicies() {
78 Set<PDPPolicy> failedPolicies = new HashSet<>();
79 failedPolicies.add(new StdPDPPolicy());
80 stdPDPStatus.setFailedPolicies(failedPolicies);
81 assertEquals(failedPolicies, stdPDPStatus.getFailedPolicies());
85 public void testSetAndGetLoadedPipConfigs() {
86 Set<PDPPIPConfig> loadedPipConfigs = new HashSet<>();
87 loadedPipConfigs.add(new StdPDPPIPConfig());
88 stdPDPStatus.setLoadedPipConfigs(loadedPipConfigs);
89 assertEquals(loadedPipConfigs, stdPDPStatus.getLoadedPipConfigs());
93 public void testSetAndGetFailedPipConfigs() {
94 Set<PDPPIPConfig> failedPipConfigs = new HashSet<>();
95 failedPipConfigs.add(new StdPDPPIPConfig());
96 stdPDPStatus.setFailedPipConfigs(failedPipConfigs);
97 assertEquals(failedPipConfigs, stdPDPStatus.getFailedPipConfigs());
101 public void testPoliciesOK() {
102 assertTrue(stdPDPStatus.policiesOK());
103 stdPDPStatus.addFailedPolicy(new StdPDPPolicy());
104 assertFalse(stdPDPStatus.policiesOK());
108 public void testPipConfigOK() {
109 assertTrue(stdPDPStatus.pipConfigOK());
110 stdPDPStatus.addFailedPipConfig(new StdPDPPIPConfig());
111 assertFalse(stdPDPStatus.pipConfigOK());
115 public void testIsOkFailedPolicy() {
116 stdPDPStatus.setStatus(Status.UP_TO_DATE);
117 assertTrue(stdPDPStatus.isOk());
118 stdPDPStatus.addFailedPolicy(new StdPDPPolicy());
119 assertFalse(stdPDPStatus.isOk());
123 public void testIsOkFailedPipConfig() {
124 stdPDPStatus.setStatus(Status.UP_TO_DATE);
125 assertTrue(stdPDPStatus.isOk());
126 stdPDPStatus.addFailedPipConfig(new StdPDPPIPConfig());
127 assertFalse(stdPDPStatus.isOk());
131 public void testIsOkStatusOutOfSync() {
132 stdPDPStatus.setStatus(Status.UP_TO_DATE);
133 assertTrue(stdPDPStatus.isOk());
134 stdPDPStatus.setStatus(Status.OUT_OF_SYNCH);
135 assertFalse(stdPDPStatus.isOk());
139 public void testAddLoadError() {
140 stdPDPStatus.addLoadError("An error");
141 assertEquals("An error", stdPDPStatus.getLoadErrors().iterator().next());
145 public void testAddLoadWarning() {
146 stdPDPStatus.addLoadWarning("A warning");
147 assertEquals("A warning", stdPDPStatus.getLoadWarnings().iterator().next());
151 public void testAddLoadedPolicy() {
152 PDPPolicy policy = new StdPDPPolicy();
153 stdPDPStatus.addLoadedPolicy(policy);
154 assertEquals(policy, stdPDPStatus.getLoadedPolicies().iterator().next());
158 public void testAddRootPolicy() {
159 PDPPolicy policy = new StdPDPPolicy();
160 stdPDPStatus.addRootPolicy(policy);
161 assertEquals(policy, stdPDPStatus.getLoadedRootPolicies().iterator().next());
165 public void testAddAllLoadedRootPolicy() {
166 Set<PDPPolicy> policies = new HashSet<>();
167 PDPPolicy policy = new StdPDPPolicy();
168 policies.add(policy);
169 stdPDPStatus.addAllLoadedRootPolicies(policies);
170 assertEquals(policies, stdPDPStatus.getLoadedRootPolicies());
174 public void testAddLoadedPipConfig() {
175 PDPPIPConfig pipConfig = new StdPDPPIPConfig();
176 stdPDPStatus.addLoadedPipConfig(pipConfig);
177 assertEquals(pipConfig, stdPDPStatus.getLoadedPipConfigs().iterator().next());
181 public void testSet() {
182 Status status = Status.UP_TO_DATE;
183 Set<PDPPIPConfig> failedPIPConfigs = new HashSet<>();
184 failedPIPConfigs.add(new StdPDPPIPConfig());
185 Set<PDPPolicy> failedPolicies = new HashSet<>();
186 failedPolicies.add(new StdPDPPolicy());
187 Set<PDPPIPConfig> loadedPIPConfigs = new HashSet<>();
188 loadedPIPConfigs.add(new StdPDPPIPConfig());
189 Set<PDPPolicy> loadedPolicies = new HashSet<>();
190 loadedPolicies.add(new StdPDPPolicy());
191 Set<PDPPolicy> loadedRootPolicies = new HashSet<>();
192 loadedRootPolicies.add(new StdPDPPolicy());
193 Set<String> loadErrors = new HashSet<>();
194 loadErrors.add("An error");
195 Set<String> loadWarnings = new HashSet<>();
196 loadWarnings.add("An error");
198 stdPDPStatus.setStatus(status);
199 stdPDPStatus.setFailedPipConfigs(failedPIPConfigs);
200 stdPDPStatus.setFailedPolicies(failedPolicies);
201 stdPDPStatus.setLoadedPipConfigs(loadedPIPConfigs);
202 stdPDPStatus.setLoadedPolicies(loadedPolicies);
203 stdPDPStatus.setLoadedRootPolicies(loadedRootPolicies);
204 stdPDPStatus.setLoadErrors(loadErrors);
205 stdPDPStatus.setLoadWarnings(loadWarnings);
207 StdPDPStatus stdPDPStatus1 = new StdPDPStatus();
208 stdPDPStatus1.set(stdPDPStatus);
210 assertEquals(status, stdPDPStatus1.getStatus());
211 assertEquals(loadErrors, stdPDPStatus1.getLoadErrors());
212 assertEquals(loadWarnings, stdPDPStatus1.getLoadWarnings());
213 assertEquals(loadedPolicies, stdPDPStatus1.getLoadedPolicies());
214 assertEquals(loadedRootPolicies, stdPDPStatus1.getLoadedRootPolicies());
215 assertEquals(failedPolicies, stdPDPStatus1.getFailedPolicies());
216 assertEquals(loadedPIPConfigs, stdPDPStatus1.getLoadedPipConfigs());
217 assertEquals(failedPIPConfigs, stdPDPStatus1.getFailedPipConfigs());
220 "StdPDPStatus [status=UP_TO_DATE, loadErrors=[An error], loadWarnings=[An error],"
221 + " loadedPolicies=[StdPDPPolicy [id=null, name=null, policyId=null, description=null,"
222 + " version=, isRoot=false, isValid=false, location=null]],"
223 + " loadedRootPolicies=[StdPDPPolicy [id=null, name=null, policyId=null, description=null,"
224 + " version=, isRoot=false, isValid=false, location=null]],"
225 + " failedPolicies=[StdPDPPolicy [id=null, name=null, policyId=null, description=null,"
226 + " version=, isRoot=false, isValid=false, location=null]], loadedPIPConfigs=[StdPDPPIPConfig"
227 + " [id=null, name=null, description=null, classname=null, config={}]], failedPIPConfigs="
228 + "[StdPDPPIPConfig [id=null, name=null, description=null, classname=null, config={}]]]",
229 stdPDPStatus1.toString());
233 public void testEqualsAndHashCode() {
234 Status status = Status.UP_TO_DATE;
235 Set<PDPPIPConfig> failedPIPConfigs = new HashSet<>();
236 failedPIPConfigs.add(new StdPDPPIPConfig());
237 Set<PDPPolicy> failedPolicies = new HashSet<>();
238 failedPolicies.add(new StdPDPPolicy());
239 Set<PDPPIPConfig> loadedPIPConfigs = new HashSet<>();
240 loadedPIPConfigs.add(new StdPDPPIPConfig());
241 Set<PDPPolicy> loadedPolicies = new HashSet<>();
242 loadedPolicies.add(new StdPDPPolicy());
243 Set<PDPPolicy> loadedRootPolicies = new HashSet<>();
244 loadedRootPolicies.add(new StdPDPPolicy());
245 Set<String> loadErrors = new HashSet<>();
246 loadErrors.add("An error");
247 Set<String> loadWarnings = new HashSet<>();
248 loadWarnings.add("An error");
250 StdPDPStatus stdPDPStatus1 = new StdPDPStatus();
252 assertTrue(stdPDPStatus.equals(stdPDPStatus1));
254 stdPDPStatus.setStatus(status);
255 assertFalse(stdPDPStatus.equals(stdPDPStatus1));
256 stdPDPStatus1.setStatus(status);
257 assertTrue(stdPDPStatus.equals(stdPDPStatus1));
258 assertEquals(stdPDPStatus.hashCode(), stdPDPStatus1.hashCode());
260 stdPDPStatus.setFailedPipConfigs(failedPIPConfigs);
261 assertFalse(stdPDPStatus.equals(stdPDPStatus1));
262 stdPDPStatus1.setFailedPipConfigs(failedPIPConfigs);
263 assertTrue(stdPDPStatus.equals(stdPDPStatus1));
264 assertEquals(stdPDPStatus.hashCode(), stdPDPStatus1.hashCode());
266 stdPDPStatus.setFailedPolicies(failedPolicies);
267 assertFalse(stdPDPStatus.equals(stdPDPStatus1));
268 stdPDPStatus1.setFailedPolicies(failedPolicies);
269 assertTrue(stdPDPStatus.equals(stdPDPStatus1));
270 assertEquals(stdPDPStatus.hashCode(), stdPDPStatus1.hashCode());
272 stdPDPStatus.setLoadedPipConfigs(loadedPIPConfigs);
273 assertFalse(stdPDPStatus.equals(stdPDPStatus1));
274 stdPDPStatus1.setLoadedPipConfigs(loadedPIPConfigs);
275 assertTrue(stdPDPStatus.equals(stdPDPStatus1));
276 assertEquals(stdPDPStatus.hashCode(), stdPDPStatus1.hashCode());
278 stdPDPStatus.setLoadedPolicies(loadedPolicies);
279 assertFalse(stdPDPStatus.equals(stdPDPStatus1));
280 stdPDPStatus1.setLoadedPolicies(loadedPolicies);
281 assertTrue(stdPDPStatus.equals(stdPDPStatus1));
282 assertEquals(stdPDPStatus.hashCode(), stdPDPStatus1.hashCode());
284 stdPDPStatus.setLoadedRootPolicies(loadedRootPolicies);
285 assertFalse(stdPDPStatus.equals(stdPDPStatus1));
286 stdPDPStatus1.setLoadedRootPolicies(loadedRootPolicies);
287 assertTrue(stdPDPStatus.equals(stdPDPStatus1));
288 assertEquals(stdPDPStatus.hashCode(), stdPDPStatus1.hashCode());
290 stdPDPStatus.setLoadErrors(loadErrors);
291 assertFalse(stdPDPStatus.equals(stdPDPStatus1));
292 stdPDPStatus1.setLoadErrors(loadErrors);
293 assertTrue(stdPDPStatus.equals(stdPDPStatus1));
294 assertEquals(stdPDPStatus.hashCode(), stdPDPStatus1.hashCode());
296 stdPDPStatus.setLoadWarnings(loadWarnings);
297 assertFalse(stdPDPStatus.equals(stdPDPStatus1));
298 stdPDPStatus1.setLoadWarnings(loadWarnings);
299 assertTrue(stdPDPStatus.equals(stdPDPStatus1));
300 assertEquals(stdPDPStatus.hashCode(), stdPDPStatus1.hashCode());
304 public void testEqualsSameObject() {
305 assertTrue(stdPDPStatus.equals(stdPDPStatus));
309 public void testEqualsNull() {
310 assertFalse(stdPDPStatus.equals(null));
314 public void testEqualsInstanceOfDiffClass() {
315 assertFalse(stdPDPStatus.equals(""));