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