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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * Copyright (C) 2018 Ericsson. All rights reserved.
   4  * ================================================================================
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *      http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  * ============LICENSE_END=========================================================
  17  */
  18 package org.onap.policy.xacml.test.std.pap;
  19
  20 import static org.junit.Assert.*;
  21 import java.util.HashSet;
  22 import java.util.Set;
  23 import org.junit.Test;
  24 import org.onap.policy.xacml.std.pap.StdPDPPIPConfig;
  25 import org.onap.policy.xacml.std.pap.StdPDPPolicy;
  26 import org.onap.policy.xacml.std.pap.StdPDPStatus;
  27 import com.att.research.xacml.api.pap.PDPPIPConfig;
  28 import com.att.research.xacml.api.pap.PDPPolicy;
  29 import com.att.research.xacml.api.pap.PDPStatus.Status;
  30
  31 public class StdPDPStatusTest {
  32
  33     StdPDPStatus stdPDPStatus = new StdPDPStatus();
  34
  35     @Test
  36     public void testSetAndGetStatus() {
  37         Status status = Status.UP_TO_DATE;
  38         stdPDPStatus.setStatus(status);
  39         assertEquals(status, stdPDPStatus.getStatus());
  40     }
  41
  42     @Test
  43     public void testSetAndGetLoadErrors() {
  44         Set<String> errors = new HashSet<>();
  45         errors.add("An error");
  46         stdPDPStatus.setLoadErrors(errors);
  47         assertEquals(errors, stdPDPStatus.getLoadErrors());
  48     }
  49
  50     @Test
  51     public void testSetAndGetLoadWarnings() {
  52         Set<String> warnings = new HashSet<>();
  53         warnings.add("An error");
  54         stdPDPStatus.setLoadWarnings(warnings);
  55         assertEquals(warnings, stdPDPStatus.getLoadWarnings());
  56     }
  57
  58     @Test
  59     public void testSetAndGetLoadedPolicies() {
  60         Set<PDPPolicy> loadedPolicies = new HashSet<>();
  61         loadedPolicies.add(new StdPDPPolicy());
  62         stdPDPStatus.setLoadedPolicies(loadedPolicies);
  63         assertEquals(loadedPolicies, stdPDPStatus.getLoadedPolicies());
  64     }
  65
  66     @Test
  67     public void testSetAndGetLoadedRootPolicies() {
  68         Set<PDPPolicy> loadedRootPolicies = new HashSet<>();
  69         loadedRootPolicies.add(new StdPDPPolicy());
  70         stdPDPStatus.setLoadedRootPolicies(loadedRootPolicies);
  71         assertEquals(loadedRootPolicies, stdPDPStatus.getLoadedRootPolicies());
  72     }
  73
  74     @Test
  75     public void testSetAndGetFailedPolicies() {
  76         Set<PDPPolicy> failedPolicies = new HashSet<>();
  77         failedPolicies.add(new StdPDPPolicy());
  78         stdPDPStatus.setFailedPolicies(failedPolicies);
  79         assertEquals(failedPolicies, stdPDPStatus.getFailedPolicies());
  80     }
  81
  82     @Test
  83     public void testSetAndGetLoadedPipConfigs() {
  84         Set<PDPPIPConfig> loadedPipConfigs = new HashSet<>();
  85         loadedPipConfigs.add(new StdPDPPIPConfig());
  86         stdPDPStatus.setLoadedPipConfigs(loadedPipConfigs);
  87         assertEquals(loadedPipConfigs, stdPDPStatus.getLoadedPipConfigs());
  88     }
  89
  90     @Test
  91     public void testSetAndGetFailedPipConfigs() {
  92         Set<PDPPIPConfig> failedPipConfigs = new HashSet<>();
  93         failedPipConfigs.add(new StdPDPPIPConfig());
  94         stdPDPStatus.setFailedPipConfigs(failedPipConfigs);
  95         assertEquals(failedPipConfigs, stdPDPStatus.getFailedPipConfigs());
  96     }
  97
  98     @Test
  99     public void testPoliciesOK() {
 100         assertTrue(stdPDPStatus.policiesOK());
 101         stdPDPStatus.addFailedPolicy(new StdPDPPolicy());
 102         assertFalse(stdPDPStatus.policiesOK());
 103     }
 104
 105     @Test
 106     public void testPipConfigOK() {
 107         assertTrue(stdPDPStatus.pipConfigOK());
 108         stdPDPStatus.addFailedPipConfig(new StdPDPPIPConfig());
 109         assertFalse(stdPDPStatus.pipConfigOK());
 110     }
 111
 112     @Test
 113     public void testIsOkFailedPolicy() {
 114         stdPDPStatus.setStatus(Status.UP_TO_DATE);
 115         assertTrue(stdPDPStatus.isOk());
 116         stdPDPStatus.addFailedPolicy(new StdPDPPolicy());
 117         assertFalse(stdPDPStatus.isOk());
 118     }
 119
 120     @Test
 121     public void testIsOkFailedPipConfig() {
 122         stdPDPStatus.setStatus(Status.UP_TO_DATE);
 123         assertTrue(stdPDPStatus.isOk());
 124         stdPDPStatus.addFailedPipConfig(new StdPDPPIPConfig());
 125         assertFalse(stdPDPStatus.isOk());
 126     }
 127
 128     @Test
 129     public void testIsOkStatusOutOfSync() {
 130         stdPDPStatus.setStatus(Status.UP_TO_DATE);
 131         assertTrue(stdPDPStatus.isOk());
 132         stdPDPStatus.setStatus(Status.OUT_OF_SYNCH);
 133         assertFalse(stdPDPStatus.isOk());
 134     }
 135
 136     @Test
 137     public void testAddLoadError() {
 138         stdPDPStatus.addLoadError("An error");
 139         assertEquals("An error", stdPDPStatus.getLoadErrors().iterator().next());
 140     }
 141
 142     @Test
 143     public void testAddLoadWarning() {
 144         stdPDPStatus.addLoadWarning("A warning");
 145         assertEquals("A warning", stdPDPStatus.getLoadWarnings().iterator().next());
 146     }
 147
 148     @Test
 149     public void testAddLoadedPolicy() {
 150         PDPPolicy policy = new StdPDPPolicy();
 151         stdPDPStatus.addLoadedPolicy(policy);
 152         assertEquals(policy, stdPDPStatus.getLoadedPolicies().iterator().next());
 153     }
 154
 155     @Test
 156     public void testAddRootPolicy() {
 157         PDPPolicy policy = new StdPDPPolicy();
 158         stdPDPStatus.addRootPolicy(policy);
 159         assertEquals(policy, stdPDPStatus.getLoadedRootPolicies().iterator().next());
 160     }
 161
 162     @Test
 163     public void testAddAllLoadedRootPolicy() {
 164         Set<PDPPolicy> policies = new HashSet<>();
 165         PDPPolicy policy = new StdPDPPolicy();
 166         policies.add(policy);
 167         stdPDPStatus.addAllLoadedRootPolicies(policies);
 168         assertEquals(policies, stdPDPStatus.getLoadedRootPolicies());
 169     }
 170
 171     @Test
 172     public void testAddLoadedPipConfig(){
 173         PDPPIPConfig pipConfig = new StdPDPPIPConfig();
 174         stdPDPStatus.addLoadedPipConfig(pipConfig);
 175         assertEquals(pipConfig, stdPDPStatus.getLoadedPipConfigs().iterator().next());
 176     }
 177
 178     @Test
 179     public void testSet() {
 180         Status status = Status.UP_TO_DATE;
 181         Set<PDPPIPConfig> failedPIPConfigs = new HashSet<>();
 182         failedPIPConfigs.add(new StdPDPPIPConfig());
 183         Set<PDPPolicy> failedPolicies = new HashSet<>();
 184         failedPolicies.add(new StdPDPPolicy());
 185         Set<PDPPIPConfig> loadedPIPConfigs = new HashSet<>();
 186         loadedPIPConfigs.add(new StdPDPPIPConfig());
 187         Set<PDPPolicy> loadedPolicies = new HashSet<>();
 188         loadedPolicies.add(new StdPDPPolicy());
 189         Set<PDPPolicy> loadedRootPolicies = new HashSet<>();
 190         loadedRootPolicies.add(new StdPDPPolicy());
 191         Set<String> loadErrors = new HashSet<>();
 192         loadErrors.add("An error");
 193         Set<String> loadWarnings = new HashSet<>();
 194         loadWarnings.add("An error");
 195
 196         stdPDPStatus.setStatus(status);
 197         stdPDPStatus.setFailedPipConfigs(failedPIPConfigs);
 198         stdPDPStatus.setFailedPolicies(failedPolicies);
 199         stdPDPStatus.setLoadedPipConfigs(loadedPIPConfigs);
 200         stdPDPStatus.setLoadedPolicies(loadedPolicies);
 201         stdPDPStatus.setLoadedRootPolicies(loadedRootPolicies);
 202         stdPDPStatus.setLoadErrors(loadErrors);
 203         stdPDPStatus.setLoadWarnings(loadWarnings);
 204
 205         StdPDPStatus stdPDPStatus1 = new StdPDPStatus();
 206         stdPDPStatus1.set(stdPDPStatus);
 207
 208         assertEquals(status, stdPDPStatus1.getStatus());
 209         assertEquals(loadErrors, stdPDPStatus1.getLoadErrors());
 210         assertEquals(loadWarnings, stdPDPStatus1.getLoadWarnings());
 211         assertEquals(loadedPolicies, stdPDPStatus1.getLoadedPolicies());
 212         assertEquals(loadedRootPolicies, stdPDPStatus1.getLoadedRootPolicies());
 213         assertEquals(failedPolicies, stdPDPStatus1.getFailedPolicies());
 214         assertEquals(loadedPIPConfigs, stdPDPStatus1.getLoadedPipConfigs());
 215         assertEquals(failedPIPConfigs, stdPDPStatus1.getFailedPipConfigs());
 216
 217         assertEquals("StdPDPStatus [status=UP_TO_DATE, loadErrors=[An error], loadWarnings=[An error], loadedPolicies=[StdPDPPolicy "
 218                         + "[id=null, name=null, policyId=null, description=null, version=, isRoot=false, isValid=false, location=null]], "
 219                         + "loadedRootPolicies=[StdPDPPolicy [id=null, name=null, policyId=null, description=null, version=, isRoot=false, "
 220                         + "isValid=false, location=null]], failedPolicies=[StdPDPPolicy [id=null, name=null, policyId=null, description=null, "
 221                         + "version=, isRoot=false, isValid=false, location=null]], loadedPIPConfigs=[StdPDPPIPConfig [id=null, name=null, "
 222                         + "description=null, classname=null, config={}]], failedPIPConfigs=[StdPDPPIPConfig [id=null, name=null, description=null, classname=null, config={}]]]",
 223                 stdPDPStatus1.toString());
 224     }
 225
 226     @Test
 227     public void testEqualsAndHashCode() {
 228         Status status = Status.UP_TO_DATE;
 229         Set<PDPPIPConfig> failedPIPConfigs = new HashSet<>();
 230         failedPIPConfigs.add(new StdPDPPIPConfig());
 231         Set<PDPPolicy> failedPolicies = new HashSet<>();
 232         failedPolicies.add(new StdPDPPolicy());
 233         Set<PDPPIPConfig> loadedPIPConfigs = new HashSet<>();
 234         loadedPIPConfigs.add(new StdPDPPIPConfig());
 235         Set<PDPPolicy> loadedPolicies = new HashSet<>();
 236         loadedPolicies.add(new StdPDPPolicy());
 237         Set<PDPPolicy> loadedRootPolicies = new HashSet<>();
 238         loadedRootPolicies.add(new StdPDPPolicy());
 239         Set<String> loadErrors = new HashSet<>();
 240         loadErrors.add("An error");
 241         Set<String> loadWarnings = new HashSet<>();
 242         loadWarnings.add("An error");
 243
 244         StdPDPStatus stdPDPStatus1 = new StdPDPStatus();
 245
 246         assertTrue(stdPDPStatus.equals(stdPDPStatus1));
 247
 248         stdPDPStatus.setStatus(status);
 249         assertFalse(stdPDPStatus.equals(stdPDPStatus1));
 250         stdPDPStatus1.setStatus(status);
 251         assertTrue(stdPDPStatus.equals(stdPDPStatus1));
 252         assertEquals(stdPDPStatus.hashCode(), stdPDPStatus1.hashCode());
 253
 254         stdPDPStatus.setFailedPipConfigs(failedPIPConfigs);
 255         assertFalse(stdPDPStatus.equals(stdPDPStatus1));
 256         stdPDPStatus1.setFailedPipConfigs(failedPIPConfigs);
 257         assertTrue(stdPDPStatus.equals(stdPDPStatus1));
 258         assertEquals(stdPDPStatus.hashCode(), stdPDPStatus1.hashCode());
 259
 260         stdPDPStatus.setFailedPolicies(failedPolicies);
 261         assertFalse(stdPDPStatus.equals(stdPDPStatus1));
 262         stdPDPStatus1.setFailedPolicies(failedPolicies);
 263         assertTrue(stdPDPStatus.equals(stdPDPStatus1));
 264         assertEquals(stdPDPStatus.hashCode(), stdPDPStatus1.hashCode());
 265
 266         stdPDPStatus.setLoadedPipConfigs(loadedPIPConfigs);
 267         assertFalse(stdPDPStatus.equals(stdPDPStatus1));
 268         stdPDPStatus1.setLoadedPipConfigs(loadedPIPConfigs);
 269         assertTrue(stdPDPStatus.equals(stdPDPStatus1));
 270         assertEquals(stdPDPStatus.hashCode(), stdPDPStatus1.hashCode());
 271
 272         stdPDPStatus.setLoadedPolicies(loadedPolicies);
 273         assertFalse(stdPDPStatus.equals(stdPDPStatus1));
 274         stdPDPStatus1.setLoadedPolicies(loadedPolicies);
 275         assertTrue(stdPDPStatus.equals(stdPDPStatus1));
 276         assertEquals(stdPDPStatus.hashCode(), stdPDPStatus1.hashCode());
 277
 278         stdPDPStatus.setLoadedRootPolicies(loadedRootPolicies);
 279         assertFalse(stdPDPStatus.equals(stdPDPStatus1));
 280         stdPDPStatus1.setLoadedRootPolicies(loadedRootPolicies);
 281         assertTrue(stdPDPStatus.equals(stdPDPStatus1));
 282         assertEquals(stdPDPStatus.hashCode(), stdPDPStatus1.hashCode());
 283
 284         stdPDPStatus.setLoadErrors(loadErrors);
 285         assertFalse(stdPDPStatus.equals(stdPDPStatus1));
 286         stdPDPStatus1.setLoadErrors(loadErrors);
 287         assertTrue(stdPDPStatus.equals(stdPDPStatus1));
 288         assertEquals(stdPDPStatus.hashCode(), stdPDPStatus1.hashCode());
 289
 290         stdPDPStatus.setLoadWarnings(loadWarnings);
 291         assertFalse(stdPDPStatus.equals(stdPDPStatus1));
 292         stdPDPStatus1.setLoadWarnings(loadWarnings);
 293         assertTrue(stdPDPStatus.equals(stdPDPStatus1));
 294         assertEquals(stdPDPStatus.hashCode(), stdPDPStatus1.hashCode());
 295     }
 296
 297     @Test
 298     public void testEqualsSameObject() {
 299         assertTrue(stdPDPStatus.equals(stdPDPStatus));
 300     }
 301
 302     @Test
 303     public void testEqualsNull() {
 304         assertFalse(stdPDPStatus.equals(null));
 305     }
 306
 307     @Test
 308     public void testEqualsInstanceOfDiffClass() {
 309         assertFalse(stdPDPStatus.equals(""));
 310     }
 311 }