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.assertFalse;
27 import static org.junit.Assert.assertNotNull;
28 import static org.junit.Assert.assertTrue;
30 import com.att.research.xacml.api.pap.PDP;
31 import com.att.research.xacml.api.pap.PDPGroupStatus.Status;
32 import com.att.research.xacml.api.pap.PDPPIPConfig;
33 import com.att.research.xacml.api.pap.PDPPolicy;
35 import java.util.HashSet;
38 import org.junit.Before;
39 import org.junit.Test;
40 import org.onap.policy.common.logging.flexlogger.FlexLogger;
41 import org.onap.policy.common.logging.flexlogger.Logger;
42 import org.onap.policy.xacml.std.pap.StdPDP;
43 import org.onap.policy.xacml.std.pap.StdPDPGroupStatus;
44 import org.onap.policy.xacml.std.pap.StdPDPPIPConfig;
45 import org.onap.policy.xacml.std.pap.StdPDPPolicy;
47 public class StdPDPGroupStatusTest {
49 private static Logger logger = FlexLogger.getLogger(StdPDPGroupStatus.class);
51 private StdPDPGroupStatus stdPDPGroupStatus;
60 stdPDPGroupStatus = new StdPDPGroupStatus();
61 } catch (Exception e) {
67 public void tesGgetStatus() {
69 assertTrue(stdPDPGroupStatus.getStatus() != null);
70 } catch (Exception e) {
76 public void testGetFailedPIPConfigs() {
78 assertTrue(stdPDPGroupStatus.getFailedPIPConfigs() != null);
79 } catch (Exception e) {
85 public void testGetUnknownPDPs() {
87 assertTrue(stdPDPGroupStatus.getUnknownPDPs() != null);
88 } catch (Exception e) {
94 public void testGetLoadErrors() {
96 stdPDPGroupStatus.setLoadErrors(new HashSet<String>());
97 assertTrue(stdPDPGroupStatus.getLoadErrors() != null);
98 } catch (Exception e) {
104 public void testGetLoadWarnings() {
106 stdPDPGroupStatus.setLoadWarnings(new HashSet<>());
107 assertNotNull(stdPDPGroupStatus.getLoadWarnings());
108 stdPDPGroupStatus.addLoadWarning("warn");
109 assertEquals(1, stdPDPGroupStatus.getLoadWarnings().size());
110 } catch (Exception e) {
116 public void testGetLoadedPolicies() {
118 stdPDPGroupStatus.setLoadedPolicies(new HashSet<>());
119 assertTrue(stdPDPGroupStatus.getLoadedPolicies() != null);
120 } catch (Exception e) {
126 public void testGetFailedPolicies() {
128 stdPDPGroupStatus.setFailedPolicies(new HashSet<>());
129 assertTrue(stdPDPGroupStatus.getFailedPolicies() != null);
130 } catch (Exception e) {
136 public void testGetLoadedPipConfigs() {
138 stdPDPGroupStatus.addLoadedPipConfig(new StdPDPPIPConfig());
139 assertTrue(stdPDPGroupStatus.getLoadedPipConfigs() != null);
140 } catch (Exception e) {
146 public void testGetFailedPipConfigs() {
148 stdPDPGroupStatus.addFailedPipConfig(new StdPDPPIPConfig());
149 assertTrue(stdPDPGroupStatus.getFailedPipConfigs() != null);
150 } catch (Exception e) {
156 public void testGetInSynchPDPs() {
158 stdPDPGroupStatus.addInSynchPDP(new StdPDP());
159 assertTrue(stdPDPGroupStatus.getInSynchPDPs() != null);
160 } catch (Exception e) {
166 public void testGetOutOfSynchPDPs() {
168 stdPDPGroupStatus.addOutOfSynchPDP(new StdPDP());
169 assertTrue(stdPDPGroupStatus.getOutOfSynchPDPs() != null);
170 } catch (Exception e) {
176 public void testGetFailedPDPs() {
178 stdPDPGroupStatus.addFailedPDP(new StdPDP());
179 assertTrue(stdPDPGroupStatus.getFailedPDPs() != null);
180 } catch (Exception e) {
186 public void testGetUpdatingPDPs() {
188 stdPDPGroupStatus.addUpdatingPDP(new StdPDP());
189 assertTrue(stdPDPGroupStatus.getUpdatingPDPs() != null);
190 } catch (Exception e) {
196 public void testGetLastUpdateFailedPDPs() {
198 stdPDPGroupStatus.addLastUpdateFailedPDP(new StdPDP());
199 assertTrue(stdPDPGroupStatus.getLastUpdateFailedPDPs() != null);
200 } catch (Exception e) {
206 public void testGetUnknownStatusPDPs() {
208 stdPDPGroupStatus.addUnknownPDP(new StdPDP());
209 assertTrue(stdPDPGroupStatus.getUnknownStatusPDPs() != null);
210 } catch (Exception e) {
216 public void testIsGroupOk() {
218 stdPDPGroupStatus.policiesOK();
219 assertTrue(stdPDPGroupStatus.isGroupOk() == false);
220 } catch (Exception e) {
226 public void testPoliciesOK() {
227 assertTrue(stdPDPGroupStatus.policiesOK());
228 stdPDPGroupStatus.addFailedPolicy(new StdPDPPolicy());
229 assertFalse(stdPDPGroupStatus.policiesOK());
233 public void testPipConfigOK() {
234 assertTrue(stdPDPGroupStatus.pipConfigOK());
235 stdPDPGroupStatus.addFailedPipConfig(new StdPDPPIPConfig());
236 assertFalse(stdPDPGroupStatus.pipConfigOK());
240 public void testPdpsOKOutOfSyncPdp() {
241 assertTrue(stdPDPGroupStatus.pdpsOK());
242 stdPDPGroupStatus.addOutOfSynchPDP(new StdPDP());
243 assertFalse(stdPDPGroupStatus.pdpsOK());
247 public void testPdpsOKFailedPdp() {
248 assertTrue(stdPDPGroupStatus.pdpsOK());
249 stdPDPGroupStatus.addFailedPDP(new StdPDP());
250 assertFalse(stdPDPGroupStatus.pdpsOK());
254 public void testPdpsOKLastUpdateFailedPdp() {
255 assertTrue(stdPDPGroupStatus.pdpsOK());
256 stdPDPGroupStatus.addLastUpdateFailedPDP(new StdPDP());
257 assertFalse(stdPDPGroupStatus.pdpsOK());
261 public void testPdpsOKUnknownPdp() {
262 assertTrue(stdPDPGroupStatus.pdpsOK());
263 stdPDPGroupStatus.addUnknownPDP(new StdPDP());
264 assertFalse(stdPDPGroupStatus.pdpsOK());
268 public void testIsGroupOkFailedPolicy() {
269 stdPDPGroupStatus.setStatus(Status.OK);
270 assertTrue(stdPDPGroupStatus.isGroupOk());
271 stdPDPGroupStatus.addFailedPolicy(new StdPDPPolicy());
272 assertFalse(stdPDPGroupStatus.isGroupOk());
276 public void testIsGroupOkFailedPipConfig() {
277 stdPDPGroupStatus.setStatus(Status.OK);
278 assertTrue(stdPDPGroupStatus.isGroupOk());
279 stdPDPGroupStatus.addFailedPipConfig(new StdPDPPIPConfig());
280 assertFalse(stdPDPGroupStatus.isGroupOk());
284 public void testIsGroupOkFailedPdp() {
285 stdPDPGroupStatus.setStatus(Status.OK);
286 assertTrue(stdPDPGroupStatus.isGroupOk());
287 stdPDPGroupStatus.addLastUpdateFailedPDP(new StdPDP());
288 assertFalse(stdPDPGroupStatus.isGroupOk());
292 public void testIsGroupOkLoadErrors() {
293 stdPDPGroupStatus.setStatus(Status.OK);
294 assertTrue(stdPDPGroupStatus.isGroupOk());
295 stdPDPGroupStatus.addLoadError("A load error");
296 assertFalse(stdPDPGroupStatus.isGroupOk());
300 public void testIsGroupOkStatusOutOfSynch() {
301 stdPDPGroupStatus.setStatus(Status.OK);
302 assertTrue(stdPDPGroupStatus.isGroupOk());
303 stdPDPGroupStatus.setStatus(Status.OUT_OF_SYNCH);
304 assertFalse(stdPDPGroupStatus.isGroupOk());
308 public void testConstructor() {
309 Status status = Status.OK;
310 Set<PDP> failedPDPs = new HashSet<>();
311 failedPDPs.add(new StdPDP());
312 Set<PDPPIPConfig> failedPIPConfigs = new HashSet<>();
313 failedPIPConfigs.add(new StdPDPPIPConfig());
314 Set<PDPPolicy> failedPolicies = new HashSet<>();
315 failedPolicies.add(new StdPDPPolicy());
316 Set<PDP> inSynchPDPs = new HashSet<>();
317 inSynchPDPs.add(new StdPDP());
318 Set<PDP> lastUpdateFailedPDPs = new HashSet<>();
319 lastUpdateFailedPDPs.add(new StdPDP());
320 Set<PDPPIPConfig> loadedPIPConfigs = new HashSet<>();
321 loadedPIPConfigs.add(new StdPDPPIPConfig());
322 Set<PDPPolicy> loadedPolicies = new HashSet<>();
323 loadedPolicies.add(new StdPDPPolicy());
324 Set<String> loadErrors = new HashSet<>();
325 loadErrors.add("An error");
326 Set<String> loadWarnings = new HashSet<>();
327 loadWarnings.add("An error");
328 Set<PDP> outOfSynchPDPs = new HashSet<>();
329 outOfSynchPDPs.add(new StdPDP());
330 Set<PDP> unknownPDPs = new HashSet<>();
331 unknownPDPs.add(new StdPDP());
332 Set<PDP> updatingPDPs = new HashSet<>();
333 updatingPDPs.add(new StdPDP());
335 stdPDPGroupStatus.setStatus(status);
336 stdPDPGroupStatus.setFailedPDPs(failedPDPs);
337 stdPDPGroupStatus.setFailedPIPConfigs(failedPIPConfigs);
338 stdPDPGroupStatus.setFailedPolicies(failedPolicies);
339 stdPDPGroupStatus.setInSynchPDPs(inSynchPDPs);
340 stdPDPGroupStatus.setLastUpdateFailedPDPs(lastUpdateFailedPDPs);
341 stdPDPGroupStatus.setLoadedPIPConfigs(loadedPIPConfigs);
342 stdPDPGroupStatus.setLoadedPolicies(loadedPolicies);
343 stdPDPGroupStatus.setLoadErrors(loadErrors);
344 stdPDPGroupStatus.setLoadWarnings(loadWarnings);
345 stdPDPGroupStatus.setOutOfSynchPDPs(outOfSynchPDPs);
346 stdPDPGroupStatus.setUnknownPDPs(unknownPDPs);
347 stdPDPGroupStatus.setUpdatingPDPs(updatingPDPs);
349 StdPDPGroupStatus stdPDPGroupStatus2 = new StdPDPGroupStatus(stdPDPGroupStatus);
351 assertEquals(status, stdPDPGroupStatus2.getStatus());
352 assertEquals(failedPDPs, stdPDPGroupStatus2.getFailedPDPs());
353 assertEquals(failedPIPConfigs, stdPDPGroupStatus2.getFailedPIPConfigs());
354 assertEquals(failedPolicies, stdPDPGroupStatus2.getFailedPolicies());
355 assertEquals(inSynchPDPs, stdPDPGroupStatus2.getInSynchPDPs());
356 assertEquals(lastUpdateFailedPDPs, stdPDPGroupStatus2.getLastUpdateFailedPDPs());
357 assertEquals(loadedPIPConfigs, stdPDPGroupStatus2.getLoadedPIPConfigs());
358 assertEquals(loadedPolicies, stdPDPGroupStatus2.getLoadedPolicies());
359 assertEquals(loadErrors, stdPDPGroupStatus2.getLoadErrors());
360 assertEquals(loadWarnings, stdPDPGroupStatus2.getLoadWarnings());
361 assertEquals(outOfSynchPDPs, stdPDPGroupStatus2.getOutOfSynchPDPs());
362 assertEquals(unknownPDPs, stdPDPGroupStatus2.getUnknownPDPs());
363 assertEquals(updatingPDPs, stdPDPGroupStatus2.getUpdatingPDPs());
367 public void testEqualsAndHashCode() {
368 Status status = Status.OK;
369 Set<PDP> failedPDPs = new HashSet<>();
370 failedPDPs.add(new StdPDP());
371 Set<PDPPIPConfig> failedPIPConfigs = new HashSet<>();
372 failedPIPConfigs.add(new StdPDPPIPConfig());
373 Set<PDPPolicy> failedPolicies = new HashSet<>();
374 failedPolicies.add(new StdPDPPolicy());
375 Set<PDP> inSynchPDPs = new HashSet<>();
376 inSynchPDPs.add(new StdPDP());
377 Set<PDP> lastUpdateFailedPDPs = new HashSet<>();
378 lastUpdateFailedPDPs.add(new StdPDP());
379 Set<PDPPIPConfig> loadedPIPConfigs = new HashSet<>();
380 loadedPIPConfigs.add(new StdPDPPIPConfig());
381 Set<PDPPolicy> loadedPolicies = new HashSet<>();
382 loadedPolicies.add(new StdPDPPolicy());
383 Set<String> loadErrors = new HashSet<>();
384 loadErrors.add("An error");
385 Set<String> loadWarnings = new HashSet<>();
386 loadWarnings.add("An error");
387 Set<PDP> outOfSynchPDPs = new HashSet<>();
388 outOfSynchPDPs.add(new StdPDP());
389 Set<PDP> unknownPDPs = new HashSet<>();
390 unknownPDPs.add(new StdPDP());
391 Set<PDP> updatingPDPs = new HashSet<>();
392 updatingPDPs.add(new StdPDP());
394 StdPDPGroupStatus stdPDPGroupStatus1 = new StdPDPGroupStatus();
396 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
398 stdPDPGroupStatus.setStatus(status);
399 assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
400 stdPDPGroupStatus1.setStatus(status);
401 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
402 assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
404 stdPDPGroupStatus.setFailedPDPs(failedPDPs);
405 assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
406 stdPDPGroupStatus1.setFailedPDPs(failedPDPs);
407 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
408 assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
410 stdPDPGroupStatus.setFailedPIPConfigs(failedPIPConfigs);
411 assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
412 stdPDPGroupStatus1.setFailedPIPConfigs(failedPIPConfigs);
413 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
414 assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
416 stdPDPGroupStatus.setFailedPolicies(failedPolicies);
417 assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
418 stdPDPGroupStatus1.setFailedPolicies(failedPolicies);
419 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
420 assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
422 stdPDPGroupStatus.setInSynchPDPs(inSynchPDPs);
423 assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
424 stdPDPGroupStatus1.setInSynchPDPs(inSynchPDPs);
425 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
426 assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
428 stdPDPGroupStatus.setLastUpdateFailedPDPs(lastUpdateFailedPDPs);
429 assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
430 stdPDPGroupStatus1.setLastUpdateFailedPDPs(lastUpdateFailedPDPs);
431 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
432 assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
434 stdPDPGroupStatus.setLoadedPIPConfigs(loadedPIPConfigs);
435 assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
436 stdPDPGroupStatus1.setLoadedPIPConfigs(loadedPIPConfigs);
437 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
438 assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
440 stdPDPGroupStatus.setLoadedPolicies(loadedPolicies);
441 assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
442 stdPDPGroupStatus1.setLoadedPolicies(loadedPolicies);
443 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
444 assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
446 stdPDPGroupStatus.setLoadErrors(loadErrors);
447 assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
448 stdPDPGroupStatus1.setLoadErrors(loadErrors);
449 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
450 assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
452 stdPDPGroupStatus.setLoadWarnings(loadWarnings);
453 assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
454 stdPDPGroupStatus1.setLoadWarnings(loadWarnings);
455 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
456 assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
458 stdPDPGroupStatus.setOutOfSynchPDPs(outOfSynchPDPs);
459 assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
460 stdPDPGroupStatus1.setOutOfSynchPDPs(outOfSynchPDPs);
461 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
462 assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
464 stdPDPGroupStatus.setUnknownPDPs(unknownPDPs);
465 assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
466 stdPDPGroupStatus1.setUnknownPDPs(unknownPDPs);
467 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
468 assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
470 stdPDPGroupStatus.setUpdatingPDPs(updatingPDPs);
471 assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
472 stdPDPGroupStatus1.setUpdatingPDPs(updatingPDPs);
473 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
474 assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
478 public void testEqualsSameObject() {
479 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus));
483 public void testEqualsNull() {
484 assertFalse(stdPDPGroupStatus.equals(null));
488 public void testEqualsInstanceOfDiffClass() {
489 assertFalse(stdPDPGroupStatus.equals(""));