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