import static org.junit.Assert.assertEquals;
import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.ArgumentMatchers.same;
-import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.reset;
import static org.mockito.Mockito.verify;
import akka.japi.Procedure;
import com.google.common.util.concurrent.MoreExecutors;
-import java.util.Collections;
+import java.util.Map;
+import java.util.function.Consumer;
import org.junit.Before;
import org.junit.Test;
+import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.ArgumentMatcher;
import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
import org.mockito.internal.matchers.Same;
+import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.controller.cluster.DataPersistenceProvider;
import org.opendaylight.controller.cluster.raft.MockRaftActorContext.MockPayload;
import org.opendaylight.controller.cluster.raft.behaviors.RaftActorBehavior;
*
* @author Thomas Pantelis
*/
+@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class ReplicatedLogImplTest {
private static final Logger LOG = LoggerFactory.getLogger(RaftActorRecoverySupportTest.class);
@Before
public void setup() {
- MockitoAnnotations.initMocks(this);
-
context = new RaftActorContextImpl(null, null, "test",
- new ElectionTermImpl(mockPersistence, "test", LOG), -1, -1, Collections.<String,String>emptyMap(),
+ new ElectionTermImpl(mockPersistence, "test", LOG), -1, -1, Map.of(),
configParams, mockPersistence, applyState -> { }, LOG, MoreExecutors.directExecutor());
}
- private void verifyPersist(Object message) throws Exception {
+ private void verifyPersist(final Object message) throws Exception {
verifyPersist(message, new Same(message), true);
}
@SuppressWarnings({ "unchecked", "rawtypes" })
- private void verifyPersist(Object message, ArgumentMatcher<?> matcher, boolean async) throws Exception {
+ private void verifyPersist(final Object message, final ArgumentMatcher<?> matcher, final boolean async)
+ throws Exception {
ArgumentCaptor<Procedure> procedure = ArgumentCaptor.forClass(Procedure.class);
if (async) {
verify(mockPersistence).persistAsync(argThat(matcher), procedure.capture());
procedure.getValue().apply(message);
}
- @SuppressWarnings("unchecked")
@Test
+ @SuppressWarnings("unchecked")
public void testAppendAndPersistExpectingNoCapture() throws Exception {
ReplicatedLog log = ReplicatedLogImpl.newInstance(context);
reset(mockPersistence);
ReplicatedLogEntry logEntry2 = new SimpleReplicatedLogEntry(2, 1, new MockPayload("2"));
- Procedure<ReplicatedLogEntry> mockCallback = mock(Procedure.class);
+ Consumer<ReplicatedLogEntry> mockCallback = mock(Consumer.class);
log.appendAndPersist(logEntry2, mockCallback, true);
verifyPersist(logEntry2);
- verify(mockCallback).apply(same(logEntry2));
+ verify(mockCallback).accept(same(logEntry2));
assertEquals("size", 2, log.size());
}
public void testAppendAndPersisWithDuplicateEntry() throws Exception {
ReplicatedLog log = ReplicatedLogImpl.newInstance(context);
- Procedure<ReplicatedLogEntry> mockCallback = mock(Procedure.class);
+ Consumer<ReplicatedLogEntry> mockCallback = mock(Consumer.class);
ReplicatedLogEntry logEntry = new SimpleReplicatedLogEntry(1, 1, new MockPayload("1"));
log.appendAndPersist(logEntry, mockCallback, true);
public void testAppendAndPersistExpectingCaptureDueToJournalCount() throws Exception {
configParams.setSnapshotBatchCount(2);
- doReturn(1L).when(mockBehavior).getReplicatedToAllIndex();
-
ReplicatedLog log = ReplicatedLogImpl.newInstance(context);
final ReplicatedLogEntry logEntry1 = new SimpleReplicatedLogEntry(2, 1, new MockPayload("2"));
@Test
public void testAppendAndPersistExpectingCaptureDueToDataSize() throws Exception {
- doReturn(1L).when(mockBehavior).getReplicatedToAllIndex();
-
context.setTotalMemoryRetriever(() -> 100);
ReplicatedLog log = ReplicatedLogImpl.newInstance(context);
verifyNoMoreInteractions(mockPersistence);
}
- public ArgumentMatcher<DeleteEntries> match(final DeleteEntries actual) {
+ @Test
+ public void testCommitFakeSnapshot() {
+ ReplicatedLog log = ReplicatedLogImpl.newInstance(context);
+
+ log.append(new SimpleReplicatedLogEntry(0, 1, new MockPayload("0")));
+ final int dataSizeAfterFirstPayload = log.dataSize();
+
+ log.snapshotPreCommit(0,1);
+ log.snapshotCommit(false);
+
+ assertEquals(0, log.size());
+ assertEquals(dataSizeAfterFirstPayload, log.dataSize());
+ }
+
+ private static ArgumentMatcher<DeleteEntries> match(final DeleteEntries actual) {
return other -> actual.getFromIndex() == other.getFromIndex();
}
}