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