openstack/net-virt/src/test/java/org/opendaylight/netvirt/openstack/netvirt/LBaaSHandlerTest.java

   1 /*
   2  * Copyright (c) 2015, 2016 Inocybe 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.netvirt.openstack.netvirt;
  10
  11 import static org.junit.Assert.assertEquals;
  12 import static org.junit.Assert.assertTrue;
  13 import static org.mockito.Matchers.any;
  14 import static org.mockito.Matchers.same;
  15 import static org.mockito.Mockito.mock;
  16 import static org.mockito.Mockito.times;
  17 import static org.mockito.Mockito.verify;
  18 import static org.mockito.Mockito.when;
  19
  20 import java.lang.reflect.Field;
  21 import java.net.HttpURLConnection;
  22 import java.util.ArrayList;
  23 import java.util.Collections;
  24 import java.util.List;
  25 import java.util.Map;
  26 import java.util.Map.Entry;
  27
  28 import org.junit.Assert;
  29 import org.junit.Before;
  30 import org.junit.Test;
  31 import org.junit.runner.RunWith;
  32 import org.mockito.InjectMocks;
  33 import org.mockito.Mock;
  34 import org.mockito.Mockito;
  35 import org.mockito.runners.MockitoJUnitRunner;
  36 import org.opendaylight.netvirt.openstack.netvirt.api.Action;
  37 import org.opendaylight.netvirt.openstack.netvirt.api.EventDispatcher;
  38 import org.opendaylight.netvirt.openstack.netvirt.api.LoadBalancerConfiguration;
  39 import org.opendaylight.netvirt.openstack.netvirt.api.LoadBalancerProvider;
  40 import org.opendaylight.netvirt.openstack.netvirt.api.NodeCacheManager;
  41 import org.opendaylight.netvirt.openstack.netvirt.translator.NeutronLoadBalancer;
  42 import org.opendaylight.netvirt.openstack.netvirt.translator.NeutronLoadBalancerPool;
  43 import org.opendaylight.netvirt.openstack.netvirt.translator.NeutronLoadBalancerPoolMember;
  44 import org.opendaylight.netvirt.openstack.netvirt.translator.NeutronNetwork;
  45 import org.opendaylight.netvirt.openstack.netvirt.translator.crud.INeutronLoadBalancerCRUD;
  46 import org.opendaylight.netvirt.openstack.netvirt.translator.crud.INeutronLoadBalancerPoolCRUD;
  47 import org.opendaylight.netvirt.openstack.netvirt.translator.crud.INeutronNetworkCRUD;
  48 import org.opendaylight.netvirt.openstack.netvirt.translator.crud.INeutronPortCRUD;
  49 import org.opendaylight.netvirt.openstack.netvirt.translator.NeutronPort;
  50 import org.opendaylight.netvirt.openstack.netvirt.translator.NeutronSubnet;
  51 import org.opendaylight.netvirt.openstack.netvirt.translator.Neutron_IPs;
  52 import org.opendaylight.netvirt.openstack.netvirt.translator.crud.INeutronSubnetCRUD;
  53 import org.opendaylight.netvirt.utils.servicehelper.ServiceHelper;
  54 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology
  55         .Node;
  56 import org.osgi.framework.ServiceReference;
  57
  58 /**
  59  * Unit test for {@link LBaaSHandler}
  60  */
  61 @RunWith(MockitoJUnitRunner.class)
  62 public class LBaaSHandlerTest {
  63
  64     @InjectMocks private LBaaSHandler lbaasHandler;
  65     private LBaaSHandler lbaasHandlerSpy;
  66
  67     @Mock private INeutronLoadBalancerCRUD neutronLBCache;
  68     @Mock private INeutronLoadBalancerPoolCRUD neutronLBPoolCache;
  69     @Mock private LoadBalancerProvider loadBalancerProvider;
  70     @Mock private NodeCacheManager nodeCacheManager;
  71     @Mock private NeutronLoadBalancer neutronLB;
  72     @Mock private INeutronSubnetCRUD neutronSubnetCache;
  73     @Mock private INeutronNetworkCRUD neutronNetworkCache;
  74     @Mock private INeutronPortCRUD neutronPortCache;
  75
  76     @Before
  77     public void setUp(){
  78         NorthboundEvent ev = mock(NorthboundEvent.class);
  79         Map.Entry<String,String> providerInfo = mock(Entry.class);
  80         NeutronLoadBalancerPoolMember neutronLBPoolMember = mock(NeutronLoadBalancerPoolMember.class);
  81         NeutronLoadBalancerPool neutronLBPool = mock(NeutronLoadBalancerPool.class);
  82         List<NeutronLoadBalancerPoolMember> members = new ArrayList();
  83         List<NeutronLoadBalancerPool> list_neutronLBPool = new ArrayList();
  84         List<NeutronLoadBalancer> list_neutronLB = new ArrayList();
  85         List<Node> list_node = new ArrayList();
  86
  87         lbaasHandlerSpy = Mockito.spy(lbaasHandler);
  88
  89         neutronLB = mock(NeutronLoadBalancer.class);
  90         when(neutronLB.getLoadBalancerName()).thenReturn("load_balancer_name");
  91         when(neutronLB.getLoadBalancerVipAddress()).thenReturn("vip_address");
  92         when(neutronLB.getLoadBalancerVipSubnetID()).thenReturn("subnetID");
  93
  94         when(ev.getLoadBalancer()).thenReturn(neutronLB);
  95
  96         when(providerInfo.getKey()).thenReturn("key");
  97         when(providerInfo.getValue()).thenReturn("value");
  98
  99         lbaasHandler.setDependencies(neutronPortCache);
 100         final NeutronPort neutronPort = new NeutronPort();
 101         final Neutron_IPs neutronIP1 = new Neutron_IPs();
 102         neutronIP1.setSubnetUUID("pool_member_subnetID");
 103         neutronIP1.setIpAddress("pool_member_address");
 104         final Neutron_IPs neutronIP2 = new Neutron_IPs();
 105         neutronIP2.setSubnetUUID("subnetID");
 106         neutronIP2.setIpAddress("vip_address");
 107         final Neutron_IPs neutronIP3 = new Neutron_IPs();
 108         neutronIP3.setSubnetUUID("subnetID");
 109         neutronIP3.setIpAddress("pool_member_address");
 110         final List<Neutron_IPs> neutronIPs = new ArrayList<>();
 111         neutronIPs.add(neutronIP1);
 112         neutronIPs.add(neutronIP2);
 113         neutronIPs.add(neutronIP3);
 114         neutronPort.setFixedIPs(neutronIPs);
 115         neutronPort.setMacAddress("mac_address");
 116         when(neutronPortCache.getAllPorts()).thenReturn(Collections.singletonList(neutronPort));
 117
 118         lbaasHandler.setDependencies(neutronSubnetCache);
 119         final NeutronSubnet neutronSubnet1 = new NeutronSubnet();
 120         neutronSubnet1.setID("pool_member_subnetID");
 121         neutronSubnet1.setNetworkUUID("pool_member_networkUUID");
 122         final NeutronSubnet neutronSubnet2 = new NeutronSubnet();
 123         neutronSubnet2.setID("subnetID");
 124         neutronSubnet2.setNetworkUUID("pool_member_networkUUID");
 125         List<NeutronSubnet> neutronSubnets = new ArrayList<>();
 126         neutronSubnets.add(neutronSubnet1);
 127         neutronSubnets.add(neutronSubnet2);
 128         when(neutronSubnetCache.getAllSubnets()).thenReturn(neutronSubnets);
 129
 130         lbaasHandler.setDependencies(neutronNetworkCache);
 131         final NeutronNetwork neutronNetwork = new NeutronNetwork();
 132         neutronNetwork.setNetworkUUID("pool_member_networkUUID");
 133         neutronNetwork.setProviderNetworkType("key");
 134         neutronNetwork.setProviderSegmentationID("value");
 135         when(neutronNetworkCache.getAllNetworks()).thenReturn(Collections.singletonList(neutronNetwork));
 136
 137         when(neutronLBPoolMember.getPoolMemberAdminStateIsUp()).thenReturn(true);
 138         when(neutronLBPoolMember.getPoolMemberSubnetID()).thenReturn("subnetID");
 139         when(neutronLBPoolMember.getID()).thenReturn("pool_memberID");
 140         when(neutronLBPoolMember.getPoolMemberAddress()).thenReturn("pool_member_address");
 141         when(neutronLBPoolMember.getPoolMemberProtoPort()).thenReturn(1);
 142         members.add(neutronLBPoolMember);
 143
 144         when(neutronLBPool.getLoadBalancerPoolMembers()).thenReturn(members);
 145         when(neutronLBPool.getLoadBalancerPoolProtocol()).thenReturn(LoadBalancerConfiguration.PROTOCOL_TCP);
 146         list_neutronLBPool.add(neutronLBPool);
 147         when(neutronLBPoolCache.getAllNeutronLoadBalancerPools()).thenReturn(list_neutronLBPool);
 148
 149         list_neutronLB.add(neutronLB);
 150         when(neutronLBCache.getAllNeutronLoadBalancers()).thenReturn(list_neutronLB );
 151
 152         list_node.add(mock(Node.class));
 153         when(nodeCacheManager.getBridgeNodes()).thenReturn(list_node);
 154     }
 155
 156     @Test
 157     public void testCanCreateNeutronLoadBalancer(){
 158         assertEquals("Error, canCreateNeutronLoadBalancer() did not return the correct value ", HttpURLConnection.HTTP_OK, lbaasHandler.canCreateNeutronLoadBalancer(null));
 159     }
 160
 161     @Test
 162     public void testCanUpdateNeutronLoadBalancer(){
 163         assertEquals("Error, canUpdateNeutronLoadBalancer() did not return the correct value ", HttpURLConnection.HTTP_OK, lbaasHandler.canUpdateNeutronLoadBalancer(null, null));
 164     }
 165
 166     @Test
 167     public void testCanDeleteNeutronLoadBalancer(){
 168         assertEquals("Error, canDeleteNeutronLoadBalancer() did not return the correct value ", HttpURLConnection.HTTP_OK, lbaasHandler.canDeleteNeutronLoadBalancer(null));
 169     }
 170
 171     /**
 172      * Test method {@link LBaaSHandler#processEvent(AbstractEvent)}
 173      */
 174     @Test
 175     public void testProcessEvent(){
 176         NorthboundEvent ev = mock(NorthboundEvent.class);
 177         when(ev.getLoadBalancer()).thenReturn(neutronLB);
 178
 179         when(ev.getAction()).thenReturn(Action.ADD);
 180         lbaasHandlerSpy.processEvent(ev);
 181         verify(lbaasHandlerSpy, times(1)).extractLBConfiguration(any(NeutronLoadBalancer.class));
 182         verify(loadBalancerProvider, times(1)).programLoadBalancerRules(any(Node.class), any(LoadBalancerConfiguration.class), same(Action.ADD));
 183
 184         when(ev.getAction()).thenReturn(Action.DELETE);
 185         lbaasHandlerSpy.processEvent(ev);
 186         verify(lbaasHandlerSpy, times(2)).extractLBConfiguration(any(NeutronLoadBalancer.class)); // 1 + 1 above
 187         verify(loadBalancerProvider, times(1)).programLoadBalancerRules(any(Node.class), any(LoadBalancerConfiguration.class), same(Action.DELETE));
 188
 189         when(ev.getAction()).thenReturn(Action.UPDATE);
 190         lbaasHandlerSpy.processEvent(ev);
 191         verify(lbaasHandlerSpy, times(4)).extractLBConfiguration(any(NeutronLoadBalancer.class)); // 2 + 2 above
 192         verify(loadBalancerProvider, times(2)).programLoadBalancerRules(any(Node.class), any(LoadBalancerConfiguration.class), same(Action.DELETE)); // 1 + 1 above
 193         verify(loadBalancerProvider, times(2)).programLoadBalancerRules(any(Node.class), any(LoadBalancerConfiguration.class), same(Action.ADD)); // 1 + 1 above
 194     }
 195
 196     /**
 197      * Test method {@link LBaaSHandler#extractLBConfiguration(NeutronLoadBalancer)}
 198      */
 199     @Test
 200     public void testExtractLBConfiguration(){
 201         LoadBalancerConfiguration lbConfig = lbaasHandler.extractLBConfiguration(neutronLB);
 202
 203         verify(neutronLBPoolCache, times(1)).getAllNeutronLoadBalancerPools();
 204
 205         // make sure the load balancer configuration was correctly populated
 206         assertEquals("Error, did not return the correct value",  "key", lbConfig.getProviderNetworkType());
 207         assertEquals("Error, did not return the correct value",  "value", lbConfig.getProviderSegmentationId());
 208         assertEquals("Error, did not return the correct value",  "mac_address", lbConfig.getVmac());
 209
 210         // make sure the load balancer pool member was correctly populated
 211         LoadBalancerConfiguration.LoadBalancerPoolMember member = lbConfig.getMembers().get("pool_memberID");
 212         assertEquals("Error, did not return the correct value",  "pool_member_address", member.getIP());
 213         assertEquals("Error, did not return the correct value",  "mac_address", member.getMAC());
 214         assertEquals("Error, did not return the correct value",  LoadBalancerConfiguration.PROTOCOL_TCP, member.getProtocol());
 215         assertTrue("Error, did not return the correct value",  1 ==  member.getPort());
 216     }
 217
 218     /**
 219      * Test method {@link LBaaSHandler#notifyNode(Node, Action)}
 220      */
 221     @Test
 222     public void testNotifyNode() {
 223         lbaasHandlerSpy.notifyNode(mock(Node.class), Action.ADD);
 224
 225         verify(lbaasHandlerSpy, times(1)).extractLBConfiguration(any(NeutronLoadBalancer.class));
 226         verify(neutronLBCache, times(1)).getAllNeutronLoadBalancers();
 227         verify(neutronLBPoolCache, times(1)).getAllNeutronLoadBalancerPools();
 228         verify(loadBalancerProvider, times(1)).programLoadBalancerRules(any(Node.class), any(LoadBalancerConfiguration.class), any(Action.class));
 229     }
 230
 231     @Test
 232     public void testSetDependencies() throws Exception {
 233         EventDispatcher eventDispatcher = mock(EventDispatcher.class);
 234         LoadBalancerProvider loadBalancerProvider = mock(LoadBalancerProvider.class);
 235         NodeCacheManager nodeCacheManager = mock(NodeCacheManager.class);
 236
 237         ServiceHelper.overrideGlobalInstance(EventDispatcher.class, eventDispatcher);
 238         ServiceHelper.overrideGlobalInstance(LoadBalancerProvider.class, loadBalancerProvider);
 239         ServiceHelper.overrideGlobalInstance(NodeCacheManager.class, nodeCacheManager);
 240
 241         lbaasHandler.setDependencies(mock(ServiceReference.class));
 242
 243         Assert.assertEquals("Error, did not return the correct object", lbaasHandler.eventDispatcher, eventDispatcher);
 244         assertEquals("Error, did not return the correct object", getField("loadBalancerProvider"), loadBalancerProvider);
 245         assertEquals("Error, did not return the correct object", getField("nodeCacheManager"), nodeCacheManager);
 246     }
 247
 248     @Test
 249     public void testSetDependenciesObject() throws Exception{
 250         INeutronNetworkCRUD iNeutronNetworkCRUD = mock(INeutronNetworkCRUD.class);
 251         lbaasHandler.setDependencies(iNeutronNetworkCRUD);
 252         assertEquals("Error, did not return the correct object", getField("neutronNetworkCache"), iNeutronNetworkCRUD);
 253
 254         INeutronPortCRUD iNeutronPortCRUD = mock(INeutronPortCRUD.class);
 255         lbaasHandler.setDependencies(iNeutronPortCRUD);
 256         assertEquals("Error, did not return the correct object", getField("neutronPortCache"), iNeutronPortCRUD);
 257
 258         INeutronSubnetCRUD iNeutronSubnetCRUD = mock(INeutronSubnetCRUD.class);
 259         lbaasHandler.setDependencies(iNeutronSubnetCRUD);
 260         assertEquals("Error, did not return the correct object", getField("neutronSubnetCache"), iNeutronSubnetCRUD);
 261
 262         INeutronLoadBalancerCRUD iNeutronLoadBalancerCRUD = mock(INeutronLoadBalancerCRUD.class);
 263         lbaasHandler.setDependencies(iNeutronLoadBalancerCRUD);
 264         assertEquals("Error, did not return the correct object", getField("neutronLBCache"), iNeutronLoadBalancerCRUD);
 265
 266         INeutronLoadBalancerPoolCRUD iNeutronLoadBalancerPoolCRUD = mock(INeutronLoadBalancerPoolCRUD.class);
 267         lbaasHandler.setDependencies(iNeutronLoadBalancerPoolCRUD);
 268         assertEquals("Error, did not return the correct object", getField("neutronLBPoolCache"), iNeutronLoadBalancerPoolCRUD);
 269
 270         LoadBalancerProvider loadBalancerProvider = mock(LoadBalancerProvider.class);
 271         lbaasHandler.setDependencies(loadBalancerProvider);
 272         assertEquals("Error, did not return the correct object", getField("loadBalancerProvider"), loadBalancerProvider);
 273     }
 274
 275     private Object getField(String fieldName) throws Exception {
 276         Field field = LBaaSHandler.class.getDeclaredField(fieldName);
 277         field.setAccessible(true);
 278         return field.get(lbaasHandler);
 279     }
 280 }