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

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