feature-pooling-dmaap/src/test/java/org/onap/policy/drools/pooling/message/BucketAssignmentsTest.java

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