ONAP-XACML/src/test/java/org/onap/policy/xacml/test/std/pap/StdPDPGroupStatusTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP-XACML
   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
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  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=========================================================
  21  */
  22 package org.onap.policy.xacml.test.std.pap;
  23
  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;
  28 import java.util.Set;
  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;
  41
  42 public class StdPDPGroupStatusTest {
  43
  44     private static Logger logger = FlexLogger.getLogger(StdPDPGroupStatus.class);
  45
  46     private StdPDPGroupStatus stdPDPGroupStatus;
  47
  48     @Before
  49     public void setUp() {
  50
  51         try {
  52             stdPDPGroupStatus = new StdPDPGroupStatus();
  53         } catch (Exception e) {
  54             logger.error(e);
  55         }
  56     }
  57
  58     @Test
  59     public void tesGgetStatus() {
  60         try {
  61             assertTrue(stdPDPGroupStatus.getStatus() != null);
  62         } catch (Exception e) {
  63             logger.error(e);
  64         }
  65     }
  66
  67     @Test
  68     public void testGetFailedPIPConfigs() {
  69         try {
  70             assertTrue(stdPDPGroupStatus.getFailedPIPConfigs() != null);
  71         } catch (Exception e) {
  72             logger.error(e);
  73         }
  74     }
  75
  76     @Test
  77     public void testGetUnknownPDPs() {
  78         try {
  79             assertTrue(stdPDPGroupStatus.getUnknownPDPs() != null);
  80         } catch (Exception e) {
  81             logger.error(e);
  82         }
  83     }
  84
  85     @Test
  86     public void testGetLoadErrors() {
  87         try {
  88             stdPDPGroupStatus.setLoadErrors(new HashSet<String>());
  89             assertTrue(stdPDPGroupStatus.getLoadErrors() != null);
  90         } catch (Exception e) {
  91             logger.error(e);
  92         }
  93     }
  94
  95     @Test
  96     public void testGetLoadWarnings() {
  97         try {
  98             stdPDPGroupStatus.setLoadWarnings(new HashSet<>());
  99             assertTrue(stdPDPGroupStatus.getLoadWarnings() != null);
 100         } catch (Exception e) {
 101             logger.error(e);
 102         }
 103     }
 104
 105     @Test
 106     public void testGetLoadedPolicies() {
 107         try {
 108             stdPDPGroupStatus.setLoadedPolicies(new HashSet<>());
 109             assertTrue(stdPDPGroupStatus.getLoadedPolicies() != null);
 110         } catch (Exception e) {
 111             logger.error(e);
 112         }
 113     }
 114
 115     @Test
 116     public void testGetFailedPolicies() {
 117         try {
 118             stdPDPGroupStatus.setFailedPolicies(new HashSet<>());
 119             assertTrue(stdPDPGroupStatus.getFailedPolicies() != null);
 120         } catch (Exception e) {
 121             logger.error(e);
 122         }
 123     }
 124
 125     @Test
 126     public void testGetLoadedPipConfigs() {
 127         try {
 128             stdPDPGroupStatus.addLoadedPipConfig(new StdPDPPIPConfig());
 129             assertTrue(stdPDPGroupStatus.getLoadedPipConfigs() != null);
 130         } catch (Exception e) {
 131             logger.error(e);
 132         }
 133     }
 134
 135     @Test
 136     public void testGetFailedPipConfigs() {
 137         try {
 138             stdPDPGroupStatus.addFailedPipConfig(new StdPDPPIPConfig());
 139             assertTrue(stdPDPGroupStatus.getFailedPipConfigs() != null);
 140         } catch (Exception e) {
 141             logger.error(e);
 142         }
 143     }
 144
 145     @Test
 146     public void testGetInSynchPDPs() {
 147         try {
 148             stdPDPGroupStatus.addInSynchPDP(new StdPDP());
 149             assertTrue(stdPDPGroupStatus.getInSynchPDPs() != null);
 150         } catch (Exception e) {
 151             logger.error(e);
 152         }
 153     }
 154
 155     @Test
 156     public void testGetOutOfSynchPDPs() {
 157         try {
 158             stdPDPGroupStatus.addOutOfSynchPDP(new StdPDP());
 159             assertTrue(stdPDPGroupStatus.getOutOfSynchPDPs() != null);
 160         } catch (Exception e) {
 161             logger.error(e);
 162         }
 163     }
 164
 165     @Test
 166     public void testGetFailedPDPs() {
 167         try {
 168             stdPDPGroupStatus.addFailedPDP(new StdPDP());
 169             assertTrue(stdPDPGroupStatus.getFailedPDPs() != null);
 170         } catch (Exception e) {
 171             logger.error(e);
 172         }
 173     }
 174
 175     @Test
 176     public void testGetUpdatingPDPs() {
 177         try {
 178             stdPDPGroupStatus.addUpdatingPDP(new StdPDP());
 179             assertTrue(stdPDPGroupStatus.getUpdatingPDPs() != null);
 180         } catch (Exception e) {
 181             logger.error(e);
 182         }
 183     }
 184
 185     @Test
 186     public void testGetLastUpdateFailedPDPs() {
 187         try {
 188             stdPDPGroupStatus.addLastUpdateFailedPDP(new StdPDP());
 189             assertTrue(stdPDPGroupStatus.getLastUpdateFailedPDPs() != null);
 190         } catch (Exception e) {
 191             logger.error(e);
 192         }
 193     }
 194
 195     @Test
 196     public void testGetUnknownStatusPDPs() {
 197         try {
 198             stdPDPGroupStatus.addUnknownPDP(new StdPDP());
 199             assertTrue(stdPDPGroupStatus.getUnknownStatusPDPs() != null);
 200         } catch (Exception e) {
 201             logger.error(e);
 202         }
 203     }
 204
 205     @Test
 206     public void testIsGroupOk() {
 207         try {
 208             stdPDPGroupStatus.policiesOK();
 209             assertTrue(stdPDPGroupStatus.isGroupOk() == false);
 210         } catch (Exception e) {
 211             logger.error(e);
 212         }
 213     }
 214
 215     @Test
 216     public void testPoliciesOK() {
 217         assertTrue(stdPDPGroupStatus.policiesOK());
 218         stdPDPGroupStatus.addFailedPolicy(new StdPDPPolicy());
 219         assertFalse(stdPDPGroupStatus.policiesOK());
 220     }
 221
 222     @Test
 223     public void testPipConfigOK() {
 224         assertTrue(stdPDPGroupStatus.pipConfigOK());
 225         stdPDPGroupStatus.addFailedPipConfig(new StdPDPPIPConfig());
 226         assertFalse(stdPDPGroupStatus.pipConfigOK());
 227     }
 228
 229     @Test
 230     public void testPdpsOKOutOfSyncPdp() {
 231         assertTrue(stdPDPGroupStatus.pdpsOK());
 232         stdPDPGroupStatus.addOutOfSynchPDP(new StdPDP());
 233         assertFalse(stdPDPGroupStatus.pdpsOK());
 234     }
 235
 236     @Test
 237     public void testPdpsOKFailedPdp() {
 238         assertTrue(stdPDPGroupStatus.pdpsOK());
 239         stdPDPGroupStatus.addFailedPDP(new StdPDP());
 240         assertFalse(stdPDPGroupStatus.pdpsOK());
 241     }
 242
 243     @Test
 244     public void testPdpsOKLastUpdateFailedPdp() {
 245         assertTrue(stdPDPGroupStatus.pdpsOK());
 246         stdPDPGroupStatus.addLastUpdateFailedPDP(new StdPDP());
 247         assertFalse(stdPDPGroupStatus.pdpsOK());
 248     }
 249
 250     @Test
 251     public void testPdpsOKUnknownPdp() {
 252         assertTrue(stdPDPGroupStatus.pdpsOK());
 253         stdPDPGroupStatus.addUnknownPDP(new StdPDP());
 254         assertFalse(stdPDPGroupStatus.pdpsOK());
 255     }
 256
 257     @Test
 258     public void testIsGroupOkFailedPolicy() {
 259         stdPDPGroupStatus.setStatus(Status.OK);
 260         assertTrue(stdPDPGroupStatus.isGroupOk());
 261         stdPDPGroupStatus.addFailedPolicy(new StdPDPPolicy());
 262         assertFalse(stdPDPGroupStatus.isGroupOk());
 263     }
 264
 265     @Test
 266     public void testIsGroupOkFailedPipConfig() {
 267         stdPDPGroupStatus.setStatus(Status.OK);
 268         assertTrue(stdPDPGroupStatus.isGroupOk());
 269         stdPDPGroupStatus.addFailedPipConfig(new StdPDPPIPConfig());
 270         assertFalse(stdPDPGroupStatus.isGroupOk());
 271     }
 272
 273     @Test
 274     public void testIsGroupOkFailedPdp() {
 275         stdPDPGroupStatus.setStatus(Status.OK);
 276         assertTrue(stdPDPGroupStatus.isGroupOk());
 277         stdPDPGroupStatus.addLastUpdateFailedPDP(new StdPDP());
 278         assertFalse(stdPDPGroupStatus.isGroupOk());
 279     }
 280
 281     @Test
 282     public void testIsGroupOkLoadErrors() {
 283         stdPDPGroupStatus.setStatus(Status.OK);
 284         assertTrue(stdPDPGroupStatus.isGroupOk());
 285         stdPDPGroupStatus.addLoadError("A load error");
 286         assertFalse(stdPDPGroupStatus.isGroupOk());
 287     }
 288
 289     @Test
 290     public void testIsGroupOkStatusOutOfSynch() {
 291         stdPDPGroupStatus.setStatus(Status.OK);
 292         assertTrue(stdPDPGroupStatus.isGroupOk());
 293         stdPDPGroupStatus.setStatus(Status.OUT_OF_SYNCH);
 294         assertFalse(stdPDPGroupStatus.isGroupOk());
 295     }
 296
 297     @Test
 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());
 324
 325
 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);
 339
 340         StdPDPGroupStatus stdPDPGroupStatus2 = new StdPDPGroupStatus(stdPDPGroupStatus);
 341
 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());
 355     }
 356
 357     @Test
 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());
 384
 385         StdPDPGroupStatus stdPDPGroupStatus1 = new StdPDPGroupStatus();
 386
 387         assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
 388
 389         stdPDPGroupStatus.setStatus(status);
 390         assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
 391         stdPDPGroupStatus1.setStatus(status);
 392         assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
 393         assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
 394
 395         stdPDPGroupStatus.setFailedPDPs(failedPDPs);
 396         assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
 397         stdPDPGroupStatus1.setFailedPDPs(failedPDPs);
 398         assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
 399         assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
 400
 401         stdPDPGroupStatus.setFailedPIPConfigs(failedPIPConfigs);
 402         assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
 403         stdPDPGroupStatus1.setFailedPIPConfigs(failedPIPConfigs);
 404         assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
 405         assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
 406
 407         stdPDPGroupStatus.setFailedPolicies(failedPolicies);
 408         assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
 409         stdPDPGroupStatus1.setFailedPolicies(failedPolicies);
 410         assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
 411         assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
 412
 413         stdPDPGroupStatus.setInSynchPDPs(inSynchPDPs);
 414         assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
 415         stdPDPGroupStatus1.setInSynchPDPs(inSynchPDPs);
 416         assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
 417         assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
 418
 419         stdPDPGroupStatus.setLastUpdateFailedPDPs(lastUpdateFailedPDPs);
 420         assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
 421         stdPDPGroupStatus1.setLastUpdateFailedPDPs(lastUpdateFailedPDPs);
 422         assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
 423         assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
 424
 425         stdPDPGroupStatus.setLoadedPIPConfigs(loadedPIPConfigs);
 426         assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
 427         stdPDPGroupStatus1.setLoadedPIPConfigs(loadedPIPConfigs);
 428         assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
 429         assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
 430
 431         stdPDPGroupStatus.setLoadedPolicies(loadedPolicies);
 432         assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
 433         stdPDPGroupStatus1.setLoadedPolicies(loadedPolicies);
 434         assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
 435         assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
 436
 437         stdPDPGroupStatus.setLoadErrors(loadErrors);
 438         assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
 439         stdPDPGroupStatus1.setLoadErrors(loadErrors);
 440         assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
 441         assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
 442
 443         stdPDPGroupStatus.setLoadWarnings(loadWarnings);
 444         assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
 445         stdPDPGroupStatus1.setLoadWarnings(loadWarnings);
 446         assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
 447         assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
 448
 449         stdPDPGroupStatus.setOutOfSynchPDPs(outOfSynchPDPs);
 450         assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
 451         stdPDPGroupStatus1.setOutOfSynchPDPs(outOfSynchPDPs);
 452         assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
 453         assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
 454
 455         stdPDPGroupStatus.setUnknownPDPs(unknownPDPs);
 456         assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
 457         stdPDPGroupStatus1.setUnknownPDPs(unknownPDPs);
 458         assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
 459         assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
 460
 461         stdPDPGroupStatus.setUpdatingPDPs(updatingPDPs);
 462         assertFalse(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
 463         stdPDPGroupStatus1.setUpdatingPDPs(updatingPDPs);
 464         assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus1));
 465         assertEquals(stdPDPGroupStatus.hashCode(), stdPDPGroupStatus1.hashCode());
 466     }
 467
 468     @Test
 469     public void testEqualsSameObject() {
 470         assertTrue(stdPDPGroupStatus.equals(stdPDPGroupStatus));
 471     }
 472
 473     @Test
 474     public void testEqualsNull() {
 475         assertFalse(stdPDPGroupStatus.equals(null));
 476     }
 477
 478     @Test
 479     public void testEqualsInstanceOfDiffClass() {
 480         assertFalse(stdPDPGroupStatus.equals(""));
 481     }
 482 }