<artifactId>mockito-all</artifactId>
<scope>test</scope>
</dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>mockito-configuration</artifactId>
- <scope>test</scope>
- </dependency>
<dependency>
<groupId>org.slf4j</groupId>
package org.opendaylight.controller.cluster.raft;
import static org.junit.Assert.assertEquals;
-import static org.mockito.Mockito.any;
-import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.verify;
import akka.japi.Procedure;
import org.junit.Before;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
import org.opendaylight.controller.cluster.DataPersistenceProvider;
import org.opendaylight.controller.cluster.raft.base.messages.UpdateElectionTerm;
import org.slf4j.Logger;
@Mock
private DataPersistenceProvider mockPersistence;
- @SuppressWarnings("unchecked")
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
-
- doAnswer(new Answer<Void>() {
- @Override
- public Void answer(InvocationOnMock invocation) throws Exception {
- final Object[] args = invocation.getArguments();
- ((Procedure<Object>)args[1]).apply(args[0]);
- return null;
- }
- }).when(mockPersistence).persist(any(Object.class), any(Procedure.class));
}
@SuppressWarnings({ "rawtypes", "unchecked" })
package org.opendaylight.controller.cluster.raft;
import static org.junit.Assert.assertEquals;
-import static org.mockito.Mockito.any;
-import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.mock;
import akka.actor.ActorRef;
import akka.actor.Props;
super(builder.id, builder.peerAddresses, Optional.fromNullable(builder.config), PAYLOAD_VERSION);
state = new ArrayList<>();
this.actorDelegate = mock(RaftActor.class);
- doNothing().when(this.actorDelegate).onRecoveryComplete();
- doNothing().when(this.actorDelegate).onStateChanged();
- doNothing().when(this.actorDelegate).applyState(any(ActorRef.class), any(String.class), any(Object.class));
-
this.recoveryCohortDelegate = mock(RaftActorRecoveryCohort.class);
- doNothing().when(this.recoveryCohortDelegate).applyRecoverySnapshot(any(byte[].class));
-
this.snapshotCohortDelegate = mock(RaftActorSnapshotCohort.class);
- doNothing().when(this.snapshotCohortDelegate).applySnapshot(any(byte[].class));
- doNothing().when(this.snapshotCohortDelegate).createSnapshot(any(ActorRef.class));
if(builder.dataPersistenceProvider == null){
setPersistence(builder.persistent.isPresent() ? builder.persistent.get() : true);
*/
package org.opendaylight.controller.cluster.raft;
-import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.doAnswer;
-import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.verify;
import akka.japi.Procedure;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
import org.opendaylight.controller.cluster.DataPersistenceProvider;
import org.opendaylight.controller.cluster.PersistentDataProvider;
import org.opendaylight.controller.cluster.raft.protobuff.client.messages.Payload;
private RaftActorDelegatingPersistentDataProvider provider;
- @SuppressWarnings("unchecked")
@Before
- public void setup() throws Exception {
+ public void setup() {
MockitoAnnotations.initMocks(this);
doReturn(PERSISTENT_PAYLOAD).when(mockPersistentLogEntry).getData();
doReturn(NON_PERSISTENT_PAYLOAD).when(mockNonPersistentLogEntry).getData();
-
- doAnswer(new Answer<Void>() {
- @Override
- public Void answer(InvocationOnMock invocation) throws Exception {
- final Object[] args = invocation.getArguments();
- ((Procedure<Object>)args[1]).apply(args[0]);
- return null;
- }
- }).when(mockPersistentProvider).persist(any(Object.class), any(Procedure.class));
-
- doNothing().when(mockDelegateProvider).persist(any(Object.class), any(Procedure.class));
- doNothing().when(mockProcedure).apply(any(Object.class));
provider = new RaftActorDelegatingPersistentDataProvider(mockDelegateProvider, mockPersistentProvider);
}
*/
package org.opendaylight.controller.cluster.raft;
-import static org.mockito.Mockito.any;
-import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.timeout;
import static org.mockito.Mockito.verify;
-import akka.actor.ActorRef;
import akka.dispatch.Dispatchers;
import com.google.common.base.Function;
import org.junit.After;
}
private void setup() {
- doNothing().when(onComplete).onSuccess(any(ActorRef.class), any(ActorRef.class));
- doNothing().when(onComplete).onFailure(any(ActorRef.class), any(ActorRef.class));
-
String persistenceId = factory.generateActorId("leader-");
mockRaftActor = factory.<MockRaftActor>createTestActor(MockRaftActor.builder().id(persistenceId).config(
config).pauseLeaderFunction(pauseLeaderFunction).props().withDispatcher(Dispatchers.DefaultDispatcherId()),
import static org.junit.Assert.assertTrue;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyInt;
-import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
public void setup() {
MockitoAnnotations.initMocks(this);
- doNothing().when(mockCohort).startLogRecoveryBatch(any(int.class));
- doNothing().when(mockCohort).applyCurrentLogRecoveryBatch();
- doNothing().when(mockCohort).applyRecoverySnapshot(any(byte[].class));
- doNothing().when(mockCohort).appendRecoveredLogEntry(any(Payload.class));
- doReturn(null).when(mockCohort).getRestoreFromSnapshot();
- doReturn(true).when(mockPersistence).isRecoveryApplicable();
- doNothing().when(mockPersistence).deleteMessages(any(long.class));
- doNothing().when(mockPersistentProvider).deleteMessages(any(long.class));
- doNothing().when(mockPersistentProvider).deleteSnapshots(any(SnapshotSelectionCriteria.class));
- doNothing().when(mockPersistentProvider).persist(any(Object.class), any(Procedure.class));
-
context = new RaftActorContextImpl(null, null, localId, new ElectionTermImpl(mockPersistentProvider, "test", LOG),
-1, -1, Collections.<String,String>emptyMap(), configParams, mockPersistence, LOG);
+
support = new RaftActorRecoverySupport(context, mockBehavior , mockCohort);
+
+ doReturn(true).when(mockPersistence).isRecoveryApplicable();
+
context.setReplicatedLog(ReplicatedLogImpl.newInstance(context, mockBehavior));
}
import static org.mockito.Matchers.anyLong;
import static org.mockito.Matchers.eq;
import static org.mockito.Matchers.same;
-import static org.mockito.Mockito.any;
-import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.verify;
import akka.actor.ActorRef;
-import akka.japi.Procedure;
import akka.persistence.SaveSnapshotFailure;
import akka.persistence.SaveSnapshotSuccess;
import akka.persistence.SnapshotMetadata;
public void setup() {
MockitoAnnotations.initMocks(this);
- doNothing().when(mockSnapshotManager).setApplySnapshotProcedure(any(Procedure.class));
- doNothing().when(mockSnapshotManager).setCreateSnapshotCallable(any(Procedure.class));
- doNothing().when(mockSnapshotManager).apply(any(ApplySnapshot.class));
- doNothing().when(mockSnapshotManager).commit(any(long.class), any(RaftActorBehavior.class));
- doNothing().when(mockSnapshotManager).persist(any(byte[].class), any(RaftActorBehavior.class), any(long.class));
- doNothing().when(mockSnapshotManager).rollback();
-
context = new RaftActorContextImpl(mockRaftActorRef, null, "test",
new ElectionTermImpl(mockPersistence, "test", LOG),
-1, -1, Collections.<String,String>emptyMap(), configParams, mockPersistence, LOG) {
import static org.mockito.Matchers.anyObject;
import static org.mockito.Matchers.eq;
import static org.mockito.Matchers.same;
-import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import akka.persistence.SaveSnapshotSuccess;
import akka.persistence.SnapshotMetadata;
import akka.persistence.SnapshotOffer;
-import akka.persistence.SnapshotSelectionCriteria;
import akka.testkit.JavaTestKit;
import akka.testkit.TestActorRef;
import com.google.common.base.Optional;
factory = new TestActorFactory(getSystem());
}
- @SuppressWarnings("unchecked")
- private static DataPersistenceProvider mockPersistenceProvider() {
- final DataPersistenceProvider dataPersistenceProvider = mock(DataPersistenceProvider.class);
- doReturn(false).when(dataPersistenceProvider).isRecoveryApplicable();
- doReturn(0L).when(dataPersistenceProvider).getLastSequenceNumber();
- doNothing().when(dataPersistenceProvider).saveSnapshot(any(Object.class));
- doNothing().when(dataPersistenceProvider).persist(any(Object.class), any(Procedure.class));
- doNothing().when(dataPersistenceProvider).deleteSnapshots(any(SnapshotSelectionCriteria.class));
- doNothing().when(dataPersistenceProvider).deleteMessages(0L);
-
- return dataPersistenceProvider;
- }
-
@After
public void tearDown() throws Exception {
factory.close();
mockRaftActor.waitForRecoveryComplete();
RaftActorRecoverySupport mockSupport = mock(RaftActorRecoverySupport.class);
- doReturn(false).when(mockSupport).handleRecoveryMessage(any(Object.class), any(PersistentDataProvider.class));
- mockRaftActor.setRaftActorRecoverySupport(mockSupport);
+ mockRaftActor.setRaftActorRecoverySupport(mockSupport );
Snapshot snapshot = Snapshot.create(new byte[]{1}, Collections.<ReplicatedLogEntry>emptyList(), 3, 1, 3, 1);
SnapshotOffer snapshotOffer = new SnapshotOffer(new SnapshotMetadata("test", 6, 12345), snapshot);
config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS));
- DataPersistenceProvider dataPersistenceProvider = mockPersistenceProvider();
+ DataPersistenceProvider dataPersistenceProvider = mock(DataPersistenceProvider.class);
TestActorRef<MockRaftActor> mockActorRef = factory.createTestActor(MockRaftActor.props(persistenceId,
Collections.<String, String>emptyMap(), config, dataPersistenceProvider), persistenceId);
config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS));
- DataPersistenceProvider dataPersistenceProvider = mockPersistenceProvider();
+ DataPersistenceProvider dataPersistenceProvider = mock(DataPersistenceProvider.class);
TestActorRef<MockRaftActor> mockActorRef = factory.createTestActor(MockRaftActor.props(persistenceId,
Collections.<String, String>emptyMap(), config, dataPersistenceProvider), persistenceId);
config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS));
config.setIsolatedLeaderCheckInterval(new FiniteDuration(1, TimeUnit.DAYS));
- DataPersistenceProvider dataPersistenceProvider = mockPersistenceProvider();
+ DataPersistenceProvider dataPersistenceProvider = mock(DataPersistenceProvider.class);
Map<String, String> peerAddresses = new HashMap<>();
peerAddresses.put(follower1Id, followerActor1.path().toString());
config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS));
config.setIsolatedLeaderCheckInterval(new FiniteDuration(1, TimeUnit.DAYS));
- DataPersistenceProvider dataPersistenceProvider = mockPersistenceProvider();
+ DataPersistenceProvider dataPersistenceProvider = mock(DataPersistenceProvider.class);
Map<String, String> peerAddresses = new HashMap<>();
peerAddresses.put(leaderId, leaderActor1.path().toString());
config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS));
config.setIsolatedLeaderCheckInterval(new FiniteDuration(1, TimeUnit.DAYS));
- DataPersistenceProvider dataPersistenceProvider = mockPersistenceProvider();
+ DataPersistenceProvider dataPersistenceProvider = mock(DataPersistenceProvider.class);
Map<String, String> peerAddresses = new HashMap<>();
peerAddresses.put(follower1Id, followerActor1.path().toString());
String persistenceId = factory.generateActorId("follower-");
ImmutableMap<String, String> peerAddresses =
ImmutableMap.<String, String>builder().put("member1", "address").build();
- DataPersistenceProvider dataPersistenceProvider = mockPersistenceProvider();
+ DataPersistenceProvider dataPersistenceProvider = mock(DataPersistenceProvider.class);
TestActorRef<MockRaftActor> actorRef = factory.createTestActor(
MockRaftActor.props(persistenceId, peerAddresses, emptyConfig, dataPersistenceProvider), persistenceId);
verify(mockRaftActor.snapshotCohortDelegate, timeout(5000)).createSnapshot(any(ActorRef.class));
mockRaftActor.snapshotCohortDelegate = mock(RaftActorSnapshotCohort.class);
- doNothing().when(mockRaftActor.snapshotCohortDelegate).createSnapshot(any(ActorRef.class));
raftActorRef.tell(GetSnapshot.INSTANCE, kit.getRef());
mockRaftActor.getSnapshotMessageSupport().setSnapshotReplyActorTimeout(Duration.create(200, TimeUnit.MILLISECONDS));
reset(mockRaftActor.snapshotCohortDelegate);
- doNothing().when(mockRaftActor.snapshotCohortDelegate).createSnapshot(any(ActorRef.class));
raftActorRef.tell(GetSnapshot.INSTANCE, kit.getRef());
Failure failure = kit.expectMsgClass(akka.actor.Status.Failure.class);
mockRaftActor.setPersistence(false);
reset(mockRaftActor.snapshotCohortDelegate);
- doNothing().when(mockRaftActor.snapshotCohortDelegate).createSnapshot(any(ActorRef.class));
raftActorRef.tell(GetSnapshot.INSTANCE, kit.getRef());
reply = kit.expectMsgClass(GetSnapshotReply.class);
package org.opendaylight.controller.cluster.raft;
import static org.junit.Assert.assertEquals;
-import static org.mockito.Matchers.any;
import static org.mockito.Matchers.same;
-import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.reset;
import static org.mockito.Mockito.verify;
public void setup() {
MockitoAnnotations.initMocks(this);
- doNothing().when(mockPersistence).persist(any(Object.class), any(Procedure.class));
-
context = new RaftActorContextImpl(null, null, "test",
new ElectionTermImpl(mockPersistence, "test", LOG),
-1, -1, Collections.<String,String>emptyMap(), configParams, mockPersistence, LOG);
reset(mockPersistence);
- doNothing().when(mockPersistence).persist(any(MockReplicatedLogEntry.class), any(Procedure.class));
-
Procedure<ReplicatedLogEntry> mockCallback = Mockito.mock(Procedure.class);
- doNothing().when(mockCallback).apply(logEntry);
log.appendAndPersist(logEntry, mockCallback);
verifyPersist(logEntry);
reset(mockPersistence);
- doNothing().when(mockPersistence).persist(any(MockReplicatedLogEntry.class), any(Procedure.class));
-
log.appendAndPersist(logEntry2);
verifyPersist(logEntry2);
reset(mockPersistence);
- doNothing().when(mockPersistence).persist(any(MockReplicatedLogEntry.class), any(Procedure.class));
-
logEntry = new MockReplicatedLogEntry(1, 3, new MockPayload("3", 5));
log.appendAndPersist(logEntry);
import static org.junit.Assert.assertTrue;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyLong;
-import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.mock;
private TestActorRef<MessageCollectorActor> actorRef;
@Before
- public void setUp() throws Exception {
+ public void setUp(){
MockitoAnnotations.initMocks(this);
doReturn(false).when(mockRaftActorContext).hasFollowers();
doReturn("123").when(mockRaftActorContext).getId();
doReturn(mockDataPersistenceProvider).when(mockRaftActorContext).getPersistenceProvider();
doReturn("123").when(mockRaftActorBehavior).getLeaderId();
- doReturn(null).when(mockRaftActorBehavior).handleMessage(any(ActorRef.class), any(Object.class));
- doReturn(0L).when(mockRaftActorBehavior).getReplicatedToAllIndex();
doReturn(mockElectionTerm).when(mockRaftActorContext).getTermInformation();
doReturn(5L).when(mockElectionTerm).getCurrentTerm();
actorRef = factory.createTestActor(MessageCollectorActor.props(), factory.generateActorId("test-"));
doReturn(actorRef).when(mockRaftActorContext).getActor();
- doReturn(0L).when(mockRaftActorContext).getLastApplied();
- doReturn(null).when(mockRaftActorContext).getPeerServerInfo(any(boolean.class));
- doReturn(null).when(mockReplicatedLog).get(any(long.class));
- doReturn(null).when(mockReplicatedLog).getFrom(any(long.class));
- doReturn(0).when(mockReplicatedLog).dataSize();
- doReturn(0L).when(mockReplicatedLog).size();
- doReturn(0L).when(mockReplicatedLog).getSnapshotIndex();
- doReturn(0L).when(mockReplicatedLog).getSnapshotTerm();
- doNothing().when(mockReplicatedLog).snapshotPreCommit(any(long.class), any(long.class));
- doNothing().when(mockReplicatedLog).snapshotRollback();
- doNothing().when(mockReplicatedLog).snapshotCommit();
- doNothing().when(mockRaftActorBehavior).setReplicatedToAllIndex(any(long.class));
-
- doReturn(0L).when(mockDataPersistenceProvider).getLastSequenceNumber();
- doNothing().when(mockDataPersistenceProvider).saveSnapshot(any(Object.class));
- doNothing().when(mockDataPersistenceProvider).persist(any(Object.class), any(Procedure.class));
- doNothing().when(mockDataPersistenceProvider).deleteSnapshots(any(SnapshotSelectionCriteria.class));
- doNothing().when(mockDataPersistenceProvider).deleteMessages(any(long.class));
-
- doNothing().when(mockProcedure).apply(null);
snapshotManager.setCreateSnapshotCallable(mockProcedure);
}
public void testBecomeLeaderOnReceivingMajorityVotesWithNonVotingPeers(){
ElectionTerm mockElectionTerm = Mockito.mock(ElectionTerm.class);
Mockito.doReturn(1L).when(mockElectionTerm).getCurrentTerm();
- Mockito.doNothing().when(mockElectionTerm).updateAndPersist(Mockito.any(long.class), Mockito.any(String.class));
-
RaftActorContext raftActorContext = new RaftActorContextImpl(candidateActor, candidateActor.actorContext(),
"candidate", mockElectionTerm, -1, -1, setupPeers(4), new DefaultConfigParamsImpl(),
new NonPersistentDataProvider(), LOG);
// Send an unknown message so that the state of the RaftActor remains unchanged
RaftActorBehavior expected = behavior.handleMessage(candidateActor, "unknown");
- assertTrue(expected instanceof Candidate);
RaftActorBehavior raftBehavior = behavior.handleMessage(candidateActor, appendEntries);
return new MockRaftActorContext("candidate", getSystem(), candidateActor);
}
- @SuppressWarnings("unchecked")
private Map<String, String> setupPeers(int count) {
Map<String, String> peerMap = new HashMap<>();
peerActors = new TestActorRef[count];
// Send an append entry
AppendEntries appendEntries = mock(AppendEntries.class);
doReturn(context.getTermInformation().getCurrentTerm()).when(appendEntries).getTerm();
- doReturn(null).when(appendEntries).getEntries();
follower.handleMessage(leaderActor, appendEntries);
MockRaftActorContext context = createActorContext();
follower = createBehavior(context);
follower.handleMessage(leaderActor, new RaftRPC() {
- private static final long serialVersionUID = 1L;
-
@Override
public long getTerm() {
return 100;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
-import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
MessageCollectorActor.clearMessages(followerActor);
RaftActorLeadershipTransferCohort mockTransferCohort = mock(RaftActorLeadershipTransferCohort.class);
- doNothing().when(mockTransferCohort).transferComplete();
leader.transferLeadership(mockTransferCohort);
verify(mockTransferCohort, never()).transferComplete();
MessageCollectorActor.clearMessages(followerActor);
RaftActorLeadershipTransferCohort mockTransferCohort = mock(RaftActorLeadershipTransferCohort.class);
- doNothing().when(mockTransferCohort).transferComplete();
leader.transferLeadership(mockTransferCohort);
verify(mockTransferCohort, never()).transferComplete();
MessageCollectorActor.clearMessages(followerActor);
RaftActorLeadershipTransferCohort mockTransferCohort = mock(RaftActorLeadershipTransferCohort.class);
- doNothing().when(mockTransferCohort).transferComplete();
leader.transferLeadership(mockTransferCohort);
verify(mockTransferCohort, never()).transferComplete();
MessageCollectorActor.clearMessages(followerActor);
RaftActorLeadershipTransferCohort mockTransferCohort = mock(RaftActorLeadershipTransferCohort.class);
- doNothing().when(mockTransferCohort).abortTransfer();
leader.transferLeadership(mockTransferCohort);
verify(mockTransferCohort, never()).transferComplete();