X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fcds-access-client%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fcluster%2Faccess%2Fclient%2FConnectingClientConnectionTest.java;h=d566e0ec3b4f515903fa8894862bae9bb978a33e;hp=2d5b696271e13869262be29c60eb953c0ce55871;hb=94814a5aaa12aa5d72a7b98042d0d48bbcd92fc6;hpb=cd2a6fa0d8fa6281be28d3c7b9828ecf4e932811 diff --git a/opendaylight/md-sal/cds-access-client/src/test/java/org/opendaylight/controller/cluster/access/client/ConnectingClientConnectionTest.java b/opendaylight/md-sal/cds-access-client/src/test/java/org/opendaylight/controller/cluster/access/client/ConnectingClientConnectionTest.java index 2d5b696271..d566e0ec3b 100644 --- a/opendaylight/md-sal/cds-access-client/src/test/java/org/opendaylight/controller/cluster/access/client/ConnectingClientConnectionTest.java +++ b/opendaylight/md-sal/cds-access-client/src/test/java/org/opendaylight/controller/cluster/access/client/ConnectingClientConnectionTest.java @@ -13,16 +13,18 @@ import static org.junit.Assert.assertNotNull; 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.ActorRef; import akka.actor.ActorSystem; import akka.testkit.TestProbe; -import java.util.Optional; +import com.google.common.testing.FakeTicker; +import java.util.OptionalLong; import java.util.concurrent.ThreadLocalRandom; import java.util.concurrent.TimeUnit; import java.util.function.Consumer; @@ -31,9 +33,10 @@ import org.junit.AfterClass; 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; @@ -43,16 +46,15 @@ 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.common.actor.TestTicker; +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 { private static final long serialVersionUID = 1L; @@ -109,7 +111,7 @@ public class ConnectingClientConnectionTest { @Mock private ClientActorContext mockContext; - private TestTicker ticker; + private FakeTicker ticker; private BackendInfo mockBackendInfo; private MockRequest mockRequest; private MockRequest mockRequest2; @@ -134,23 +136,26 @@ public class ConnectingClientConnectionTest { @Before public void setup() { - MockitoAnnotations.initMocks(this); - doNothing().when(mockCallback).accept(any(MockFailure.class)); - ticker = new TestTicker(); - ticker.increment(ThreadLocalRandom.current().nextLong()); + 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 @@ -191,7 +196,7 @@ public class ConnectingClientConnectionTest { @Test public void testSendRequestNeedsBackend() { queue.sendRequest(mockRequest, mockCallback); - final Optional ret = queue.checkTimeout(ticker.read()); + final OptionalLong ret = queue.checkTimeout(ticker.read()); assertNotNull(ret); assertTrue(ret.isPresent()); } @@ -207,67 +212,66 @@ public class ConnectingClientConnectionTest { setupBackend(); queue.sendRequest(mockRequest, mockCallback); - final Optional 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 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 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.increment(AbstractClientConnection.REQUEST_TIMEOUT_NANOS - 1); + ticker.advance(AbstractClientConnection.DEFAULT_BACKEND_ALIVE_TIMEOUT_NANOS - 1); - Optional 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.increment(AbstractClientConnection.REQUEST_TIMEOUT_NANOS); + ticker.advance(AbstractClientConnection.DEFAULT_BACKEND_ALIVE_TIMEOUT_NANOS); - Optional 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.increment(AbstractClientConnection.REQUEST_TIMEOUT_NANOS + 1); + ticker.advance(AbstractClientConnection.DEFAULT_BACKEND_ALIVE_TIMEOUT_NANOS + 1); - Optional 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.increment(AbstractClientConnection.NO_PROGRESS_TIMEOUT_NANOS); + ticker.advance(AbstractClientConnection.DEFAULT_NO_PROGRESS_TIMEOUT_NANOS); // Kaboom queue.runTimer((ClientActorBehavior) mockBehavior); @@ -275,10 +279,10 @@ public class ConnectingClientConnectionTest { } @SuppressWarnings({ "rawtypes", "unchecked" }) - public void testRunTimeoutWithoutProgressMore() throws NoProgressException { + public void testRunTimeoutWithoutProgressMore() { queue.sendRequest(mockRequest, mockCallback); - ticker.increment(AbstractClientConnection.NO_PROGRESS_TIMEOUT_NANOS + 1); + ticker.advance(AbstractClientConnection.DEFAULT_NO_PROGRESS_TIMEOUT_NANOS + 1); // Kaboom queue.runTimer((ClientActorBehavior) mockBehavior); @@ -286,23 +290,19 @@ public class ConnectingClientConnectionTest { } @Test - public void testRunTimeoutEmptyWithoutProgressExact() throws NoProgressException { - ticker.increment(AbstractClientConnection.NO_PROGRESS_TIMEOUT_NANOS); + public void testRunTimeoutEmptyWithoutProgressExact() { + ticker.advance(AbstractClientConnection.DEFAULT_NO_PROGRESS_TIMEOUT_NANOS); // No problem - Optional ret = queue.checkTimeout(ticker.read()); - assertNotNull(ret); - assertFalse(ret.isPresent()); + assertEquals(OptionalLong.empty(), queue.checkTimeout(ticker.read())); } @Test - public void testRunTimeoutEmptyWithoutProgressMore() throws NoProgressException { - ticker.increment(AbstractClientConnection.NO_PROGRESS_TIMEOUT_NANOS + 1); + public void testRunTimeoutEmptyWithoutProgressMore() { + ticker.advance(AbstractClientConnection.DEFAULT_NO_PROGRESS_TIMEOUT_NANOS + 1); // No problem - Optional ret = queue.checkTimeout(ticker.read()); - assertNotNull(ret); - assertFalse(ret.isPresent()); + assertEquals(OptionalLong.empty(), queue.checkTimeout(ticker.read())); } @Test @@ -337,26 +337,27 @@ public class ConnectingClientConnectionTest { } @Test - public void testProgressRecord() throws NoProgressException { + public void testProgressRecord() { setupBackend(); queue.sendRequest(mockRequest, mockCallback); - ticker.increment(10); + ticker.advance(10); queue.sendRequest(mockRequest2, mockCallback); queue.receiveResponse(mockResponseEnvelope); - ticker.increment(AbstractClientConnection.NO_PROGRESS_TIMEOUT_NANOS - 11); + ticker.advance(AbstractClientConnection.DEFAULT_NO_PROGRESS_TIMEOUT_NANOS - 11); - Optional 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 connectingConn = + new ConnectingClientConnection<>(mockContext, mockCookie, "test"); + final ConnectedClientConnection connectedConn = + new ConnectedClientConnection<>(connectingConn, mockBackendInfo); + queue.setForwarder(new SimpleReconnectForwarder(connectedConn)); + queue = connectedConn; } private void assertTransmit(final Request expected, final long sequence) {