2 * ============LICENSE_START=======================================================
3 * Copyright (C) 2018 Ericsson. All rights reserved.
4 * ================================================================================
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
9 * http://www.apache.org/licenses/LICENSE-2.0
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 * ============LICENSE_END=========================================================
18 package org.onap.policy.xacml.test.std.pap;
20 import static org.junit.Assert.*;
21 import java.util.HashSet;
23 import org.junit.Test;
24 import org.onap.policy.xacml.std.pap.StdPDPPIPConfig;
25 import org.onap.policy.xacml.std.pap.StdPDPPolicy;
26 import org.onap.policy.xacml.std.pap.StdPDPStatus;
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 public class StdPDPStatusTest {
33 StdPDPStatus stdPDPStatus = new StdPDPStatus();
36 public void testSetAndGetStatus() {
37 Status status = Status.UP_TO_DATE;
38 stdPDPStatus.setStatus(status);
39 assertEquals(status, stdPDPStatus.getStatus());
43 public void testSetAndGetLoadErrors() {
44 Set<String> errors = new HashSet<>();
45 errors.add("An error");
46 stdPDPStatus.setLoadErrors(errors);
47 assertEquals(errors, stdPDPStatus.getLoadErrors());
51 public void testSetAndGetLoadWarnings() {
52 Set<String> warnings = new HashSet<>();
53 warnings.add("An error");
54 stdPDPStatus.setLoadWarnings(warnings);
55 assertEquals(warnings, stdPDPStatus.getLoadWarnings());
59 public void testSetAndGetLoadedPolicies() {
60 Set<PDPPolicy> loadedPolicies = new HashSet<>();
61 loadedPolicies.add(new StdPDPPolicy());
62 stdPDPStatus.setLoadedPolicies(loadedPolicies);
63 assertEquals(loadedPolicies, stdPDPStatus.getLoadedPolicies());
67 public void testSetAndGetLoadedRootPolicies() {
68 Set<PDPPolicy> loadedRootPolicies = new HashSet<>();
69 loadedRootPolicies.add(new StdPDPPolicy());
70 stdPDPStatus.setLoadedRootPolicies(loadedRootPolicies);
71 assertEquals(loadedRootPolicies, stdPDPStatus.getLoadedRootPolicies());
75 public void testSetAndGetFailedPolicies() {
76 Set<PDPPolicy> failedPolicies = new HashSet<>();
77 failedPolicies.add(new StdPDPPolicy());
78 stdPDPStatus.setFailedPolicies(failedPolicies);
79 assertEquals(failedPolicies, stdPDPStatus.getFailedPolicies());
83 public void testSetAndGetLoadedPipConfigs() {
84 Set<PDPPIPConfig> loadedPipConfigs = new HashSet<>();
85 loadedPipConfigs.add(new StdPDPPIPConfig());
86 stdPDPStatus.setLoadedPipConfigs(loadedPipConfigs);
87 assertEquals(loadedPipConfigs, stdPDPStatus.getLoadedPipConfigs());
91 public void testSetAndGetFailedPipConfigs() {
92 Set<PDPPIPConfig> failedPipConfigs = new HashSet<>();
93 failedPipConfigs.add(new StdPDPPIPConfig());
94 stdPDPStatus.setFailedPipConfigs(failedPipConfigs);
95 assertEquals(failedPipConfigs, stdPDPStatus.getFailedPipConfigs());
99 public void testPoliciesOK() {
100 assertTrue(stdPDPStatus.policiesOK());
101 stdPDPStatus.addFailedPolicy(new StdPDPPolicy());
102 assertFalse(stdPDPStatus.policiesOK());
106 public void testPipConfigOK() {
107 assertTrue(stdPDPStatus.pipConfigOK());
108 stdPDPStatus.addFailedPipConfig(new StdPDPPIPConfig());
109 assertFalse(stdPDPStatus.pipConfigOK());
113 public void testIsOkFailedPolicy() {
114 stdPDPStatus.setStatus(Status.UP_TO_DATE);
115 assertTrue(stdPDPStatus.isOk());
116 stdPDPStatus.addFailedPolicy(new StdPDPPolicy());
117 assertFalse(stdPDPStatus.isOk());
121 public void testIsOkFailedPipConfig() {
122 stdPDPStatus.setStatus(Status.UP_TO_DATE);
123 assertTrue(stdPDPStatus.isOk());
124 stdPDPStatus.addFailedPipConfig(new StdPDPPIPConfig());
125 assertFalse(stdPDPStatus.isOk());
129 public void testIsOkStatusOutOfSync() {
130 stdPDPStatus.setStatus(Status.UP_TO_DATE);
131 assertTrue(stdPDPStatus.isOk());
132 stdPDPStatus.setStatus(Status.OUT_OF_SYNCH);
133 assertFalse(stdPDPStatus.isOk());
137 public void testAddLoadError() {
138 stdPDPStatus.addLoadError("An error");
139 assertEquals("An error", stdPDPStatus.getLoadErrors().iterator().next());
143 public void testAddLoadWarning() {
144 stdPDPStatus.addLoadWarning("A warning");
145 assertEquals("A warning", stdPDPStatus.getLoadWarnings().iterator().next());
149 public void testAddLoadedPolicy() {
150 PDPPolicy policy = new StdPDPPolicy();
151 stdPDPStatus.addLoadedPolicy(policy);
152 assertEquals(policy, stdPDPStatus.getLoadedPolicies().iterator().next());
156 public void testAddRootPolicy() {
157 PDPPolicy policy = new StdPDPPolicy();
158 stdPDPStatus.addRootPolicy(policy);
159 assertEquals(policy, stdPDPStatus.getLoadedRootPolicies().iterator().next());
163 public void testAddAllLoadedRootPolicy() {
164 Set<PDPPolicy> policies = new HashSet<>();
165 PDPPolicy policy = new StdPDPPolicy();
166 policies.add(policy);
167 stdPDPStatus.addAllLoadedRootPolicies(policies);
168 assertEquals(policies, stdPDPStatus.getLoadedRootPolicies());
172 public void testAddLoadedPipConfig(){
173 PDPPIPConfig pipConfig = new StdPDPPIPConfig();
174 stdPDPStatus.addLoadedPipConfig(pipConfig);
175 assertEquals(pipConfig, stdPDPStatus.getLoadedPipConfigs().iterator().next());
179 public void testSet() {
180 Status status = Status.UP_TO_DATE;
181 Set<PDPPIPConfig> failedPIPConfigs = new HashSet<>();
182 failedPIPConfigs.add(new StdPDPPIPConfig());
183 Set<PDPPolicy> failedPolicies = new HashSet<>();
184 failedPolicies.add(new StdPDPPolicy());
185 Set<PDPPIPConfig> loadedPIPConfigs = new HashSet<>();
186 loadedPIPConfigs.add(new StdPDPPIPConfig());
187 Set<PDPPolicy> loadedPolicies = new HashSet<>();
188 loadedPolicies.add(new StdPDPPolicy());
189 Set<PDPPolicy> loadedRootPolicies = new HashSet<>();
190 loadedRootPolicies.add(new StdPDPPolicy());
191 Set<String> loadErrors = new HashSet<>();
192 loadErrors.add("An error");
193 Set<String> loadWarnings = new HashSet<>();
194 loadWarnings.add("An error");
196 stdPDPStatus.setStatus(status);
197 stdPDPStatus.setFailedPipConfigs(failedPIPConfigs);
198 stdPDPStatus.setFailedPolicies(failedPolicies);
199 stdPDPStatus.setLoadedPipConfigs(loadedPIPConfigs);
200 stdPDPStatus.setLoadedPolicies(loadedPolicies);
201 stdPDPStatus.setLoadedRootPolicies(loadedRootPolicies);
202 stdPDPStatus.setLoadErrors(loadErrors);
203 stdPDPStatus.setLoadWarnings(loadWarnings);
205 StdPDPStatus stdPDPStatus1 = new StdPDPStatus();
206 stdPDPStatus1.set(stdPDPStatus);
208 assertEquals(status, stdPDPStatus1.getStatus());
209 assertEquals(loadErrors, stdPDPStatus1.getLoadErrors());
210 assertEquals(loadWarnings, stdPDPStatus1.getLoadWarnings());
211 assertEquals(loadedPolicies, stdPDPStatus1.getLoadedPolicies());
212 assertEquals(loadedRootPolicies, stdPDPStatus1.getLoadedRootPolicies());
213 assertEquals(failedPolicies, stdPDPStatus1.getFailedPolicies());
214 assertEquals(loadedPIPConfigs, stdPDPStatus1.getLoadedPipConfigs());
215 assertEquals(failedPIPConfigs, stdPDPStatus1.getFailedPipConfigs());
217 assertEquals("StdPDPStatus [status=UP_TO_DATE, loadErrors=[An error], loadWarnings=[An error], loadedPolicies=[StdPDPPolicy "
218 + "[id=null, name=null, policyId=null, description=null, version=, isRoot=false, isValid=false, location=null]], "
219 + "loadedRootPolicies=[StdPDPPolicy [id=null, name=null, policyId=null, description=null, version=, isRoot=false, "
220 + "isValid=false, location=null]], failedPolicies=[StdPDPPolicy [id=null, name=null, policyId=null, description=null, "
221 + "version=, isRoot=false, isValid=false, location=null]], loadedPIPConfigs=[StdPDPPIPConfig [id=null, name=null, "
222 + "description=null, classname=null, config={}]], failedPIPConfigs=[StdPDPPIPConfig [id=null, name=null, description=null, classname=null, config={}]]]",
223 stdPDPStatus1.toString());
227 public void testEqualsAndHashCode() {
228 Status status = Status.UP_TO_DATE;
229 Set<PDPPIPConfig> failedPIPConfigs = new HashSet<>();
230 failedPIPConfigs.add(new StdPDPPIPConfig());
231 Set<PDPPolicy> failedPolicies = new HashSet<>();
232 failedPolicies.add(new StdPDPPolicy());
233 Set<PDPPIPConfig> loadedPIPConfigs = new HashSet<>();
234 loadedPIPConfigs.add(new StdPDPPIPConfig());
235 Set<PDPPolicy> loadedPolicies = new HashSet<>();
236 loadedPolicies.add(new StdPDPPolicy());
237 Set<PDPPolicy> loadedRootPolicies = new HashSet<>();
238 loadedRootPolicies.add(new StdPDPPolicy());
239 Set<String> loadErrors = new HashSet<>();
240 loadErrors.add("An error");
241 Set<String> loadWarnings = new HashSet<>();
242 loadWarnings.add("An error");
244 StdPDPStatus stdPDPStatus1 = new StdPDPStatus();
246 assertTrue(stdPDPStatus.equals(stdPDPStatus1));
248 stdPDPStatus.setStatus(status);
249 assertFalse(stdPDPStatus.equals(stdPDPStatus1));
250 stdPDPStatus1.setStatus(status);
251 assertTrue(stdPDPStatus.equals(stdPDPStatus1));
252 assertEquals(stdPDPStatus.hashCode(), stdPDPStatus1.hashCode());
254 stdPDPStatus.setFailedPipConfigs(failedPIPConfigs);
255 assertFalse(stdPDPStatus.equals(stdPDPStatus1));
256 stdPDPStatus1.setFailedPipConfigs(failedPIPConfigs);
257 assertTrue(stdPDPStatus.equals(stdPDPStatus1));
258 assertEquals(stdPDPStatus.hashCode(), stdPDPStatus1.hashCode());
260 stdPDPStatus.setFailedPolicies(failedPolicies);
261 assertFalse(stdPDPStatus.equals(stdPDPStatus1));
262 stdPDPStatus1.setFailedPolicies(failedPolicies);
263 assertTrue(stdPDPStatus.equals(stdPDPStatus1));
264 assertEquals(stdPDPStatus.hashCode(), stdPDPStatus1.hashCode());
266 stdPDPStatus.setLoadedPipConfigs(loadedPIPConfigs);
267 assertFalse(stdPDPStatus.equals(stdPDPStatus1));
268 stdPDPStatus1.setLoadedPipConfigs(loadedPIPConfigs);
269 assertTrue(stdPDPStatus.equals(stdPDPStatus1));
270 assertEquals(stdPDPStatus.hashCode(), stdPDPStatus1.hashCode());
272 stdPDPStatus.setLoadedPolicies(loadedPolicies);
273 assertFalse(stdPDPStatus.equals(stdPDPStatus1));
274 stdPDPStatus1.setLoadedPolicies(loadedPolicies);
275 assertTrue(stdPDPStatus.equals(stdPDPStatus1));
276 assertEquals(stdPDPStatus.hashCode(), stdPDPStatus1.hashCode());
278 stdPDPStatus.setLoadedRootPolicies(loadedRootPolicies);
279 assertFalse(stdPDPStatus.equals(stdPDPStatus1));
280 stdPDPStatus1.setLoadedRootPolicies(loadedRootPolicies);
281 assertTrue(stdPDPStatus.equals(stdPDPStatus1));
282 assertEquals(stdPDPStatus.hashCode(), stdPDPStatus1.hashCode());
284 stdPDPStatus.setLoadErrors(loadErrors);
285 assertFalse(stdPDPStatus.equals(stdPDPStatus1));
286 stdPDPStatus1.setLoadErrors(loadErrors);
287 assertTrue(stdPDPStatus.equals(stdPDPStatus1));
288 assertEquals(stdPDPStatus.hashCode(), stdPDPStatus1.hashCode());
290 stdPDPStatus.setLoadWarnings(loadWarnings);
291 assertFalse(stdPDPStatus.equals(stdPDPStatus1));
292 stdPDPStatus1.setLoadWarnings(loadWarnings);
293 assertTrue(stdPDPStatus.equals(stdPDPStatus1));
294 assertEquals(stdPDPStatus.hashCode(), stdPDPStatus1.hashCode());
298 public void testEqualsSameObject() {
299 assertTrue(stdPDPStatus.equals(stdPDPStatus));
303 public void testEqualsNull() {
304 assertFalse(stdPDPStatus.equals(null));
308 public void testEqualsInstanceOfDiffClass() {
309 assertFalse(stdPDPStatus.equals(""));