openflow-protocol-impl/src/test/java/org/opendaylight/openflowjava/protocol/impl/core/PublishingChannelInitializerTest.java

   1 /*
   2  * Copyright (c) 2014 Brocade Communications Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.openflowjava.protocol.impl.core;
  10
  11 import static org.junit.Assert.assertEquals;
  12 import static org.mockito.Matchers.any;
  13 import static org.mockito.Matchers.eq;
  14 import static org.mockito.Mockito.doThrow;
  15 import static org.mockito.Mockito.times;
  16 import static org.mockito.Mockito.verify;
  17 import static org.mockito.Mockito.when;
  18 import io.netty.channel.ChannelHandler;
  19 import io.netty.channel.ChannelPipeline;
  20 import io.netty.channel.group.DefaultChannelGroup;
  21 import io.netty.channel.socket.SocketChannel;
  22 import io.netty.handler.ssl.SslHandler;
  23 import java.net.InetAddress;
  24 import java.net.InetSocketAddress;
  25 import java.net.UnknownHostException;
  26 import javax.net.ssl.SSLEngine;
  27 import org.junit.Before;
  28 import org.junit.Test;
  29 import org.mockito.Mock;
  30 import org.mockito.MockitoAnnotations;
  31 import org.opendaylight.openflowjava.protocol.api.connection.SwitchConnectionHandler;
  32 import org.opendaylight.openflowjava.protocol.api.connection.TlsConfiguration;
  33 import org.opendaylight.openflowjava.protocol.api.connection.TlsConfigurationImpl;
  34 import org.opendaylight.openflowjava.protocol.impl.core.connection.ConnectionAdapterFactory;
  35 import org.opendaylight.openflowjava.protocol.impl.core.connection.ConnectionFacade;
  36 import org.opendaylight.openflowjava.protocol.impl.deserialization.DeserializationFactory;
  37 import org.opendaylight.openflowjava.protocol.impl.serialization.SerializationFactory;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.config.rev140630.KeystoreType;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.config.rev140630.PathType;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflow._switch.connection.provider.impl.rev140328.Tls;
  41
  42 import com.google.common.collect.Lists;
  43
  44 /**
  45  *
  46  * @author james.hall
  47  */
  48 public class PublishingChannelInitializerTest {
  49
  50     @Mock SocketChannel mockSocketCh ;
  51     @Mock ChannelPipeline mockChPipeline ;
  52     @Mock SwitchConnectionHandler mockSwConnHandler ;
  53     @Mock ConnectionAdapterFactory mockConnAdaptorFactory;
  54     @Mock DefaultChannelGroup mockChGrp ;
  55     @Mock ConnectionFacade mockConnFacade ;
  56     @Mock Tls mockTls ;
  57     SSLEngine sslEngine ;
  58
  59     @Mock SerializationFactory mockSerializationFactory ;
  60     @Mock DeserializationFactory mockDeserializationFactory ;
  61
  62     TlsConfiguration tlsConfiguration ;
  63     InetSocketAddress inetSockAddr;
  64     TcpChannelInitializer pubChInitializer  ;
  65
  66     /**
  67      * Sets up test environment
  68      * @throws Exception
  69      */
  70     @Before
  71     public void setUp() throws Exception {
  72         MockitoAnnotations.initMocks(this);
  73         pubChInitializer= new TcpChannelInitializer(mockChGrp, mockConnAdaptorFactory) ;
  74         pubChInitializer.setSerializationFactory(mockSerializationFactory);
  75         pubChInitializer.setDeserializationFactory(mockDeserializationFactory);
  76         pubChInitializer.setSwitchIdleTimeout(1) ;
  77         pubChInitializer.getConnectionIterator() ;
  78         pubChInitializer.setUseBarrier(true);
  79
  80         when( mockChGrp.size()).thenReturn(1) ;
  81         pubChInitializer.setSwitchConnectionHandler( mockSwConnHandler ) ;
  82
  83         inetSockAddr = new InetSocketAddress(InetAddress.getLocalHost(), 8675 ) ;
  84
  85         when(mockConnAdaptorFactory.createConnectionFacade(mockSocketCh, null, true))
  86         .thenReturn(mockConnFacade);
  87         when(mockSocketCh.remoteAddress()).thenReturn(inetSockAddr) ;
  88         when(mockSocketCh.localAddress()).thenReturn(inetSockAddr) ;
  89         when(mockSocketCh.remoteAddress()).thenReturn(inetSockAddr) ;
  90         when(mockSwConnHandler.accept(eq(InetAddress.getLocalHost()))).thenReturn(true) ;
  91         when(mockSocketCh.pipeline()).thenReturn(mockChPipeline) ;
  92
  93         tlsConfiguration = new TlsConfigurationImpl(KeystoreType.JKS, "/selfSignedSwitch", PathType.CLASSPATH,
  94                 KeystoreType.JKS, "/selfSignedController", PathType.CLASSPATH,
  95                 Lists.newArrayList("TLS_RSA_WITH_AES_128_CBC_SHA", "TLS_RSA_WITH_AES_128_CBC_SHA256"));
  96     }
  97
  98
  99     /**
 100      * Test channel initialization with encryption config set
 101      */
 102     @Test
 103     public void testinitChannelEncryptionSet()  {
 104         pubChInitializer.setTlsConfiguration(tlsConfiguration);
 105         pubChInitializer.initChannel(mockSocketCh) ;
 106
 107         verifyCommonHandlers();
 108         verify(mockChPipeline, times(1)).addLast(eq(PipelineHandlers.SSL_HANDLER.name()),any(SslHandler.class)) ;
 109     }
 110
 111     /**
 112      * Test channel initialization with null encryption config
 113      */
 114     @Test
 115     public void testinitChannelEncryptionSetNullTls()  {
 116         pubChInitializer.setTlsConfiguration(null);
 117         pubChInitializer.initChannel(mockSocketCh) ;
 118
 119         verifyCommonHandlers();
 120         verify(mockChPipeline, times(0)).addLast(eq(PipelineHandlers.SSL_HANDLER.name()),any(SslHandler.class)) ;
 121     }
 122
 123     /**
 124      * Test channel initialization without setting the encryption
 125      */
 126     @Test
 127     public void testinitChannelEncryptionNotSet()  {
 128         // Without encryption, only the common
 129         pubChInitializer.initChannel(mockSocketCh) ;
 130
 131         verifyCommonHandlers();
 132     }
 133
 134     /**
 135      * Test disconnect on new connection rejected
 136      * @throws UnknownHostException
 137      */
 138     @Test
 139     public void testinitChannelNoEncryptionAcceptFails() throws UnknownHostException  {
 140         when(mockSwConnHandler.accept(eq(InetAddress.getLocalHost()))).thenReturn(false) ;
 141         pubChInitializer.initChannel(mockSocketCh) ;
 142
 143         verify(mockSocketCh, times(1)).disconnect();
 144         verify(mockChPipeline, times(0))
 145         .addLast( any(String.class), any(ChannelHandler.class) ) ;
 146     }
 147
 148     /**
 149      * Test channel close on exception during initialization
 150      */
 151     @Test
 152     public void testExceptionThrown() {
 153         doThrow(new IllegalArgumentException()).when(mockSocketCh).pipeline() ;
 154         pubChInitializer.initChannel(mockSocketCh);
 155
 156         verify( mockSocketCh, times(1)).close() ;
 157     }
 158
 159     /**
 160      * All paths should install these six handlers:
 161      */
 162     private void verifyCommonHandlers() {
 163         verify(mockChPipeline, times(1)).addLast(eq(PipelineHandlers.IDLE_HANDLER.name()),any(IdleHandler.class)) ;
 164         verify(mockChPipeline, times(1)).addLast(eq(PipelineHandlers.OF_DECODER.name()),any(OFDecoder.class)) ;
 165         verify(mockChPipeline, times(1)).addLast(eq(PipelineHandlers.OF_ENCODER.name()),any(OFEncoder.class)) ;
 166         verify(mockChPipeline, times(1)).addLast(eq(PipelineHandlers.OF_FRAME_DECODER.name()),any(OFFrameDecoder.class)) ;
 167         verify(mockChPipeline, times(1)).addLast(eq(PipelineHandlers.OF_VERSION_DETECTOR.name()),any(OFVersionDetector.class)) ;
 168         verify(mockChPipeline, times(1)).addLast(eq(PipelineHandlers.DELEGATING_INBOUND_HANDLER.name()),any(DelegatingInboundHandler.class));
 169         assertEquals(1, pubChInitializer.size()) ;
 170     }
 171 }