Merge "Migrate netconf to mockito ArgumentMatchers"

[netconf.git] / netconf / callhome-provider / src / test / java / org / opendaylight / netconf / callhome / mount / CallHomeMountDispatcherTest.java

diff --git a/netconf/callhome-provider/src/test/java/org/opendaylight/netconf/callhome/mount/CallHomeMountDispatcherTest.java b/netconf/callhome-provider/src/test/java/org/opendaylight/netconf/callhome/mount/CallHomeMountDispatcherTest.java
index fc59e276a471f0dc8147e3ab76c818d338b2d489..2fa318857a864e51927450d5818f8812f68359f4 100644 (file)
--- a/netconf/callhome-provider/src/test/java/org/opendaylight/netconf/callhome/mount/CallHomeMountDispatcherTest.java
+++ b/netconf/callhome-provider/src/test/java/org/opendaylight/netconf/callhome/mount/CallHomeMountDispatcherTest.java
@@ -9,23 +9,27 @@
 package org.opendaylight.netconf.callhome.mount;
 
 import static org.junit.Assert.assertFalse;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
 
 import io.netty.util.concurrent.EventExecutor;
 import io.netty.util.concurrent.Future;
-import java.net.InetAddress;
 import java.net.InetSocketAddress;
 import java.net.UnknownHostException;
 import org.junit.Before;
 import org.junit.Test;
+import org.opendaylight.aaa.encrypt.AAAEncryptionService;
 import org.opendaylight.controller.config.threadpool.ScheduledThreadPool;
 import org.opendaylight.controller.config.threadpool.ThreadPool;
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
 import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
-import org.opendaylight.controller.sal.core.api.Broker;
 import org.opendaylight.netconf.api.messages.NetconfHelloMessageAdditionalHeader;
 import org.opendaylight.netconf.callhome.protocol.CallHomeChannelActivator;
+import org.opendaylight.netconf.callhome.protocol.CallHomeProtocolSessionContext;
 import org.opendaylight.netconf.client.NetconfClientSession;
 import org.opendaylight.netconf.client.NetconfClientSessionListener;
 import org.opendaylight.netconf.client.conf.NetconfClientConfiguration;
@@ -33,44 +37,63 @@ import org.opendaylight.netconf.client.conf.NetconfClientConfigurationBuilder;
 import org.opendaylight.netconf.nettyutil.handler.ssh.authentication.AuthenticationHandler;
 import org.opendaylight.netconf.topology.api.SchemaRepositoryProvider;
 import org.opendaylight.protocol.framework.ReconnectStrategy;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
 
 public class CallHomeMountDispatcherTest {
     private String topologyId;
-    private BindingAwareBroker mockBroker;
     private EventExecutor mockExecutor;
     private ScheduledThreadPool mockKeepAlive;
     private ThreadPool mockProcessingExecutor;
     private SchemaRepositoryProvider mockSchemaRepoProvider;
-    private Broker mockDomBroker;
 
     private CallHomeMountDispatcher instance;
     private DataBroker mockDataBroker;
     private DOMMountPointService mockMount;
 
+    private CallHomeMountSessionManager mockSessMgr;
+    private CallHomeTopology mockTopology;
+    private CallHomeProtocolSessionContext mockProtoSess;
+    private AAAEncryptionService mockEncryptionService;
+
     @Before
     public void setup() {
         topologyId = "";
-        mockBroker = mock(BindingAwareBroker.class);
         mockExecutor = mock(EventExecutor.class);
         mockKeepAlive = mock(ScheduledThreadPool.class);
         mockProcessingExecutor = mock(ThreadPool.class);
         mockSchemaRepoProvider = mock(SchemaRepositoryProvider.class);
-        mockDomBroker = mock(Broker.class);
         mockDataBroker = mock(DataBroker.class);
         mockMount = mock(DOMMountPointService.class);
-        instance = new CallHomeMountDispatcher(topologyId, mockBroker, mockExecutor, mockKeepAlive,
-                mockProcessingExecutor, mockSchemaRepoProvider, mockDomBroker, mockDataBroker, mockMount);
+        mockSessMgr = mock(CallHomeMountSessionManager.class);
+        mockTopology = mock(CallHomeTopology.class);
+        mockProtoSess = mock(CallHomeProtocolSessionContext.class);
+        mockEncryptionService = mock(AAAEncryptionService.class);
+
+        instance = new CallHomeMountDispatcher(topologyId, mockExecutor, mockKeepAlive,
+                mockProcessingExecutor, mockSchemaRepoProvider, mockDataBroker, mockMount,
+                mockEncryptionService) {
+            @Override
+            public CallHomeMountSessionManager getSessionManager() {
+                return mockSessMgr;
+            }
+
+            @Override
+            void createTopology() {
+                this.topology = mockTopology;
+            }
+        };
     }
 
-    NetconfClientConfiguration someConfiguration(InetSocketAddress address) {
+    NetconfClientConfiguration someConfiguration(final InetSocketAddress address) {
         // NetconfClientConfiguration has mostly final methods, making it un-mock-able
 
-        NetconfClientConfiguration.NetconfClientProtocol protocol =
+        final NetconfClientConfiguration.NetconfClientProtocol protocol =
                 NetconfClientConfiguration.NetconfClientProtocol.SSH;
-        NetconfHelloMessageAdditionalHeader additionalHeader = mock(NetconfHelloMessageAdditionalHeader.class);
-        NetconfClientSessionListener sessionListener = mock(NetconfClientSessionListener.class);
-        ReconnectStrategy reconnectStrategy = mock(ReconnectStrategy.class);
-        AuthenticationHandler authHandler = mock(AuthenticationHandler.class);
+        final NetconfHelloMessageAdditionalHeader additionalHeader = mock(NetconfHelloMessageAdditionalHeader.class);
+        final NetconfClientSessionListener sessionListener = mock(NetconfClientSessionListener.class);
+        final ReconnectStrategy reconnectStrategy = mock(ReconnectStrategy.class);
+        final AuthenticationHandler authHandler = mock(AuthenticationHandler.class);
 
         return NetconfClientConfigurationBuilder.create().withProtocol(protocol).withAddress(address)
                 .withConnectionTimeoutMillis(0).withAdditionalHeader(additionalHeader)
@@ -81,24 +104,24 @@ public class CallHomeMountDispatcherTest {
     @Test
     public void canCreateASessionFromAConfiguration() {
         // given
-        CallHomeMountSessionContext mockContext = mock(CallHomeMountSessionContext.class);
-        InetSocketAddress someAddress = InetSocketAddress.createUnresolved("1.2.3.4", 123);
-        // instance.contextByAddress.put(someAddress, mockContext);
+        final CallHomeMountSessionContext mockContext = mock(CallHomeMountSessionContext.class);
+        final InetSocketAddress someAddress = InetSocketAddress.createUnresolved("1.2.3.4", 123);
+        doReturn(mockContext).when(mockSessMgr).getByAddress(eq(someAddress));
 
-        NetconfClientConfiguration someCfg = someConfiguration(someAddress);
+        final NetconfClientConfiguration someCfg = someConfiguration(someAddress);
         // when
         instance.createClient(someCfg);
         // then
-        // verify(mockContext, times(1)).activate(any(NetconfClientSessionListener.class));
+        verify(mockContext, times(1)).activateNetconfChannel(any(NetconfClientSessionListener.class));
     }
 
     @Test
     public void noSessionIsCreatedWithoutAContextAvailableForAGivenAddress() {
         // given
-        InetSocketAddress someAddress = InetSocketAddress.createUnresolved("1.2.3.4", 123);
-        NetconfClientConfiguration someCfg = someConfiguration(someAddress);
+        final InetSocketAddress someAddress = InetSocketAddress.createUnresolved("1.2.3.4", 123);
+        final NetconfClientConfiguration someCfg = someConfiguration(someAddress);
         // when
-        Future<NetconfClientSession> future = instance.createClient(someCfg);
+        final Future<NetconfClientSession> future = instance.createClient(someCfg);
         // then
         assertFalse(future.isSuccess());
     }
@@ -106,12 +129,18 @@ public class CallHomeMountDispatcherTest {
     @Test
     public void nodeIsInsertedIntoTopologyWhenSubsystemIsOpened() throws UnknownHostException {
         // given
-        InetSocketAddress someAddress = new InetSocketAddress(InetAddress.getByName("1.2.3.4"), 123);
-        CallHomeChannelActivator activator = mock(CallHomeChannelActivator.class);
-        // instance.topology = mock(CallHomeTopology.class);
+        final NodeId mockNodeId = mock(NodeId.class);
+        final Node mockNode = mock(Node.class);
+        final CallHomeMountSessionContext mockDevCtxt = mock(CallHomeMountSessionContext.class);
+        doReturn(mockNodeId).when(mockDevCtxt).getId();
+        doReturn(mockNode).when(mockDevCtxt).getConfigNode();
+        doReturn(mockDevCtxt).when(mockSessMgr).createSession(any(CallHomeProtocolSessionContext.class),
+                any(CallHomeChannelActivator.class), any(CallHomeMountSessionContext.CloseCallback.class));
+        final CallHomeChannelActivator activator = mock(CallHomeChannelActivator.class);
+        instance.createTopology();
         // when
-        // instance.onNetconfSubsystemOpened(someAddress, activator);
+        instance.onNetconfSubsystemOpened(mockProtoSess, activator);
         // then
-        // verify(instance.topology, times(1)).connectNode(any(NodeId.class), any(Node.class));
+        verify(instance.topology, times(1)).connectNode(any(NodeId.class), any(Node.class));
     }
 }