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