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  * Modifications Copyright (C) 2019 Samsung
   5  * Modifications Copyright (C) 2019 AT&T Intellectual Property.
   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
  21 package org.onap.policy.xacml.test.std.pap;
  22
  23 import static org.junit.Assert.assertEquals;
  24 import static org.junit.Assert.assertFalse;
  25 import static org.junit.Assert.assertTrue;
  26
  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 import java.util.HashSet;
  32 import java.util.Set;
  33
  34 import org.junit.Test;
  35 import org.onap.policy.xacml.std.pap.StdPDPPIPConfig;
  36 import org.onap.policy.xacml.std.pap.StdPDPPolicy;
  37 import org.onap.policy.xacml.std.pap.StdPDPStatus;
  38
  39 public class StdPDPStatusTest {
  40
  41     StdPDPStatus stdPDPStatus = new StdPDPStatus();
  42
  43     @Test
  44     public void testSetAndGetStatus() {
  45         Status status = Status.UP_TO_DATE;
  46         stdPDPStatus.setStatus(status);
  47         assertEquals(status, stdPDPStatus.getStatus());
  48     }
  49
  50     @Test
  51     public void testSetAndGetLoadErrors() {
  52         Set<String> errors = new HashSet<>();
  53         errors.add("An error");
  54         stdPDPStatus.setLoadErrors(errors);
  55         assertEquals(errors, stdPDPStatus.getLoadErrors());
  56     }
  57
  58     @Test
  59     public void testSetAndGetLoadWarnings() {
  60         Set<String> warnings = new HashSet<>();
  61         warnings.add("An error");
  62         stdPDPStatus.setLoadWarnings(warnings);
  63         assertEquals(warnings, stdPDPStatus.getLoadWarnings());
  64     }
  65
  66     @Test
  67     public void testSetAndGetLoadedPolicies() {
  68         Set<PDPPolicy> loadedPolicies = new HashSet<>();
  69         loadedPolicies.add(new StdPDPPolicy());
  70         stdPDPStatus.setLoadedPolicies(loadedPolicies);
  71         assertEquals(loadedPolicies, stdPDPStatus.getLoadedPolicies());
  72     }
  73
  74     @Test
  75     public void testSetAndGetLoadedRootPolicies() {
  76         Set<PDPPolicy> loadedRootPolicies = new HashSet<>();
  77         loadedRootPolicies.add(new StdPDPPolicy());
  78         stdPDPStatus.setLoadedRootPolicies(loadedRootPolicies);
  79         assertEquals(loadedRootPolicies, stdPDPStatus.getLoadedRootPolicies());
  80     }
  81
  82     @Test
  83     public void testSetAndGetFailedPolicies() {
  84         Set<PDPPolicy> failedPolicies = new HashSet<>();
  85         failedPolicies.add(new StdPDPPolicy());
  86         stdPDPStatus.setFailedPolicies(failedPolicies);
  87         assertEquals(failedPolicies, stdPDPStatus.getFailedPolicies());
  88     }
  89
  90     @Test
  91     public void testSetAndGetLoadedPipConfigs() {
  92         Set<PDPPIPConfig> loadedPipConfigs = new HashSet<>();
  93         loadedPipConfigs.add(new StdPDPPIPConfig());
  94         stdPDPStatus.setLoadedPipConfigs(loadedPipConfigs);
  95         assertEquals(loadedPipConfigs, stdPDPStatus.getLoadedPipConfigs());
  96     }
  97
  98     @Test
  99     public void testSetAndGetFailedPipConfigs() {
 100         Set<PDPPIPConfig> failedPipConfigs = new HashSet<>();
 101         failedPipConfigs.add(new StdPDPPIPConfig());
 102         stdPDPStatus.setFailedPipConfigs(failedPipConfigs);
 103         assertEquals(failedPipConfigs, stdPDPStatus.getFailedPipConfigs());
 104     }
 105
 106     @Test
 107     public void testPoliciesOK() {
 108         assertTrue(stdPDPStatus.policiesOK());
 109         stdPDPStatus.addFailedPolicy(new StdPDPPolicy());
 110         assertFalse(stdPDPStatus.policiesOK());
 111     }
 112
 113     @Test
 114     public void testPipConfigOK() {
 115         assertTrue(stdPDPStatus.pipConfigOK());
 116         stdPDPStatus.addFailedPipConfig(new StdPDPPIPConfig());
 117         assertFalse(stdPDPStatus.pipConfigOK());
 118     }
 119
 120     @Test
 121     public void testIsOkFailedPolicy() {
 122         stdPDPStatus.setStatus(Status.UP_TO_DATE);
 123         assertTrue(stdPDPStatus.isOk());
 124         stdPDPStatus.addFailedPolicy(new StdPDPPolicy());
 125         assertFalse(stdPDPStatus.isOk());
 126     }
 127
 128     @Test
 129     public void testIsOkFailedPipConfig() {
 130         stdPDPStatus.setStatus(Status.UP_TO_DATE);
 131         assertTrue(stdPDPStatus.isOk());
 132         stdPDPStatus.addFailedPipConfig(new StdPDPPIPConfig());
 133         assertFalse(stdPDPStatus.isOk());
 134     }
 135
 136     @Test
 137     public void testIsOkStatusOutOfSync() {
 138         stdPDPStatus.setStatus(Status.UP_TO_DATE);
 139         assertTrue(stdPDPStatus.isOk());
 140         stdPDPStatus.setStatus(Status.OUT_OF_SYNCH);
 141         assertFalse(stdPDPStatus.isOk());
 142     }
 143
 144     @Test
 145     public void testAddLoadError() {
 146         stdPDPStatus.addLoadError("An error");
 147         assertEquals("An error", stdPDPStatus.getLoadErrors().iterator().next());
 148     }
 149
 150     @Test
 151     public void testAddLoadWarning() {
 152         stdPDPStatus.addLoadWarning("A warning");
 153         assertEquals("A warning", stdPDPStatus.getLoadWarnings().iterator().next());
 154     }
 155
 156     @Test
 157     public void testAddLoadedPolicy() {
 158         PDPPolicy policy = new StdPDPPolicy();
 159         stdPDPStatus.addLoadedPolicy(policy);
 160         assertEquals(policy, stdPDPStatus.getLoadedPolicies().iterator().next());
 161     }
 162
 163     @Test
 164     public void testAddRootPolicy() {
 165         PDPPolicy policy = new StdPDPPolicy();
 166         stdPDPStatus.addRootPolicy(policy);
 167         assertEquals(policy, stdPDPStatus.getLoadedRootPolicies().iterator().next());
 168     }
 169
 170     @Test
 171     public void testAddAllLoadedRootPolicy() {
 172         Set<PDPPolicy> policies = new HashSet<>();
 173         PDPPolicy policy = new StdPDPPolicy();
 174         policies.add(policy);
 175         stdPDPStatus.addAllLoadedRootPolicies(policies);
 176         assertEquals(policies, stdPDPStatus.getLoadedRootPolicies());
 177     }
 178
 179     @Test
 180     public void testAddLoadedPipConfig() {
 181         PDPPIPConfig pipConfig = new StdPDPPIPConfig();
 182         stdPDPStatus.addLoadedPipConfig(pipConfig);
 183         assertEquals(pipConfig, stdPDPStatus.getLoadedPipConfigs().iterator().next());
 184     }
 185
 186     @Test
 187     public void testSet() {
 188         final Status status = Status.UP_TO_DATE;
 189         Set<PDPPIPConfig> failedPipConfigs = new HashSet<>();
 190         failedPipConfigs.add(new StdPDPPIPConfig());
 191         Set<PDPPolicy> failedPolicies = new HashSet<>();
 192         failedPolicies.add(new StdPDPPolicy());
 193         Set<PDPPIPConfig> loadedPipConfigs = new HashSet<>();
 194         loadedPipConfigs.add(new StdPDPPIPConfig());
 195         Set<PDPPolicy> loadedPolicies = new HashSet<>();
 196         loadedPolicies.add(new StdPDPPolicy());
 197         Set<PDPPolicy> loadedRootPolicies = new HashSet<>();
 198         loadedRootPolicies.add(new StdPDPPolicy());
 199         Set<String> loadErrors = new HashSet<>();
 200         loadErrors.add("An error");
 201         Set<String> loadWarnings = new HashSet<>();
 202         loadWarnings.add("An error");
 203
 204         stdPDPStatus.setStatus(status);
 205         stdPDPStatus.setFailedPipConfigs(failedPipConfigs);
 206         stdPDPStatus.setFailedPolicies(failedPolicies);
 207         stdPDPStatus.setLoadedPipConfigs(loadedPipConfigs);
 208         stdPDPStatus.setLoadedPolicies(loadedPolicies);
 209         stdPDPStatus.setLoadedRootPolicies(loadedRootPolicies);
 210         stdPDPStatus.setLoadErrors(loadErrors);
 211         stdPDPStatus.setLoadWarnings(loadWarnings);
 212
 213         StdPDPStatus stdPdpStatus1 = new StdPDPStatus();
 214         stdPdpStatus1.set(stdPDPStatus);
 215
 216         assertEquals(status, stdPdpStatus1.getStatus());
 217         assertEquals(loadErrors, stdPdpStatus1.getLoadErrors());
 218         assertEquals(loadWarnings, stdPdpStatus1.getLoadWarnings());
 219         assertEquals(loadedPolicies, stdPdpStatus1.getLoadedPolicies());
 220         assertEquals(loadedRootPolicies, stdPdpStatus1.getLoadedRootPolicies());
 221         assertEquals(failedPolicies, stdPdpStatus1.getFailedPolicies());
 222         assertEquals(loadedPipConfigs, stdPdpStatus1.getLoadedPipConfigs());
 223         assertEquals(failedPipConfigs, stdPdpStatus1.getFailedPipConfigs());
 224
 225         assertTrue(stdPdpStatus1.toString().startsWith("StdPDPStatus"));
 226     }
 227
 228     @Test
 229     public void testEqualsAndHashCode() {
 230         final Status status = Status.UP_TO_DATE;
 231         Set<PDPPIPConfig> failedPipConfigs = new HashSet<>();
 232         failedPipConfigs.add(new StdPDPPIPConfig());
 233         Set<PDPPolicy> failedPolicies = new HashSet<>();
 234         failedPolicies.add(new StdPDPPolicy());
 235         Set<PDPPIPConfig> loadedPipConfigs = new HashSet<>();
 236         loadedPipConfigs.add(new StdPDPPIPConfig());
 237         Set<PDPPolicy> loadedPolicies = new HashSet<>();
 238         loadedPolicies.add(new StdPDPPolicy());
 239         Set<PDPPolicy> loadedRootPolicies = new HashSet<>();
 240         loadedRootPolicies.add(new StdPDPPolicy());
 241         Set<String> loadErrors = new HashSet<>();
 242         loadErrors.add("An error");
 243         Set<String> loadWarnings = new HashSet<>();
 244         loadWarnings.add("An error");
 245
 246         StdPDPStatus stdPdpStatus1 = new StdPDPStatus();
 247
 248         assertTrue(stdPDPStatus.equals(stdPdpStatus1));
 249
 250         stdPDPStatus.setStatus(status);
 251         assertFalse(stdPDPStatus.equals(stdPdpStatus1));
 252         stdPdpStatus1.setStatus(status);
 253         assertTrue(stdPDPStatus.equals(stdPdpStatus1));
 254         assertEquals(stdPDPStatus.hashCode(), stdPdpStatus1.hashCode());
 255
 256         stdPDPStatus.setFailedPipConfigs(failedPipConfigs);
 257         assertFalse(stdPDPStatus.equals(stdPdpStatus1));
 258         stdPdpStatus1.setFailedPipConfigs(failedPipConfigs);
 259         assertTrue(stdPDPStatus.equals(stdPdpStatus1));
 260         assertEquals(stdPDPStatus.hashCode(), stdPdpStatus1.hashCode());
 261
 262         stdPDPStatus.setFailedPolicies(failedPolicies);
 263         assertFalse(stdPDPStatus.equals(stdPdpStatus1));
 264         stdPdpStatus1.setFailedPolicies(failedPolicies);
 265         assertTrue(stdPDPStatus.equals(stdPdpStatus1));
 266         assertEquals(stdPDPStatus.hashCode(), stdPdpStatus1.hashCode());
 267
 268         stdPDPStatus.setLoadedPipConfigs(loadedPipConfigs);
 269         assertFalse(stdPDPStatus.equals(stdPdpStatus1));
 270         stdPdpStatus1.setLoadedPipConfigs(loadedPipConfigs);
 271         assertTrue(stdPDPStatus.equals(stdPdpStatus1));
 272         assertEquals(stdPDPStatus.hashCode(), stdPdpStatus1.hashCode());
 273
 274         stdPDPStatus.setLoadedPolicies(loadedPolicies);
 275         assertFalse(stdPDPStatus.equals(stdPdpStatus1));
 276         stdPdpStatus1.setLoadedPolicies(loadedPolicies);
 277         assertTrue(stdPDPStatus.equals(stdPdpStatus1));
 278         assertEquals(stdPDPStatus.hashCode(), stdPdpStatus1.hashCode());
 279
 280         stdPDPStatus.setLoadedRootPolicies(loadedRootPolicies);
 281         assertFalse(stdPDPStatus.equals(stdPdpStatus1));
 282         stdPdpStatus1.setLoadedRootPolicies(loadedRootPolicies);
 283         assertTrue(stdPDPStatus.equals(stdPdpStatus1));
 284         assertEquals(stdPDPStatus.hashCode(), stdPdpStatus1.hashCode());
 285
 286         stdPDPStatus.setLoadErrors(loadErrors);
 287         assertFalse(stdPDPStatus.equals(stdPdpStatus1));
 288         stdPdpStatus1.setLoadErrors(loadErrors);
 289         assertTrue(stdPDPStatus.equals(stdPdpStatus1));
 290         assertEquals(stdPDPStatus.hashCode(), stdPdpStatus1.hashCode());
 291
 292         stdPDPStatus.setLoadWarnings(loadWarnings);
 293         assertFalse(stdPDPStatus.equals(stdPdpStatus1));
 294         stdPdpStatus1.setLoadWarnings(loadWarnings);
 295         assertTrue(stdPDPStatus.equals(stdPdpStatus1));
 296         assertEquals(stdPDPStatus.hashCode(), stdPdpStatus1.hashCode());
 297     }
 298
 299     @Test
 300     public void testEqualsSameObject() {
 301         assertTrue(stdPDPStatus.equals(stdPDPStatus));
 302     }
 303
 304     @Test
 305     public void testEqualsNull() {
 306         assertFalse(stdPDPStatus.equals(null));
 307     }
 308
 309     @Test
 310     public void testEqualsInstanceOfDiffClass() {
 311         assertFalse(stdPDPStatus.equals(""));
 312     }
 313 }