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