NetconfSessionPreferences is a record

[netconf.git] / netconf / sal-netconf-connector / src / test / java / org / opendaylight / netconf / sal / connect / netconf / listener / NetconfDeviceCommunicatorTest.java

diff --git a/netconf/sal-netconf-connector/src/test/java/org/opendaylight/netconf/sal/connect/netconf/listener/NetconfDeviceCommunicatorTest.java b/netconf/sal-netconf-connector/src/test/java/org/opendaylight/netconf/sal/connect/netconf/listener/NetconfDeviceCommunicatorTest.java
index 942c31d25c66cdb7e77e21ac906407634d1aa54d..ac68f007d2dd73735cfd4f5c5f418aa98e417d7a 100644 (file)
--- a/netconf/sal-netconf-connector/src/test/java/org/opendaylight/netconf/sal/connect/netconf/listener/NetconfDeviceCommunicatorTest.java
+++ b/netconf/sal-netconf-connector/src/test/java/org/opendaylight/netconf/sal/connect/netconf/listener/NetconfDeviceCommunicatorTest.java
@@ -26,7 +26,6 @@ import static org.opendaylight.netconf.api.xml.XmlNetconfConstants.URN_IETF_PARA
 
 import com.google.common.base.CharMatcher;
 import com.google.common.base.Strings;
-import com.google.common.collect.Sets;
 import com.google.common.util.concurrent.ListenableFuture;
 import io.netty.channel.ChannelFuture;
 import io.netty.channel.EventLoopGroup;
@@ -39,17 +38,18 @@ import io.netty.util.concurrent.GlobalEventExecutor;
 import java.io.ByteArrayInputStream;
 import java.net.InetSocketAddress;
 import java.util.ArrayList;
-import java.util.Collection;
 import java.util.Collections;
+import java.util.Set;
 import java.util.UUID;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import javax.xml.parsers.ParserConfigurationException;
 import org.junit.Before;
 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.netconf.api.NetconfMessage;
 import org.opendaylight.netconf.api.NetconfTerminationReason;
 import org.opendaylight.netconf.api.xml.XmlNetconfConstants;
@@ -65,6 +65,9 @@ import org.opendaylight.netconf.sal.connect.api.RemoteDevice;
 import org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil;
 import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
 import org.opendaylight.yangtools.util.xml.UntrustedXML;
+import org.opendaylight.yangtools.yang.common.ErrorSeverity;
+import org.opendaylight.yangtools.yang.common.ErrorTag;
+import org.opendaylight.yangtools.yang.common.ErrorType;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.common.RpcError;
 import org.opendaylight.yangtools.yang.common.RpcResult;
@@ -73,6 +76,7 @@ import org.slf4j.LoggerFactory;
 import org.w3c.dom.Document;
 import org.w3c.dom.Element;
 
+@RunWith(MockitoJUnitRunner.StrictStubs.class)
 public class NetconfDeviceCommunicatorTest {
 
     private static final Logger LOG = LoggerFactory.getLogger(NetconfDeviceCommunicatorTest.class);
@@ -81,14 +85,12 @@ public class NetconfDeviceCommunicatorTest {
     NetconfClientSession mockSession;
 
     @Mock
-    RemoteDevice<NetconfSessionPreferences, NetconfMessage, NetconfDeviceCommunicator> mockDevice;
+    RemoteDevice<NetconfDeviceCommunicator> mockDevice;
 
     NetconfDeviceCommunicator communicator;
 
     @Before
     public void setUp() throws Exception {
-        MockitoAnnotations.initMocks(this);
-
         communicator = new NetconfDeviceCommunicator(
                 new RemoteDeviceId("test", InetSocketAddress.createUnresolved("localhost", 22)), mockDevice, 10);
     }
@@ -128,15 +130,14 @@ public class NetconfDeviceCommunicatorTest {
 
     @Test
     public void testOnSessionUp() {
-        String testCapability = "urn:opendaylight:params:xml:ns:test?module=test-module&revision=2014-06-02";
-        Collection<String> serverCapabilities =
-                Sets.newHashSet(NetconfMessageTransformUtil.NETCONF_ROLLBACK_ON_ERROR_URI.toString(),
-                        NetconfMessageTransformUtil.IETF_NETCONF_MONITORING.getNamespace().toString(),
-                        testCapability);
+        final var testCapability = "urn:opendaylight:params:xml:ns:test?module=test-module&revision=2014-06-02";
+        final var serverCapabilities = Set.of(
+            NetconfMessageTransformUtil.NETCONF_ROLLBACK_ON_ERROR_URI.toString(),
+            NetconfMessageTransformUtil.IETF_NETCONF_MONITORING.getNamespace().toString(),
+            testCapability);
         doReturn(serverCapabilities).when(mockSession).getServerCapabilities();
 
-        ArgumentCaptor<NetconfSessionPreferences> netconfSessionPreferences =
-                ArgumentCaptor.forClass(NetconfSessionPreferences.class);
+        final var netconfSessionPreferences = ArgumentCaptor.forClass(NetconfSessionPreferences.class);
         doNothing().when(mockDevice).onRemoteSessionUp(netconfSessionPreferences.capture(), eq(communicator));
 
         communicator.onSessionUp(mockSession);
@@ -145,14 +146,13 @@ public class NetconfDeviceCommunicatorTest {
         verify(mockDevice).onRemoteSessionUp(netconfSessionPreferences.capture(), eq(communicator));
 
         NetconfSessionPreferences actualCapabilites = netconfSessionPreferences.getValue();
-        assertEquals("containsModuleCapability", true, actualCapabilites.containsNonModuleCapability(
+        assertTrue(actualCapabilites.containsNonModuleCapability(
                 NetconfMessageTransformUtil.NETCONF_ROLLBACK_ON_ERROR_URI.toString()));
-        assertEquals("containsModuleCapability", false, actualCapabilites.containsNonModuleCapability(testCapability));
-        assertEquals("getModuleBasedCaps", Sets.newHashSet(
-                QName.create("urn:opendaylight:params:xml:ns:test", "2014-06-02", "test-module")),
-                actualCapabilites.getModuleBasedCaps());
-        assertEquals("isRollbackSupported", true, actualCapabilites.isRollbackSupported());
-        assertEquals("isMonitoringSupported", true, actualCapabilites.isMonitoringSupported());
+        assertFalse(actualCapabilites.containsNonModuleCapability(testCapability));
+        assertEquals(Set.of(QName.create("urn:opendaylight:params:xml:ns:test", "2014-06-02", "test-module")),
+                actualCapabilites.moduleBasedCaps().keySet());
+        assertTrue(actualCapabilites.isRollbackSupported());
+        assertTrue(actualCapabilites.isMonitoringSupported());
     }
 
     @SuppressWarnings("unchecked")
@@ -167,8 +167,8 @@ public class NetconfDeviceCommunicatorTest {
 
         communicator.onSessionDown(mockSession, new Exception("mock ex"));
 
-        verifyErrorRpcResult(resultFuture1.get(), RpcError.ErrorType.TRANSPORT, "operation-failed");
-        verifyErrorRpcResult(resultFuture2.get(), RpcError.ErrorType.TRANSPORT, "operation-failed");
+        verifyErrorRpcResult(resultFuture1.get(), ErrorType.TRANSPORT, ErrorTag.OPERATION_FAILED);
+        verifyErrorRpcResult(resultFuture2.get(), ErrorType.TRANSPORT, ErrorTag.OPERATION_FAILED);
 
         verify(mockDevice).onRemoteSessionDown();
 
@@ -191,8 +191,7 @@ public class NetconfDeviceCommunicatorTest {
         NetconfTerminationReason reason = new NetconfTerminationReason(reasonText);
         communicator.onSessionTerminated(mockSession, reason);
 
-        RpcError rpcError = verifyErrorRpcResult(resultFuture.get(), RpcError.ErrorType.TRANSPORT,
-                "operation-failed");
+        RpcError rpcError = verifyErrorRpcResult(resultFuture.get(), ErrorType.TRANSPORT, ErrorTag.OPERATION_FAILED);
         assertEquals("RpcError message", reasonText, rpcError.getMessage());
 
         verify(mockDevice).onRemoteSessionDown();
@@ -228,7 +227,6 @@ public class NetconfDeviceCommunicatorTest {
         verify(mockChannelFuture).addListener(futureListener.capture());
         Future<Void> operationFuture = mock(Future.class);
         doReturn(true).when(operationFuture).isSuccess();
-        doReturn(true).when(operationFuture).isDone();
         futureListener.getValue().operationComplete(operationFuture);
 
         try {
@@ -250,7 +248,7 @@ public class NetconfDeviceCommunicatorTest {
         // Should have an immediate result
         RpcResult<NetconfMessage> rpcResult = resultFuture.get(3, TimeUnit.MILLISECONDS);
 
-        verifyErrorRpcResult(rpcResult, RpcError.ErrorType.TRANSPORT, "operation-failed");
+        verifyErrorRpcResult(rpcResult, ErrorType.TRANSPORT, ErrorTag.OPERATION_FAILED);
     }
 
     private static NetconfMessage createSuccessResponseMessage(final String messageID)
@@ -290,14 +288,13 @@ public class NetconfDeviceCommunicatorTest {
 
         Future<Void> operationFuture = mock(Future.class);
         doReturn(false).when(operationFuture).isSuccess();
-        doReturn(true).when(operationFuture).isDone();
         doReturn(new Exception("mock error")).when(operationFuture).cause();
         futureListener.getValue().operationComplete(operationFuture);
 
         // Should have an immediate result
         RpcResult<NetconfMessage> rpcResult = resultFuture.get(3, TimeUnit.MILLISECONDS);
 
-        RpcError rpcError = verifyErrorRpcResult(rpcResult, RpcError.ErrorType.TRANSPORT, "operation-failed");
+        RpcError rpcError = verifyErrorRpcResult(rpcResult, ErrorType.TRANSPORT, ErrorTag.OPERATION_FAILED);
         assertEquals("RpcError message contains \"mock error\"", true,
                 rpcError.getMessage().contains("mock error"));
     }
@@ -349,8 +346,7 @@ public class NetconfDeviceCommunicatorTest {
 
         communicator.onMessage(mockSession, createErrorResponseMessage(messageID));
 
-        RpcError rpcError = verifyErrorRpcResult(resultFuture.get(), RpcError.ErrorType.RPC,
-                "missing-attribute");
+        RpcError rpcError = verifyErrorRpcResult(resultFuture.get(), ErrorType.RPC, ErrorTag.MISSING_ATTRIBUTE);
         assertEquals("RpcError message", "Missing attribute", rpcError.getMessage());
 
         String errorInfo = rpcError.getInfo();
@@ -368,8 +364,7 @@ public class NetconfDeviceCommunicatorTest {
 
         communicator.onMessage(mockSession, createMultiErrorResponseMessage(messageID));
 
-        RpcError rpcError = verifyErrorRpcResult(resultFuture.get(), RpcError.ErrorType.PROTOCOL,
-                "operation-failed");
+        RpcError rpcError = verifyErrorRpcResult(resultFuture.get(), ErrorType.PROTOCOL, ErrorTag.OPERATION_FAILED);
 
         String errorInfo = rpcError.getInfo();
         assertNotNull("RpcError info is null", errorInfo);
@@ -386,24 +381,26 @@ public class NetconfDeviceCommunicatorTest {
      * Test whether reconnect is scheduled properly.
      */
     @Test
-    public void testNetconfDeviceReconnectInCommunicator() throws Exception {
-        final RemoteDevice<NetconfSessionPreferences, NetconfMessage, NetconfDeviceCommunicator> device =
-                mock(RemoteDevice.class);
+    public void testNetconfDeviceReconnectInCommunicator() {
+        final RemoteDevice<NetconfDeviceCommunicator> device = mock(RemoteDevice.class);
 
         final TimedReconnectStrategy timedReconnectStrategy =
                 new TimedReconnectStrategy(GlobalEventExecutor.INSTANCE, 10000, 0, 1.0, null, 100L, null);
         final ReconnectStrategy reconnectStrategy = spy(new ReconnectStrategy() {
             @Override
+            @Deprecated
             public int getConnectTimeout() throws Exception {
                 return timedReconnectStrategy.getConnectTimeout();
             }
 
             @Override
+            @Deprecated
             public Future<Void> scheduleReconnect(final Throwable cause) {
                 return timedReconnectStrategy.scheduleReconnect(cause);
             }
 
             @Override
+            @Deprecated
             public void reconnectSuccessful() {
                 timedReconnectStrategy.reconnectSuccessful();
             }
@@ -427,7 +424,7 @@ public class NetconfDeviceCommunicatorTest {
             listener.initializeRemoteConnection(new NetconfClientDispatcherImpl(group, group, time), cfg);
 
             verify(reconnectStrategy,
-                    timeout((int) TimeUnit.MINUTES.toMillis(3)).times(101)).scheduleReconnect(any(Throwable.class));
+                    timeout(TimeUnit.MINUTES.toMillis(4)).times(101)).scheduleReconnect(any(Throwable.class));
         } finally {
             time.stop();
             group.shutdownGracefully();
@@ -443,8 +440,7 @@ public class NetconfDeviceCommunicatorTest {
 
         communicator.onMessage(mockSession, createSuccessResponseMessage(UUID.randomUUID().toString()));
 
-        RpcError rpcError = verifyErrorRpcResult(resultFuture.get(), RpcError.ErrorType.PROTOCOL,
-                "bad-attribute");
+        RpcError rpcError = verifyErrorRpcResult(resultFuture.get(), ErrorType.PROTOCOL, ErrorTag.BAD_ATTRIBUTE);
         assertFalse("RpcError message non-empty", Strings.isNullOrEmpty(rpcError.getMessage()));
 
         String errorInfo = rpcError.getInfo();
@@ -538,13 +534,13 @@ public class NetconfDeviceCommunicatorTest {
     }
 
     private static RpcError verifyErrorRpcResult(final RpcResult<NetconfMessage> rpcResult,
-                                                 final RpcError.ErrorType expErrorType, final String expErrorTag) {
+                                                 final ErrorType expErrorType, final ErrorTag expErrorTag) {
         assertNotNull("RpcResult is null", rpcResult);
         assertFalse("isSuccessful", rpcResult.isSuccessful());
         assertNotNull("RpcResult errors is null", rpcResult.getErrors());
         assertEquals("Errors size", 1, rpcResult.getErrors().size());
         RpcError rpcError = rpcResult.getErrors().iterator().next();
-        assertEquals("getErrorSeverity", RpcError.ErrorSeverity.ERROR, rpcError.getSeverity());
+        assertEquals("getErrorSeverity", ErrorSeverity.ERROR, rpcError.getSeverity());
         assertEquals("getErrorType", expErrorType, rpcError.getErrorType());
         assertEquals("getErrorTag", expErrorTag, rpcError.getTag());