package org.opendaylight.controller.cluster.access.client;
import static org.hamcrest.CoreMatchers.hasItems;
-import static org.mockito.Matchers.anyLong;
-import static org.mockito.Matchers.argThat;
-import static org.mockito.Matchers.isA;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.isA;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.timeout;
import static org.mockito.Mockito.verify;
import akka.actor.ActorRef;
import akka.actor.ActorSystem;
-import akka.testkit.JavaTestKit;
import akka.testkit.TestProbe;
-import java.util.Optional;
+import akka.testkit.javadsl.TestKit;
+import com.google.common.collect.Iterables;
+import java.util.OptionalLong;
import java.util.function.Consumer;
import org.junit.After;
-import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
-import org.mockito.MockitoAnnotations;
import org.opendaylight.controller.cluster.access.commands.AbortLocalTransactionRequest;
import org.opendaylight.controller.cluster.access.commands.TransactionAbortSuccess;
import org.opendaylight.controller.cluster.access.commands.TransactionFailure;
protected TestProbe replyToProbe;
@Before
- public void setUp() throws Exception {
- MockitoAnnotations.initMocks(this);
+ public void setUp() {
system = ActorSystem.apply();
backendProbe = new TestProbe(system);
contextProbe = new TestProbe(system);
- context = new ClientActorContext(contextProbe.ref(), system.scheduler(), system.dispatcher(),
- PERSISTENCE_ID, CLIENT_ID);
+ context = new ClientActorContext(contextProbe.ref(), PERSISTENCE_ID, system,
+ CLIENT_ID, AccessClientUtil.newMockClientActorConfig());
replyToProbe = new TestProbe(system);
connection = createConnection();
}
protected abstract T createConnection();
@Test
- public void testLocalActor() throws Exception {
- Assert.assertEquals(contextProbe.ref(), connection.localActor());
+ public void testLocalActor() {
+ assertEquals(contextProbe.ref(), connection.localActor());
}
@Test
- public abstract void testReconnectConnection() throws Exception;
+ public abstract void testReconnectConnection();
@Test
- public void testPoison() throws Exception {
+ public void testPoison() {
final Consumer<Response<?, ?>> callback = mock(Consumer.class);
final Request<?, ?> request = createRequest(replyToProbe.ref());
final ConnectionEntry entry = new ConnectionEntry(request, callback, 0L);
}
@Test
- public void testSendRequestReceiveResponse() throws Exception {
+ public void testSendRequestReceiveResponse() {
final Consumer<Response<?, ?>> callback = mock(Consumer.class);
final Request<?, ?> request = createRequest(replyToProbe.ref());
connection.sendRequest(request, callback);
final RequestEnvelope requestEnvelope = backendProbe.expectMsgClass(RequestEnvelope.class);
- Assert.assertEquals(request, requestEnvelope.getMessage());
+ assertEquals(request, requestEnvelope.getMessage());
final LocalHistoryIdentifier historyId = new LocalHistoryIdentifier(CLIENT_ID, 0L);
final RequestSuccess<?, ?> message = new TransactionAbortSuccess(new TransactionIdentifier(historyId, 0L), 0L);
final ResponseEnvelope<?> envelope = new SuccessEnvelope(message, 0L, 0L, 0L);
}
@Test
- public void testRun() throws Exception {
+ public void testRun() {
final ClientActorBehavior<U> behavior = mock(ClientActorBehavior.class);
- Assert.assertSame(behavior, connection.runTimer(behavior));
+ assertSame(behavior, connection.runTimer(behavior));
}
@Test
- public void testCheckTimeoutEmptyQueue() throws Exception {
- final Optional<Long> timeout = connection.checkTimeout(context.ticker().read());
- Assert.assertFalse(timeout.isPresent());
+ public void testCheckTimeoutEmptyQueue() {
+ assertEquals(OptionalLong.empty(), connection.checkTimeout(context.ticker().read()));
}
@Test
- public void testCheckTimeoutConnectionTimeouted() throws Exception {
- final Consumer<Response<?, ?>> callback = mock(Consumer.class);
- connection.sendRequest(createRequest(replyToProbe.ref()), callback);
- final long now = context.ticker().read() + ConnectedClientConnection.BACKEND_ALIVE_TIMEOUT_NANOS;
- final Optional<Long> timeout = connection.checkTimeout(now);
- Assert.assertNull(timeout);
- }
-
- @Test
- public void testCheckTimeout() throws Exception {
+ public void testCheckTimeout() {
final Consumer<Response<?, ?>> callback = mock(Consumer.class);
connection.sendRequest(createRequest(replyToProbe.ref()), callback);
final long now = context.ticker().read();
- final Optional<Long> timeout = connection.checkTimeout(now);
- Assert.assertTrue(timeout.isPresent());
+ final OptionalLong timeout = connection.checkTimeout(now);
+ assertTrue(timeout.isPresent());
}
@Test
- public void testReplay() throws Exception {
+ public void testReplay() {
final Consumer<Response<?, ?>> callback = mock(Consumer.class);
final Request<?, ?> request1 = createRequest(replyToProbe.ref());
final Request<?, ?> request2 = createRequest(replyToProbe.ref());
connection.sendRequest(request1, callback);
connection.sendRequest(request2, callback);
final Iterable<ConnectionEntry> entries = connection.startReplay();
- Assert.assertThat(entries, hasItems(entryWithRequest(request1), entryWithRequest(request2)));
+ assertThat(entries, hasItems(entryWithRequest(request1), entryWithRequest(request2)));
+ assertEquals(2, Iterables.size(entries));
+ Iterables.removeIf(entries, e -> true);
final ReconnectForwarder forwarder = mock(ReconnectForwarder.class);
connection.finishReplay(forwarder);
- verify(forwarder).forwardEntry(argThat(entryWithRequest(request1)), anyLong());
- verify(forwarder).forwardEntry(argThat(entryWithRequest(request2)), anyLong());
}
@After
- public void tearDown() throws Exception {
- JavaTestKit.shutdownActorSystem(system);
+ public void tearDown() {
+ TestKit.shutdownActorSystem(system);
}
protected Request<?, ?> createRequest(final ActorRef replyTo) {
return new AbortLocalTransactionRequest(identifier, replyTo);
}
-}
\ No newline at end of file
+}
Code Review / controller.git / blobdiff