Eliminate use of deprecated mockito methods

[controller.git] / opendaylight / md-sal / sal-akka-raft / src / test / java / org / opendaylight / controller / cluster / raft / RaftActorContextImplTest.java

diff --git a/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/RaftActorContextImplTest.java b/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/RaftActorContextImplTest.java
index a2f9e78769420e5675183fa54c1fc6b123b4c21d..54661b67fc7a12e24fbf6bf2144bcb39f6d066c8 100644 (file)
--- a/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/RaftActorContextImplTest.java
+++ b/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/RaftActorContextImplTest.java
@@ -8,21 +8,28 @@
 package org.opendaylight.controller.cluster.raft;
 
 import static org.junit.Assert.assertEquals;
-import static org.mockito.Matchers.anyString;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.reset;
 import static org.mockito.Mockito.verify;
+
 import akka.actor.Props;
 import akka.testkit.TestActorRef;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Maps;
+import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Map;
 import org.junit.After;
 import org.junit.Test;
+import org.opendaylight.controller.cluster.DataPersistenceProvider;
 import org.opendaylight.controller.cluster.NonPersistentDataProvider;
+import org.opendaylight.controller.cluster.raft.persisted.ServerConfigurationPayload;
+import org.opendaylight.controller.cluster.raft.persisted.ServerInfo;
 import org.opendaylight.controller.cluster.raft.utils.DoNothingActor;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -38,7 +45,7 @@ public class RaftActorContextImplTest extends AbstractActorTest {
     private final TestActorRef<DoNothingActor> actor = actorFactory.createTestActor(
             Props.create(DoNothingActor.class), actorFactory.generateActorId("actor"));
 
-    private final Logger log = LoggerFactory.getLogger(RaftActorContextImplTest.class);
+    private static final Logger LOG = LoggerFactory.getLogger(RaftActorContextImplTest.class);
 
     @After
     public void tearDown() {
@@ -52,21 +59,23 @@ public class RaftActorContextImplTest extends AbstractActorTest {
         peerMap.put("peer2", null);
         DefaultConfigParamsImpl configParams = new DefaultConfigParamsImpl();
         RaftActorContextImpl context = new RaftActorContextImpl(actor, actor.underlyingActor().getContext(),
-                "test", new ElectionTermImpl(new NonPersistentDataProvider(), "test", log), -1, -1,
-                peerMap, configParams, new NonPersistentDataProvider(), log);
+                "test", new ElectionTermImpl(createProvider(), "test", LOG), -1, -1,
+                peerMap, configParams, createProvider(), applyState -> { }, LOG);
 
         assertEquals("getPeerAddress", "peerAddress1", context.getPeerAddress("peer1"));
         assertEquals("getPeerAddress", null, context.getPeerAddress("peer2"));
 
         PeerAddressResolver mockResolver = mock(PeerAddressResolver.class);
         doReturn("peerAddress2").when(mockResolver).resolve("peer2");
+        doReturn("peerAddress3").when(mockResolver).resolve("peer3");
         configParams.setPeerAddressResolver(mockResolver);
 
         assertEquals("getPeerAddress", "peerAddress2", context.getPeerAddress("peer2"));
+        assertEquals("getPeerAddress", "peerAddress3", context.getPeerAddress("peer3"));
 
         reset(mockResolver);
-        assertEquals("getPeerAddress", "peerAddress2", context.getPeerAddress("peer2"));
         assertEquals("getPeerAddress", "peerAddress1", context.getPeerAddress("peer1"));
+        assertEquals("getPeerAddress", "peerAddress2", context.getPeerAddress("peer2"));
         verify(mockResolver, never()).resolve(anyString());
     }
 
@@ -74,9 +83,9 @@ public class RaftActorContextImplTest extends AbstractActorTest {
     public void testSetPeerAddress() {
         DefaultConfigParamsImpl configParams = new DefaultConfigParamsImpl();
         RaftActorContextImpl context = new RaftActorContextImpl(actor, actor.underlyingActor().getContext(),
-                "test", new ElectionTermImpl(new NonPersistentDataProvider(), "test", log), -1, -1,
+                "test", new ElectionTermImpl(createProvider(), "test", LOG), -1, -1,
                 Maps.newHashMap(ImmutableMap.<String, String>of("peer1", "peerAddress1")), configParams,
-                new NonPersistentDataProvider(), log);
+                createProvider(), applyState -> { }, LOG);
 
         context.setPeerAddress("peer1", "peerAddress1_1");
         assertEquals("getPeerAddress", "peerAddress1_1", context.getPeerAddress("peer1"));
@@ -84,4 +93,46 @@ public class RaftActorContextImplTest extends AbstractActorTest {
         context.setPeerAddress("peer2", "peerAddress2");
         assertEquals("getPeerAddress", null, context.getPeerAddress("peer2"));
     }
+
+    @Test
+    public void testUpdatePeerIds() {
+        RaftActorContextImpl context = new RaftActorContextImpl(actor, actor.underlyingActor().getContext(),
+                "self", new ElectionTermImpl(createProvider(), "test", LOG), -1, -1,
+                Maps.newHashMap(ImmutableMap.<String, String>of("peer1", "peerAddress1")),
+                new DefaultConfigParamsImpl(), createProvider(), applyState -> { }, LOG);
+
+        context.updatePeerIds(new ServerConfigurationPayload(Arrays.asList(new ServerInfo("self", false),
+                new ServerInfo("peer2", true), new ServerInfo("peer3", false))));
+        verifyPeerInfo(context, "peer1", null);
+        verifyPeerInfo(context, "peer2", true);
+        verifyPeerInfo(context, "peer3", false);
+        assertEquals("isVotingMember", false, context.isVotingMember());
+
+        context.updatePeerIds(new ServerConfigurationPayload(Arrays.asList(new ServerInfo("self", true),
+                new ServerInfo("peer2", true), new ServerInfo("peer3", true))));
+        verifyPeerInfo(context, "peer2", true);
+        verifyPeerInfo(context, "peer3", true);
+        assertEquals("isVotingMember", true, context.isVotingMember());
+
+        context.updatePeerIds(new ServerConfigurationPayload(Arrays.asList(new ServerInfo("peer2", true),
+                new ServerInfo("peer3", true))));
+        verifyPeerInfo(context, "peer2", true);
+        verifyPeerInfo(context, "peer3", true);
+        assertEquals("isVotingMember", false, context.isVotingMember());
+    }
+
+    private static DataPersistenceProvider createProvider() {
+        return new NonPersistentDataProvider(Runnable::run);
+    }
+
+    private static void verifyPeerInfo(final RaftActorContextImpl context, final String peerId, final Boolean voting) {
+        PeerInfo peerInfo = context.getPeerInfo(peerId);
+        if (voting != null) {
+            assertNotNull("Expected peer " + peerId, peerInfo);
+            assertEquals("getVotingState for " + peerId, voting.booleanValue()
+                    ? VotingState.VOTING : VotingState.NON_VOTING, peerInfo.getVotingState());
+        } else {
+            assertNull("Unexpected peer " + peerId, peerInfo);
+        }
+    }
 }