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.assertFalse;
24 import static org.junit.Assert.assertTrue;
25 import java.util.HashSet;
27 import org.junit.Before;
28 import org.junit.Test;
29 import org.onap.policy.common.logging.flexlogger.FlexLogger;
30 import org.onap.policy.common.logging.flexlogger.Logger;
31 import org.onap.policy.xacml.std.pap.StdPDP;
32 import org.onap.policy.xacml.std.pap.StdPDPGroupStatus;
33 import org.onap.policy.xacml.std.pap.StdPDPPIPConfig;
34 import org.onap.policy.xacml.std.pap.StdPDPPolicy;
35 import com.att.research.xacml.api.pap.PDP;
36 import com.att.research.xacml.api.pap.PDPGroupStatus.Status;
37 import com.att.research.xacml.api.pap.PDPPIPConfig;
38 import com.att.research.xacml.api.pap.PDPPolicy;
40 public class StdPDPGroupStatusTest {
42 private static Logger logger = FlexLogger.getLogger(StdPDPGroupStatus.class);
44 private StdPDPGroupStatus stdPDPGroupStatus;
50 stdPDPGroupStatus = new StdPDPGroupStatus();
51 } catch (Exception e) {
57 public void tesGgetStatus() {
59 assertTrue(stdPDPGroupStatus.getStatus() != null);
60 } catch (Exception e) {
66 public void testGetFailedPIPConfigs() {
68 assertTrue(stdPDPGroupStatus.getFailedPIPConfigs() != null);
69 } catch (Exception e) {
75 public void testGetUnknownPDPs() {
77 assertTrue(stdPDPGroupStatus.getUnknownPDPs() != null);
78 } catch (Exception e) {
84 public void testGetLoadErrors() {
86 stdPDPGroupStatus.setLoadErrors(new HashSet<String>());
87 assertTrue(stdPDPGroupStatus.getLoadErrors() != null);
88 } catch (Exception e) {
94 public void testGetLoadWarnings() {
96 stdPDPGroupStatus.setLoadWarnings(new HashSet<>());
97 assertTrue(stdPDPGroupStatus.getLoadWarnings() != null);
98 } catch (Exception e) {
104 public void testGetLoadedPolicies() {
106 stdPDPGroupStatus.setLoadedPolicies(new HashSet<>());
107 assertTrue(stdPDPGroupStatus.getLoadedPolicies() != null);
108 } catch (Exception e) {
114 public void testGetFailedPolicies() {
116 stdPDPGroupStatus.setFailedPolicies(new HashSet<>());
117 assertTrue(stdPDPGroupStatus.getFailedPolicies() != null);
118 } catch (Exception e) {
124 public void testGetLoadedPipConfigs() {
126 stdPDPGroupStatus.addLoadedPipConfig(new StdPDPPIPConfig());
127 assertTrue(stdPDPGroupStatus.getLoadedPipConfigs() != null);
128 } catch (Exception e) {
134 public void testGetFailedPipConfigs() {
136 stdPDPGroupStatus.addFailedPipConfig(new StdPDPPIPConfig());
137 assertTrue(stdPDPGroupStatus.getFailedPipConfigs() != null);
138 } catch (Exception e) {
144 public void testGetInSynchPDPs() {
146 stdPDPGroupStatus.addInSynchPDP(new StdPDP());
147 assertTrue(stdPDPGroupStatus.getInSynchPDPs() != null);
148 } catch (Exception e) {
154 public void testGetOutOfSynchPDPs() {
156 stdPDPGroupStatus.addOutOfSynchPDP(new StdPDP());
157 assertTrue(stdPDPGroupStatus.getOutOfSynchPDPs() != null);
158 } catch (Exception e) {
164 public void testGetFailedPDPs() {
166 stdPDPGroupStatus.addFailedPDP(new StdPDP());
167 assertTrue(stdPDPGroupStatus.getFailedPDPs() != null);
168 } catch (Exception e) {
174 public void testGetUpdatingPDPs() {
176 stdPDPGroupStatus.addUpdatingPDP(new StdPDP());
177 assertTrue(stdPDPGroupStatus.getUpdatingPDPs() != null);
178 } catch (Exception e) {
184 public void testGetLastUpdateFailedPDPs() {
186 stdPDPGroupStatus.addLastUpdateFailedPDP(new StdPDP());
187 assertTrue(stdPDPGroupStatus.getLastUpdateFailedPDPs() != null);
188 } catch (Exception e) {
194 public void testGetUnknownStatusPDPs() {
196 stdPDPGroupStatus.addUnknownPDP(new StdPDP());
197 assertTrue(stdPDPGroupStatus.getUnknownStatusPDPs() != null);
198 } catch (Exception e) {
204 public void testIsGroupOk() {
206 stdPDPGroupStatus.policiesOK();
207 assertTrue(stdPDPGroupStatus.isGroupOk() == false);
208 } catch (Exception e) {
214 public void testPoliciesOK() {
215 assertTrue(stdPDPGroupStatus.policiesOK());
216 stdPDPGroupStatus.addFailedPolicy(new StdPDPPolicy());
217 assertFalse(stdPDPGroupStatus.policiesOK());
221 public void testPipConfigOK() {
222 assertTrue(stdPDPGroupStatus.pipConfigOK());
223 stdPDPGroupStatus.addFailedPipConfig(new StdPDPPIPConfig());
224 assertFalse(stdPDPGroupStatus.pipConfigOK());
228 public void testPdpsOKOutOfSyncPdp() {
229 assertTrue(stdPDPGroupStatus.pdpsOK());
230 stdPDPGroupStatus.addOutOfSynchPDP(new StdPDP());
231 assertFalse(stdPDPGroupStatus.pdpsOK());
235 public void testPdpsOKFailedPdp() {
236 assertTrue(stdPDPGroupStatus.pdpsOK());
237 stdPDPGroupStatus.addFailedPDP(new StdPDP());
238 assertFalse(stdPDPGroupStatus.pdpsOK());
242 public void testPdpsOKLastUpdateFailedPdp() {
243 assertTrue(stdPDPGroupStatus.pdpsOK());
244 stdPDPGroupStatus.addLastUpdateFailedPDP(new StdPDP());
245 assertFalse(stdPDPGroupStatus.pdpsOK());
249 public void testPdpsOKUnknownPdp() {
250 assertTrue(stdPDPGroupStatus.pdpsOK());
251 stdPDPGroupStatus.addUnknownPDP(new StdPDP());
252 assertFalse(stdPDPGroupStatus.pdpsOK());
256 public void testIsGroupOkFailedPolicy() {
257 stdPDPGroupStatus.setStatus(Status.OK);
258 assertTrue(stdPDPGroupStatus.isGroupOk());
259 stdPDPGroupStatus.addFailedPolicy(new StdPDPPolicy());
260 assertFalse(stdPDPGroupStatus.isGroupOk());
264 public void testIsGroupOkFailedPipConfig() {
265 stdPDPGroupStatus.setStatus(Status.OK);
266 assertTrue(stdPDPGroupStatus.isGroupOk());
267 stdPDPGroupStatus.addFailedPipConfig(new StdPDPPIPConfig());
268 assertFalse(stdPDPGroupStatus.isGroupOk());
272 public void testIsGroupOkFailedPdp() {
273 stdPDPGroupStatus.setStatus(Status.OK);
274 assertTrue(stdPDPGroupStatus.isGroupOk());
275 stdPDPGroupStatus.addLastUpdateFailedPDP(new StdPDP());
276 assertFalse(stdPDPGroupStatus.isGroupOk());
280 public void testIsGroupOkLoadErrors() {
281 stdPDPGroupStatus.setStatus(Status.OK);
282 assertTrue(stdPDPGroupStatus.isGroupOk());
283 stdPDPGroupStatus.addLoadError("A load error");
284 assertFalse(stdPDPGroupStatus.isGroupOk());
288 public void testIsGroupOkStatusOutOfSynch() {
289 stdPDPGroupStatus.setStatus(Status.OK);
290 assertTrue(stdPDPGroupStatus.isGroupOk());
291 stdPDPGroupStatus.setStatus(Status.OUT_OF_SYNCH);
292 assertFalse(stdPDPGroupStatus.isGroupOk());
296 public void testConstructor() {
297 Status status = Status.OK;
298 Set<PDP> failedPDPs = new HashSet<>();
299 failedPDPs.add(new StdPDP());
300 Set<PDPPIPConfig> failedPIPConfigs = new HashSet<>();
301 failedPIPConfigs.add(new StdPDPPIPConfig());
302 Set<PDPPolicy> failedPolicies = new HashSet<>();
303 failedPolicies.add(new StdPDPPolicy());
304 Set<PDP> inSynchPDPs = new HashSet<>();
305 inSynchPDPs.add(new StdPDP());
306 Set<PDP> lastUpdateFailedPDPs = new HashSet<>();
307 lastUpdateFailedPDPs.add(new StdPDP());
308 Set<PDPPIPConfig> loadedPIPConfigs = new HashSet<>();
309 loadedPIPConfigs.add(new StdPDPPIPConfig());
310 Set<PDPPolicy> loadedPolicies = new HashSet<>();
311 loadedPolicies.add(new StdPDPPolicy());
312 Set<String> loadErrors = new HashSet<>();
313 loadErrors.add("An error");
314 Set<String> loadWarnings = new HashSet<>();
315 loadWarnings.add("An error");
316 Set<PDP> outOfSynchPDPs = new HashSet<>();
317 outOfSynchPDPs.add(new StdPDP());
318 Set<PDP> unknownPDPs = new HashSet<>();
319 unknownPDPs.add(new StdPDP());
320 Set<PDP> updatingPDPs = new HashSet<>();
321 updatingPDPs.add(new StdPDP());
324 stdPDPGroupStatus.setStatus(status);
325 stdPDPGroupStatus.setFailedPDPs(failedPDPs);
326 stdPDPGroupStatus.setFailedPIPConfigs(failedPIPConfigs);
327 stdPDPGroupStatus.setFailedPolicies(failedPolicies);
328 stdPDPGroupStatus.setInSynchPDPs(inSynchPDPs);
329 stdPDPGroupStatus.setLastUpdateFailedPDPs(lastUpdateFailedPDPs);
330 stdPDPGroupStatus.setLoadedPIPConfigs(loadedPIPConfigs);
331 stdPDPGroupStatus.setLoadedPolicies(loadedPolicies);
332 stdPDPGroupStatus.setLoadErrors(loadErrors);
333 stdPDPGroupStatus.setLoadWarnings(loadWarnings);
334 stdPDPGroupStatus.setOutOfSynchPDPs(outOfSynchPDPs);
335 stdPDPGroupStatus.setUnknownPDPs(unknownPDPs);
336 stdPDPGroupStatus.setUpdatingPDPs(updatingPDPs);
338 StdPDPGroupStatus stdPDPGroupStatus2 = new StdPDPGroupStatus(stdPDPGroupStatus);
340 assertEquals(status, stdPDPGroupStatus2.getStatus());
341 assertEquals(failedPDPs, stdPDPGroupStatus2.getFailedPDPs());
342 assertEquals(failedPIPConfigs, stdPDPGroupStatus2.getFailedPIPConfigs());
343 assertEquals(failedPolicies, stdPDPGroupStatus2.getFailedPolicies());
344 assertEquals(inSynchPDPs, stdPDPGroupStatus2.getInSynchPDPs());
345 assertEquals(lastUpdateFailedPDPs, stdPDPGroupStatus2.getLastUpdateFailedPDPs());
346 assertEquals(loadedPIPConfigs, stdPDPGroupStatus2.getLoadedPIPConfigs());
347 assertEquals(loadedPolicies, stdPDPGroupStatus2.getLoadedPolicies());
348 assertEquals(loadErrors, stdPDPGroupStatus2.getLoadErrors());
349 assertEquals(loadWarnings, stdPDPGroupStatus2.getLoadWarnings());
350 assertEquals(outOfSynchPDPs, stdPDPGroupStatus2.getOutOfSynchPDPs());
351 assertEquals(unknownPDPs, stdPDPGroupStatus2.getUnknownPDPs());
352 assertEquals(updatingPDPs, stdPDPGroupStatus2.getUpdatingPDPs());
356 public void testEqualsAndHashCode() {
357 Status status = Status.OK;
358 Set<PDP> failedPDPs = new HashSet<>();
359 failedPDPs.add(new StdPDP());
360 Set<PDPPIPConfig> failedPIPConfigs = new HashSet<>();
361 failedPIPConfigs.add(new StdPDPPIPConfig());
362 Set<PDPPolicy> failedPolicies = new HashSet<>();
363 failedPolicies.add(new StdPDPPolicy());
364 Set<PDP> inSynchPDPs = new HashSet<>();
365 inSynchPDPs.add(new StdPDP());
366 Set<PDP> lastUpdateFailedPDPs = new HashSet<>();
367 lastUpdateFailedPDPs.add(new StdPDP());
368 Set<PDPPIPConfig> loadedPIPConfigs = new HashSet<>();
369 loadedPIPConfigs.add(new StdPDPPIPConfig());
370 Set<PDPPolicy> loadedPolicies = new HashSet<>();
371 loadedPolicies.add(new StdPDPPolicy());
372 Set<String> loadErrors = new HashSet<>();
373 loadErrors.add("An error");
374 Set<String> loadWarnings = new HashSet<>();
375 loadWarnings.add("An error");
376 Set<PDP> outOfSynchPDPs = new HashSet<>();
377 outOfSynchPDPs.add(new StdPDP());
378 Set<PDP> unknownPDPs = new HashSet<>();
379 unknownPDPs.add(new StdPDP());
380 Set<PDP> updatingPDPs = new HashSet<>();
381 updatingPDPs.add(new StdPDP());
383 StdPDPGroupStatus stdPDPGroupStatus1 = new StdPDPGroupStatus();
385 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
387 stdPDPGroupStatus.setStatus(status);
388 assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
389 stdPDPGroupStatus1.setStatus(status);
390 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
391 assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
393 stdPDPGroupStatus.setFailedPDPs(failedPDPs);
394 assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
395 stdPDPGroupStatus1.setFailedPDPs(failedPDPs);
396 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
397 assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
399 stdPDPGroupStatus.setFailedPIPConfigs(failedPIPConfigs);
400 assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
401 stdPDPGroupStatus1.setFailedPIPConfigs(failedPIPConfigs);
402 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
403 assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
405 stdPDPGroupStatus.setFailedPolicies(failedPolicies);
406 assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
407 stdPDPGroupStatus1.setFailedPolicies(failedPolicies);
408 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
409 assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
411 stdPDPGroupStatus.setInSynchPDPs(inSynchPDPs);
412 assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
413 stdPDPGroupStatus1.setInSynchPDPs(inSynchPDPs);
414 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
415 assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
417 stdPDPGroupStatus.setLastUpdateFailedPDPs(lastUpdateFailedPDPs);
418 assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
419 stdPDPGroupStatus1.setLastUpdateFailedPDPs(lastUpdateFailedPDPs);
420 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
421 assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
423 stdPDPGroupStatus.setLoadedPIPConfigs(loadedPIPConfigs);
424 assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
425 stdPDPGroupStatus1.setLoadedPIPConfigs(loadedPIPConfigs);
426 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
427 assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
429 stdPDPGroupStatus.setLoadedPolicies(loadedPolicies);
430 assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
431 stdPDPGroupStatus1.setLoadedPolicies(loadedPolicies);
432 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
433 assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
435 stdPDPGroupStatus.setLoadErrors(loadErrors);
436 assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
437 stdPDPGroupStatus1.setLoadErrors(loadErrors);
438 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
439 assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
441 stdPDPGroupStatus.setLoadWarnings(loadWarnings);
442 assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
443 stdPDPGroupStatus1.setLoadWarnings(loadWarnings);
444 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
445 assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
447 stdPDPGroupStatus.setOutOfSynchPDPs(outOfSynchPDPs);
448 assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
449 stdPDPGroupStatus1.setOutOfSynchPDPs(outOfSynchPDPs);
450 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
451 assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
453 stdPDPGroupStatus.setUnknownPDPs(unknownPDPs);
454 assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
455 stdPDPGroupStatus1.setUnknownPDPs(unknownPDPs);
456 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
457 assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
459 stdPDPGroupStatus.setUpdatingPDPs(updatingPDPs);
460 assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
461 stdPDPGroupStatus1.setUpdatingPDPs(updatingPDPs);
462 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
463 assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
467 public void testEqualsSameObject() {
468 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus));
472 public void testEqualsNull() {
473 assertFalse(stdPDPGroupStatus.equals(null));
477 public void testEqualsInstanceOfDiffClass() {
478 assertFalse(stdPDPGroupStatus.equals(""));