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-2019 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 import org.junit.Test;
  33
  34 public class ConstraintTest {
  35
  36     private static final String TIME_WINDOW_VALUE = "timeWindowValue";
  37     private static final String TIME_WINDOW_KEY = "timeWindowKey";
  38     private static final String BLACKLIST_ITEM = "blacklist item";
  39
  40     @Test
  41     public void testConstraint() {
  42         Constraint constraint = new Constraint();
  43
  44         assertNull(constraint.getFreq_limit_per_target());
  45         assertNull(constraint.getTime_window());
  46         assertNull(constraint.getActive_time_range());
  47         assertNull(constraint.getBlacklist());
  48     }
  49
  50     @Test
  51     public void testGetAndSetFreq_limit_per_target() {
  52         Integer freqLimitPerTarget = 10;
  53         Constraint constraint = new Constraint();
  54         constraint.setFreq_limit_per_target(freqLimitPerTarget);
  55         assertEquals(freqLimitPerTarget, constraint.getFreq_limit_per_target());
  56     }
  57
  58     @Test
  59     public void testGetAndSetTime_window() {
  60         Map<String, String> timeWindow = new HashMap<>();
  61         timeWindow.put(TIME_WINDOW_KEY, TIME_WINDOW_VALUE);
  62         Constraint constraint = new Constraint();
  63         constraint.setTime_window(timeWindow);
  64         assertEquals(timeWindow, constraint.getTime_window());
  65     }
  66
  67     @Test
  68     public void testGetAndSetActive_time_range() {
  69         Map<String, String> activeTimeRange = new HashMap<>();
  70         activeTimeRange.put(TIME_WINDOW_KEY, TIME_WINDOW_VALUE);
  71         Constraint constraint = new Constraint();
  72         constraint.setActive_time_range(activeTimeRange);;
  73         assertEquals(activeTimeRange, constraint.getActive_time_range());
  74     }
  75
  76     @Test
  77     public void testGetAndSetBlacklist() {
  78         List<String> blacklist = new ArrayList<>();
  79         blacklist.add(BLACKLIST_ITEM);
  80         Constraint constraint = new Constraint();
  81         constraint.setBlacklist(blacklist);
  82         assertEquals(blacklist, constraint.getBlacklist());
  83     }
  84
  85     @Test
  86     public void testConstraintIntegerMapOfStringString() {
  87         Integer freqLimitPerTarget = 10;
  88         Map<String, String> timeWindow = new HashMap<>();
  89
  90         Constraint constraint = new Constraint(freqLimitPerTarget, timeWindow);
  91
  92         assertEquals(freqLimitPerTarget, constraint.getFreq_limit_per_target());
  93         assertEquals(timeWindow, constraint.getTime_window());
  94         assertNull(constraint.getActive_time_range());
  95         assertNull(constraint.getBlacklist());
  96     }
  97
  98     @Test
  99     public void testConstraintListOfString() {
 100         List<String> blacklist = new ArrayList<>();
 101         blacklist.add(BLACKLIST_ITEM);
 102         Constraint constraint = new Constraint(blacklist);
 103
 104         assertNull(constraint.getFreq_limit_per_target());
 105         assertNull(constraint.getTime_window());
 106         assertNull(constraint.getActive_time_range());
 107         assertEquals(blacklist, constraint.getBlacklist());
 108     }
 109
 110     @Test
 111     public void testConstraintIntegerMapOfStringStringListOfString() {
 112         Integer freqLimitPerTarget = 10;
 113         Map<String, String> timeWindow = new HashMap<>();
 114         List<String> blacklist = new ArrayList<>();
 115         blacklist.add(BLACKLIST_ITEM);
 116         Constraint constraint = new Constraint(freqLimitPerTarget, timeWindow, blacklist);
 117
 118         assertEquals(freqLimitPerTarget, constraint.getFreq_limit_per_target());
 119         assertEquals(timeWindow, constraint.getTime_window());
 120         assertNull(constraint.getActive_time_range());
 121         assertEquals(blacklist, constraint.getBlacklist());
 122     }
 123
 124     @Test
 125     public void testConstraintIntegerMapOfStringStringMapOfStringString() {
 126         Integer freqLimitPerTarget = 10;
 127         Map<String, String> timeWindow = new HashMap<>();
 128         Map<String, String> activeTimeRange = new HashMap<>();
 129         activeTimeRange.put(TIME_WINDOW_KEY, TIME_WINDOW_VALUE);
 130         Constraint constraint = new Constraint(freqLimitPerTarget, timeWindow, activeTimeRange);
 131
 132         assertEquals(freqLimitPerTarget, constraint.getFreq_limit_per_target());
 133         assertEquals(timeWindow, constraint.getTime_window());
 134         assertEquals(activeTimeRange, constraint.getActive_time_range());
 135         assertNull(constraint.getBlacklist());
 136
 137     }
 138
 139     @Test
 140     public void testConstraintIntegerMapOfStringStringMapOfStringStringListOfString() {
 141         Integer freqLimitPerTarget = 10;
 142         Map<String, String> timeWindow = new HashMap<>();
 143         Map<String, String> activeTimeRange = new HashMap<>();
 144         activeTimeRange.put(TIME_WINDOW_KEY, TIME_WINDOW_VALUE);
 145         List<String> blacklist = new ArrayList<>();
 146         blacklist.add(BLACKLIST_ITEM);
 147         Constraint constraint = new Constraint(freqLimitPerTarget, timeWindow, activeTimeRange, blacklist);
 148
 149         assertEquals(freqLimitPerTarget, constraint.getFreq_limit_per_target());
 150         assertEquals(timeWindow, constraint.getTime_window());
 151         assertEquals(activeTimeRange, constraint.getActive_time_range());
 152         assertEquals(blacklist, constraint.getBlacklist());
 153     }
 154
 155     @Test
 156     public void testConstraintConstraint() {
 157         Integer freqLimitPerTarget = 10;
 158         Map<String, String> timeWindow = new HashMap<>();
 159         Map<String, String> activeTimeRange = new HashMap<>();
 160         activeTimeRange.put(TIME_WINDOW_KEY, TIME_WINDOW_VALUE);
 161         List<String> blacklist = new ArrayList<>();
 162         blacklist.add(BLACKLIST_ITEM);
 163         Constraint constraint1 = new Constraint(freqLimitPerTarget, timeWindow, activeTimeRange, blacklist);
 164         Constraint constraint2 = new Constraint(constraint1);
 165
 166         assertEquals(freqLimitPerTarget, constraint2.getFreq_limit_per_target());
 167         assertEquals(timeWindow, constraint2.getTime_window());
 168         assertEquals(activeTimeRange, constraint2.getActive_time_range());
 169         assertEquals(blacklist, constraint2.getBlacklist());
 170     }
 171
 172     @Test
 173     public void testIsValid() {
 174         Integer freqLimitPerTarget = 10;
 175         final Map<String, String> timeWindow = new HashMap<>();
 176
 177         Constraint constraint = new Constraint();
 178         assertTrue(constraint.isValid());
 179
 180         constraint.setFreq_limit_per_target(freqLimitPerTarget);
 181         assertFalse(constraint.isValid());
 182
 183         constraint.setTime_window(timeWindow);
 184         assertTrue(constraint.isValid());
 185
 186         constraint.setFreq_limit_per_target(null);
 187         assertFalse(constraint.isValid());
 188     }
 189
 190     @Test
 191     public void testToString() {
 192         Integer freqLimitPerTarget = 10;
 193         Map<String, String> timeWindow = new HashMap<>();
 194         Map<String, String> activeTimeRange = new HashMap<>();
 195         activeTimeRange.put(TIME_WINDOW_KEY, TIME_WINDOW_VALUE);
 196         List<String> blacklist = new ArrayList<>();
 197         blacklist.add(BLACKLIST_ITEM);
 198         Constraint constraint = new Constraint(freqLimitPerTarget, timeWindow, activeTimeRange, blacklist);
 199
 200         assertEquals(constraint.toString(), "Constraint [freq_limit_per_target=" + freqLimitPerTarget + ", time_window="
 201                 + timeWindow + ", active_time_range=" + activeTimeRange + ", blacklist=" + blacklist + "]");
 202     }
 203
 204     @Test
 205     public void testEquals() {
 206         Integer freqLimitPerTarget = 10;
 207         final Map<String, String> timeWindow = new HashMap<>();
 208         final Map<String, String> activeTimeRange = new HashMap<>();
 209         List<String> blacklist = new ArrayList<>();
 210         blacklist.add(BLACKLIST_ITEM);
 211
 212         Constraint constraint1 = new Constraint();
 213         Constraint constraint2 = new Constraint();
 214         assertTrue(constraint1.equals(constraint2));
 215
 216         constraint1.setFreq_limit_per_target(freqLimitPerTarget);
 217         assertFalse(constraint1.equals(constraint2));
 218         constraint2.setFreq_limit_per_target(freqLimitPerTarget);
 219         assertTrue(constraint1.equals(constraint2));
 220         assertEquals(constraint1.hashCode(), constraint2.hashCode());
 221
 222         constraint1.setTime_window(timeWindow);
 223         assertFalse(constraint1.equals(constraint2));
 224         constraint2.setTime_window(timeWindow);
 225         assertTrue(constraint1.equals(constraint2));
 226         assertEquals(constraint1.hashCode(), constraint2.hashCode());
 227
 228         constraint1.setActive_time_range(activeTimeRange);
 229         assertFalse(constraint1.equals(constraint2));
 230         constraint2.setActive_time_range(activeTimeRange);
 231         assertTrue(constraint1.equals(constraint2));
 232         assertEquals(constraint1.hashCode(), constraint2.hashCode());
 233
 234         constraint1.setBlacklist(blacklist);
 235         assertFalse(constraint1.equals(constraint2));
 236         constraint2.setBlacklist(blacklist);
 237         assertTrue(constraint1.equals(constraint2));
 238         assertEquals(constraint1.hashCode(), constraint2.hashCode());
 239     }
 240
 241     @Test
 242     public void testEqualsSameObject() {
 243         Constraint constraint = new Constraint();
 244         assertTrue(constraint.equals(constraint));
 245     }
 246
 247     @Test
 248     public void testEqualsNull() {
 249         Constraint constraint = new Constraint();
 250         assertFalse(constraint.equals(null));
 251     }
 252
 253     @Test
 254     public void testEqualsInstanceOfDiffClass() {
 255         Constraint constraint = new Constraint();
 256         assertFalse(constraint.equals(""));
 257     }
 258
 259 }