vpnservice/natservice/natservice-impl/src/test/java/org/opendaylight/vpnservice/natservice/internal/test/NaptManagerTest.java

   1 package org.opendaylight.vpnservice.natservice.internal.test;
   2
   3 import static org.junit.Assert.assertEquals;
   4
   5 import org.junit.Before;
   6 import org.junit.Ignore;
   7 import org.junit.Test;
   8 import org.junit.runner.RunWith;
   9 import org.mockito.Matchers;
  10 import org.mockito.Mock;
  11 import org.mockito.Mockito;
  12 import org.mockito.MockitoAnnotations;
  13 import org.mockito.stubbing.OngoingStubbing;
  14
  15 import static org.mockito.Matchers.any;
  16 import static org.mockito.Mockito.when;
  17 import static org.mockito.Mockito.eq;
  18
  19 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  20 import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
  21 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  22 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
  23 import org.opendaylight.vpnservice.mdsalutil.MDSALUtil;
  24 import org.opendaylight.vpnservice.natservice.internal.IPAddress;
  25 import org.opendaylight.vpnservice.natservice.internal.NaptManager;
  26 import org.opendaylight.vpnservice.natservice.internal.SessionAddress;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.CreateIdPoolInput;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.IdManagerService;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.IntextIpMap;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.IntextIpPortMap;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.intext.ip.map.IpMapping;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.intext.ip.map.IpMappingKey;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.intext.ip.map.ip.mapping.IpMap;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.intext.ip.map.ip.mapping.IpMapBuilder;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.intext.ip.map.ip.mapping.IpMapKey;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.intext.ip.port.map.IpPortMapping;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.intext.ip.port.map.IpPortMappingKey;
  38 import org.opendaylight.yangtools.concepts.ListenerRegistration;
  39 import org.opendaylight.yangtools.yang.binding.DataObject;
  40 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  41 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
  42 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
  43
  44 import com.google.common.util.concurrent.Futures;
  45
  46 import org.powermock.api.mockito.PowerMockito;
  47 import org.powermock.core.classloader.annotations.PrepareForTest;
  48 import org.powermock.modules.junit4.PowerMockRunner;
  49
  50
  51 @RunWith(PowerMockRunner.class)
  52 @PrepareForTest(MDSALUtil.class)
  53 public class NaptManagerTest {
  54
  55     @Mock IdManagerService idMgr;
  56     @Mock DataBroker dataBroker;
  57     @Mock ListenerRegistration<DataChangeListener> dataChangeListenerRegistration;
  58     InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.intext.ip.map.ip.mapping.IpMap> ipmapId = null;
  59     org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.natservice.rev160111.intext.ip.map.ip.mapping.IpMap ipmap = null;
  60
  61     private NaptManager naptManager;
  62
  63     @Before
  64     public void init() {
  65         MockitoAnnotations.initMocks(this);
  66         when(dataBroker.registerDataChangeListener(
  67                 any(LogicalDatastoreType.class),
  68                 any(InstanceIdentifier.class),
  69                 any(DataChangeListener.class),
  70                 any(DataChangeScope.class)))
  71                 .thenReturn(dataChangeListenerRegistration);
  72         naptManager = new NaptManager(dataBroker);
  73         when(idMgr.createIdPool(any(CreateIdPoolInput.class)))
  74                   .thenReturn(Futures.immediateFuture(RpcResultBuilder.<Void>success().build()));
  75         naptManager.setIdManager(idMgr);
  76
  77         PowerMockito.mockStatic(MDSALUtil.class);
  78
  79     }
  80
  81
  82     @Ignore @Test
  83     public void testRegisterMappingIpIP() {
  84         // TODO : This needs to be modified to make it work
  85         // TODO : Issue with Mockito.any() usage, so for now run registerMapping testcases as seperate Tests. This needs to be fixed properly.
  86         ipmapId = InstanceIdentifier.builder(
  87                 IntextIpMap.class).child(IpMapping.class, new IpMappingKey(5L)).child(IpMap.class, new IpMapKey("10.0.0.1")).build();
  88         ipmap = new IpMapBuilder().setKey(new IpMapKey("10.0.0.1")).setInternalIp("10.0.0.1").setExternalIp("192.17.13.1").build();
  89         try {
  90             PowerMockito.doNothing().when(MDSALUtil.class, "syncWrite", dataBroker, LogicalDatastoreType.OPERATIONAL, ipmapId, ipmap);
  91         } catch (Exception e) {
  92             // Test failed anyways
  93             assertEquals("true", "false");
  94         }
  95         IPAddress internal = new IPAddress("10.0.0.1",0);
  96         IPAddress external = new IPAddress("192.17.13.1", 0);
  97         naptManager.registerMapping(5, internal, external);
  98         PowerMockito.verifyStatic();
  99
 100     }
 101
 102     @Ignore @Test
 103     public void testRegisterMappingIpSubnet() {
 104         // TODO : This needs to be modified to make it work
 105         ipmapId = InstanceIdentifier.builder(
 106                 IntextIpMap.class).child(IpMapping.class, new IpMappingKey(5L)).child(IpMap.class, new IpMapKey("10.0.0.1")).build();
 107         ipmap = new IpMapBuilder().setKey(new IpMapKey("10.0.0.1")).setInternalIp("10.0.0.1").setExternalIp("192.17.13.1/24").build();
 108         try {
 109             PowerMockito.doNothing().when(MDSALUtil.class, "syncWrite", dataBroker, LogicalDatastoreType.OPERATIONAL, ipmapId, ipmap);
 110         } catch (Exception e) {
 111             // Test failed anyways
 112             assertEquals("true", "false");
 113         }
 114         IPAddress internal = new IPAddress("10.0.0.1",0);
 115         IPAddress external = new IPAddress("192.17.13.1", 24);
 116         naptManager.registerMapping(5, internal, external);
 117         PowerMockito.verifyStatic();
 118     }
 119
 120     @Ignore @Test
 121     public void testRegisterMappingSubnetIp() {
 122         // TODO : This needs to be modified to make it work
 123         ipmapId = InstanceIdentifier.builder(
 124                 IntextIpMap.class).child(IpMapping.class, new IpMappingKey(6L)).child(IpMap.class, new IpMapKey("10.0.2.1/16")).build();
 125         ipmap = new IpMapBuilder().setKey(new IpMapKey("10.0.0.1")).setInternalIp("10.0.0.1").setExternalIp("192.19.15.3").build();
 126         try {
 127             PowerMockito.doNothing().when(MDSALUtil.class, "syncWrite", dataBroker, LogicalDatastoreType.OPERATIONAL, ipmapId, ipmap);
 128         } catch (Exception e) {
 129             // Test failed anyways
 130             assertEquals("true", "false");
 131         }
 132         IPAddress internal = new IPAddress("10.0.2.1",16);
 133         IPAddress external = new IPAddress("192.19.15.3", 0);
 134         naptManager.registerMapping(6, internal, external);
 135         PowerMockito.verifyStatic();
 136      }
 137
 138     @Ignore @Test
 139     public void testRegisterMappingSubnetSubnet() {
 140         // TODO : This needs to be modified to make it work
 141         ipmapId = InstanceIdentifier.builder(
 142                 IntextIpMap.class).child(IpMapping.class, new IpMappingKey(6L)).child(IpMap.class, new IpMapKey("10.2.0.1/24")).build();
 143         ipmap = new IpMapBuilder().setKey(new IpMapKey("10.2.0.1/24")).setInternalIp("10.2.0.1/24").setExternalIp("192.21.16.1/16").build();
 144         try {
 145             PowerMockito.doNothing().when(MDSALUtil.class, "syncWrite", dataBroker, LogicalDatastoreType.OPERATIONAL, ipmapId, ipmap);
 146         } catch (Exception e) {
 147             // Test failed anyways
 148             assertEquals("true", "false");
 149         }
 150         IPAddress internal = new IPAddress("10.2.0.1",24);
 151         IPAddress external = new IPAddress("192.21.16.1", 16);
 152         naptManager.registerMapping(6, internal, external);
 153         PowerMockito.verifyStatic();
 154     }
 155
 156
 157     @Test
 158     public void testgetExternalAddressMapping() {
 159         // TODO : This needs to be modified to make it work
 160         // Testcase to test when no entry exists in ip-pot-map
 161         /*SessionAddress internalIpPort = new SessionAddress("10.0.0.1", 2);
 162         InstanceIdentifierBuilder<IpPortMapping> idBuilder =
 163                 InstanceIdentifier.builder(IntextIpPortMap.class).child(IpPortMapping.class, new IpPortMappingKey(5L));
 164         InstanceIdentifier<IpPortMapping> id = idBuilder.build();
 165         try {
 166              PowerMockito.when(MDSALUtil.class, "read", dataBroker, LogicalDatastoreType.CONFIGURATION, id).thenReturn(null);
 167         } catch (Exception e) {
 168             // Test failed anyways
 169             assertEquals("true", "false");
 170         }
 171         naptManager.getExternalAddressMapping(5, internalIpPort);
 172         PowerMockito.verifyStatic(); */
 173     }
 174
 175     @Test
 176     public void testReleaseAddressMapping() {
 177         // TODO : Below needs to be modified to make it work
 178       /*  InstanceIdentifierBuilder<IpMapping> idBuilder =
 179                 InstanceIdentifier.builder(IntextIpMap.class).child(IpMapping.class, new IpMappingKey(5L));
 180         InstanceIdentifier<IpMapping> id = idBuilder.build();
 181         try {
 182             PowerMockito.doNothing().when(MDSALUtil.class, "read", dataBroker, LogicalDatastoreType.OPERATIONAL, id);
 183         } catch (Exception e) {
 184             // Test failed anyways
 185             assertEquals("true", "false");
 186         }
 187         IPAddress internal = new IPAddress("10.0.0.1",0);
 188         IPAddress external = new IPAddress("192.17.13.1", 0);
 189         naptManager.registerMapping(5, internal, external);
 190         SessionAddress internalSession = new SessionAddress("10.0.0.1", 0);
 191         naptManager.releaseAddressMapping(5L, internalSession);*/
 192     }
 193
 194
 195 }