opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/behaviors/LeaderTest.java

   1 package org.opendaylight.controller.cluster.raft.behaviors;
   2
   3 import akka.actor.ActorRef;
   4 import akka.actor.Props;
   5 import akka.testkit.JavaTestKit;
   6 import junit.framework.Assert;
   7 import org.junit.Test;
   8 import org.opendaylight.controller.cluster.raft.MockRaftActorContext;
   9 import org.opendaylight.controller.cluster.raft.RaftActorContext;
  10 import org.opendaylight.controller.cluster.raft.RaftState;
  11 import org.opendaylight.controller.cluster.raft.ReplicatedLogImplEntry;
  12 import org.opendaylight.controller.cluster.raft.base.messages.ApplyState;
  13 import org.opendaylight.controller.cluster.raft.base.messages.Replicate;
  14 import org.opendaylight.controller.cluster.raft.base.messages.SendHeartBeat;
  15 import org.opendaylight.controller.cluster.raft.messages.AppendEntries;
  16 import org.opendaylight.controller.cluster.raft.utils.DoNothingActor;
  17
  18 import java.util.HashMap;
  19 import java.util.Map;
  20
  21 import static org.junit.Assert.assertEquals;
  22
  23 public class LeaderTest extends AbstractRaftActorBehaviorTest {
  24
  25     private ActorRef leaderActor =
  26         getSystem().actorOf(Props.create(DoNothingActor.class));
  27     private ActorRef senderActor =
  28         getSystem().actorOf(Props.create(DoNothingActor.class));
  29
  30     @Test
  31     public void testHandleMessageForUnknownMessage() throws Exception {
  32         new JavaTestKit(getSystem()) {{
  33             Leader leader =
  34                 new Leader(createActorContext());
  35
  36             // handle message should return the Leader state when it receives an
  37             // unknown message
  38             RaftState state = leader.handleMessage(senderActor, "foo");
  39             Assert.assertEquals(RaftState.Leader, state);
  40         }};
  41     }
  42
  43
  44     @Test
  45     public void testThatLeaderSendsAHeartbeatMessageToAllFollowers() {
  46         new JavaTestKit(getSystem()) {{
  47
  48             new Within(duration("1 seconds")) {
  49                 protected void run() {
  50
  51                     ActorRef followerActor = getTestActor();
  52
  53                     MockRaftActorContext actorContext =
  54                         (MockRaftActorContext) createActorContext();
  55
  56                     Map<String, String> peerAddresses = new HashMap();
  57
  58                     peerAddresses.put(followerActor.path().toString(),
  59                         followerActor.path().toString());
  60
  61                     actorContext.setPeerAddresses(peerAddresses);
  62
  63                     Leader leader = new Leader(actorContext);
  64                     leader.handleMessage(senderActor, new SendHeartBeat());
  65
  66                     final String out =
  67                         new ExpectMsg<String>(duration("1 seconds"), "match hint") {
  68                             // do not put code outside this method, will run afterwards
  69                             protected String match(Object in) {
  70                                 Object msg = fromSerializableMessage(in);
  71                                 if (msg instanceof AppendEntries) {
  72                                     if (((AppendEntries)msg).getTerm() == 0) {
  73                                         return "match";
  74                                     }
  75                                     return null;
  76                                 } else {
  77                                     throw noMatch();
  78                                 }
  79                             }
  80                         }.get(); // this extracts the received message
  81
  82                     assertEquals("match", out);
  83
  84                 }
  85
  86
  87             };
  88         }};
  89     }
  90
  91     @Test
  92     public void testHandleReplicateMessageSendAppendEntriesToFollower() {
  93         new JavaTestKit(getSystem()) {{
  94
  95             new Within(duration("1 seconds")) {
  96                 protected void run() {
  97
  98                     ActorRef followerActor = getTestActor();
  99
 100                     MockRaftActorContext actorContext =
 101                         (MockRaftActorContext) createActorContext();
 102
 103                     Map<String, String> peerAddresses = new HashMap();
 104
 105                     peerAddresses.put(followerActor.path().toString(),
 106                         followerActor.path().toString());
 107
 108                     actorContext.setPeerAddresses(peerAddresses);
 109
 110                     Leader leader = new Leader(actorContext);
 111                     RaftState raftState = leader
 112                         .handleMessage(senderActor, new Replicate(null, null,
 113                             new MockRaftActorContext.MockReplicatedLogEntry(1,
 114                                 100,
 115                                 new MockRaftActorContext.MockPayload("foo"))
 116                         ));
 117
 118                     // State should not change
 119                     assertEquals(RaftState.Leader, raftState);
 120
 121                     final String out =
 122                         new ExpectMsg<String>(duration("1 seconds"), "match hint") {
 123                             // do not put code outside this method, will run afterwards
 124                             protected String match(Object in) {
 125                                 Object msg = fromSerializableMessage(in);
 126                                 if (msg instanceof AppendEntries) {
 127                                     if (((AppendEntries)msg).getTerm() == 0) {
 128                                         return "match";
 129                                     }
 130                                     return null;
 131                                 } else {
 132                                     throw noMatch();
 133                                 }
 134                             }
 135                         }.get(); // this extracts the received message
 136
 137                     assertEquals("match", out);
 138
 139                 }
 140
 141
 142             };
 143         }};
 144     }
 145
 146     @Test
 147     public void testHandleReplicateMessageWhenThereAreNoFollowers() {
 148         new JavaTestKit(getSystem()) {{
 149
 150             new Within(duration("1 seconds")) {
 151                 protected void run() {
 152
 153                     ActorRef raftActor = getTestActor();
 154
 155                     MockRaftActorContext actorContext =
 156                         new MockRaftActorContext("test", getSystem(), raftActor);
 157
 158                     actorContext.getReplicatedLog().removeFrom(0);
 159
 160                     actorContext.getReplicatedLog().append(new ReplicatedLogImplEntry(0, 1,
 161                         new MockRaftActorContext.MockPayload("foo")));
 162
 163                     ReplicatedLogImplEntry entry =
 164                         new ReplicatedLogImplEntry(1, 1,
 165                             new MockRaftActorContext.MockPayload("foo"));
 166
 167                     actorContext.getReplicatedLog().append(entry);
 168
 169                     Leader leader = new Leader(actorContext);
 170                     RaftState raftState = leader
 171                         .handleMessage(senderActor, new Replicate(null, "state-id",entry));
 172
 173                     // State should not change
 174                     assertEquals(RaftState.Leader, raftState);
 175
 176                     assertEquals(1, actorContext.getCommitIndex());
 177
 178                     final String out =
 179                         new ExpectMsg<String>(duration("1 seconds"),
 180                             "match hint") {
 181                             // do not put code outside this method, will run afterwards
 182                             protected String match(Object in) {
 183                                 if (in instanceof ApplyState) {
 184                                     if (((ApplyState) in).getIdentifier().equals("state-id")) {
 185                                         return "match";
 186                                     }
 187                                     return null;
 188                                 } else {
 189                                     throw noMatch();
 190                                 }
 191                             }
 192                         }.get(); // this extracts the received message
 193
 194                     assertEquals("match", out);
 195
 196                 }
 197
 198
 199             };
 200         }};
 201     }
 202
 203     @Override protected RaftActorBehavior createBehavior(
 204         RaftActorContext actorContext) {
 205         return new Leader(actorContext);
 206     }
 207
 208     @Override protected RaftActorContext createActorContext() {
 209         return new MockRaftActorContext("test", getSystem(), leaderActor);
 210     }
 211 }