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

   1 /*
   2  * Copyright (c) 2015 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.controller.cluster.raft;
  10
  11 import static org.junit.Assert.assertArrayEquals;
  12 import static org.junit.Assert.assertEquals;
  13 import static org.junit.Assert.assertFalse;
  14 import static org.junit.Assert.assertTrue;
  15 import static org.mockito.Matchers.any;
  16 import static org.mockito.Matchers.anyLong;
  17 import static org.mockito.Mockito.doReturn;
  18 import static org.mockito.Mockito.doThrow;
  19 import static org.mockito.Mockito.mock;
  20 import static org.mockito.Mockito.never;
  21 import static org.mockito.Mockito.reset;
  22 import static org.mockito.Mockito.times;
  23 import static org.mockito.Mockito.verify;
  24 import akka.actor.ActorRef;
  25 import akka.japi.Procedure;
  26 import akka.persistence.SnapshotSelectionCriteria;
  27 import akka.testkit.TestActorRef;
  28 import java.util.Arrays;
  29 import org.junit.After;
  30 import org.junit.Before;
  31 import org.junit.Test;
  32 import org.mockito.ArgumentCaptor;
  33 import org.mockito.Mock;
  34 import org.mockito.MockitoAnnotations;
  35 import org.opendaylight.controller.cluster.DataPersistenceProvider;
  36 import org.opendaylight.controller.cluster.raft.SnapshotManager.LastAppliedTermInformationReader;
  37 import org.opendaylight.controller.cluster.raft.base.messages.CaptureSnapshot;
  38 import org.opendaylight.controller.cluster.raft.base.messages.SendInstallSnapshot;
  39 import org.opendaylight.controller.cluster.raft.base.messages.SnapshotComplete;
  40 import org.opendaylight.controller.cluster.raft.behaviors.RaftActorBehavior;
  41 import org.opendaylight.controller.cluster.raft.utils.MessageCollectorActor;
  42 import org.slf4j.LoggerFactory;
  43
  44 public class SnapshotManagerTest extends AbstractActorTest {
  45
  46     @Mock
  47     private RaftActorContext mockRaftActorContext;
  48
  49     @Mock
  50     private ConfigParams mockConfigParams;
  51
  52     @Mock
  53     private ReplicatedLog mockReplicatedLog;
  54
  55     @Mock
  56     private DataPersistenceProvider mockDataPersistenceProvider;
  57
  58     @Mock
  59     private RaftActorBehavior mockRaftActorBehavior;
  60
  61     @Mock
  62     private Procedure<Void> mockProcedure;
  63
  64     @Mock
  65     private ElectionTerm mockElectionTerm;
  66
  67     private SnapshotManager snapshotManager;
  68
  69     private TestActorFactory factory;
  70
  71     private TestActorRef<MessageCollectorActor> actorRef;
  72
  73     @Before
  74     public void setUp(){
  75         MockitoAnnotations.initMocks(this);
  76
  77         doReturn(false).when(mockRaftActorContext).hasFollowers();
  78         doReturn(mockConfigParams).when(mockRaftActorContext).getConfigParams();
  79         doReturn(10L).when(mockConfigParams).getSnapshotBatchCount();
  80         doReturn(70).when(mockConfigParams).getSnapshotDataThresholdPercentage();
  81         doReturn(mockReplicatedLog).when(mockRaftActorContext).getReplicatedLog();
  82         doReturn("123").when(mockRaftActorContext).getId();
  83         doReturn(mockDataPersistenceProvider).when(mockRaftActorContext).getPersistenceProvider();
  84         doReturn(mockRaftActorBehavior).when(mockRaftActorContext).getCurrentBehavior();
  85         doReturn("123").when(mockRaftActorBehavior).getLeaderId();
  86
  87         doReturn(mockElectionTerm).when(mockRaftActorContext).getTermInformation();
  88         doReturn(5L).when(mockElectionTerm).getCurrentTerm();
  89         doReturn("member5").when(mockElectionTerm).getVotedFor();
  90
  91         snapshotManager = new SnapshotManager(mockRaftActorContext, LoggerFactory.getLogger(this.getClass()));
  92         factory = new TestActorFactory(getSystem());
  93
  94         actorRef = factory.createTestActor(MessageCollectorActor.props(), factory.generateActorId("test-"));
  95         doReturn(actorRef).when(mockRaftActorContext).getActor();
  96
  97         snapshotManager.setCreateSnapshotCallable(mockProcedure);
  98     }
  99
 100     @After
 101     public void tearDown(){
 102         factory.close();
 103     }
 104
 105     @Test
 106     public void testConstruction(){
 107         assertEquals(false, snapshotManager.isCapturing());
 108     }
 109
 110     @Test
 111     public void testCaptureToInstall() throws Exception {
 112
 113         // Force capturing toInstall = true
 114         snapshotManager.captureToInstall(new MockRaftActorContext.MockReplicatedLogEntry(1, 0,
 115                 new MockRaftActorContext.MockPayload()), 0, "follower-1");
 116
 117         assertEquals(true, snapshotManager.isCapturing());
 118
 119         verify(mockProcedure).apply(null);
 120
 121         CaptureSnapshot captureSnapshot = snapshotManager.getCaptureSnapshot();
 122
 123         // LastIndex and LastTerm are picked up from the lastLogEntry
 124         assertEquals(0L, captureSnapshot.getLastIndex());
 125         assertEquals(1L, captureSnapshot.getLastTerm());
 126
 127         // Since the actor does not have any followers (no peer addresses) lastApplied will be from lastLogEntry
 128         assertEquals(0L, captureSnapshot.getLastAppliedIndex());
 129         assertEquals(1L, captureSnapshot.getLastAppliedTerm());
 130
 131         //
 132         assertEquals(-1L, captureSnapshot.getReplicatedToAllIndex());
 133         assertEquals(-1L, captureSnapshot.getReplicatedToAllTerm());
 134         actorRef.underlyingActor().clear();
 135     }
 136
 137     @Test
 138     public void testCapture() throws Exception {
 139         boolean capture = snapshotManager.capture(new MockRaftActorContext.MockReplicatedLogEntry(1,9,
 140                 new MockRaftActorContext.MockPayload()), 9);
 141
 142         assertTrue(capture);
 143
 144         assertEquals(true, snapshotManager.isCapturing());
 145
 146         verify(mockProcedure).apply(null);
 147
 148         CaptureSnapshot captureSnapshot = snapshotManager.getCaptureSnapshot();
 149
 150         // LastIndex and LastTerm are picked up from the lastLogEntry
 151         assertEquals(9L, captureSnapshot.getLastIndex());
 152         assertEquals(1L, captureSnapshot.getLastTerm());
 153
 154         // Since the actor does not have any followers (no peer addresses) lastApplied will be from lastLogEntry
 155         assertEquals(9L, captureSnapshot.getLastAppliedIndex());
 156         assertEquals(1L, captureSnapshot.getLastAppliedTerm());
 157
 158         //
 159         assertEquals(-1L, captureSnapshot.getReplicatedToAllIndex());
 160         assertEquals(-1L, captureSnapshot.getReplicatedToAllTerm());
 161
 162         actorRef.underlyingActor().clear();
 163
 164     }
 165
 166     @Test
 167     public void testCaptureWithNullLastLogEntry() throws Exception {
 168         boolean capture = snapshotManager.capture(null, 1);
 169
 170         assertTrue(capture);
 171
 172         assertEquals(true, snapshotManager.isCapturing());
 173
 174         verify(mockProcedure).apply(null);
 175
 176         CaptureSnapshot captureSnapshot = snapshotManager.getCaptureSnapshot();
 177
 178         System.out.println(captureSnapshot);
 179
 180         // LastIndex and LastTerm are picked up from the lastLogEntry
 181         assertEquals(-1L, captureSnapshot.getLastIndex());
 182         assertEquals(-1L, captureSnapshot.getLastTerm());
 183
 184         // Since the actor does not have any followers (no peer addresses) lastApplied will be from lastLogEntry
 185         assertEquals(-1L, captureSnapshot.getLastAppliedIndex());
 186         assertEquals(-1L, captureSnapshot.getLastAppliedTerm());
 187
 188         //
 189         assertEquals(-1L, captureSnapshot.getReplicatedToAllIndex());
 190         assertEquals(-1L, captureSnapshot.getReplicatedToAllTerm());
 191         actorRef.underlyingActor().clear();
 192
 193     }
 194
 195     @Test
 196     public void testCaptureWithCreateProcedureError () throws Exception {
 197         doThrow(new Exception("mock")).when(mockProcedure).apply(null);
 198
 199         boolean capture = snapshotManager.capture(new MockRaftActorContext.MockReplicatedLogEntry(1,9,
 200                 new MockRaftActorContext.MockPayload()), 9);
 201
 202         assertFalse(capture);
 203
 204         assertEquals(false, snapshotManager.isCapturing());
 205
 206         verify(mockProcedure).apply(null);
 207     }
 208
 209     @Test
 210     public void testIllegalCapture() throws Exception {
 211         boolean capture = snapshotManager.capture(new MockRaftActorContext.MockReplicatedLogEntry(1,9,
 212                 new MockRaftActorContext.MockPayload()), 9);
 213
 214         assertTrue(capture);
 215
 216         verify(mockProcedure).apply(null);
 217
 218         reset(mockProcedure);
 219
 220         // This will not cause snapshot capture to start again
 221         capture = snapshotManager.capture(new MockRaftActorContext.MockReplicatedLogEntry(1,9,
 222                 new MockRaftActorContext.MockPayload()), 9);
 223
 224         assertFalse(capture);
 225
 226         verify(mockProcedure, never()).apply(null);
 227     }
 228
 229     @Test
 230     public void testPersistWhenReplicatedToAllIndexMinusOne(){
 231         doReturn(7L).when(mockReplicatedLog).getSnapshotIndex();
 232         doReturn(1L).when(mockReplicatedLog).getSnapshotTerm();
 233
 234         doReturn(true).when(mockRaftActorContext).hasFollowers();
 235
 236         doReturn(8L).when(mockRaftActorContext).getLastApplied();
 237
 238         MockRaftActorContext.MockReplicatedLogEntry lastLogEntry = new MockRaftActorContext.MockReplicatedLogEntry(
 239                 3L, 9L, new MockRaftActorContext.MockPayload());
 240
 241         MockRaftActorContext.MockReplicatedLogEntry lastAppliedEntry = new MockRaftActorContext.MockReplicatedLogEntry(
 242                 2L, 8L, new MockRaftActorContext.MockPayload());
 243
 244         doReturn(lastAppliedEntry).when(mockReplicatedLog).get(8L);
 245         doReturn(Arrays.asList(lastLogEntry)).when(mockReplicatedLog).getFrom(9L);
 246
 247         // when replicatedToAllIndex = -1
 248         snapshotManager.capture(lastLogEntry, -1);
 249
 250         byte[] bytes = new byte[] {1,2,3,4,5,6,7,8,9,10};
 251         snapshotManager.persist(bytes, Runtime.getRuntime().totalMemory());
 252
 253         ArgumentCaptor<Snapshot> snapshotArgumentCaptor = ArgumentCaptor.forClass(Snapshot.class);
 254         verify(mockDataPersistenceProvider).saveSnapshot(snapshotArgumentCaptor.capture());
 255
 256         Snapshot snapshot = snapshotArgumentCaptor.getValue();
 257
 258         assertEquals("getLastTerm", 3L, snapshot.getLastTerm());
 259         assertEquals("getLastIndex", 9L, snapshot.getLastIndex());
 260         assertEquals("getLastAppliedTerm", 2L, snapshot.getLastAppliedTerm());
 261         assertEquals("getLastAppliedIndex", 8L, snapshot.getLastAppliedIndex());
 262         assertArrayEquals("getState", bytes, snapshot.getState());
 263         assertEquals("getUnAppliedEntries", Arrays.asList(lastLogEntry), snapshot.getUnAppliedEntries());
 264         assertEquals("electionTerm", mockElectionTerm.getCurrentTerm(), snapshot.getElectionTerm());
 265         assertEquals("electionVotedFor", mockElectionTerm.getVotedFor(), snapshot.getElectionVotedFor());
 266
 267         verify(mockReplicatedLog).snapshotPreCommit(7L, 1L);
 268     }
 269
 270     @Test
 271     public void testPersistWhenReplicatedToAllIndexNotMinus(){
 272         doReturn(45L).when(mockReplicatedLog).getSnapshotIndex();
 273         doReturn(6L).when(mockReplicatedLog).getSnapshotTerm();
 274         ReplicatedLogEntry replicatedLogEntry = mock(ReplicatedLogEntry.class);
 275         doReturn(replicatedLogEntry).when(mockReplicatedLog).get(9);
 276         doReturn(6L).when(replicatedLogEntry).getTerm();
 277         doReturn(9L).when(replicatedLogEntry).getIndex();
 278
 279         // when replicatedToAllIndex != -1
 280         snapshotManager.capture(new MockRaftActorContext.MockReplicatedLogEntry(6,9,
 281                 new MockRaftActorContext.MockPayload()), 9);
 282
 283         byte[] bytes = new byte[] {1,2,3,4,5,6,7,8,9,10};
 284         snapshotManager.persist(bytes, Runtime.getRuntime().totalMemory());
 285
 286         ArgumentCaptor<Snapshot> snapshotArgumentCaptor = ArgumentCaptor.forClass(Snapshot.class);
 287         verify(mockDataPersistenceProvider).saveSnapshot(snapshotArgumentCaptor.capture());
 288
 289         Snapshot snapshot = snapshotArgumentCaptor.getValue();
 290
 291         assertEquals("getLastTerm", 6L, snapshot.getLastTerm());
 292         assertEquals("getLastIndex", 9L, snapshot.getLastIndex());
 293         assertEquals("getLastAppliedTerm", 6L, snapshot.getLastAppliedTerm());
 294         assertEquals("getLastAppliedIndex", 9L, snapshot.getLastAppliedIndex());
 295         assertArrayEquals("getState", bytes, snapshot.getState());
 296         assertEquals("getUnAppliedEntries size", 0, snapshot.getUnAppliedEntries().size());
 297
 298         verify(mockReplicatedLog).snapshotPreCommit(9L, 6L);
 299
 300         verify(mockRaftActorBehavior).setReplicatedToAllIndex(9);
 301     }
 302
 303     @Test
 304     public void testPersistWhenReplicatedLogDataSizeGreaterThanThreshold(){
 305         doReturn(Integer.MAX_VALUE).when(mockReplicatedLog).dataSize();
 306
 307         // when replicatedToAllIndex = -1
 308         snapshotManager.capture(new MockRaftActorContext.MockReplicatedLogEntry(6,9,
 309                 new MockRaftActorContext.MockPayload()), -1);
 310
 311         snapshotManager.persist(new byte[]{}, Runtime.getRuntime().totalMemory());
 312
 313         verify(mockDataPersistenceProvider).saveSnapshot(any(Snapshot.class));
 314
 315         verify(mockReplicatedLog).snapshotPreCommit(9L, 6L);
 316
 317         verify(mockRaftActorBehavior, never()).setReplicatedToAllIndex(anyLong());
 318     }
 319
 320     @Test
 321     public void testPersistWhenReplicatedLogSizeExceedsSnapshotBatchCount() {
 322         doReturn(10L).when(mockReplicatedLog).size(); // matches snapshotBatchCount
 323         doReturn(100).when(mockReplicatedLog).dataSize();
 324
 325         doReturn(5L).when(mockReplicatedLog).getSnapshotIndex();
 326         doReturn(5L).when(mockReplicatedLog).getSnapshotTerm();
 327
 328         long replicatedToAllIndex = 1;
 329         ReplicatedLogEntry replicatedLogEntry = mock(ReplicatedLogEntry.class);
 330         doReturn(replicatedLogEntry).when(mockReplicatedLog).get(replicatedToAllIndex);
 331         doReturn(6L).when(replicatedLogEntry).getTerm();
 332         doReturn(replicatedToAllIndex).when(replicatedLogEntry).getIndex();
 333
 334         snapshotManager.capture(new MockRaftActorContext.MockReplicatedLogEntry(6, 9,
 335                 new MockRaftActorContext.MockPayload()), replicatedToAllIndex);
 336
 337         snapshotManager.persist(new byte[]{}, 2000000L);
 338
 339         verify(mockDataPersistenceProvider).saveSnapshot(any(Snapshot.class));
 340
 341         verify(mockReplicatedLog).snapshotPreCommit(9L, 6L);
 342
 343         verify(mockRaftActorBehavior).setReplicatedToAllIndex(replicatedToAllIndex);
 344     }
 345
 346     @Test
 347     public void testPersistSendInstallSnapshot(){
 348         doReturn(Integer.MAX_VALUE).when(mockReplicatedLog).dataSize();
 349
 350         // when replicatedToAllIndex = -1
 351         boolean capture = snapshotManager.captureToInstall(new MockRaftActorContext.MockReplicatedLogEntry(6, 9,
 352                 new MockRaftActorContext.MockPayload()), -1, "follower-1");
 353
 354         assertTrue(capture);
 355
 356         byte[] bytes = new byte[] {1,2,3,4,5,6,7,8,9,10};
 357
 358         snapshotManager.persist(bytes, Runtime.getRuntime().totalMemory());
 359
 360         assertEquals(true, snapshotManager.isCapturing());
 361
 362         verify(mockDataPersistenceProvider).saveSnapshot(any(Snapshot.class));
 363
 364         verify(mockReplicatedLog).snapshotPreCommit(9L, 6L);
 365
 366         ArgumentCaptor<SendInstallSnapshot> sendInstallSnapshotArgumentCaptor
 367                 = ArgumentCaptor.forClass(SendInstallSnapshot.class);
 368
 369         verify(mockRaftActorBehavior).handleMessage(any(ActorRef.class), sendInstallSnapshotArgumentCaptor.capture());
 370
 371         SendInstallSnapshot sendInstallSnapshot = sendInstallSnapshotArgumentCaptor.getValue();
 372
 373         assertTrue(Arrays.equals(bytes, sendInstallSnapshot.getSnapshot().getState()));
 374     }
 375
 376     @Test
 377     public void testCallingPersistWithoutCaptureWillDoNothing(){
 378         snapshotManager.persist(new byte[]{}, Runtime.getRuntime().totalMemory());
 379
 380         verify(mockDataPersistenceProvider, never()).saveSnapshot(any(Snapshot.class));
 381
 382         verify(mockReplicatedLog, never()).snapshotPreCommit(9L, 6L);
 383
 384         verify(mockRaftActorBehavior, never()).handleMessage(any(ActorRef.class), any(SendInstallSnapshot.class));
 385     }
 386     @Test
 387     public void testCallingPersistTwiceWillDoNoHarm(){
 388         doReturn(Integer.MAX_VALUE).when(mockReplicatedLog).dataSize();
 389
 390         // when replicatedToAllIndex = -1
 391         snapshotManager.captureToInstall(new MockRaftActorContext.MockReplicatedLogEntry(6, 9,
 392                 new MockRaftActorContext.MockPayload()), -1, "follower-1");
 393
 394         snapshotManager.persist(new byte[]{}, Runtime.getRuntime().totalMemory());
 395
 396         snapshotManager.persist(new byte[]{}, Runtime.getRuntime().totalMemory());
 397
 398         verify(mockDataPersistenceProvider).saveSnapshot(any(Snapshot.class));
 399
 400         verify(mockReplicatedLog).snapshotPreCommit(9L, 6L);
 401
 402         verify(mockRaftActorBehavior).handleMessage(any(ActorRef.class), any(SendInstallSnapshot.class));
 403     }
 404
 405     @Test
 406     public void testCommit(){
 407         doReturn(50L).when(mockDataPersistenceProvider).getLastSequenceNumber();
 408
 409         // when replicatedToAllIndex = -1
 410         snapshotManager.captureToInstall(new MockRaftActorContext.MockReplicatedLogEntry(6, 9,
 411                 new MockRaftActorContext.MockPayload()), -1, "follower-1");
 412
 413         snapshotManager.persist(new byte[]{}, Runtime.getRuntime().totalMemory());
 414
 415         assertEquals(true, snapshotManager.isCapturing());
 416
 417         snapshotManager.commit(100L);
 418
 419         assertEquals(false, snapshotManager.isCapturing());
 420
 421         verify(mockReplicatedLog).snapshotCommit();
 422
 423         verify(mockDataPersistenceProvider).deleteMessages(50L);
 424
 425         ArgumentCaptor<SnapshotSelectionCriteria> criteriaCaptor = ArgumentCaptor.forClass(SnapshotSelectionCriteria.class);
 426
 427         verify(mockDataPersistenceProvider).deleteSnapshots(criteriaCaptor.capture());
 428
 429         assertEquals(90, criteriaCaptor.getValue().maxSequenceNr()); // sequenceNumber = 100
 430                                                                      // config snapShotBatchCount = 10
 431                                                                      // therefore maxSequenceNumber = 90
 432
 433         MessageCollectorActor.expectFirstMatching(actorRef, SnapshotComplete.class);
 434     }
 435
 436     @Test
 437     public void testCommitBeforePersist(){
 438         // when replicatedToAllIndex = -1
 439         snapshotManager.captureToInstall(new MockRaftActorContext.MockReplicatedLogEntry(6, 9,
 440                 new MockRaftActorContext.MockPayload()), -1, "follower-1");
 441
 442         snapshotManager.commit(100L);
 443
 444         verify(mockReplicatedLog, never()).snapshotCommit();
 445
 446         verify(mockDataPersistenceProvider, never()).deleteMessages(100L);
 447
 448         verify(mockDataPersistenceProvider, never()).deleteSnapshots(any(SnapshotSelectionCriteria.class));
 449
 450     }
 451
 452     @Test
 453     public void testCommitBeforeCapture(){
 454         snapshotManager.commit(100L);
 455
 456         verify(mockReplicatedLog, never()).snapshotCommit();
 457
 458         verify(mockDataPersistenceProvider, never()).deleteMessages(anyLong());
 459
 460         verify(mockDataPersistenceProvider, never()).deleteSnapshots(any(SnapshotSelectionCriteria.class));
 461
 462     }
 463
 464     @Test
 465     public void testCallingCommitMultipleTimesCausesNoHarm(){
 466         doReturn(50L).when(mockDataPersistenceProvider).getLastSequenceNumber();
 467
 468         // when replicatedToAllIndex = -1
 469         snapshotManager.captureToInstall(new MockRaftActorContext.MockReplicatedLogEntry(6, 9,
 470                 new MockRaftActorContext.MockPayload()), -1, "follower-1");
 471
 472         snapshotManager.persist(new byte[]{}, Runtime.getRuntime().totalMemory());
 473
 474         snapshotManager.commit(100L);
 475
 476         snapshotManager.commit(100L);
 477
 478         verify(mockReplicatedLog, times(1)).snapshotCommit();
 479
 480         verify(mockDataPersistenceProvider, times(1)).deleteMessages(50L);
 481
 482         verify(mockDataPersistenceProvider, times(1)).deleteSnapshots(any(SnapshotSelectionCriteria.class));
 483     }
 484
 485     @Test
 486     public void testRollback(){
 487         // when replicatedToAllIndex = -1
 488         snapshotManager.captureToInstall(new MockRaftActorContext.MockReplicatedLogEntry(6, 9,
 489                 new MockRaftActorContext.MockPayload()), -1, "follower-1");
 490
 491         snapshotManager.persist(new byte[]{}, Runtime.getRuntime().totalMemory());
 492
 493         snapshotManager.rollback();
 494
 495         verify(mockReplicatedLog).snapshotRollback();
 496
 497         MessageCollectorActor.expectFirstMatching(actorRef, SnapshotComplete.class);
 498     }
 499
 500
 501     @Test
 502     public void testRollbackBeforePersist(){
 503         // when replicatedToAllIndex = -1
 504         snapshotManager.captureToInstall(new MockRaftActorContext.MockReplicatedLogEntry(6, 9,
 505                 new MockRaftActorContext.MockPayload()), -1, "follower-1");
 506
 507         snapshotManager.rollback();
 508
 509         verify(mockReplicatedLog, never()).snapshotRollback();
 510     }
 511
 512     @Test
 513     public void testRollbackBeforeCapture(){
 514         snapshotManager.rollback();
 515
 516         verify(mockReplicatedLog, never()).snapshotRollback();
 517     }
 518
 519     @Test
 520     public void testCallingRollbackMultipleTimesCausesNoHarm(){
 521         // when replicatedToAllIndex = -1
 522         snapshotManager.captureToInstall(new MockRaftActorContext.MockReplicatedLogEntry(6, 9,
 523                 new MockRaftActorContext.MockPayload()), -1, "follower-1");
 524
 525         snapshotManager.persist(new byte[]{}, Runtime.getRuntime().totalMemory());
 526
 527         snapshotManager.rollback();
 528
 529         snapshotManager.rollback();
 530
 531         verify(mockReplicatedLog, times(1)).snapshotRollback();
 532     }
 533
 534     @Test
 535     public void testTrimLogWhenTrimIndexLessThanLastApplied() {
 536         doReturn(20L).when(mockRaftActorContext).getLastApplied();
 537
 538         ReplicatedLogEntry replicatedLogEntry = mock(ReplicatedLogEntry.class);
 539         doReturn(true).when(mockReplicatedLog).isPresent(10);
 540         doReturn(replicatedLogEntry).when((mockReplicatedLog)).get(10);
 541         doReturn(5L).when(replicatedLogEntry).getTerm();
 542
 543         long retIndex = snapshotManager.trimLog(10);
 544         assertEquals("return index", 10L, retIndex);
 545
 546         verify(mockReplicatedLog).snapshotPreCommit(10, 5);
 547         verify(mockReplicatedLog).snapshotCommit();
 548
 549         verify(mockRaftActorBehavior, never()).setReplicatedToAllIndex(anyLong());
 550     }
 551
 552     @Test
 553     public void testTrimLogWhenLastAppliedNotSet() {
 554         doReturn(-1L).when(mockRaftActorContext).getLastApplied();
 555
 556         ReplicatedLogEntry replicatedLogEntry = mock(ReplicatedLogEntry.class);
 557         doReturn(true).when(mockReplicatedLog).isPresent(10);
 558         doReturn(replicatedLogEntry).when((mockReplicatedLog)).get(10);
 559         doReturn(5L).when(replicatedLogEntry).getTerm();
 560
 561         long retIndex = snapshotManager.trimLog(10);
 562         assertEquals("return index", -1L, retIndex);
 563
 564         verify(mockReplicatedLog, never()).snapshotPreCommit(anyLong(), anyLong());
 565         verify(mockReplicatedLog, never()).snapshotCommit();
 566
 567         verify(mockRaftActorBehavior, never()).setReplicatedToAllIndex(anyLong());
 568     }
 569
 570     @Test
 571     public void testTrimLogWhenLastAppliedZero() {
 572         doReturn(0L).when(mockRaftActorContext).getLastApplied();
 573
 574         ReplicatedLogEntry replicatedLogEntry = mock(ReplicatedLogEntry.class);
 575         doReturn(true).when(mockReplicatedLog).isPresent(10);
 576         doReturn(replicatedLogEntry).when((mockReplicatedLog)).get(10);
 577         doReturn(5L).when(replicatedLogEntry).getTerm();
 578
 579         long retIndex = snapshotManager.trimLog(10);
 580         assertEquals("return index", -1L, retIndex);
 581
 582         verify(mockReplicatedLog, never()).snapshotPreCommit(anyLong(), anyLong());
 583         verify(mockReplicatedLog, never()).snapshotCommit();
 584
 585         verify(mockRaftActorBehavior, never()).setReplicatedToAllIndex(anyLong());
 586     }
 587
 588     @Test
 589     public void testTrimLogWhenTrimIndexNotPresent() {
 590         doReturn(20L).when(mockRaftActorContext).getLastApplied();
 591
 592         doReturn(false).when(mockReplicatedLog).isPresent(10);
 593
 594         long retIndex = snapshotManager.trimLog(10);
 595         assertEquals("return index", -1L, retIndex);
 596
 597         verify(mockReplicatedLog, never()).snapshotPreCommit(anyLong(), anyLong());
 598         verify(mockReplicatedLog, never()).snapshotCommit();
 599
 600         // Trim index is greater than replicatedToAllIndex so should update it.
 601         verify(mockRaftActorBehavior).setReplicatedToAllIndex(10L);
 602     }
 603
 604     @Test
 605     public void testTrimLogAfterCapture(){
 606         boolean capture = snapshotManager.capture(new MockRaftActorContext.MockReplicatedLogEntry(1,9,
 607                 new MockRaftActorContext.MockPayload()), 9);
 608
 609         assertTrue(capture);
 610
 611         assertEquals(true, snapshotManager.isCapturing());
 612
 613         ReplicatedLogEntry replicatedLogEntry = mock(ReplicatedLogEntry.class);
 614         doReturn(20L).when(mockRaftActorContext).getLastApplied();
 615         doReturn(true).when(mockReplicatedLog).isPresent(10);
 616         doReturn(replicatedLogEntry).when((mockReplicatedLog)).get(10);
 617         doReturn(5L).when(replicatedLogEntry).getTerm();
 618
 619         snapshotManager.trimLog(10);
 620
 621         verify(mockReplicatedLog, never()).snapshotPreCommit(anyLong(), anyLong());
 622         verify(mockReplicatedLog, never()).snapshotCommit();
 623
 624     }
 625
 626     @Test
 627     public void testTrimLogAfterCaptureToInstall(){
 628         boolean capture = snapshotManager.captureToInstall(new MockRaftActorContext.MockReplicatedLogEntry(1,9,
 629                 new MockRaftActorContext.MockPayload()), 9, "follower-1");
 630
 631         assertTrue(capture);
 632
 633         assertEquals(true, snapshotManager.isCapturing());
 634
 635         ReplicatedLogEntry replicatedLogEntry = mock(ReplicatedLogEntry.class);
 636         doReturn(20L).when(mockRaftActorContext).getLastApplied();
 637         doReturn(true).when(mockReplicatedLog).isPresent(10);
 638         doReturn(replicatedLogEntry).when((mockReplicatedLog)).get(10);
 639         doReturn(5L).when(replicatedLogEntry).getTerm();
 640
 641         snapshotManager.trimLog(10);
 642
 643         verify(mockReplicatedLog, never()).snapshotPreCommit(10, 5);
 644         verify(mockReplicatedLog, never()).snapshotCommit();
 645
 646     }
 647
 648     @Test
 649     public void testLastAppliedTermInformationReader() {
 650
 651         LastAppliedTermInformationReader reader = new LastAppliedTermInformationReader();
 652
 653         doReturn(4L).when(mockReplicatedLog).getSnapshotTerm();
 654         doReturn(7L).when(mockReplicatedLog).getSnapshotIndex();
 655
 656         ReplicatedLogEntry lastLogEntry = new MockRaftActorContext.MockReplicatedLogEntry(6L, 9L,
 657                 new MockRaftActorContext.MockPayload());
 658
 659         // No followers and valid lastLogEntry
 660         reader.init(mockReplicatedLog, 1L, lastLogEntry, false);
 661
 662         assertEquals("getTerm", 6L, reader.getTerm());
 663         assertEquals("getIndex", 9L, reader.getIndex());
 664
 665         // No followers and null lastLogEntry
 666         reader.init(mockReplicatedLog, 1L, null, false);
 667
 668         assertEquals("getTerm", -1L, reader.getTerm());
 669         assertEquals("getIndex", -1L, reader.getIndex());
 670
 671         // Followers and valid originalIndex entry
 672         doReturn(new MockRaftActorContext.MockReplicatedLogEntry(5L, 8L,
 673                 new MockRaftActorContext.MockPayload())).when(mockReplicatedLog).get(8L);
 674         reader.init(mockReplicatedLog, 8L, lastLogEntry, true);
 675
 676         assertEquals("getTerm", 5L, reader.getTerm());
 677         assertEquals("getIndex", 8L, reader.getIndex());
 678
 679         // Followers and null originalIndex entry and valid snapshot index
 680         reader.init(mockReplicatedLog, 7L, lastLogEntry, true);
 681
 682         assertEquals("getTerm", 4L, reader.getTerm());
 683         assertEquals("getIndex", 7L, reader.getIndex());
 684
 685         // Followers and null originalIndex entry and invalid snapshot index
 686         doReturn(-1L).when(mockReplicatedLog).getSnapshotIndex();
 687         reader.init(mockReplicatedLog, 7L, lastLogEntry, true);
 688
 689         assertEquals("getTerm", -1L, reader.getTerm());
 690         assertEquals("getIndex", -1L, reader.getIndex());
 691     }
 692 }