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

   1 /*
   2  * ============LICENSE_START=======================================================
   3  * ONAP
   4  * ================================================================================
   5  * Copyright (C) 2018 AT&T Intellectual Property. All rights reserved.
   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.drools.pooling.message;
  22
  23 import static org.junit.Assert.assertEquals;
  24 import static org.junit.Assert.assertFalse;
  25 import static org.junit.Assert.assertNotNull;
  26 import static org.junit.Assert.assertNull;
  27 import static org.junit.Assert.assertTrue;
  28 import static org.junit.Assert.fail;
  29
  30 import java.util.Arrays;
  31 import java.util.SortedSet;
  32 import java.util.TreeSet;
  33 import org.junit.Test;
  34 import org.onap.policy.drools.pooling.PoolingFeatureException;
  35
  36 public class BucketAssignmentsTest {
  37
  38     @Test
  39     public void testBucketAssignments() {
  40         new BucketAssignments();
  41     }
  42
  43     @Test
  44     public void testBucketAssignmentsStringArray() {
  45         String[] arr = {"abc", "def"};
  46         BucketAssignments asgn = new BucketAssignments(arr);
  47
  48         assertNotNull(asgn.getHostArray());
  49         assertEquals(arr.toString(), asgn.getHostArray().toString());
  50     }
  51
  52     @Test
  53     public void testGetHostArray_testSetHostArray() {
  54
  55         String[] arr = {"abc", "def"};
  56         BucketAssignments asgn = new BucketAssignments(arr);
  57
  58         assertNotNull(asgn.getHostArray());
  59         assertEquals(arr.toString(), asgn.getHostArray().toString());
  60
  61         String[] arr2 = {"xyz"};
  62         asgn.setHostArray(arr2);
  63
  64         assertNotNull(asgn.getHostArray());
  65         assertEquals(arr2.toString(), asgn.getHostArray().toString());
  66     }
  67
  68     @Test
  69     public void testGetLeader() {
  70         // host array is null
  71         BucketAssignments asgn = new BucketAssignments();
  72         assertNull(asgn.getLeader());
  73
  74         // array is non-null, but empty
  75         asgn.setHostArray(new String[0]);
  76         assertNull(asgn.getLeader());
  77
  78         // all entries are null
  79         asgn.setHostArray(new String[5]);
  80         assertNull(asgn.getLeader());
  81
  82         // some entries are null
  83         asgn.setHostArray(new String[] {null, "abc", null});
  84         assertEquals("abc", asgn.getLeader());
  85
  86         // only one entry
  87         asgn.setHostArray(new String[] {"abc"});
  88         assertEquals("abc", asgn.getLeader());
  89
  90         // first is least
  91         asgn.setHostArray(new String[] {"Ahost", "Bhost", "Chost"});
  92         assertEquals("Ahost", asgn.getLeader());
  93
  94         // middle is least
  95         asgn.setHostArray(new String[] {"Xhost", "Bhost", "Chost"});
  96         assertEquals("Bhost", asgn.getLeader());
  97
  98         // last is least
  99         asgn.setHostArray(new String[] {"Xhost", "Yhost", "Chost"});
 100         assertEquals("Chost", asgn.getLeader());
 101
 102         // multiple entries
 103         asgn.setHostArray(new String[] {"Xhost", "Bhost", "Chost", "Bhost", "Xhost", "Chost"});
 104         assertEquals("Bhost", asgn.getLeader());
 105     }
 106
 107     @Test
 108     public void testHasAssignment() {
 109         // host array is null
 110         BucketAssignments asgn = new BucketAssignments();
 111         assertFalse(asgn.hasAssignment("abc"));
 112
 113         // array is non-null, but empty
 114         asgn.setHostArray(new String[0]);
 115         assertFalse(asgn.hasAssignment("abc"));
 116
 117         // all entries are null
 118         asgn.setHostArray(new String[5]);
 119         assertFalse(asgn.hasAssignment("abc"));
 120
 121         // some entries are null
 122         asgn.setHostArray(new String[] {null, "abc", null});
 123         assertTrue(asgn.hasAssignment("abc"));
 124
 125         // only one entry
 126         asgn.setHostArray(new String[] {"abc"});
 127         assertTrue(asgn.hasAssignment("abc"));
 128
 129         // appears as first entry
 130         asgn.setHostArray(new String[] {"abc", "Bhost", "Chost"});
 131         assertTrue(asgn.hasAssignment("abc"));
 132
 133         // appears in middle
 134         asgn.setHostArray(new String[] {"Xhost", "abc", "Chost"});
 135         assertTrue(asgn.hasAssignment("abc"));
 136
 137         // appears last
 138         asgn.setHostArray(new String[] {"Xhost", "Yhost", "abc"});
 139         assertTrue(asgn.hasAssignment("abc"));
 140
 141         // appears repeatedly
 142         asgn.setHostArray(new String[] {"Xhost", "Bhost", "Chost", "Bhost", "Xhost", "Chost"});
 143         assertTrue(asgn.hasAssignment("Bhost"));
 144     }
 145
 146     @Test
 147     public void testGetAllHosts() {
 148         // host array is null
 149         BucketAssignments asgn = new BucketAssignments();
 150         assertEquals("[]", getSortedHosts(asgn).toString());
 151
 152         // array is non-null, but empty
 153         asgn.setHostArray(new String[0]);
 154         assertEquals("[]", getSortedHosts(asgn).toString());
 155
 156         // all entries are null
 157         asgn.setHostArray(new String[5]);
 158         assertEquals("[]", getSortedHosts(asgn).toString());
 159
 160         // some entries are null
 161         asgn.setHostArray(new String[] {null, "abc", null});
 162         assertEquals("[abc]", getSortedHosts(asgn).toString());
 163
 164         // only one entry
 165         asgn.setHostArray(new String[] {"abc"});
 166         assertEquals("[abc]", getSortedHosts(asgn).toString());
 167
 168         // multiple, repeated entries
 169         asgn.setHostArray(new String[] {"def", "abc", "def", "ghi", "def", "def", "xyz"});
 170         assertEquals("[abc, def, ghi, xyz]", getSortedHosts(asgn).toString());
 171     }
 172
 173     /**
 174      * Gets the hosts, sorted, so that the order is predictable.
 175      *
 176      * @param asgn assignment whose hosts are to be retrieved
 177      * @return a new, sorted set of hosts
 178      */
 179     private SortedSet<String> getSortedHosts(BucketAssignments asgn) {
 180         return new TreeSet<>(asgn.getAllHosts());
 181     }
 182
 183     @Test
 184     public void testGetAssignedHost() {
 185         // host array is null
 186         BucketAssignments asgn = new BucketAssignments();
 187         assertNull(asgn.getAssignedHost(3));
 188
 189         // array is non-null, but empty
 190         asgn.setHostArray(new String[0]);
 191         assertNull(asgn.getAssignedHost(3));
 192
 193         // all entries are null
 194         asgn.setHostArray(new String[5]);
 195         assertNull(asgn.getAssignedHost(3));
 196
 197         // multiple, repeated entries
 198         String[] arr = {"def", "abc", "def", "ghi", "def", "def", "xyz"};
 199         asgn.setHostArray(arr);
 200
 201         /*
 202          * get assignments for consecutive integers, including negative numbers and
 203          * numbers extending past the length of the array.
 204          *
 205          */
 206         TreeSet<String> seen = new TreeSet<>();
 207         for (int x = -1; x < arr.length + 2; ++x) {
 208             seen.add(asgn.getAssignedHost(x));
 209         }
 210
 211         TreeSet<String> expected = new TreeSet<>(Arrays.asList(arr));
 212         assertEquals(expected, seen);
 213
 214         // try a much bigger number
 215         assertNotNull(asgn.getAssignedHost(arr.length * 1000));
 216     }
 217
 218     @Test
 219     public void testSize() {
 220         // host array is null
 221         BucketAssignments asgn = new BucketAssignments();
 222         assertEquals(0, asgn.size());
 223
 224         // array is non-null, but empty
 225         asgn.setHostArray(new String[0]);
 226         assertEquals(0, asgn.size());
 227
 228         // all entries are null
 229         asgn.setHostArray(new String[5]);
 230         assertEquals(5, asgn.size());
 231
 232         // multiple, repeated entries
 233         String[] arr = {"def", "abc", "def", "ghi", "def", "def", "xyz"};
 234         asgn.setHostArray(arr);
 235         assertEquals(arr.length, asgn.size());
 236     }
 237
 238     @Test
 239     public void testCheckValidity() throws Exception {
 240         // host array is null
 241         BucketAssignments asgn = new BucketAssignments();
 242         expectException(asgn);
 243
 244         // array is non-null, but empty
 245         asgn.setHostArray(new String[0]);
 246         expectException(asgn);
 247
 248         // array is too big
 249         asgn.setHostArray(new String[BucketAssignments.MAX_BUCKETS + 1]);
 250         expectException(asgn);
 251
 252         // all entries are null
 253         asgn.setHostArray(new String[5]);
 254         expectException(asgn);
 255
 256         // null at the beginning
 257         asgn.setHostArray(new String[] {null, "Bhost", "Chost"});
 258         expectException(asgn);
 259
 260         // null in the middle
 261         asgn.setHostArray(new String[] {"Ahost", null, "Chost"});
 262         expectException(asgn);
 263
 264         // null at the end
 265         asgn.setHostArray(new String[] {"Ahost", "Bhost", null});
 266         expectException(asgn);
 267
 268         // only one entry
 269         asgn.setHostArray(new String[] {"abc"});
 270         asgn.checkValidity();
 271
 272         // multiple entries
 273         asgn.setHostArray(new String[] {"Ahost", "Bhost", "Chost"});
 274         asgn.checkValidity();
 275     }
 276
 277     @Test
 278     public void testHashCode() {
 279         // with null assignments
 280         BucketAssignments asgn = new BucketAssignments();
 281         asgn.hashCode();
 282
 283         // with empty array
 284         asgn = new BucketAssignments(new String[0]);
 285         asgn.hashCode();
 286
 287         // with null items
 288         asgn = new BucketAssignments(new String[] {"abc", null, "def"});
 289         asgn.hashCode();
 290
 291         // same assignments
 292         asgn = new BucketAssignments(new String[] {"abc", null, "def"});
 293         int code = asgn.hashCode();
 294
 295         asgn = new BucketAssignments(new String[] {"abc", null, "def"});
 296         assertEquals(code, asgn.hashCode());
 297
 298         // slightly different values (i.e., changed "def" to "eef")
 299         asgn = new BucketAssignments(new String[] {"abc", null, "eef"});
 300         assertTrue(code != asgn.hashCode());
 301     }
 302
 303     @Test
 304     public void testEquals() {
 305         // null object
 306         BucketAssignments asgn = new BucketAssignments();
 307         assertFalse(asgn.equals(null));
 308
 309         // same object
 310         asgn = new BucketAssignments();
 311         assertTrue(asgn.equals(asgn));
 312
 313         // different class of object
 314         asgn = new BucketAssignments();
 315         assertFalse(asgn.equals("not an assignment object"));
 316
 317         // with null assignments
 318         asgn = new BucketAssignments();
 319         assertTrue(asgn.equals(new BucketAssignments()));
 320
 321         assertFalse(asgn.equals(new BucketAssignments(new String[] {"abc"})));
 322
 323         // with empty array
 324         asgn = new BucketAssignments(new String[0]);
 325         assertTrue(asgn.equals(asgn));
 326
 327         assertFalse(asgn.equals(new BucketAssignments()));
 328         assertFalse(asgn.equals(new BucketAssignments(new String[] {"abc"})));
 329
 330         // with null items
 331         String[] arr = {"abc", null, "def"};
 332         asgn = new BucketAssignments(arr);
 333         assertTrue(asgn.equals(asgn));
 334         assertTrue(asgn.equals(new BucketAssignments(arr)));
 335         assertTrue(asgn.equals(new BucketAssignments(new String[] {"abc", null, "def"})));
 336
 337         assertFalse(asgn.equals(new BucketAssignments()));
 338         assertFalse(asgn.equals(new BucketAssignments(new String[] {"abc", null, "XYZ"})));
 339
 340         assertFalse(asgn.equals(new BucketAssignments()));
 341     }
 342
 343     /**
 344      * Expects an exception when checkValidity() is called.
 345      *
 346      * @param asgn assignments to be checked
 347      */
 348     private void expectException(BucketAssignments asgn) {
 349         try {
 350             asgn.checkValidity();
 351             fail("missing exception");
 352
 353         } catch (PoolingFeatureException expected) {
 354             // success
 355         }
 356     }
 357
 358 }