* ONAP
* ================================================================================
* Copyright (C) 2018, 2020-2021 AT&T Intellectual Property. All rights reserved.
+ * Modifications Copyright (C) 2024 Nordix Foundation.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
package org.onap.policy.drools.pooling.state;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNotSame;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNotSame;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.when;
import java.util.Arrays;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import org.onap.policy.drools.pooling.message.BucketAssignments;
import org.onap.policy.drools.pooling.message.Identification;
import org.onap.policy.drools.pooling.message.Leader;
import org.onap.policy.drools.pooling.message.Query;
import org.onap.policy.drools.pooling.state.ProcessingState.HostBucket;
-public class ProcessingStateTest extends SupportBasicStateTester {
+class ProcessingStateTest extends SupportBasicStateTester {
private ProcessingState state;
private HostBucket hostBucket;
/**
* Setup.
*/
- @Before
+ @BeforeEach
public void setUp() throws Exception {
super.setUp();
}
@Test
- public void testProcessQuery() {
+ void testProcessQuery() {
State next = mock(State.class);
when(mgr.goQuery()).thenReturn(next);
}
@Test
- public void testProcessingState() {
+ void testProcessingState() {
/*
* Null assignments should be OK.
*/
assertEquals(ASGN3, state.getAssignments());
}
- @Test(expected = IllegalArgumentException.class)
- public void testProcessingState_NullLeader() {
+ @Test
+ void testProcessingState_NullLeader() {
when(mgr.getAssignments()).thenReturn(EMPTY_ASGN);
- state = new ProcessingState(mgr, null);
+ assertThrows(NullPointerException.class, () -> state = new ProcessingState(mgr, null));
}
- @Test(expected = IllegalArgumentException.class)
- public void testProcessingState_ZeroLengthHostArray() {
+ @Test
+ void testProcessingState_ZeroLengthHostArray() {
when(mgr.getAssignments()).thenReturn(new BucketAssignments(new String[] {}));
- state = new ProcessingState(mgr, LEADER);
+ assertThrows(IllegalArgumentException.class, () -> state = new ProcessingState(mgr, LEADER));
}
@Test
- public void testGetAssignments() {
+ void testGetAssignments() {
// assignments from constructor
assertEquals(ASGN3, state.getAssignments());
}
@Test
- public void testSetAssignments() {
+ void testSetAssignments() {
state.setAssignments(null);
verify(mgr, never()).startDistributing(any());
}
@Test
- public void testGetLeader() {
+ void testGetLeader() {
// check value from constructor
assertEquals(MY_HOST, state.getLeader());
}
@Test
- public void testSetLeader() {
+ void testSetLeader() {
state.setLeader(MY_HOST);
assertEquals(MY_HOST, state.getLeader());
}
- @Test(expected = NullPointerException.class)
- public void testSetLeader_Null() {
- state.setLeader(null);
+ @Test
+ void testSetLeader_Null() {
+ assertThrows(NullPointerException.class, () -> state.setLeader(null));
}
@Test
- public void testIsLeader() {
+ void testIsLeader() {
state.setLeader(MY_HOST);
assertTrue(state.isLeader());
}
@Test
- public void testBecomeLeader() {
+ void testBecomeLeader() {
State next = mock(State.class);
when(mgr.goActive()).thenReturn(next);
verify(mgr).goActive();
}
- @Test(expected = IllegalArgumentException.class)
- public void testBecomeLeader_NotFirstAlive() {
+ @Test
+ void testBecomeLeader_NotFirstAlive() {
// alive list contains something before my host name
- state.becomeLeader(sortHosts(PREV_HOST, MY_HOST));
+ var sortedHosts = sortHosts(PREV_HOST, MY_HOST);
+ assertThrows(IllegalArgumentException.class, () -> state.becomeLeader(sortedHosts));
}
@Test
- public void testMakeLeader() throws Exception {
+ void testMakeLeader() throws Exception {
state.becomeLeader(sortHosts(MY_HOST, HOST2));
Leader msg = captureAdminMessage(Leader.class);
}
@Test
- public void testMakeAssignments() throws Exception {
+ void testMakeAssignments() throws Exception {
state.becomeLeader(sortHosts(MY_HOST, HOST2));
captureAssignments().checkValidity();
}
@Test
- public void testMakeBucketArray_NullAssignments() {
+ void testMakeBucketArray_NullAssignments() {
when(mgr.getAssignments()).thenReturn(null);
state = new ProcessingState(mgr, MY_HOST);
state.becomeLeader(sortHosts(MY_HOST));
assertEquals(BucketAssignments.MAX_BUCKETS, arr.length);
- assertTrue(Arrays.asList(arr).stream().allMatch(host -> MY_HOST.equals(host)));
+ assertTrue(Arrays.stream(arr).allMatch(MY_HOST::equals));
}
@Test
- public void testMakeBucketArray_ZeroAssignments() {
+ void testMakeBucketArray_ZeroAssignments() {
// bucket assignment with a zero-length array
state.setAssignments(new BucketAssignments(new String[0]));
assertEquals(BucketAssignments.MAX_BUCKETS, arr.length);
- assertTrue(Arrays.asList(arr).stream().allMatch(host -> MY_HOST.equals(host)));
+ assertTrue(Arrays.stream(arr).allMatch(MY_HOST::equals));
}
@Test
- public void testMakeBucketArray() {
+ void testMakeBucketArray() {
/*
* All hosts are still alive, so it should have the exact same assignments as it
* had to start.
}
@Test
- public void testRemoveExcessHosts() {
+ void testRemoveExcessHosts() {
/*
* All hosts are still alive, plus some others.
*/
}
@Test
- public void testAddIndicesToHostBuckets() {
+ void testAddIndicesToHostBuckets() {
// some are null, some hosts are no longer alive
String[] asgn = {null, MY_HOST, HOST3, null, HOST4, HOST1, HOST2};
}
@Test
- public void testAssignNullBuckets() {
+ void testAssignNullBuckets() {
/*
* Ensure buckets are assigned to the host with the fewest buckets.
*/
}
@Test
- public void testRebalanceBuckets() {
+ void testRebalanceBuckets() {
/*
* Some are very lopsided.
*/
}
@Test
- public void testHostBucketRemove_testHostBucketAdd_testHostBucketSize() {
+ void testHostBucketRemove_testHostBucketAdd_testHostBucketSize() {
assertEquals(0, hostBucket.size());
hostBucket.add(20);
}
@Test
- public void testHostBucketCompareTo() {
+ void testHostBucketCompareTo() {
HostBucket hb1 = new HostBucket(PREV_HOST);
HostBucket hb2 = new HostBucket(MY_HOST);
assertTrue(hb2.compareTo(hb1) > 0);
}
- @Test(expected = UnsupportedOperationException.class)
- public void testHostBucketHashCode() {
- hostBucket.hashCode();
+ @Test
+ void testHostBucketHashCode() {
+ assertThrows(UnsupportedOperationException.class, () -> hostBucket.hashCode());
}
- @Test(expected = UnsupportedOperationException.class)
- public void testHostBucketEquals() {
- hostBucket.equals(hostBucket);
+ @Test
+ void testHostBucketEquals() {
+ assertThrows(UnsupportedOperationException.class, () -> hostBucket.equals(hostBucket));
}
}
Code Review / policy / drools-pdp.git / blobdiff