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