controlloop/common/policy-yaml/src/test/java/org/onap/policy/controlloop/policy/guard/ConstraintTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * Copyright (C) 2018 Ericsson. All rights reserved.
   4  * Modifications Copyright (C) 2018 AT&T Intellectual Property. All rights reserved.
   5  * ================================================================================
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  * ============LICENSE_END=========================================================
  18  */
  19
  20 package org.onap.policy.controlloop.policy.guard;
  21
  22 import static org.junit.Assert.assertEquals;
  23 import static org.junit.Assert.assertFalse;
  24 import static org.junit.Assert.assertNull;
  25 import static org.junit.Assert.assertTrue;
  26
  27 import java.util.ArrayList;
  28 import java.util.HashMap;
  29 import java.util.List;
  30 import java.util.Map;
  31
  32 import org.junit.Test;
  33
  34 public class ConstraintTest {
  35
  36     @Test
  37     public void testConstraint() {
  38         Constraint constraint = new Constraint();
  39
  40         assertNull(constraint.getFreq_limit_per_target());
  41         assertNull(constraint.getTime_window());
  42         assertNull(constraint.getActive_time_range());
  43         assertNull(constraint.getBlacklist());
  44     }
  45
  46     @Test
  47     public void testGetAndSetFreq_limit_per_target() {
  48         Integer freqLimitPerTarget = 10;
  49         Constraint constraint = new Constraint();
  50         constraint.setFreq_limit_per_target(freqLimitPerTarget);
  51         assertEquals(freqLimitPerTarget, constraint.getFreq_limit_per_target());
  52     }
  53
  54     @Test
  55     public void testGetAndSetTime_window() {
  56         Map<String, String> timeWindow = new HashMap<>();
  57         timeWindow.put("timeWindowKey", "timeWindowValue");
  58         Constraint constraint = new Constraint();
  59         constraint.setTime_window(timeWindow);
  60         assertEquals(timeWindow, constraint.getTime_window());
  61     }
  62
  63     @Test
  64     public void testGetAndSetActive_time_range() {
  65         Map<String, String> activeTimeRange = new HashMap<>();
  66         activeTimeRange.put("timeWindowKey", "timeWindowValue");
  67         Constraint constraint = new Constraint();
  68         constraint.setActive_time_range(activeTimeRange);;
  69         assertEquals(activeTimeRange, constraint.getActive_time_range());
  70     }
  71
  72     @Test
  73     public void testGetAndSetBlacklist() {
  74         List<String> blacklist = new ArrayList<>();
  75         blacklist.add("blacklist item");
  76         Constraint constraint = new Constraint();
  77         constraint.setBlacklist(blacklist);
  78         assertEquals(blacklist, constraint.getBlacklist());
  79     }
  80
  81     @Test
  82     public void testConstraintIntegerMapOfStringString() {
  83         Integer freqLimitPerTarget = 10;
  84         Map<String, String> timeWindow = new HashMap<>();
  85
  86         Constraint constraint = new Constraint(freqLimitPerTarget, timeWindow);
  87
  88         assertEquals(freqLimitPerTarget, constraint.getFreq_limit_per_target());
  89         assertEquals(timeWindow, constraint.getTime_window());
  90         assertNull(constraint.getActive_time_range());
  91         assertNull(constraint.getBlacklist());
  92     }
  93
  94     @Test
  95     public void testConstraintListOfString() {
  96         List<String> blacklist = new ArrayList<>();
  97         blacklist.add("blacklist item");
  98         Constraint constraint = new Constraint(blacklist);
  99
 100         assertNull(constraint.getFreq_limit_per_target());
 101         assertNull(constraint.getTime_window());
 102         assertNull(constraint.getActive_time_range());
 103         assertEquals(blacklist, constraint.getBlacklist());
 104     }
 105
 106     @Test
 107     public void testConstraintIntegerMapOfStringStringListOfString() {
 108         Integer freqLimitPerTarget = 10;
 109         Map<String, String> timeWindow = new HashMap<>();
 110         List<String> blacklist = new ArrayList<>();
 111         blacklist.add("blacklist item");
 112         Constraint constraint = new Constraint(freqLimitPerTarget, timeWindow, blacklist);
 113
 114         assertEquals(freqLimitPerTarget, constraint.getFreq_limit_per_target());
 115         assertEquals(timeWindow, constraint.getTime_window());
 116         assertNull(constraint.getActive_time_range());
 117         assertEquals(blacklist, constraint.getBlacklist());
 118     }
 119
 120     @Test
 121     public void testConstraintIntegerMapOfStringStringMapOfStringString() {
 122         Integer freqLimitPerTarget = 10;
 123         Map<String, String> timeWindow = new HashMap<>();
 124         Map<String, String> activeTimeRange = new HashMap<>();
 125         activeTimeRange.put("timeWindowKey", "timeWindowValue");
 126         Constraint constraint = new Constraint(freqLimitPerTarget, timeWindow, activeTimeRange);
 127
 128         assertEquals(freqLimitPerTarget, constraint.getFreq_limit_per_target());
 129         assertEquals(timeWindow, constraint.getTime_window());
 130         assertEquals(activeTimeRange, constraint.getActive_time_range());
 131         assertNull(constraint.getBlacklist());
 132
 133     }
 134
 135     @Test
 136     public void testConstraintIntegerMapOfStringStringMapOfStringStringListOfString() {
 137         Integer freqLimitPerTarget = 10;
 138         Map<String, String> timeWindow = new HashMap<>();
 139         Map<String, String> activeTimeRange = new HashMap<>();
 140         activeTimeRange.put("timeWindowKey", "timeWindowValue");
 141         List<String> blacklist = new ArrayList<>();
 142         blacklist.add("blacklist item");
 143         Constraint constraint = new Constraint(freqLimitPerTarget, timeWindow, activeTimeRange, blacklist);
 144
 145         assertEquals(freqLimitPerTarget, constraint.getFreq_limit_per_target());
 146         assertEquals(timeWindow, constraint.getTime_window());
 147         assertEquals(activeTimeRange, constraint.getActive_time_range());
 148         assertEquals(blacklist, constraint.getBlacklist());
 149     }
 150
 151     @Test
 152     public void testConstraintConstraint() {
 153         Integer freqLimitPerTarget = 10;
 154         Map<String, String> timeWindow = new HashMap<>();
 155         Map<String, String> activeTimeRange = new HashMap<>();
 156         activeTimeRange.put("timeWindowKey", "timeWindowValue");
 157         List<String> blacklist = new ArrayList<>();
 158         blacklist.add("blacklist item");
 159         Constraint constraint1 = new Constraint(freqLimitPerTarget, timeWindow, activeTimeRange, blacklist);
 160         Constraint constraint2 = new Constraint(constraint1);
 161
 162         assertEquals(freqLimitPerTarget, constraint2.getFreq_limit_per_target());
 163         assertEquals(timeWindow, constraint2.getTime_window());
 164         assertEquals(activeTimeRange, constraint2.getActive_time_range());
 165         assertEquals(blacklist, constraint2.getBlacklist());
 166     }
 167
 168     @Test
 169     public void testIsValid() {
 170         Integer freqLimitPerTarget = 10;
 171         final Map<String, String> timeWindow = new HashMap<>();
 172
 173         Constraint constraint = new Constraint();
 174         assertTrue(constraint.isValid());
 175
 176         constraint.setFreq_limit_per_target(freqLimitPerTarget);
 177         assertFalse(constraint.isValid());
 178
 179         constraint.setTime_window(timeWindow);
 180         assertTrue(constraint.isValid());
 181
 182         constraint.setFreq_limit_per_target(null);
 183         assertFalse(constraint.isValid());
 184     }
 185
 186     @Test
 187     public void testToString() {
 188         Integer freqLimitPerTarget = 10;
 189         Map<String, String> timeWindow = new HashMap<>();
 190         Map<String, String> activeTimeRange = new HashMap<>();
 191         activeTimeRange.put("timeWindowKey", "timeWindowValue");
 192         List<String> blacklist = new ArrayList<>();
 193         blacklist.add("blacklist item");
 194         Constraint constraint = new Constraint(freqLimitPerTarget, timeWindow, activeTimeRange, blacklist);
 195
 196         assertEquals(constraint.toString(), "Constraint [freq_limit_per_target=" + freqLimitPerTarget
 197                         + ", time_window=" + timeWindow + ", active_time_range=" + activeTimeRange
 198                         + ", blacklist=" + blacklist + "]");
 199     }
 200
 201     @Test
 202     public void testEquals() {
 203         Integer freqLimitPerTarget = 10;
 204         final Map<String, String> timeWindow = new HashMap<>();
 205         final Map<String, String> activeTimeRange = new HashMap<>();
 206         List<String> blacklist = new ArrayList<>();
 207         blacklist.add("blacklist item");
 208
 209         Constraint constraint1 = new Constraint();
 210         Constraint constraint2 = new Constraint();
 211         assertTrue(constraint1.equals(constraint2));
 212
 213         constraint1.setFreq_limit_per_target(freqLimitPerTarget);
 214         assertFalse(constraint1.equals(constraint2));
 215         constraint2.setFreq_limit_per_target(freqLimitPerTarget);
 216         assertTrue(constraint1.equals(constraint2));
 217         assertEquals(constraint1.hashCode(), constraint2.hashCode());
 218
 219         constraint1.setTime_window(timeWindow);
 220         assertFalse(constraint1.equals(constraint2));
 221         constraint2.setTime_window(timeWindow);
 222         assertTrue(constraint1.equals(constraint2));
 223         assertEquals(constraint1.hashCode(), constraint2.hashCode());
 224
 225         constraint1.setActive_time_range(activeTimeRange);
 226         assertFalse(constraint1.equals(constraint2));
 227         constraint2.setActive_time_range(activeTimeRange);
 228         assertTrue(constraint1.equals(constraint2));
 229         assertEquals(constraint1.hashCode(), constraint2.hashCode());
 230
 231         constraint1.setBlacklist(blacklist);
 232         assertFalse(constraint1.equals(constraint2));
 233         constraint2.setBlacklist(blacklist);
 234         assertTrue(constraint1.equals(constraint2));
 235         assertEquals(constraint1.hashCode(), constraint2.hashCode());
 236     }
 237
 238     @Test
 239     public void testEqualsSameObject() {
 240         Constraint constraint = new Constraint();
 241         assertTrue(constraint.equals(constraint));
 242     }
 243
 244     @Test
 245     public void testEqualsNull() {
 246         Constraint constraint = new Constraint();
 247         assertFalse(constraint.equals(null));
 248     }
 249
 250     @Test
 251     public void testEqualsInstanceOfDiffClass() {
 252         Constraint constraint = new Constraint();
 253         assertFalse(constraint.equals(""));
 254     }
 255
 256 }