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