gerrit.onap Code Review - policy/drools-applications.git/blob

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