BUG-5280: add AbstractClientConnection

[controller.git] / opendaylight / md-sal / cds-access-client / src / test / java / org / opendaylight / controller / cluster / access / client / ConnectionEntryTest.java

diff --git a/opendaylight/md-sal/cds-access-client/src/test/java/org/opendaylight/controller/cluster/access/client/SequencedQueueEntryTest.java b/opendaylight/md-sal/cds-access-client/src/test/java/org/opendaylight/controller/cluster/access/client/ConnectionEntryTest.java
similarity index 55%
rename from opendaylight/md-sal/cds-access-client/src/test/java/org/opendaylight/controller/cluster/access/client/SequencedQueueEntryTest.java
rename to opendaylight/md-sal/cds-access-client/src/test/java/org/opendaylight/controller/cluster/access/client/ConnectionEntryTest.java
index 8cc990ce7c98168261779a9fc803ec3d890f0555..a772ddcc7b1a940179ade2a3fb7c5876ea8c5e85 100644 (file)
--- a/opendaylight/md-sal/cds-access-client/src/test/java/org/opendaylight/controller/cluster/access/client/SequencedQueueEntryTest.java
+++ b/opendaylight/md-sal/cds-access-client/src/test/java/org/opendaylight/controller/cluster/access/client/ConnectionEntryTest.java
@@ -7,46 +7,38 @@
  */
 package org.opendaylight.controller.cluster.access.client;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-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.Mockito.doReturn;
+import static org.mockito.Mockito.doNothing;
 import static org.mockito.Mockito.verify;
 
 import akka.actor.ActorRef;
 import akka.actor.ActorSystem;
 import akka.testkit.TestProbe;
 import java.util.concurrent.ThreadLocalRandom;
-import java.util.concurrent.TimeUnit;
+import java.util.function.Consumer;
 import org.junit.After;
 import org.junit.AfterClass;
 import org.junit.Before;
 import org.junit.BeforeClass;
 import org.junit.Test;
-import org.mockito.ArgumentCaptor;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 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.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.common.actor.TestTicker;
 import org.opendaylight.yangtools.concepts.WritableIdentifier;
-import scala.concurrent.duration.Duration;
 
 /**
- * Test suite covering logic contained in {@link SequencedQueueEntry}.
+ * Test suite covering logic contained in {@link ConnectionEntry}.
  *
  * @author Robert Varga
  */
-public class SequencedQueueEntryTest {
+public class ConnectionEntryTest {
     private static class MockFailure extends RequestFailure<WritableIdentifier, MockFailure> {
         private static final long serialVersionUID = 1L;
 
@@ -96,19 +88,18 @@ public class SequencedQueueEntryTest {
     @Mock
     private RequestException mockCause;
     @Mock
-    private RequestCallback mockCallback;
+    private Consumer<Response<?, ?>> mockCallback;
     @Mock
-    private ClientActorBehavior mockBehavior;
+    private ClientActorBehavior<?> mockBehavior;
 
     private TestTicker ticker;
-    private BackendInfo mockBackendInfo;
     private Request<WritableIdentifier, ?> mockRequest;
     private Response<WritableIdentifier, ?> mockResponse;
 
     private static ActorSystem actorSystem;
     private TestProbe mockActor;
 
-    private SequencedQueueEntry entry;
+    private ConnectionEntry entry;
 
     @BeforeClass
     public static void setupClass() {
@@ -124,17 +115,16 @@ public class SequencedQueueEntryTest {
     public void setup() {
         MockitoAnnotations.initMocks(this);
 
-        doReturn(mockBehavior).when(mockCallback).complete(any(MockFailure.class));
+        doNothing().when(mockCallback).accept(any(MockFailure.class));
 
         ticker = new TestTicker();
         ticker.increment(ThreadLocalRandom.current().nextLong());
 
         mockActor = TestProbe.apply(actorSystem);
-        mockBackendInfo = new BackendInfo(mockActor.ref(), 0, ABIVersion.current(), 5);
         mockRequest = new MockRequest(mockIdentifier, mockReplyTo);
         mockResponse = mockRequest.toRequestFailure(mockCause);
 
-        entry = new SequencedQueueEntry(mockRequest, mockCallback, ticker.read());
+        entry = new ConnectionEntry(mockRequest, mockCallback, ticker.read());
     }
 
     @After
@@ -142,65 +132,9 @@ public class SequencedQueueEntryTest {
         actorSystem.stop(mockActor.ref());
     }
 
-    @Test
-    public void testGetTxDetails() {
-        assertNull(entry.getTxDetails());
-        entry.retransmit(mockBackendInfo, 0, ticker.read());
-        assertEquals(0, entry.getTxDetails().getTxSequence());
-        entry.retransmit(mockBackendInfo, 1, ticker.read());
-        assertEquals(1, entry.getTxDetails().getTxSequence());
-        entry.retransmit(mockBackendInfo, 3, ticker.read());
-        assertEquals(3, entry.getTxDetails().getTxSequence());
-    }
-
     @Test
     public void testComplete() {
         entry.complete(mockResponse);
-        verify(mockCallback).complete(mockResponse);
-    }
-
-    @Test
-    public void testPoison() {
-        entry.poison(mockCause);
-
-        final ArgumentCaptor<MockFailure> captor = ArgumentCaptor.forClass(MockFailure.class);
-        verify(mockCallback).complete(captor.capture());
-        assertSame(mockCause, captor.getValue().getCause());
-    }
-
-    @Test
-    public void testIsTimedOut() {
-        assertTrue(entry.isTimedOut(ticker.read(), 0));
-        assertFalse(entry.isTimedOut(ticker.read(), 1));
-
-        entry.retransmit(mockBackendInfo, 0, ticker.read());
-        assertTrue(entry.isTimedOut(ticker.read(), 0));
-        ticker.increment(10);
-        assertTrue(entry.isTimedOut(ticker.read(), 10));
-        assertFalse(entry.isTimedOut(ticker.read(), 20));
-
-        entry.retransmit(mockBackendInfo, 1, ticker.read());
-        assertTrue(entry.isTimedOut(ticker.read(), 0));
-        ticker.increment(10);
-        assertTrue(entry.isTimedOut(ticker.read(), 10));
-        assertFalse(entry.isTimedOut(ticker.read(), 11));
-    }
-
-    @Test
-    public void testRetransmit() {
-        assertFalse(mockActor.msgAvailable());
-        entry.retransmit(mockBackendInfo, 0, ticker.read());
-
-        assertTrue(mockActor.msgAvailable());
-        assertRequestEquals(mockRequest, mockActor.receiveOne(Duration.apply(5, TimeUnit.SECONDS)));
-    }
-
-    private static void assertRequestEquals(final Request<?, ?> expected, final Object obj) {
-        assertTrue(obj instanceof RequestEnvelope);
-
-        final RequestEnvelope actual = (RequestEnvelope) obj;
-        assertEquals(0, actual.getSessionId());
-        assertEquals(0, actual.getTxSequence());
-        assertEquals(expected.getTarget(), actual.getMessage().getTarget());
+        verify(mockCallback).accept(mockResponse);
     }
 }