2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017 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=========================================================
22 package org.onap.policy.xacml.test.std.pap;
24 import static org.junit.Assert.assertEquals;
25 import static org.junit.Assert.assertFalse;
26 import static org.junit.Assert.assertTrue;
27 import java.util.HashSet;
29 import org.junit.Before;
30 import org.junit.Test;
31 import org.onap.policy.common.logging.flexlogger.FlexLogger;
32 import org.onap.policy.common.logging.flexlogger.Logger;
33 import org.onap.policy.xacml.std.pap.StdPDP;
34 import org.onap.policy.xacml.std.pap.StdPDPGroupStatus;
35 import org.onap.policy.xacml.std.pap.StdPDPPIPConfig;
36 import org.onap.policy.xacml.std.pap.StdPDPPolicy;
37 import com.att.research.xacml.api.pap.PDP;
38 import com.att.research.xacml.api.pap.PDPGroupStatus.Status;
39 import com.att.research.xacml.api.pap.PDPPIPConfig;
40 import com.att.research.xacml.api.pap.PDPPolicy;
42 public class StdPDPGroupStatusTest {
44 private static Logger logger = FlexLogger.getLogger(StdPDPGroupStatus.class);
46 private StdPDPGroupStatus stdPDPGroupStatus;
52 stdPDPGroupStatus = new StdPDPGroupStatus();
53 } catch (Exception e) {
59 public void tesGgetStatus() {
61 assertTrue(stdPDPGroupStatus.getStatus() != null);
62 } catch (Exception e) {
68 public void testGetFailedPIPConfigs() {
70 assertTrue(stdPDPGroupStatus.getFailedPIPConfigs() != null);
71 } catch (Exception e) {
77 public void testGetUnknownPDPs() {
79 assertTrue(stdPDPGroupStatus.getUnknownPDPs() != null);
80 } catch (Exception e) {
86 public void testGetLoadErrors() {
88 stdPDPGroupStatus.setLoadErrors(new HashSet<String>());
89 assertTrue(stdPDPGroupStatus.getLoadErrors() != null);
90 } catch (Exception e) {
96 public void testGetLoadWarnings() {
98 stdPDPGroupStatus.setLoadWarnings(new HashSet<>());
99 assertTrue(stdPDPGroupStatus.getLoadWarnings() != null);
100 } catch (Exception e) {
106 public void testGetLoadedPolicies() {
108 stdPDPGroupStatus.setLoadedPolicies(new HashSet<>());
109 assertTrue(stdPDPGroupStatus.getLoadedPolicies() != null);
110 } catch (Exception e) {
116 public void testGetFailedPolicies() {
118 stdPDPGroupStatus.setFailedPolicies(new HashSet<>());
119 assertTrue(stdPDPGroupStatus.getFailedPolicies() != null);
120 } catch (Exception e) {
126 public void testGetLoadedPipConfigs() {
128 stdPDPGroupStatus.addLoadedPipConfig(new StdPDPPIPConfig());
129 assertTrue(stdPDPGroupStatus.getLoadedPipConfigs() != null);
130 } catch (Exception e) {
136 public void testGetFailedPipConfigs() {
138 stdPDPGroupStatus.addFailedPipConfig(new StdPDPPIPConfig());
139 assertTrue(stdPDPGroupStatus.getFailedPipConfigs() != null);
140 } catch (Exception e) {
146 public void testGetInSynchPDPs() {
148 stdPDPGroupStatus.addInSynchPDP(new StdPDP());
149 assertTrue(stdPDPGroupStatus.getInSynchPDPs() != null);
150 } catch (Exception e) {
156 public void testGetOutOfSynchPDPs() {
158 stdPDPGroupStatus.addOutOfSynchPDP(new StdPDP());
159 assertTrue(stdPDPGroupStatus.getOutOfSynchPDPs() != null);
160 } catch (Exception e) {
166 public void testGetFailedPDPs() {
168 stdPDPGroupStatus.addFailedPDP(new StdPDP());
169 assertTrue(stdPDPGroupStatus.getFailedPDPs() != null);
170 } catch (Exception e) {
176 public void testGetUpdatingPDPs() {
178 stdPDPGroupStatus.addUpdatingPDP(new StdPDP());
179 assertTrue(stdPDPGroupStatus.getUpdatingPDPs() != null);
180 } catch (Exception e) {
186 public void testGetLastUpdateFailedPDPs() {
188 stdPDPGroupStatus.addLastUpdateFailedPDP(new StdPDP());
189 assertTrue(stdPDPGroupStatus.getLastUpdateFailedPDPs() != null);
190 } catch (Exception e) {
196 public void testGetUnknownStatusPDPs() {
198 stdPDPGroupStatus.addUnknownPDP(new StdPDP());
199 assertTrue(stdPDPGroupStatus.getUnknownStatusPDPs() != null);
200 } catch (Exception e) {
206 public void testIsGroupOk() {
208 stdPDPGroupStatus.policiesOK();
209 assertTrue(stdPDPGroupStatus.isGroupOk() == false);
210 } catch (Exception e) {
216 public void testPoliciesOK() {
217 assertTrue(stdPDPGroupStatus.policiesOK());
218 stdPDPGroupStatus.addFailedPolicy(new StdPDPPolicy());
219 assertFalse(stdPDPGroupStatus.policiesOK());
223 public void testPipConfigOK() {
224 assertTrue(stdPDPGroupStatus.pipConfigOK());
225 stdPDPGroupStatus.addFailedPipConfig(new StdPDPPIPConfig());
226 assertFalse(stdPDPGroupStatus.pipConfigOK());
230 public void testPdpsOKOutOfSyncPdp() {
231 assertTrue(stdPDPGroupStatus.pdpsOK());
232 stdPDPGroupStatus.addOutOfSynchPDP(new StdPDP());
233 assertFalse(stdPDPGroupStatus.pdpsOK());
237 public void testPdpsOKFailedPdp() {
238 assertTrue(stdPDPGroupStatus.pdpsOK());
239 stdPDPGroupStatus.addFailedPDP(new StdPDP());
240 assertFalse(stdPDPGroupStatus.pdpsOK());
244 public void testPdpsOKLastUpdateFailedPdp() {
245 assertTrue(stdPDPGroupStatus.pdpsOK());
246 stdPDPGroupStatus.addLastUpdateFailedPDP(new StdPDP());
247 assertFalse(stdPDPGroupStatus.pdpsOK());
251 public void testPdpsOKUnknownPdp() {
252 assertTrue(stdPDPGroupStatus.pdpsOK());
253 stdPDPGroupStatus.addUnknownPDP(new StdPDP());
254 assertFalse(stdPDPGroupStatus.pdpsOK());
258 public void testIsGroupOkFailedPolicy() {
259 stdPDPGroupStatus.setStatus(Status.OK);
260 assertTrue(stdPDPGroupStatus.isGroupOk());
261 stdPDPGroupStatus.addFailedPolicy(new StdPDPPolicy());
262 assertFalse(stdPDPGroupStatus.isGroupOk());
266 public void testIsGroupOkFailedPipConfig() {
267 stdPDPGroupStatus.setStatus(Status.OK);
268 assertTrue(stdPDPGroupStatus.isGroupOk());
269 stdPDPGroupStatus.addFailedPipConfig(new StdPDPPIPConfig());
270 assertFalse(stdPDPGroupStatus.isGroupOk());
274 public void testIsGroupOkFailedPdp() {
275 stdPDPGroupStatus.setStatus(Status.OK);
276 assertTrue(stdPDPGroupStatus.isGroupOk());
277 stdPDPGroupStatus.addLastUpdateFailedPDP(new StdPDP());
278 assertFalse(stdPDPGroupStatus.isGroupOk());
282 public void testIsGroupOkLoadErrors() {
283 stdPDPGroupStatus.setStatus(Status.OK);
284 assertTrue(stdPDPGroupStatus.isGroupOk());
285 stdPDPGroupStatus.addLoadError("A load error");
286 assertFalse(stdPDPGroupStatus.isGroupOk());
290 public void testIsGroupOkStatusOutOfSynch() {
291 stdPDPGroupStatus.setStatus(Status.OK);
292 assertTrue(stdPDPGroupStatus.isGroupOk());
293 stdPDPGroupStatus.setStatus(Status.OUT_OF_SYNCH);
294 assertFalse(stdPDPGroupStatus.isGroupOk());
298 public void testConstructor() {
299 Status status = Status.OK;
300 Set<PDP> failedPDPs = new HashSet<>();
301 failedPDPs.add(new StdPDP());
302 Set<PDPPIPConfig> failedPIPConfigs = new HashSet<>();
303 failedPIPConfigs.add(new StdPDPPIPConfig());
304 Set<PDPPolicy> failedPolicies = new HashSet<>();
305 failedPolicies.add(new StdPDPPolicy());
306 Set<PDP> inSynchPDPs = new HashSet<>();
307 inSynchPDPs.add(new StdPDP());
308 Set<PDP> lastUpdateFailedPDPs = new HashSet<>();
309 lastUpdateFailedPDPs.add(new StdPDP());
310 Set<PDPPIPConfig> loadedPIPConfigs = new HashSet<>();
311 loadedPIPConfigs.add(new StdPDPPIPConfig());
312 Set<PDPPolicy> loadedPolicies = new HashSet<>();
313 loadedPolicies.add(new StdPDPPolicy());
314 Set<String> loadErrors = new HashSet<>();
315 loadErrors.add("An error");
316 Set<String> loadWarnings = new HashSet<>();
317 loadWarnings.add("An error");
318 Set<PDP> outOfSynchPDPs = new HashSet<>();
319 outOfSynchPDPs.add(new StdPDP());
320 Set<PDP> unknownPDPs = new HashSet<>();
321 unknownPDPs.add(new StdPDP());
322 Set<PDP> updatingPDPs = new HashSet<>();
323 updatingPDPs.add(new StdPDP());
326 stdPDPGroupStatus.setStatus(status);
327 stdPDPGroupStatus.setFailedPDPs(failedPDPs);
328 stdPDPGroupStatus.setFailedPIPConfigs(failedPIPConfigs);
329 stdPDPGroupStatus.setFailedPolicies(failedPolicies);
330 stdPDPGroupStatus.setInSynchPDPs(inSynchPDPs);
331 stdPDPGroupStatus.setLastUpdateFailedPDPs(lastUpdateFailedPDPs);
332 stdPDPGroupStatus.setLoadedPIPConfigs(loadedPIPConfigs);
333 stdPDPGroupStatus.setLoadedPolicies(loadedPolicies);
334 stdPDPGroupStatus.setLoadErrors(loadErrors);
335 stdPDPGroupStatus.setLoadWarnings(loadWarnings);
336 stdPDPGroupStatus.setOutOfSynchPDPs(outOfSynchPDPs);
337 stdPDPGroupStatus.setUnknownPDPs(unknownPDPs);
338 stdPDPGroupStatus.setUpdatingPDPs(updatingPDPs);
340 StdPDPGroupStatus stdPDPGroupStatus2 = new StdPDPGroupStatus(stdPDPGroupStatus);
342 assertEquals(status, stdPDPGroupStatus2.getStatus());
343 assertEquals(failedPDPs, stdPDPGroupStatus2.getFailedPDPs());
344 assertEquals(failedPIPConfigs, stdPDPGroupStatus2.getFailedPIPConfigs());
345 assertEquals(failedPolicies, stdPDPGroupStatus2.getFailedPolicies());
346 assertEquals(inSynchPDPs, stdPDPGroupStatus2.getInSynchPDPs());
347 assertEquals(lastUpdateFailedPDPs, stdPDPGroupStatus2.getLastUpdateFailedPDPs());
348 assertEquals(loadedPIPConfigs, stdPDPGroupStatus2.getLoadedPIPConfigs());
349 assertEquals(loadedPolicies, stdPDPGroupStatus2.getLoadedPolicies());
350 assertEquals(loadErrors, stdPDPGroupStatus2.getLoadErrors());
351 assertEquals(loadWarnings, stdPDPGroupStatus2.getLoadWarnings());
352 assertEquals(outOfSynchPDPs, stdPDPGroupStatus2.getOutOfSynchPDPs());
353 assertEquals(unknownPDPs, stdPDPGroupStatus2.getUnknownPDPs());
354 assertEquals(updatingPDPs, stdPDPGroupStatus2.getUpdatingPDPs());
358 public void testEqualsAndHashCode() {
359 Status status = Status.OK;
360 Set<PDP> failedPDPs = new HashSet<>();
361 failedPDPs.add(new StdPDP());
362 Set<PDPPIPConfig> failedPIPConfigs = new HashSet<>();
363 failedPIPConfigs.add(new StdPDPPIPConfig());
364 Set<PDPPolicy> failedPolicies = new HashSet<>();
365 failedPolicies.add(new StdPDPPolicy());
366 Set<PDP> inSynchPDPs = new HashSet<>();
367 inSynchPDPs.add(new StdPDP());
368 Set<PDP> lastUpdateFailedPDPs = new HashSet<>();
369 lastUpdateFailedPDPs.add(new StdPDP());
370 Set<PDPPIPConfig> loadedPIPConfigs = new HashSet<>();
371 loadedPIPConfigs.add(new StdPDPPIPConfig());
372 Set<PDPPolicy> loadedPolicies = new HashSet<>();
373 loadedPolicies.add(new StdPDPPolicy());
374 Set<String> loadErrors = new HashSet<>();
375 loadErrors.add("An error");
376 Set<String> loadWarnings = new HashSet<>();
377 loadWarnings.add("An error");
378 Set<PDP> outOfSynchPDPs = new HashSet<>();
379 outOfSynchPDPs.add(new StdPDP());
380 Set<PDP> unknownPDPs = new HashSet<>();
381 unknownPDPs.add(new StdPDP());
382 Set<PDP> updatingPDPs = new HashSet<>();
383 updatingPDPs.add(new StdPDP());
385 StdPDPGroupStatus stdPDPGroupStatus1 = new StdPDPGroupStatus();
387 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
389 stdPDPGroupStatus.setStatus(status);
390 assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
391 stdPDPGroupStatus1.setStatus(status);
392 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
393 assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
395 stdPDPGroupStatus.setFailedPDPs(failedPDPs);
396 assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
397 stdPDPGroupStatus1.setFailedPDPs(failedPDPs);
398 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
399 assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
401 stdPDPGroupStatus.setFailedPIPConfigs(failedPIPConfigs);
402 assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
403 stdPDPGroupStatus1.setFailedPIPConfigs(failedPIPConfigs);
404 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
405 assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
407 stdPDPGroupStatus.setFailedPolicies(failedPolicies);
408 assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
409 stdPDPGroupStatus1.setFailedPolicies(failedPolicies);
410 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
411 assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
413 stdPDPGroupStatus.setInSynchPDPs(inSynchPDPs);
414 assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
415 stdPDPGroupStatus1.setInSynchPDPs(inSynchPDPs);
416 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
417 assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
419 stdPDPGroupStatus.setLastUpdateFailedPDPs(lastUpdateFailedPDPs);
420 assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
421 stdPDPGroupStatus1.setLastUpdateFailedPDPs(lastUpdateFailedPDPs);
422 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
423 assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
425 stdPDPGroupStatus.setLoadedPIPConfigs(loadedPIPConfigs);
426 assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
427 stdPDPGroupStatus1.setLoadedPIPConfigs(loadedPIPConfigs);
428 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
429 assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
431 stdPDPGroupStatus.setLoadedPolicies(loadedPolicies);
432 assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
433 stdPDPGroupStatus1.setLoadedPolicies(loadedPolicies);
434 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
435 assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
437 stdPDPGroupStatus.setLoadErrors(loadErrors);
438 assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
439 stdPDPGroupStatus1.setLoadErrors(loadErrors);
440 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
441 assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
443 stdPDPGroupStatus.setLoadWarnings(loadWarnings);
444 assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
445 stdPDPGroupStatus1.setLoadWarnings(loadWarnings);
446 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
447 assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
449 stdPDPGroupStatus.setOutOfSynchPDPs(outOfSynchPDPs);
450 assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
451 stdPDPGroupStatus1.setOutOfSynchPDPs(outOfSynchPDPs);
452 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
453 assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
455 stdPDPGroupStatus.setUnknownPDPs(unknownPDPs);
456 assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
457 stdPDPGroupStatus1.setUnknownPDPs(unknownPDPs);
458 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
459 assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
461 stdPDPGroupStatus.setUpdatingPDPs(updatingPDPs);
462 assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
463 stdPDPGroupStatus1.setUpdatingPDPs(updatingPDPs);
464 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
465 assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
469 public void testEqualsSameObject() {
470 assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus));
474 public void testEqualsNull() {
475 assertFalse(stdPDPGroupStatus.equals(null));
479 public void testEqualsInstanceOfDiffClass() {
480 assertFalse(stdPDPGroupStatus.equals(""));