models-interactions/model-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  * Modifications Copyright (C) 2019 Nordix Foundation.
   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.controlloop.policy.guard;
  22
  23 import static org.junit.Assert.assertEquals;
  24 import static org.junit.Assert.assertFalse;
  25 import static org.junit.Assert.assertNull;
  26 import static org.junit.Assert.assertTrue;
  27
  28 import java.util.ArrayList;
  29 import java.util.HashMap;
  30 import java.util.List;
  31 import java.util.Map;
  32
  33 import org.junit.Test;
  34
  35 public class ConstraintTest {
  36
  37     @Test
  38     public void testConstraint() {
  39         Constraint constraint = new Constraint();
  40
  41         assertNull(constraint.getFreq_limit_per_target());
  42         assertNull(constraint.getTime_window());
  43         assertNull(constraint.getActive_time_range());
  44         assertNull(constraint.getBlacklist());
  45     }
  46
  47     @Test
  48     public void testGetAndSetFreq_limit_per_target() {
  49         Integer freqLimitPerTarget = 10;
  50         Constraint constraint = new Constraint();
  51         constraint.setFreq_limit_per_target(freqLimitPerTarget);
  52         assertEquals(freqLimitPerTarget, constraint.getFreq_limit_per_target());
  53     }
  54
  55     @Test
  56     public void testGetAndSetTime_window() {
  57         Map<String, String> timeWindow = new HashMap<>();
  58         timeWindow.put("timeWindowKey", "timeWindowValue");
  59         Constraint constraint = new Constraint();
  60         constraint.setTime_window(timeWindow);
  61         assertEquals(timeWindow, constraint.getTime_window());
  62     }
  63
  64     @Test
  65     public void testGetAndSetActive_time_range() {
  66         Map<String, String> activeTimeRange = new HashMap<>();
  67         activeTimeRange.put("timeWindowKey", "timeWindowValue");
  68         Constraint constraint = new Constraint();
  69         constraint.setActive_time_range(activeTimeRange);;
  70         assertEquals(activeTimeRange, constraint.getActive_time_range());
  71     }
  72
  73     @Test
  74     public void testGetAndSetBlacklist() {
  75         List<String> blacklist = new ArrayList<>();
  76         blacklist.add("blacklist item");
  77         Constraint constraint = new Constraint();
  78         constraint.setBlacklist(blacklist);
  79         assertEquals(blacklist, constraint.getBlacklist());
  80     }
  81
  82     @Test
  83     public void testConstraintIntegerMapOfStringString() {
  84         Integer freqLimitPerTarget = 10;
  85         Map<String, String> timeWindow = new HashMap<>();
  86
  87         Constraint constraint = new Constraint(freqLimitPerTarget, timeWindow);
  88
  89         assertEquals(freqLimitPerTarget, constraint.getFreq_limit_per_target());
  90         assertEquals(timeWindow, constraint.getTime_window());
  91         assertNull(constraint.getActive_time_range());
  92         assertNull(constraint.getBlacklist());
  93     }
  94
  95     @Test
  96     public void testConstraintListOfString() {
  97         List<String> blacklist = new ArrayList<>();
  98         blacklist.add("blacklist item");
  99         Constraint constraint = new Constraint(blacklist);
 100
 101         assertNull(constraint.getFreq_limit_per_target());
 102         assertNull(constraint.getTime_window());
 103         assertNull(constraint.getActive_time_range());
 104         assertEquals(blacklist, constraint.getBlacklist());
 105     }
 106
 107     @Test
 108     public void testConstraintIntegerMapOfStringStringListOfString() {
 109         Integer freqLimitPerTarget = 10;
 110         Map<String, String> timeWindow = new HashMap<>();
 111         List<String> blacklist = new ArrayList<>();
 112         blacklist.add("blacklist item");
 113         Constraint constraint = new Constraint(freqLimitPerTarget, timeWindow, blacklist);
 114
 115         assertEquals(freqLimitPerTarget, constraint.getFreq_limit_per_target());
 116         assertEquals(timeWindow, constraint.getTime_window());
 117         assertNull(constraint.getActive_time_range());
 118         assertEquals(blacklist, constraint.getBlacklist());
 119     }
 120
 121     @Test
 122     public void testConstraintIntegerMapOfStringStringMapOfStringString() {
 123         Integer freqLimitPerTarget = 10;
 124         Map<String, String> timeWindow = new HashMap<>();
 125         Map<String, String> activeTimeRange = new HashMap<>();
 126         activeTimeRange.put("timeWindowKey", "timeWindowValue");
 127         Constraint constraint = new Constraint(freqLimitPerTarget, timeWindow, activeTimeRange);
 128
 129         assertEquals(freqLimitPerTarget, constraint.getFreq_limit_per_target());
 130         assertEquals(timeWindow, constraint.getTime_window());
 131         assertEquals(activeTimeRange, constraint.getActive_time_range());
 132         assertNull(constraint.getBlacklist());
 133
 134     }
 135
 136     @Test
 137     public void testConstraintIntegerMapOfStringStringMapOfStringStringListOfString() {
 138         Integer freqLimitPerTarget = 10;
 139         Map<String, String> timeWindow = new HashMap<>();
 140         Map<String, String> activeTimeRange = new HashMap<>();
 141         activeTimeRange.put("timeWindowKey", "timeWindowValue");
 142         List<String> blacklist = new ArrayList<>();
 143         blacklist.add("blacklist item");
 144         Constraint constraint = new Constraint(freqLimitPerTarget, timeWindow, activeTimeRange, blacklist);
 145
 146         assertEquals(freqLimitPerTarget, constraint.getFreq_limit_per_target());
 147         assertEquals(timeWindow, constraint.getTime_window());
 148         assertEquals(activeTimeRange, constraint.getActive_time_range());
 149         assertEquals(blacklist, constraint.getBlacklist());
 150     }
 151
 152     @Test
 153     public void testConstraintConstraint() {
 154         Integer freqLimitPerTarget = 10;
 155         Map<String, String> timeWindow = new HashMap<>();
 156         Map<String, String> activeTimeRange = new HashMap<>();
 157         activeTimeRange.put("timeWindowKey", "timeWindowValue");
 158         List<String> blacklist = new ArrayList<>();
 159         blacklist.add("blacklist item");
 160         Constraint constraint1 = new Constraint(freqLimitPerTarget, timeWindow, activeTimeRange, blacklist);
 161         Constraint constraint2 = new Constraint(constraint1);
 162
 163         assertEquals(freqLimitPerTarget, constraint2.getFreq_limit_per_target());
 164         assertEquals(timeWindow, constraint2.getTime_window());
 165         assertEquals(activeTimeRange, constraint2.getActive_time_range());
 166         assertEquals(blacklist, constraint2.getBlacklist());
 167     }
 168
 169     @Test
 170     public void testIsValid() {
 171         Integer freqLimitPerTarget = 10;
 172         final Map<String, String> timeWindow = new HashMap<>();
 173
 174         Constraint constraint = new Constraint();
 175         assertTrue(constraint.isValid());
 176
 177         constraint.setFreq_limit_per_target(freqLimitPerTarget);
 178         assertFalse(constraint.isValid());
 179
 180         constraint.setTime_window(timeWindow);
 181         assertTrue(constraint.isValid());
 182
 183         constraint.setFreq_limit_per_target(null);
 184         assertFalse(constraint.isValid());
 185     }
 186
 187     @Test
 188     public void testToString() {
 189         Integer freqLimitPerTarget = 10;
 190         Map<String, String> timeWindow = new HashMap<>();
 191         Map<String, String> activeTimeRange = new HashMap<>();
 192         activeTimeRange.put("timeWindowKey", "timeWindowValue");
 193         List<String> blacklist = new ArrayList<>();
 194         blacklist.add("blacklist item");
 195         Constraint constraint = new Constraint(freqLimitPerTarget, timeWindow, activeTimeRange, blacklist);
 196
 197         assertEquals(constraint.toString(), "Constraint [freq_limit_per_target=" + freqLimitPerTarget + ", time_window="
 198                 + timeWindow + ", active_time_range=" + activeTimeRange + ", 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 }