import static org.mockito.Matchers.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 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;
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);
mockRequest = new MockRequest(mockIdentifier, mockReplyTo);
}
@Test
- public void testRunTimeoutEmpty() throws NoProgressException {
+ public void testRunTimeoutEmpty() {
Optional<Long> ret = queue.checkTimeout(ticker.read());
assertNotNull(ret);
assertFalse(ret.isPresent());
}
@Test
- public void testRunTimeoutWithoutShift() throws NoProgressException {
+ public void testRunTimeoutWithoutShift() {
queue.sendRequest(mockRequest, mockCallback);
Optional<Long> ret = queue.checkTimeout(ticker.read());
assertNotNull(ret);
}
@Test
- public void testRunTimeoutWithTimeoutLess() throws NoProgressException {
+ public void testRunTimeoutWithTimeoutLess() {
queue.sendRequest(mockRequest, mockCallback);
- ticker.advance(AbstractClientConnection.BACKEND_ALIVE_TIMEOUT_NANOS - 1);
+ ticker.advance(AbstractClientConnection.DEFAULT_BACKEND_ALIVE_TIMEOUT_NANOS - 1);
Optional<Long> ret = queue.checkTimeout(ticker.read());
assertNotNull(ret);
}
@Test
- public void testRunTimeoutWithTimeoutExact() throws NoProgressException {
+ public void testRunTimeoutWithTimeoutExact() {
setupBackend();
queue.sendRequest(mockRequest, mockCallback);
- ticker.advance(AbstractClientConnection.BACKEND_ALIVE_TIMEOUT_NANOS);
+ ticker.advance(AbstractClientConnection.DEFAULT_BACKEND_ALIVE_TIMEOUT_NANOS);
Optional<Long> ret = queue.checkTimeout(ticker.read());
assertNull(ret);
}
@Test
- public void testRunTimeoutWithTimeoutMore() throws NoProgressException {
+ public void testRunTimeoutWithTimeoutMore() {
setupBackend();
queue.sendRequest(mockRequest, mockCallback);
- ticker.advance(AbstractClientConnection.BACKEND_ALIVE_TIMEOUT_NANOS + 1);
+ ticker.advance(AbstractClientConnection.DEFAULT_BACKEND_ALIVE_TIMEOUT_NANOS + 1);
Optional<Long> ret = queue.checkTimeout(ticker.read());
assertNull(ret);
}
@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<Long> ret = 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<Long> ret = queue.checkTimeout(ticker.read());
}
@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<Long> ret = queue.checkTimeout(ticker.read());
assertNull(ret);
}
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);
+ final ConnectedClientConnection<BackendInfo> connectedConn =
+ new ConnectedClientConnection<>(connectingConn, mockBackendInfo);
+ queue.setForwarder(new SimpleReconnectForwarder(connectedConn));
+ queue = connectedConn;
}
private void assertTransmit(final Request<?, ?> expected, final long sequence) {