Cleanup and simplify tests

1 files changed, 141 insertions, 132 deletions

diff --git a/clustercontroller-core/src/test/java/com/yahoo/vespa/clustercontroller/core/NodeStateChangeCheckerTest.java b/clustercontroller-core/src/test/java/com/yahoo/vespa/clustercontroller/core/NodeStateChangeCheckerTest.java
index 6af852aa3ed..fa38462621a 100644
--- a/clustercontroller-core/src/test/java/com/yahoo/vespa/clustercontroller/core/NodeStateChangeCheckerTest.java
+++ b/clustercontroller-core/src/test/java/com/yahoo/vespa/clustercontroller/core/NodeStateChangeCheckerTest.java
@@ -8,33 +8,42 @@ import com.yahoo.vdslib.distribution.GroupVisitor;
 import com.yahoo.vdslib.state.ClusterState;
 import com.yahoo.vdslib.state.Node;
 import com.yahoo.vdslib.state.NodeState;
-import com.yahoo.vdslib.state.NodeType;
 import com.yahoo.vdslib.state.State;
 import com.yahoo.vespa.clustercontroller.core.hostinfo.HostInfo;
-import com.yahoo.vespa.clustercontroller.utils.staterestapi.requests.SetUnitStateRequest;
 import com.yahoo.vespa.config.content.StorDistributionConfig;
 import org.junit.jupiter.api.Test;
-
 import java.text.ParseException;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 
-import static org.junit.jupiter.api.Assertions.*;
+import static com.yahoo.vdslib.state.NodeType.DISTRIBUTOR;
+import static com.yahoo.vdslib.state.NodeType.STORAGE;
+import static com.yahoo.vdslib.state.State.DOWN;
+import static com.yahoo.vdslib.state.State.INITIALIZING;
+import static com.yahoo.vdslib.state.State.UP;
+import static com.yahoo.vespa.clustercontroller.utils.staterestapi.requests.SetUnitStateRequest.Condition.FORCE;
+import static com.yahoo.vespa.clustercontroller.utils.staterestapi.requests.SetUnitStateRequest.Condition.SAFE;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
+import static com.yahoo.vespa.clustercontroller.core.NodeStateChangeChecker.Result;
+
 public class NodeStateChangeCheckerTest {
 
     private static final int requiredRedundancy = 4;
     private static final int currentClusterStateVersion = 2;
 
-    private static final Node nodeDistributor = new Node(NodeType.DISTRIBUTOR, 1);
-    private static final Node nodeStorage = new Node(NodeType.STORAGE, 1);
+    private static final Node nodeDistributor = new Node(DISTRIBUTOR, 1);
+    private static final Node nodeStorage = new Node(STORAGE, 1);
 
-    private static final NodeState UP_NODE_STATE = new NodeState(NodeType.STORAGE, State.UP);
+    private static final NodeState UP_NODE_STATE = new NodeState(STORAGE, UP);
     private static final NodeState MAINTENANCE_NODE_STATE = createNodeState(State.MAINTENANCE, "Orchestrator");
-    private static final NodeState DOWN_NODE_STATE = createNodeState(State.DOWN, "RetireEarlyExpirer");
+    private static final NodeState DOWN_NODE_STATE = createNodeState(DOWN, "RetireEarlyExpirer");
 
     private static final HierarchicalGroupVisiting noopVisiting = new HierarchicalGroupVisiting() {
         @Override public boolean isHierarchical() { return false; }
@@ -42,7 +51,7 @@ public class NodeStateChangeCheckerTest {
     };
 
     private static NodeState createNodeState(State state, String description) {
-        return new NodeState(NodeType.STORAGE, state).setDescription(description);
+        return new NodeState(STORAGE, state).setDescription(description);
     }
 
     private static ClusterState clusterState(String state) {
@@ -61,7 +70,8 @@ public class NodeStateChangeCheckerTest {
         return new NodeStateChangeChecker(requiredRedundancy, noopVisiting, cluster.clusterInfo(), false);
     }
 
-    private ContentCluster createCluster(Collection<ConfiguredNode> nodes) {
+    private ContentCluster createCluster(int nodeCount) {
+        Collection<ConfiguredNode> nodes = createNodes(nodeCount);
         Distribution distribution = mock(Distribution.class);
         Group group = new Group(2, "two");
         when(distribution.getRootGroup()).thenReturn(group);
@@ -97,18 +107,18 @@ public class NodeStateChangeCheckerTest {
         final ClusterInfo clusterInfo = cluster.clusterInfo();
         final int configuredNodeCount = cluster.clusterInfo().getConfiguredNodes().size();
         for (int i = 0; i < configuredNodeCount; i++) {
-            clusterInfo.getDistributorNodeInfo(i).setReportedState(new NodeState(NodeType.DISTRIBUTOR, State.UP), 0);
+            clusterInfo.getDistributorNodeInfo(i).setReportedState(new NodeState(DISTRIBUTOR, UP), 0);
             clusterInfo.getDistributorNodeInfo(i).setHostInfo(HostInfo.createHostInfo(createDistributorHostInfo(4, 5, 6)));
-            clusterInfo.getStorageNodeInfo(i).setReportedState(new NodeState(NodeType.STORAGE, State.UP), 0);
+            clusterInfo.getStorageNodeInfo(i).setReportedState(new NodeState(STORAGE, UP), 0);
         }
     }
 
     @Test
     void testCanUpgradeForce() {
-        NodeStateChangeChecker nodeStateChangeChecker = createChangeChecker(createCluster(createNodes(1)));
-        NodeState newState = new NodeState(NodeType.STORAGE, State.INITIALIZING);
-        NodeStateChangeChecker.Result result = nodeStateChangeChecker.evaluateTransition(
-                nodeDistributor, defaultAllUpClusterState(), SetUnitStateRequest.Condition.FORCE,
+        var nodeStateChangeChecker = createChangeChecker(createCluster(1));
+        NodeState newState = new NodeState(STORAGE, INITIALIZING);
+        Result result = nodeStateChangeChecker.evaluateTransition(
+                nodeDistributor, defaultAllUpClusterState(), FORCE,
                 UP_NODE_STATE, newState);
         assertTrue(result.settingWantedStateIsAllowed());
         assertFalse(result.wantedStateAlreadySet());
@@ -116,11 +126,11 @@ public class NodeStateChangeCheckerTest {
 
     @Test
     void testDeniedInMoratorium() {
-        ContentCluster cluster = createCluster(createNodes(4));
-        NodeStateChangeChecker nodeStateChangeChecker = new NodeStateChangeChecker(
+        ContentCluster cluster = createCluster(4);
+        var nodeStateChangeChecker = new NodeStateChangeChecker(
                 requiredRedundancy, noopVisiting, cluster.clusterInfo(), true);
-        NodeStateChangeChecker.Result result = nodeStateChangeChecker.evaluateTransition(
-                new Node(NodeType.STORAGE, 10), defaultAllUpClusterState(), SetUnitStateRequest.Condition.SAFE,
+        Result result = nodeStateChangeChecker.evaluateTransition(
+                new Node(STORAGE, 10), defaultAllUpClusterState(), SAFE,
                 UP_NODE_STATE, MAINTENANCE_NODE_STATE);
         assertFalse(result.settingWantedStateIsAllowed());
         assertFalse(result.wantedStateAlreadySet());
@@ -129,11 +139,11 @@ public class NodeStateChangeCheckerTest {
 
     @Test
     void testUnknownStorageNode() {
-        ContentCluster cluster = createCluster(createNodes(4));
-        NodeStateChangeChecker nodeStateChangeChecker = new NodeStateChangeChecker(
+        ContentCluster cluster = createCluster(4);
+        var nodeStateChangeChecker = new NodeStateChangeChecker(
                 requiredRedundancy, noopVisiting, cluster.clusterInfo(), false);
-        NodeStateChangeChecker.Result result = nodeStateChangeChecker.evaluateTransition(
-                new Node(NodeType.STORAGE, 10), defaultAllUpClusterState(), SetUnitStateRequest.Condition.SAFE,
+        Result result = nodeStateChangeChecker.evaluateTransition(
+                new Node(STORAGE, 10), defaultAllUpClusterState(), SAFE,
                 UP_NODE_STATE, MAINTENANCE_NODE_STATE);
         assertFalse(result.settingWantedStateIsAllowed());
         assertFalse(result.wantedStateAlreadySet());
@@ -143,17 +153,17 @@ public class NodeStateChangeCheckerTest {
     @Test
     void testSafeMaintenanceDisallowedWhenOtherStorageNodeInFlatClusterIsSuspended() {
         // Nodes 0-3, storage node 0 being in maintenance with "Orchestrator" description.
-        ContentCluster cluster = createCluster(createNodes(4));
-        cluster.clusterInfo().getStorageNodeInfo(0).setWantedState(new NodeState(NodeType.STORAGE, State.MAINTENANCE).setDescription("Orchestrator"));
-        NodeStateChangeChecker nodeStateChangeChecker = new NodeStateChangeChecker(
+        ContentCluster cluster = createCluster(4);
+        cluster.clusterInfo().getStorageNodeInfo(0).setWantedState(new NodeState(STORAGE, State.MAINTENANCE).setDescription("Orchestrator"));
+        var nodeStateChangeChecker = new NodeStateChangeChecker(
                 requiredRedundancy, noopVisiting, cluster.clusterInfo(), false);
         ClusterState clusterStateWith0InMaintenance = clusterState(String.format(
                 "version:%d distributor:4 storage:4 .0.s:m",
                 currentClusterStateVersion));
 
-        NodeStateChangeChecker.Result result = nodeStateChangeChecker.evaluateTransition(
-                new Node(NodeType.STORAGE, 1), clusterStateWith0InMaintenance,
-                SetUnitStateRequest.Condition.SAFE, UP_NODE_STATE, MAINTENANCE_NODE_STATE);
+        Result result = nodeStateChangeChecker.evaluateTransition(
+                new Node(STORAGE, 1), clusterStateWith0InMaintenance,
+                SAFE, UP_NODE_STATE, MAINTENANCE_NODE_STATE);
         assertFalse(result.settingWantedStateIsAllowed());
         assertFalse(result.wantedStateAlreadySet());
         assertEquals("At most one node can have a wanted state when #groups = 1: Other storage node 0 has wanted state Maintenance",
@@ -163,18 +173,18 @@ public class NodeStateChangeCheckerTest {
     @Test
     void testSafeMaintenanceDisallowedWhenOtherDistributorInFlatClusterIsSuspended() {
         // Nodes 0-3, storage node 0 being in maintenance with "Orchestrator" description.
-        ContentCluster cluster = createCluster(createNodes(4));
+        ContentCluster cluster = createCluster(4);
         cluster.clusterInfo().getDistributorNodeInfo(0)
-                .setWantedState(new NodeState(NodeType.DISTRIBUTOR, State.DOWN).setDescription("Orchestrator"));
-        NodeStateChangeChecker nodeStateChangeChecker = new NodeStateChangeChecker(
+                .setWantedState(new NodeState(DISTRIBUTOR, DOWN).setDescription("Orchestrator"));
+        var nodeStateChangeChecker = new NodeStateChangeChecker(
                 requiredRedundancy, noopVisiting, cluster.clusterInfo(), false);
         ClusterState clusterStateWith0InMaintenance = clusterState(String.format(
                 "version:%d distributor:4 .0.s:d storage:4",
                 currentClusterStateVersion));
 
-        NodeStateChangeChecker.Result result = nodeStateChangeChecker.evaluateTransition(
-                new Node(NodeType.STORAGE, 1), clusterStateWith0InMaintenance,
-                SetUnitStateRequest.Condition.SAFE, UP_NODE_STATE, MAINTENANCE_NODE_STATE);
+        Result result = nodeStateChangeChecker.evaluateTransition(
+                new Node(STORAGE, 1), clusterStateWith0InMaintenance,
+                SAFE, UP_NODE_STATE, MAINTENANCE_NODE_STATE);
         assertFalse(result.settingWantedStateIsAllowed());
         assertFalse(result.wantedStateAlreadySet());
         assertEquals("At most one node can have a wanted state when #groups = 1: Other distributor 0 has wanted state Down",
@@ -185,11 +195,11 @@ public class NodeStateChangeCheckerTest {
     void testSafeMaintenanceDisallowedWhenDistributorInGroupIsDown() {
         // Nodes 0-3, distributor 0 being in maintenance with "Orchestrator" description.
         // 2 groups: nodes 0-1 is group 0, 2-3 is group 1.
-        ContentCluster cluster = createCluster(createNodes(4));
+        ContentCluster cluster = createCluster(4);
         cluster.clusterInfo().getDistributorNodeInfo(0)
-                .setWantedState(new NodeState(NodeType.STORAGE, State.DOWN).setDescription("Orchestrator"));
+                .setWantedState(new NodeState(STORAGE, DOWN).setDescription("Orchestrator"));
         HierarchicalGroupVisiting visiting = makeHierarchicalGroupVisitingWith2Groups(4);
-        NodeStateChangeChecker nodeStateChangeChecker = new NodeStateChangeChecker(
+        var nodeStateChangeChecker = new NodeStateChangeChecker(
                 requiredRedundancy, visiting, cluster.clusterInfo(), false);
         ClusterState clusterStateWith0InMaintenance = clusterState(String.format(
                 "version:%d distributor:4 .0.s:d storage:4",
@@ -197,9 +207,9 @@ public class NodeStateChangeCheckerTest {
 
         {
             // Denied for node 2 in group 1, since distributor 0 in group 0 is down
-            NodeStateChangeChecker.Result result = nodeStateChangeChecker.evaluateTransition(
-                    new Node(NodeType.STORAGE, 2), clusterStateWith0InMaintenance,
-                    SetUnitStateRequest.Condition.SAFE, UP_NODE_STATE, MAINTENANCE_NODE_STATE);
+            Result result = nodeStateChangeChecker.evaluateTransition(
+                    new Node(STORAGE, 2), clusterStateWith0InMaintenance,
+                    SAFE, UP_NODE_STATE, MAINTENANCE_NODE_STATE);
             assertFalse(result.settingWantedStateIsAllowed());
             assertFalse(result.wantedStateAlreadySet());
             assertEquals("At most one group can have wanted state: Other distributor 0 in group 0 has wanted state Down", result.getReason());
@@ -208,9 +218,9 @@ public class NodeStateChangeCheckerTest {
         {
             // Even node 1 of group 0 is not permitted, as node 0 is not considered
             // suspended since only the distributor has been set down.
-            NodeStateChangeChecker.Result result = nodeStateChangeChecker.evaluateTransition(
-                    new Node(NodeType.STORAGE, 1), clusterStateWith0InMaintenance,
-                    SetUnitStateRequest.Condition.SAFE, UP_NODE_STATE, MAINTENANCE_NODE_STATE);
+            Result result = nodeStateChangeChecker.evaluateTransition(
+                    new Node(STORAGE, 1), clusterStateWith0InMaintenance,
+                    SAFE, UP_NODE_STATE, MAINTENANCE_NODE_STATE);
             assertFalse(result.settingWantedStateIsAllowed(), result.getReason());
             assertEquals("Another distributor wants state DOWN: 0", result.getReason());
         }
@@ -220,10 +230,10 @@ public class NodeStateChangeCheckerTest {
     void testSafeMaintenanceWhenOtherStorageNodeInGroupIsSuspended() {
         // Nodes 0-3, storage node 0 being in maintenance with "Orchestrator" description.
         // 2 groups: nodes 0-1 is group 0, 2-3 is group 1.
-        ContentCluster cluster = createCluster(createNodes(4));
-        cluster.clusterInfo().getStorageNodeInfo(0).setWantedState(new NodeState(NodeType.STORAGE, State.MAINTENANCE).setDescription("Orchestrator"));
+        ContentCluster cluster = createCluster(4);
+        cluster.clusterInfo().getStorageNodeInfo(0).setWantedState(new NodeState(STORAGE, State.MAINTENANCE).setDescription("Orchestrator"));
         HierarchicalGroupVisiting visiting = makeHierarchicalGroupVisitingWith2Groups(4);
-        NodeStateChangeChecker nodeStateChangeChecker = new NodeStateChangeChecker(
+        var nodeStateChangeChecker = new NodeStateChangeChecker(
                 requiredRedundancy, visiting, cluster.clusterInfo(), false);
         ClusterState clusterStateWith0InMaintenance = clusterState(String.format(
                 "version:%d distributor:4 storage:4 .0.s:m",
@@ -231,9 +241,9 @@ public class NodeStateChangeCheckerTest {
 
         {
             // Denied for node 2 in group 1, since node 0 in group 0 is in maintenance
-            NodeStateChangeChecker.Result result = nodeStateChangeChecker.evaluateTransition(
-                    new Node(NodeType.STORAGE, 2), clusterStateWith0InMaintenance,
-                    SetUnitStateRequest.Condition.SAFE, UP_NODE_STATE, MAINTENANCE_NODE_STATE);
+            Result result = nodeStateChangeChecker.evaluateTransition(
+                    new Node(STORAGE, 2), clusterStateWith0InMaintenance,
+                    SAFE, UP_NODE_STATE, MAINTENANCE_NODE_STATE);
             assertFalse(result.settingWantedStateIsAllowed());
             assertFalse(result.wantedStateAlreadySet());
             assertEquals("At most one group can have wanted state: Other storage node 0 in group 0 has wanted state Maintenance",
@@ -243,9 +253,9 @@ public class NodeStateChangeCheckerTest {
         {
             // Permitted for node 1 in group 0, since node 0 is already in maintenance with
             // description Orchestrator, and it is in the same group
-            NodeStateChangeChecker.Result result = nodeStateChangeChecker.evaluateTransition(
-                    new Node(NodeType.STORAGE, 1), clusterStateWith0InMaintenance,
-                    SetUnitStateRequest.Condition.SAFE, UP_NODE_STATE, MAINTENANCE_NODE_STATE);
+            Result result = nodeStateChangeChecker.evaluateTransition(
+                    new Node(STORAGE, 1), clusterStateWith0InMaintenance,
+                    SAFE, UP_NODE_STATE, MAINTENANCE_NODE_STATE);
             assertTrue(result.settingWantedStateIsAllowed(), result.getReason());
             assertFalse(result.wantedStateAlreadySet());
         }
@@ -293,9 +303,9 @@ public class NodeStateChangeCheckerTest {
 
     @Test
     void testSafeSetStateDistributors() {
-        NodeStateChangeChecker nodeStateChangeChecker = createChangeChecker(createCluster(createNodes(1)));
-        NodeStateChangeChecker.Result result = nodeStateChangeChecker.evaluateTransition(
-                nodeDistributor, defaultAllUpClusterState(), SetUnitStateRequest.Condition.SAFE,
+        NodeStateChangeChecker nodeStateChangeChecker = createChangeChecker(createCluster(1));
+        Result result = nodeStateChangeChecker.evaluateTransition(
+                nodeDistributor, defaultAllUpClusterState(), SAFE,
                 UP_NODE_STATE, MAINTENANCE_NODE_STATE);
         assertFalse(result.settingWantedStateIsAllowed());
         assertFalse(result.wantedStateAlreadySet());
@@ -305,18 +315,18 @@ public class NodeStateChangeCheckerTest {
     @Test
     void testCanUpgradeSafeMissingStorage() {
         // Create a content cluster with 4 nodes, and storage node with index 3 down.
-        ContentCluster cluster = createCluster(createNodes(4));
+        ContentCluster cluster = createCluster(4);
         setAllNodesUp(cluster, HostInfo.createHostInfo(createDistributorHostInfo(4, 5, 6)));
-        cluster.clusterInfo().getStorageNodeInfo(3).setReportedState(new NodeState(NodeType.STORAGE, State.DOWN), 0);
+        cluster.clusterInfo().getStorageNodeInfo(3).setReportedState(new NodeState(STORAGE, DOWN), 0);
         ClusterState clusterStateWith3Down = clusterState(String.format(
                 "version:%d distributor:4 storage:4 .3.s:d",
                 currentClusterStateVersion));
 
         // We should then be denied setting storage node 1 safely to maintenance.
-        NodeStateChangeChecker nodeStateChangeChecker = new NodeStateChangeChecker(
+        var nodeStateChangeChecker = new NodeStateChangeChecker(
                 requiredRedundancy, noopVisiting, cluster.clusterInfo(), false);
-        NodeStateChangeChecker.Result result = nodeStateChangeChecker.evaluateTransition(
-                nodeStorage, clusterStateWith3Down, SetUnitStateRequest.Condition.SAFE,
+        Result result = nodeStateChangeChecker.evaluateTransition(
+                nodeStorage, clusterStateWith3Down, SAFE,
                 UP_NODE_STATE, MAINTENANCE_NODE_STATE);
         assertFalse(result.settingWantedStateIsAllowed());
         assertFalse(result.wantedStateAlreadySet());
@@ -325,19 +335,19 @@ public class NodeStateChangeCheckerTest {
 
     @Test
     void testCanUpgradeStorageSafeYes() {
-        NodeStateChangeChecker.Result result = transitionToMaintenanceWithNoStorageNodesDown();
+        Result result = transitionToMaintenanceWithNoStorageNodesDown();
         assertTrue(result.settingWantedStateIsAllowed());
         assertFalse(result.wantedStateAlreadySet());
     }
 
     @Test
     void testSetUpFailsIfReportedIsDown() {
-        ContentCluster cluster = createCluster(createNodes(4));
+        ContentCluster cluster = createCluster(4);
         NodeStateChangeChecker nodeStateChangeChecker = createChangeChecker(cluster);
         // Not setting nodes up -> all are down
 
-        NodeStateChangeChecker.Result result = nodeStateChangeChecker.evaluateTransition(
-                nodeStorage, defaultAllUpClusterState(), SetUnitStateRequest.Condition.SAFE,
+        Result result = nodeStateChangeChecker.evaluateTransition(
+                nodeStorage, defaultAllUpClusterState(), SAFE,
                 MAINTENANCE_NODE_STATE, UP_NODE_STATE);
         assertFalse(result.settingWantedStateIsAllowed());
         assertFalse(result.wantedStateAlreadySet());
@@ -347,7 +357,7 @@ public class NodeStateChangeCheckerTest {
     // nodes taken down implicitly due to a group having too low node availability.
     @Test
     void testSetUpSucceedsIfReportedIsUpButGeneratedIsDown() {
-        ContentCluster cluster = createCluster(createNodes(4));
+        ContentCluster cluster = createCluster(4);
         NodeStateChangeChecker nodeStateChangeChecker = createChangeChecker(cluster);
 
         markAllNodesAsReportingStateUp(cluster);
@@ -356,8 +366,8 @@ public class NodeStateChangeCheckerTest {
                 "version:%d distributor:4 storage:4 .%d.s:d",
                 currentClusterStateVersion, nodeStorage.getIndex()));
 
-        NodeStateChangeChecker.Result result = nodeStateChangeChecker.evaluateTransition(
-                nodeStorage, stateWithNodeDown, SetUnitStateRequest.Condition.SAFE,
+        Result result = nodeStateChangeChecker.evaluateTransition(
+                nodeStorage, stateWithNodeDown, SAFE,
                 MAINTENANCE_NODE_STATE, UP_NODE_STATE);
         assertTrue(result.settingWantedStateIsAllowed());
         assertFalse(result.wantedStateAlreadySet());
@@ -365,25 +375,25 @@ public class NodeStateChangeCheckerTest {
 
     @Test
     void testCanSetUpEvenIfOldWantedStateIsDown() {
-        ContentCluster cluster = createCluster(createNodes(4));
+        ContentCluster cluster = createCluster(4);
         NodeStateChangeChecker nodeStateChangeChecker = createChangeChecker(cluster);
         setAllNodesUp(cluster, HostInfo.createHostInfo(createDistributorHostInfo(4, 3, 6)));
 
-        NodeStateChangeChecker.Result result = nodeStateChangeChecker.evaluateTransition(
-                nodeStorage, defaultAllUpClusterState(), SetUnitStateRequest.Condition.SAFE,
-                new NodeState(NodeType.STORAGE, State.DOWN), UP_NODE_STATE);
+        Result result = nodeStateChangeChecker.evaluateTransition(
+                nodeStorage, defaultAllUpClusterState(), SAFE,
+                new NodeState(STORAGE, DOWN), UP_NODE_STATE);
         assertTrue(result.settingWantedStateIsAllowed());
         assertFalse(result.wantedStateAlreadySet());
     }
 
     @Test
     void testCanUpgradeStorageSafeNo() {
-        ContentCluster cluster = createCluster(createNodes(4));
+        ContentCluster cluster = createCluster(4);
         NodeStateChangeChecker nodeStateChangeChecker = createChangeChecker(cluster);
         setAllNodesUp(cluster, HostInfo.createHostInfo(createDistributorHostInfo(4, 3, 6)));
 
-        NodeStateChangeChecker.Result result = nodeStateChangeChecker.evaluateTransition(
-                nodeStorage, defaultAllUpClusterState(), SetUnitStateRequest.Condition.SAFE,
+        Result result = nodeStateChangeChecker.evaluateTransition(
+                nodeStorage, defaultAllUpClusterState(), SAFE,
                 UP_NODE_STATE, MAINTENANCE_NODE_STATE);
         assertFalse(result.settingWantedStateIsAllowed());
         assertFalse(result.wantedStateAlreadySet());
@@ -393,12 +403,12 @@ public class NodeStateChangeCheckerTest {
 
     @Test
     void testCanUpgradeIfMissingMinReplicationFactor() {
-        ContentCluster cluster = createCluster(createNodes(4));
+        ContentCluster cluster = createCluster(4);
         NodeStateChangeChecker nodeStateChangeChecker = createChangeChecker(cluster);
         setAllNodesUp(cluster, HostInfo.createHostInfo(createDistributorHostInfo(4, 3, 6)));
 
-        NodeStateChangeChecker.Result result = nodeStateChangeChecker.evaluateTransition(
-                new Node(NodeType.STORAGE, 3), defaultAllUpClusterState(), SetUnitStateRequest.Condition.SAFE,
+        Result result = nodeStateChangeChecker.evaluateTransition(
+                new Node(STORAGE, 3), defaultAllUpClusterState(), SAFE,
                 UP_NODE_STATE, MAINTENANCE_NODE_STATE);
         assertTrue(result.settingWantedStateIsAllowed());
         assertFalse(result.wantedStateAlreadySet());
@@ -406,7 +416,7 @@ public class NodeStateChangeCheckerTest {
 
     @Test
     void testCanUpgradeIfStorageNodeMissingFromNodeInfo() {
-        ContentCluster cluster = createCluster(createNodes(4));
+        ContentCluster cluster = createCluster(4);
         NodeStateChangeChecker nodeStateChangeChecker = createChangeChecker(cluster);
         String hostInfo = "{\n" +
                 "    \"cluster-state-version\": 2,\n" +
@@ -421,8 +431,8 @@ public class NodeStateChangeCheckerTest {
                 "}\n";
         setAllNodesUp(cluster, HostInfo.createHostInfo(hostInfo));
 
-        NodeStateChangeChecker.Result result = nodeStateChangeChecker.evaluateTransition(
-                new Node(NodeType.STORAGE, 1), defaultAllUpClusterState(), SetUnitStateRequest.Condition.SAFE,
+        Result result = nodeStateChangeChecker.evaluateTransition(
+                new Node(STORAGE, 1), defaultAllUpClusterState(), SAFE,
                 UP_NODE_STATE, MAINTENANCE_NODE_STATE);
         assertTrue(result.settingWantedStateIsAllowed());
         assertFalse(result.wantedStateAlreadySet());
@@ -430,115 +440,115 @@ public class NodeStateChangeCheckerTest {
 
     @Test
     void testMissingDistributorState() {
-        ContentCluster cluster = createCluster(createNodes(4));
+        ContentCluster cluster = createCluster(4);
         NodeStateChangeChecker nodeStateChangeChecker = createChangeChecker(cluster);
-        cluster.clusterInfo().getStorageNodeInfo(1).setReportedState(new NodeState(NodeType.STORAGE, State.UP), 0);
+        cluster.clusterInfo().getStorageNodeInfo(1).setReportedState(new NodeState(STORAGE, UP), 0);
 
-        NodeStateChangeChecker.Result result = nodeStateChangeChecker.evaluateTransition(
-                nodeStorage, defaultAllUpClusterState(), SetUnitStateRequest.Condition.SAFE, UP_NODE_STATE, MAINTENANCE_NODE_STATE);
+        Result result = nodeStateChangeChecker.evaluateTransition(
+                nodeStorage, defaultAllUpClusterState(), SAFE, UP_NODE_STATE, MAINTENANCE_NODE_STATE);
         assertFalse(result.settingWantedStateIsAllowed());
         assertFalse(result.wantedStateAlreadySet());
         assertEquals("Distributor node 0 has not reported any cluster state version yet.", result.getReason());
     }
 
-    private NodeStateChangeChecker.Result transitionToSameState(State state, String oldDescription, String newDescription) {
-        ContentCluster cluster = createCluster(createNodes(4));
+    private Result transitionToSameState(State state, String oldDescription, String newDescription) {
+        ContentCluster cluster = createCluster(4);
         NodeStateChangeChecker nodeStateChangeChecker = createChangeChecker(cluster);
 
         NodeState currentNodeState = createNodeState(state, oldDescription);
         NodeState newNodeState = createNodeState(state, newDescription);
         return nodeStateChangeChecker.evaluateTransition(
-                nodeStorage, defaultAllUpClusterState(), SetUnitStateRequest.Condition.SAFE,
+                nodeStorage, defaultAllUpClusterState(), SAFE,
                 currentNodeState, newNodeState);
     }
 
-    private NodeStateChangeChecker.Result transitionToSameState(String oldDescription, String newDescription) {
+    private Result transitionToSameState(String oldDescription, String newDescription) {
         return transitionToSameState(State.MAINTENANCE, oldDescription, newDescription);
     }
 
     @Test
     void testSettingUpWhenUpCausesAlreadySet() {
-        NodeStateChangeChecker.Result result = transitionToSameState(State.UP, "foo", "bar");
+        Result result = transitionToSameState(UP, "foo", "bar");
         assertTrue(result.wantedStateAlreadySet());
     }
 
     @Test
     void testSettingAlreadySetState() {
-        NodeStateChangeChecker.Result result = transitionToSameState("foo", "foo");
+        Result result = transitionToSameState("foo", "foo");
         assertFalse(result.settingWantedStateIsAllowed());
         assertTrue(result.wantedStateAlreadySet());
     }
 
     @Test
     void testDifferentDescriptionImpliesDenied() {
-        NodeStateChangeChecker.Result result = transitionToSameState("foo", "bar");
+        Result result = transitionToSameState("foo", "bar");
         assertFalse(result.settingWantedStateIsAllowed());
         assertFalse(result.wantedStateAlreadySet());
     }
 
-    private NodeStateChangeChecker.Result transitionToMaintenanceWithOneStorageNodeDown(
+    private Result transitionToMaintenanceWithOneStorageNodeDown(
             int storageNodeIndex, boolean alternatingUpRetiredAndInitializing) {
-        ContentCluster cluster = createCluster(createNodes(4));
+        ContentCluster cluster = createCluster(4);
         NodeStateChangeChecker nodeStateChangeChecker = createChangeChecker(cluster);
 
         for (int x = 0; x < cluster.clusterInfo().getConfiguredNodes().size(); x++) {
-            State state = State.UP;
+            State state = UP;
             // Pick some retired and initializing nodes too
             if (alternatingUpRetiredAndInitializing) { // TODO: Move this into the calling test
                 if (x % 3 == 1) state = State.RETIRED;
-                else if (x % 3 == 2) state = State.INITIALIZING;
+                else if (x % 3 == 2) state = INITIALIZING;
             }
-            cluster.clusterInfo().getDistributorNodeInfo(x).setReportedState(new NodeState(NodeType.DISTRIBUTOR, state), 0);
+            cluster.clusterInfo().getDistributorNodeInfo(x).setReportedState(new NodeState(DISTRIBUTOR, state), 0);
             cluster.clusterInfo().getDistributorNodeInfo(x).setHostInfo(HostInfo.createHostInfo(createDistributorHostInfo(4, 5, 6)));
-            cluster.clusterInfo().getStorageNodeInfo(x).setReportedState(new NodeState(NodeType.STORAGE, state), 0);
+            cluster.clusterInfo().getStorageNodeInfo(x).setReportedState(new NodeState(STORAGE, state), 0);
         }
 
         ClusterState clusterState = defaultAllUpClusterState();
 
         if (storageNodeIndex >= 0) { // TODO: Move this into the calling test
-            NodeState downNodeState = new NodeState(NodeType.STORAGE, State.DOWN);
+            NodeState downNodeState = new NodeState(STORAGE, DOWN);
             cluster.clusterInfo().getStorageNodeInfo(storageNodeIndex).setReportedState(downNodeState, 4 /* time */);
-            clusterState.setNodeState(new Node(NodeType.STORAGE, storageNodeIndex), downNodeState);
+            clusterState.setNodeState(new Node(STORAGE, storageNodeIndex), downNodeState);
         }
 
         return nodeStateChangeChecker.evaluateTransition(
-                nodeStorage, clusterState, SetUnitStateRequest.Condition.SAFE, UP_NODE_STATE, MAINTENANCE_NODE_STATE);
+                nodeStorage, clusterState, SAFE, UP_NODE_STATE, MAINTENANCE_NODE_STATE);
     }
 
     private void setAllNodesUp(ContentCluster cluster, HostInfo distributorHostInfo) {
         for (int x = 0; x < cluster.clusterInfo().getConfiguredNodes().size(); x++) {
-            State state = State.UP;
-            cluster.clusterInfo().getDistributorNodeInfo(x).setReportedState(new NodeState(NodeType.DISTRIBUTOR, state), 0);
+            State state = UP;
+            cluster.clusterInfo().getDistributorNodeInfo(x).setReportedState(new NodeState(DISTRIBUTOR, state), 0);
             cluster.clusterInfo().getDistributorNodeInfo(x).setHostInfo(distributorHostInfo);
-            cluster.clusterInfo().getStorageNodeInfo(x).setReportedState(new NodeState(NodeType.STORAGE, state), 0);
+            cluster.clusterInfo().getStorageNodeInfo(x).setReportedState(new NodeState(STORAGE, state), 0);
         }
     }
 
-    private NodeStateChangeChecker.Result transitionToMaintenanceWithOneStorageNodeDown(int storageNodeIndex) {
+    private Result transitionToMaintenanceWithOneStorageNodeDown(int storageNodeIndex) {
         return transitionToMaintenanceWithOneStorageNodeDown(storageNodeIndex, false);
     }
 
-    private NodeStateChangeChecker.Result transitionToMaintenanceWithNoStorageNodesDown() {
+    private Result transitionToMaintenanceWithNoStorageNodesDown() {
         return transitionToMaintenanceWithOneStorageNodeDown(-1, false);
     }
 
     @Test
     void testCanUpgradeWhenAllUp() {
-        NodeStateChangeChecker.Result result = transitionToMaintenanceWithNoStorageNodesDown();
+        Result result = transitionToMaintenanceWithNoStorageNodesDown();
         assertTrue(result.settingWantedStateIsAllowed());
         assertFalse(result.wantedStateAlreadySet());
     }
 
     @Test
     void testCanUpgradeWhenAllUpOrRetired() {
-        NodeStateChangeChecker.Result result = transitionToMaintenanceWithNoStorageNodesDown();
+        Result result = transitionToMaintenanceWithNoStorageNodesDown();
         assertTrue(result.settingWantedStateIsAllowed());
         assertFalse(result.wantedStateAlreadySet());
     }
 
     @Test
     void testCanUpgradeWhenStorageIsDown() {
-        NodeStateChangeChecker.Result result = transitionToMaintenanceWithOneStorageNodeDown(nodeStorage.getIndex());
+        Result result = transitionToMaintenanceWithOneStorageNodeDown(nodeStorage.getIndex());
         assertTrue(result.settingWantedStateIsAllowed());
         assertFalse(result.wantedStateAlreadySet());
     }
@@ -549,7 +559,7 @@ public class NodeStateChangeCheckerTest {
         // If this fails, just set otherIndex to some other valid index.
         assertNotEquals(nodeStorage.getIndex(), otherIndex);
 
-        NodeStateChangeChecker.Result result = transitionToMaintenanceWithOneStorageNodeDown(otherIndex);
+        Result result = transitionToMaintenanceWithOneStorageNodeDown(otherIndex);
         assertFalse(result.settingWantedStateIsAllowed());
         assertFalse(result.wantedStateAlreadySet());
         assertTrue(result.getReason().contains("Another storage node has state DOWN: 2"));
@@ -557,7 +567,7 @@ public class NodeStateChangeCheckerTest {
 
     @Test
     void testNodeRatioRequirementConsidersGeneratedNodeStates() {
-        ContentCluster cluster = createCluster(createNodes(4));
+        ContentCluster cluster = createCluster(4);
         NodeStateChangeChecker nodeStateChangeChecker = createChangeChecker(cluster);
 
         markAllNodesAsReportingStateUp(cluster);
@@ -570,8 +580,8 @@ public class NodeStateChangeCheckerTest {
                 "version:%d distributor:4 storage:4 .3.s:d",
                 currentClusterStateVersion));
 
-        NodeStateChangeChecker.Result result = nodeStateChangeChecker.evaluateTransition(
-                nodeStorage, stateWithNodeDown, SetUnitStateRequest.Condition.SAFE,
+        Result result = nodeStateChangeChecker.evaluateTransition(
+                nodeStorage, stateWithNodeDown, SAFE,
                 UP_NODE_STATE, MAINTENANCE_NODE_STATE);
         assertFalse(result.settingWantedStateIsAllowed());
         assertFalse(result.wantedStateAlreadySet());
@@ -579,9 +589,9 @@ public class NodeStateChangeCheckerTest {
 
     @Test
     void testDownDisallowedByNonRetiredState() {
-        NodeStateChangeChecker.Result result = evaluateDownTransition(
+        Result result = evaluateDownTransition(
                 defaultAllUpClusterState(),
-                State.UP,
+                UP,
                 currentClusterStateVersion,
                 0);
         assertFalse(result.settingWantedStateIsAllowed());
@@ -591,9 +601,9 @@ public class NodeStateChangeCheckerTest {
 
     @Test
     void testDownDisallowedByBuckets() {
-        NodeStateChangeChecker.Result result = evaluateDownTransition(
+        Result result = evaluateDownTransition(
                 retiredClusterStateSuffix(),
-                State.UP,
+                UP,
                 currentClusterStateVersion,
                 1);
         assertFalse(result.settingWantedStateIsAllowed());
@@ -603,9 +613,9 @@ public class NodeStateChangeCheckerTest {
 
     @Test
     void testDownDisallowedByReportedState() {
-        NodeStateChangeChecker.Result result = evaluateDownTransition(
+        Result result = evaluateDownTransition(
                 retiredClusterStateSuffix(),
-                State.INITIALIZING,
+                INITIALIZING,
                 currentClusterStateVersion,
                 0);
         assertFalse(result.settingWantedStateIsAllowed());
@@ -615,9 +625,9 @@ public class NodeStateChangeCheckerTest {
 
     @Test
     void testDownDisallowedByVersionMismatch() {
-        NodeStateChangeChecker.Result result = evaluateDownTransition(
+        Result result = evaluateDownTransition(
                 retiredClusterStateSuffix(),
-                State.UP,
+                UP,
                 currentClusterStateVersion - 1,
                 0);
         assertFalse(result.settingWantedStateIsAllowed());
@@ -628,29 +638,28 @@ public class NodeStateChangeCheckerTest {
 
     @Test
     void testAllowedToSetDown() {
-        NodeStateChangeChecker.Result result = evaluateDownTransition(
+        Result result = evaluateDownTransition(
                 retiredClusterStateSuffix(),
-                State.UP,
+                UP,
                 currentClusterStateVersion,
                 0);
         assertTrue(result.settingWantedStateIsAllowed());
         assertFalse(result.wantedStateAlreadySet());
     }
 
-    private NodeStateChangeChecker.Result evaluateDownTransition(
-            ClusterState clusterState,
-            State reportedState,
-            int hostInfoClusterStateVersion,
-            int lastAlldisksBuckets) {
-        ContentCluster cluster = createCluster(createNodes(4));
+    private Result evaluateDownTransition(ClusterState clusterState,
+                                          State reportedState,
+                                          int hostInfoClusterStateVersion,
+                                          int lastAlldisksBuckets) {
+        ContentCluster cluster = createCluster(4);
         NodeStateChangeChecker nodeStateChangeChecker = createChangeChecker(cluster);
 
         StorageNodeInfo nodeInfo = cluster.clusterInfo().getStorageNodeInfo(nodeStorage.getIndex());
-        nodeInfo.setReportedState(new NodeState(NodeType.STORAGE, reportedState), 0);
+        nodeInfo.setReportedState(new NodeState(STORAGE, reportedState), 0);
         nodeInfo.setHostInfo(createHostInfoWithMetrics(hostInfoClusterStateVersion, lastAlldisksBuckets));
 
         return nodeStateChangeChecker.evaluateTransition(
-                nodeStorage, clusterState, SetUnitStateRequest.Condition.SAFE,
+                nodeStorage, clusterState, SAFE,
                 UP_NODE_STATE, DOWN_NODE_STATE);
     }