import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import akka.actor.ActorSystem;
import akka.testkit.TestProbe;
import com.google.common.testing.FakeTicker;
-import java.util.Optional;
+import java.util.OptionalLong;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.TimeUnit;
import java.util.function.Consumer;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
+import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.controller.cluster.access.ABIVersion;
-import org.opendaylight.controller.cluster.access.concepts.AbstractRequestFailureProxy;
-import org.opendaylight.controller.cluster.access.concepts.AbstractRequestProxy;
import org.opendaylight.controller.cluster.access.concepts.FailureEnvelope;
import org.opendaylight.controller.cluster.access.concepts.Request;
import org.opendaylight.controller.cluster.access.concepts.RequestEnvelope;
import org.opendaylight.controller.cluster.access.concepts.RequestException;
import org.opendaylight.controller.cluster.access.concepts.RequestFailure;
import org.opendaylight.controller.cluster.access.concepts.Response;
+import org.opendaylight.controller.cluster.messaging.MessageSlicer;
import org.opendaylight.yangtools.concepts.WritableIdentifier;
import scala.concurrent.duration.FiniteDuration;
/**
* Test suite covering logic contained in {@link ConnectingClientConnection}. It assumes {@link ConnectionEntryTest}
* passes.
- *
- * @author Robert Varga
*/
+@RunWith(MockitoJUnitRunner.class)
public class ConnectingClientConnectionTest {
private static class MockFailure extends RequestFailure<WritableIdentifier, MockFailure> {
private static final long serialVersionUID = 1L;
}
@Override
- protected AbstractRequestFailureProxy<WritableIdentifier, MockFailure> externalizableProxy(
- final ABIVersion version) {
+ protected SerialForm<WritableIdentifier, MockFailure> externalizableProxy(final ABIVersion version) {
return null;
}
}
@Override
- protected AbstractRequestProxy<WritableIdentifier, MockRequest> externalizableProxy(final ABIVersion version) {
+ protected Request.SerialForm<WritableIdentifier, MockRequest> externalizableProxy(final ABIVersion version) {
return null;
}
@Before
public void setup() {
- MockitoAnnotations.initMocks(this);
-
doNothing().when(mockCallback).accept(any(MockFailure.class));
ticker = new FakeTicker();
ticker.advance(ThreadLocalRandom.current().nextLong());
doReturn(ticker).when(mockContext).ticker();
+ final ClientActorConfig mockConfig = AccessClientUtil.newMockClientActorConfig();
+ doReturn(mockConfig).when(mockContext).config();
+
+ doReturn(mock(MessageSlicer.class)).when(mockContext).messageSlicer();
+
mockActor = TestProbe.apply(actorSystem);
- mockBackendInfo = new BackendInfo(mockActor.ref(), 0, ABIVersion.current(), 5);
+ mockBackendInfo = new BackendInfo(mockActor.ref(), "test", 0, ABIVersion.current(), 5);
mockRequest = new MockRequest(mockIdentifier, mockReplyTo);
mockRequest2 = new MockRequest(mockIdentifier, mockReplyTo);
mockResponse = mockRequest.toRequestFailure(mockCause);
mockResponseEnvelope = new FailureEnvelope(mockResponse, 0, 0, 0);
mockCookie = ThreadLocalRandom.current().nextLong();
- queue = new ConnectingClientConnection<>(mockContext, mockCookie);
+ queue = new ConnectingClientConnection<>(mockContext, mockCookie, mockBackendInfo.getName());
}
@After
@Test
public void testSendRequestNeedsBackend() {
queue.sendRequest(mockRequest, mockCallback);
- final Optional<FiniteDuration> ret = queue.checkTimeout(ticker.read());
+ final OptionalLong ret = queue.checkTimeout(ticker.read());
assertNotNull(ret);
assertTrue(ret.isPresent());
}
setupBackend();
queue.sendRequest(mockRequest, mockCallback);
- final Optional<FiniteDuration> ret = queue.checkTimeout(ticker.read());
+ final OptionalLong ret = queue.checkTimeout(ticker.read());
assertNotNull(ret);
assertTrue(ret.isPresent());
assertTransmit(mockRequest, 0);
}
@Test
- public void testRunTimeoutEmpty() throws NoProgressException {
- Optional<FiniteDuration> ret = queue.checkTimeout(ticker.read());
+ public void testRunTimeoutEmpty() {
+ OptionalLong ret = queue.checkTimeout(ticker.read());
assertNotNull(ret);
assertFalse(ret.isPresent());
}
@Test
- public void testRunTimeoutWithoutShift() throws NoProgressException {
+ public void testRunTimeoutWithoutShift() {
queue.sendRequest(mockRequest, mockCallback);
- Optional<FiniteDuration> ret = queue.checkTimeout(ticker.read());
+ OptionalLong ret = queue.checkTimeout(ticker.read());
assertNotNull(ret);
assertTrue(ret.isPresent());
}
@Test
- public void testRunTimeoutWithTimeoutLess() throws NoProgressException {
+ public void testRunTimeoutWithTimeoutLess() {
queue.sendRequest(mockRequest, mockCallback);
- ticker.advance(AbstractClientConnection.REQUEST_TIMEOUT_NANOS - 1);
+ ticker.advance(AbstractClientConnection.DEFAULT_BACKEND_ALIVE_TIMEOUT_NANOS - 1);
- Optional<FiniteDuration> ret = queue.checkTimeout(ticker.read());
+ OptionalLong ret = queue.checkTimeout(ticker.read());
assertNotNull(ret);
assertTrue(ret.isPresent());
}
@Test
- public void testRunTimeoutWithTimeoutExact() throws NoProgressException {
+ public void testRunTimeoutWithTimeoutExact() {
setupBackend();
queue.sendRequest(mockRequest, mockCallback);
- ticker.advance(AbstractClientConnection.REQUEST_TIMEOUT_NANOS);
+ ticker.advance(AbstractClientConnection.DEFAULT_BACKEND_ALIVE_TIMEOUT_NANOS);
- Optional<FiniteDuration> ret = queue.checkTimeout(ticker.read());
+ OptionalLong ret = queue.checkTimeout(ticker.read());
assertNull(ret);
}
@Test
- public void testRunTimeoutWithTimeoutMore() throws NoProgressException {
+ public void testRunTimeoutWithTimeoutMore() {
setupBackend();
queue.sendRequest(mockRequest, mockCallback);
- ticker.advance(AbstractClientConnection.REQUEST_TIMEOUT_NANOS + 1);
+ ticker.advance(AbstractClientConnection.DEFAULT_BACKEND_ALIVE_TIMEOUT_NANOS + 1);
- Optional<FiniteDuration> ret = queue.checkTimeout(ticker.read());
- assertNull(ret);
+ assertNull(queue.checkTimeout(ticker.read()));
}
@SuppressWarnings({ "rawtypes", "unchecked" })
- public void testRunTimeoutWithoutProgressExact() throws NoProgressException {
+ public void testRunTimeoutWithoutProgressExact() {
queue.sendRequest(mockRequest, mockCallback);
- ticker.advance(AbstractClientConnection.NO_PROGRESS_TIMEOUT_NANOS);
+ ticker.advance(AbstractClientConnection.DEFAULT_NO_PROGRESS_TIMEOUT_NANOS);
// Kaboom
queue.runTimer((ClientActorBehavior) mockBehavior);
}
@SuppressWarnings({ "rawtypes", "unchecked" })
- public void testRunTimeoutWithoutProgressMore() throws NoProgressException {
+ public void testRunTimeoutWithoutProgressMore() {
queue.sendRequest(mockRequest, mockCallback);
- ticker.advance(AbstractClientConnection.NO_PROGRESS_TIMEOUT_NANOS + 1);
+ ticker.advance(AbstractClientConnection.DEFAULT_NO_PROGRESS_TIMEOUT_NANOS + 1);
// Kaboom
queue.runTimer((ClientActorBehavior) mockBehavior);
}
@Test
- public void testRunTimeoutEmptyWithoutProgressExact() throws NoProgressException {
- ticker.advance(AbstractClientConnection.NO_PROGRESS_TIMEOUT_NANOS);
+ public void testRunTimeoutEmptyWithoutProgressExact() {
+ ticker.advance(AbstractClientConnection.DEFAULT_NO_PROGRESS_TIMEOUT_NANOS);
// No problem
- Optional<FiniteDuration> ret = queue.checkTimeout(ticker.read());
- assertNotNull(ret);
- assertFalse(ret.isPresent());
+ assertEquals(OptionalLong.empty(), queue.checkTimeout(ticker.read()));
}
@Test
- public void testRunTimeoutEmptyWithoutProgressMore() throws NoProgressException {
- ticker.advance(AbstractClientConnection.NO_PROGRESS_TIMEOUT_NANOS + 1);
+ public void testRunTimeoutEmptyWithoutProgressMore() {
+ ticker.advance(AbstractClientConnection.DEFAULT_NO_PROGRESS_TIMEOUT_NANOS + 1);
// No problem
- Optional<FiniteDuration> ret = queue.checkTimeout(ticker.read());
- assertNotNull(ret);
- assertFalse(ret.isPresent());
+ assertEquals(OptionalLong.empty(), queue.checkTimeout(ticker.read()));
}
@Test
}
@Test
- public void testProgressRecord() throws NoProgressException {
+ public void testProgressRecord() {
setupBackend();
queue.sendRequest(mockRequest, mockCallback);
queue.sendRequest(mockRequest2, mockCallback);
queue.receiveResponse(mockResponseEnvelope);
- ticker.advance(AbstractClientConnection.NO_PROGRESS_TIMEOUT_NANOS - 11);
+ ticker.advance(AbstractClientConnection.DEFAULT_NO_PROGRESS_TIMEOUT_NANOS - 11);
- Optional<FiniteDuration> ret = queue.checkTimeout(ticker.read());
- assertNull(ret);
+ assertNull(queue.checkTimeout(ticker.read()));
}
private void setupBackend() {
- final ConnectedClientConnection<?> newConn = new ConnectedClientConnection<>(mockContext, mockCookie,
- mockBackendInfo);
- queue.setForwarder(new SimpleReconnectForwarder(newConn));
- queue = newConn;
+ final ConnectingClientConnection<BackendInfo> connectingConn =
+ new ConnectingClientConnection<>(mockContext, mockCookie, "test");
+ final ConnectedClientConnection<BackendInfo> connectedConn =
+ new ConnectedClientConnection<>(connectingConn, mockBackendInfo);
+ queue.setForwarder(new SimpleReconnectForwarder(connectedConn));
+ queue = connectedConn;
}
private void assertTransmit(final Request<?, ?> expected, final long sequence) {