import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;
import java.net.HttpURLConnection;
-import org.junit.*;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
import org.opendaylight.ovsdb.openstack.netvirt.api.EventDispatcher;
import org.opendaylight.ovsdb.openstack.netvirt.api.Status;
import org.opendaylight.ovsdb.openstack.netvirt.api.StatusCode;
/**
* Unit test for {@link AbstractHandler}
*/
-@Ignore
-// TODO SB_MIGRATION
+@RunWith(MockitoJUnitRunner.class)
public class AbstractHandlerTest {
+ @InjectMocks private AbstractHandler abstractHandler = mock(AbstractHandler.class, Mockito.CALLS_REAL_METHODS);
+ @Mock private EventDispatcher eventDispatcher;
+
@Test
- public void testAbstractHandler() {
+ public void testGetException() {
Status status = mock(Status.class);
when(status.getCode())
}
@Test
- public void testEnqueueEvent(){
- EventDispatcher eventDispatcher = mock(EventDispatcher.class);
-
- verifyNoMoreInteractions(eventDispatcher);
- eventDispatcher.enqueueEvent(mock(AbstractEvent.class));
+ public void testEnqueueEvent() throws Exception {
+ abstractHandler.enqueueEvent(mock(AbstractEvent.class));
verify(eventDispatcher, times(1)).enqueueEvent(any(AbstractEvent.class));
}
}
import java.net.HttpURLConnection;
+import org.junit.Before;
import org.junit.Test;
+import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mockito;
import org.opendaylight.neutron.spi.NeutronFirewall;
import org.opendaylight.neutron.spi.NeutronFirewallPolicy;
import org.opendaylight.neutron.spi.NeutronFirewallRule;
+import org.opendaylight.ovsdb.openstack.netvirt.api.EventDispatcher;
+import org.opendaylight.ovsdb.openstack.netvirt.impl.NeutronL3Adapter;
+import org.opendaylight.ovsdb.utils.servicehelper.ServiceHelper;
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.ServiceReference;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
/**
* Unit test for {@link FWaasHandler}
*/
+@RunWith(PowerMockRunner.class)
+@PrepareForTest(ServiceHelper.class)
public class FWaasHandlerTest {
- @InjectMocks FWaasHandler fwaasHandler = mock(FWaasHandler.class, Mockito.CALLS_REAL_METHODS);
+ @InjectMocks FWaasHandler fwaasHandler;
+
+ @Before
+ public void setUp() {
+ fwaasHandler = mock(FWaasHandler.class, Mockito.CALLS_REAL_METHODS);
+ }
@Test
public void testCanCreateNeutronFirewall(){
// when(ev.getAction()).thenReturn(Action.ADD);
// fwaasHandler.processEvent(ev);
}
+
+ @Test
+ public void testSetDependencies() {
+ EventDispatcher eventDispatcher = mock(EventDispatcher.class);
+
+ PowerMockito.mockStatic(ServiceHelper.class);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(EventDispatcher.class, fwaasHandler)).thenReturn(eventDispatcher);
+
+ fwaasHandler.setDependencies(mock(BundleContext.class), mock(ServiceReference.class));
+
+ assertEquals("Error, did not return the correct object", fwaasHandler.eventDispatcher, eventDispatcher);
+ }
}
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;
+import java.lang.reflect.Field;
import java.net.HttpURLConnection;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
-import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
+import org.mockito.Mock;
import org.opendaylight.neutron.spi.NeutronFloatingIP;
import org.opendaylight.ovsdb.openstack.netvirt.api.Action;
+import org.opendaylight.ovsdb.openstack.netvirt.api.EventDispatcher;
import org.opendaylight.ovsdb.openstack.netvirt.impl.NeutronL3Adapter;
+import org.opendaylight.ovsdb.utils.servicehelper.ServiceHelper;
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.ServiceReference;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
/**
* Unit test for {@link FloatingIPHandler}
*/
-@RunWith(MockitoJUnitRunner.class)
+@RunWith(PowerMockRunner.class)
+@PrepareForTest(ServiceHelper.class)
public class FloatingIPHandlerTest {
- @InjectMocks private FloatingIPHandler floatingHandler = mock(FloatingIPHandler.class, Mockito.CALLS_REAL_METHODS);
- @InjectMocks private NeutronL3Adapter neutronL3Adapter = mock(NeutronL3Adapter.class);
+ @InjectMocks FloatingIPHandler floatingHandler;
+ @Mock NeutronL3Adapter neutronL3Adapter;
@Test
public void testCanCreateFloatingIP(){
floatingHandler.processEvent((AbstractEvent) ev);
verify(neutronL3Adapter, times(1)).handleNeutronFloatingIPEvent(ev.getNeutronFloatingIP(), ev.getAction());;
}
+
+ @Test
+ public void testSetDependencies() throws Exception {
+ EventDispatcher eventDispatcher = mock(EventDispatcher.class);
+ NeutronL3Adapter neutronL3Adapter = mock(NeutronL3Adapter.class);
+
+ PowerMockito.mockStatic(ServiceHelper.class);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(EventDispatcher.class, floatingHandler)).thenReturn(eventDispatcher);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(NeutronL3Adapter.class, floatingHandler)).thenReturn(neutronL3Adapter);
+
+ floatingHandler.setDependencies(mock(BundleContext.class), mock(ServiceReference.class));
+
+ assertEquals("Error, did not return the correct object", floatingHandler.eventDispatcher, eventDispatcher);
+ assertEquals("Error, did not return the correct object", getNeutronL3Adapter(), neutronL3Adapter);
+ }
+
+ private NeutronL3Adapter getNeutronL3Adapter() throws Exception {
+ Field field = FloatingIPHandler.class.getDeclaredField("neutronL3Adapter");
+ field.setAccessible(true);
+ return (NeutronL3Adapter) field.get(floatingHandler);
+ }
}
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import java.lang.reflect.Field;
import java.net.HttpURLConnection;
import java.util.ArrayList;
import java.util.List;
import org.opendaylight.neutron.spi.NeutronLoadBalancerPool;
import org.opendaylight.neutron.spi.NeutronLoadBalancerPoolMember;
import org.opendaylight.ovsdb.openstack.netvirt.api.Action;
+import org.opendaylight.ovsdb.openstack.netvirt.api.EventDispatcher;
import org.opendaylight.ovsdb.openstack.netvirt.api.LoadBalancerConfiguration;
import org.opendaylight.ovsdb.openstack.netvirt.api.LoadBalancerConfiguration.LoadBalancerPoolMember;
import org.opendaylight.ovsdb.openstack.netvirt.api.LoadBalancerProvider;
import org.opendaylight.ovsdb.openstack.netvirt.api.NodeCacheManager;
+import org.opendaylight.ovsdb.utils.servicehelper.ServiceHelper;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.ServiceReference;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
* Unit test for {@link LBaaSHandler}
*/
@RunWith(PowerMockRunner.class)
-@PrepareForTest(NeutronCacheUtils.class)
+@PrepareForTest({NeutronCacheUtils.class, ServiceHelper.class})
public class LBaaSHandlerTest {
@InjectMocks private LBaaSHandler lbaasHandler;
verify(lbaasHandlerSpy, times(1)).extractLBConfiguration(any(NeutronLoadBalancer.class));
verify(neutronLBCache, times(1)).getAllNeutronLoadBalancers();
verify(neutronLBPoolCache, times(1)).getAllNeutronLoadBalancerPools();
- /* TODO SB_MIGRATION */
verify(loadBalancerProvider, times(1)).programLoadBalancerRules(any(Node.class), any(LoadBalancerConfiguration.class), any(Action.class));
}
+
+ @Test
+ public void testSetDependencies() throws Exception {
+ EventDispatcher eventDispatcher = mock(EventDispatcher.class);
+ LoadBalancerProvider loadBalancerProvider = mock(LoadBalancerProvider.class);
+ NodeCacheManager nodeCacheManager = mock(NodeCacheManager.class);
+
+ PowerMockito.mockStatic(ServiceHelper.class);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(EventDispatcher.class, lbaasHandler)).thenReturn(eventDispatcher);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(LoadBalancerProvider.class, lbaasHandler)).thenReturn(loadBalancerProvider);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(NodeCacheManager.class, lbaasHandler)).thenReturn(nodeCacheManager);
+
+ lbaasHandler.setDependencies(mock(BundleContext.class), mock(ServiceReference.class));
+
+ assertEquals("Error, did not return the correct object", lbaasHandler.eventDispatcher, eventDispatcher);
+ assertEquals("Error, did not return the correct object", getField("loadBalancerProvider"), loadBalancerProvider);
+ assertEquals("Error, did not return the correct object", getField("nodeCacheManager"), nodeCacheManager);
+ }
+
+ @Test
+ public void testSetDependenciesObject() throws Exception{
+ INeutronNetworkCRUD iNeutronNetworkCRUD = mock(INeutronNetworkCRUD.class);
+ lbaasHandler.setDependencies(iNeutronNetworkCRUD);
+ assertEquals("Error, did not return the correct object", getField("neutronNetworkCache"), iNeutronNetworkCRUD);
+
+ INeutronPortCRUD iNeutronPortCRUD = mock(INeutronPortCRUD.class);
+ lbaasHandler.setDependencies(iNeutronPortCRUD);
+ assertEquals("Error, did not return the correct object", getField("neutronPortCache"), iNeutronPortCRUD);
+
+ INeutronSubnetCRUD iNeutronSubnetCRUD = mock(INeutronSubnetCRUD.class);
+ lbaasHandler.setDependencies(iNeutronSubnetCRUD);
+ assertEquals("Error, did not return the correct object", getField("neutronSubnetCache"), iNeutronSubnetCRUD);
+
+ INeutronLoadBalancerCRUD iNeutronLoadBalancerCRUD = mock(INeutronLoadBalancerCRUD.class);
+ lbaasHandler.setDependencies(iNeutronLoadBalancerCRUD);
+ assertEquals("Error, did not return the correct object", getField("neutronLBCache"), iNeutronLoadBalancerCRUD);
+
+ INeutronLoadBalancerPoolCRUD iNeutronLoadBalancerPoolCRUD = mock(INeutronLoadBalancerPoolCRUD.class);
+ lbaasHandler.setDependencies(iNeutronLoadBalancerPoolCRUD);
+ assertEquals("Error, did not return the correct object", getField("neutronLBPoolCache"), iNeutronLoadBalancerPoolCRUD);
+
+ LoadBalancerProvider loadBalancerProvider = mock(LoadBalancerProvider.class);
+ lbaasHandler.setDependencies(loadBalancerProvider);
+ assertEquals("Error, did not return the correct object", getField("loadBalancerProvider"), loadBalancerProvider);
+ }
+
+ private Object getField(String fieldName) throws Exception {
+ Field field = LBaaSHandler.class.getDeclaredField(fieldName);
+ field.setAccessible(true);
+ return field.get(lbaasHandler);
+ }
}
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import java.lang.reflect.Field;
import java.net.HttpURLConnection;
import java.util.ArrayList;
import java.util.List;
import java.util.Map.Entry;
import org.junit.Before;
-import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.opendaylight.neutron.spi.NeutronLoadBalancerPool;
import org.opendaylight.neutron.spi.NeutronLoadBalancerPoolMember;
import org.opendaylight.ovsdb.openstack.netvirt.api.Action;
+import org.opendaylight.ovsdb.openstack.netvirt.api.EventDispatcher;
import org.opendaylight.ovsdb.openstack.netvirt.api.LoadBalancerConfiguration;
import org.opendaylight.ovsdb.openstack.netvirt.api.LoadBalancerConfiguration.LoadBalancerPoolMember;
import org.opendaylight.ovsdb.openstack.netvirt.api.LoadBalancerProvider;
import org.opendaylight.ovsdb.openstack.netvirt.api.NodeCacheManager;
+import org.opendaylight.ovsdb.utils.servicehelper.ServiceHelper;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.ServiceReference;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
/**
* Unit test for {@link LBaaSPoolMemberHandler}
*/
-/* TODO SB_MIGRATION */ @Ignore
-@PrepareForTest(NeutronCacheUtils.class)
+@PrepareForTest({NeutronCacheUtils.class, ServiceHelper.class})
@RunWith(PowerMockRunner.class)
public class LBaaSPoolHandlerTest {
public void setUp() {
when(neutronLBPool.getLoadBalancerPoolProtocol()).thenReturn(LoadBalancerConfiguration.PROTOCOL_HTTP);
- List<NeutronLoadBalancerPoolMember> members = new ArrayList();
+ List<NeutronLoadBalancerPoolMember> members = new ArrayList<NeutronLoadBalancerPoolMember>();
NeutronLoadBalancerPoolMember neutronLBPoolMember = mock(NeutronLoadBalancerPoolMember.class);
when(neutronLBPoolMember.getPoolMemberAdminStateIsUp()).thenReturn(true);
when(neutronLBPoolMember.getPoolMemberSubnetID()).thenReturn("subnetID");
members.add(neutronLBPoolMember);
when(neutronLBPool.getLoadBalancerPoolMembers()).thenReturn(members);
- List<NeutronLoadBalancer> list_neutronLB = new ArrayList();
+ List<NeutronLoadBalancer> list_neutronLB = new ArrayList<NeutronLoadBalancer>();
NeutronLoadBalancer neutronLB = mock(NeutronLoadBalancer.class);
when(neutronLB.getLoadBalancerName()).thenReturn("load_balancer_name");
when(neutronLB.getLoadBalancerVipAddress()).thenReturn("vip_address");
NorthboundEvent ev = mock(NorthboundEvent.class);
when(ev.getLoadBalancerPool()).thenReturn(neutronLBPool);
- List<Node> list_node = new ArrayList();
+ List<Node> list_node = new ArrayList<Node>();
list_node .add(mock(Node.class));
when(nodeCacheManager.getBridgeNodes()).thenReturn(list_node);
assertEquals("Error, did not return the correct value", LoadBalancerConfiguration.PROTOCOL_HTTP, member.getProtocol());
assertTrue("Error, did not return the correct value", 1 == member.getPort());
}
+
+ @Test
+ public void testSetDependencies() throws Exception {
+ EventDispatcher eventDispatcher = mock(EventDispatcher.class);
+ LoadBalancerProvider loadBalancerProvider = mock(LoadBalancerProvider.class);
+ NodeCacheManager nodeCacheManager = mock(NodeCacheManager.class);
+
+ PowerMockito.mockStatic(ServiceHelper.class);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(EventDispatcher.class, lBaaSPoolHandler)).thenReturn(eventDispatcher);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(LoadBalancerProvider.class, lBaaSPoolHandler)).thenReturn(loadBalancerProvider);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(NodeCacheManager.class, lBaaSPoolHandler)).thenReturn(nodeCacheManager);
+
+ lBaaSPoolHandler.setDependencies(mock(BundleContext.class), mock(ServiceReference.class));
+
+ assertEquals("Error, did not return the correct object", lBaaSPoolHandler.eventDispatcher, eventDispatcher);
+ assertEquals("Error, did not return the correct object", getField("loadBalancerProvider"), loadBalancerProvider);
+ assertEquals("Error, did not return the correct object", getField("nodeCacheManager"), nodeCacheManager);
+ }
+
+ @Test
+ public void testSetDependenciesObject() throws Exception{
+ INeutronNetworkCRUD iNeutronNetworkCRUD = mock(INeutronNetworkCRUD.class);
+ lBaaSPoolHandler.setDependencies(iNeutronNetworkCRUD);
+ assertEquals("Error, did not return the correct object", getField("neutronNetworkCache"), iNeutronNetworkCRUD);
+
+ INeutronPortCRUD iNeutronPortCRUD = mock(INeutronPortCRUD.class);
+ lBaaSPoolHandler.setDependencies(iNeutronPortCRUD);
+ assertEquals("Error, did not return the correct object", getField("neutronPortCache"), iNeutronPortCRUD);
+
+ INeutronSubnetCRUD iNeutronSubnetCRUD = mock(INeutronSubnetCRUD.class);
+ lBaaSPoolHandler.setDependencies(iNeutronSubnetCRUD);
+ assertEquals("Error, did not return the correct object", getField("neutronSubnetCache"), iNeutronSubnetCRUD);
+
+ INeutronLoadBalancerCRUD iNeutronLoadBalancerCRUD = mock(INeutronLoadBalancerCRUD.class);
+ lBaaSPoolHandler.setDependencies(iNeutronLoadBalancerCRUD);
+ assertEquals("Error, did not return the correct object", getField("neutronLBCache"), iNeutronLoadBalancerCRUD);
+
+ LoadBalancerProvider loadBalancerProvider = mock(LoadBalancerProvider.class);
+ lBaaSPoolHandler.setDependencies(loadBalancerProvider);
+ assertEquals("Error, did not return the correct object", getField("loadBalancerProvider"), loadBalancerProvider);
+ }
+
+ private Object getField(String fieldName) throws Exception {
+ Field field = LBaaSPoolHandler.class.getDeclaredField(fieldName);
+ field.setAccessible(true);
+ return field.get(lBaaSPoolHandler);
+ }
}
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import java.lang.reflect.Field;
import java.net.HttpURLConnection;
import java.util.ArrayList;
import java.util.List;
import java.util.Map.Entry;
import org.junit.Before;
-import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.opendaylight.neutron.spi.NeutronLoadBalancerPool;
import org.opendaylight.neutron.spi.NeutronLoadBalancerPoolMember;
import org.opendaylight.ovsdb.openstack.netvirt.api.Action;
+import org.opendaylight.ovsdb.openstack.netvirt.api.EventDispatcher;
import org.opendaylight.ovsdb.openstack.netvirt.api.LoadBalancerConfiguration;
import org.opendaylight.ovsdb.openstack.netvirt.api.LoadBalancerConfiguration.LoadBalancerPoolMember;
import org.opendaylight.ovsdb.openstack.netvirt.api.LoadBalancerProvider;
import org.opendaylight.ovsdb.openstack.netvirt.api.NodeCacheManager;
+import org.opendaylight.ovsdb.utils.servicehelper.ServiceHelper;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.ServiceReference;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
/**
* Unit test for {@link LBaaSPoolMemberHandler}
*/
-/* TODO SB_MIGRATION */ @Ignore
-@PrepareForTest(NeutronCacheUtils.class)
+@PrepareForTest({NeutronCacheUtils.class, ServiceHelper.class})
@RunWith(PowerMockRunner.class)
public class LBaaSPoolMemberHandlerTest {
when(NeutronCacheUtils.getMacAddress(any(INeutronPortCRUD.class), anyString(), anyString())).thenReturn("mac_address");
when(NeutronCacheUtils.getProviderInformation(any(INeutronNetworkCRUD.class), any(INeutronSubnetCRUD.class), anyString())).thenReturn(providerInfo);
- List<NeutronLoadBalancerPoolMember> members = new ArrayList();
+ List<NeutronLoadBalancerPoolMember> members = new ArrayList<NeutronLoadBalancerPoolMember>();
NeutronLoadBalancerPoolMember neutronLBPoolMember = mock(NeutronLoadBalancerPoolMember.class);
when(neutronLBPoolMember.getPoolMemberAdminStateIsUp()).thenReturn(true);
when(neutronLBPoolMember.getPoolMemberSubnetID()).thenReturn("subnetID");
when(neutronLBPool.getLoadBalancerPoolMembers()).thenReturn(members);
when(neutronLBPoolCache.getNeutronLoadBalancerPool(anyString())).thenReturn(neutronLBPool);
- List<NeutronLoadBalancer> list_neutronLB = new ArrayList();
+ List<NeutronLoadBalancer> list_neutronLB = new ArrayList<NeutronLoadBalancer>();
NeutronLoadBalancer neutronLB = mock(NeutronLoadBalancer.class);
when(neutronLB.getLoadBalancerName()).thenReturn("load_balancer_name");
when(neutronLB.getLoadBalancerVipAddress()).thenReturn("vip_address");
NorthboundEvent ev = mock(NorthboundEvent.class);
when(ev.getLoadBalancerPoolMember()).thenReturn(neutronLBMember);
- List<Node> list_node = new ArrayList();
+ List<Node> list_node = new ArrayList<Node>();
list_node .add(mock(Node.class));
when(nodeCacheManager.getBridgeNodes()).thenReturn(list_node);
assertEquals("Error, did not return the correct value", LoadBalancerConfiguration.PROTOCOL_TCP, member.getProtocol());
assertTrue("Error, did not return the correct value", 1 == member.getPort());
}
+
+ @Test
+ public void testSetDependencies() throws Exception {
+ EventDispatcher eventDispatcher = mock(EventDispatcher.class);
+ LoadBalancerProvider loadBalancerProvider = mock(LoadBalancerProvider.class);
+ NodeCacheManager nodeCacheManager = mock(NodeCacheManager.class);
+
+ PowerMockito.mockStatic(ServiceHelper.class);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(EventDispatcher.class, lBaaSPoolMemberHandler)).thenReturn(eventDispatcher);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(LoadBalancerProvider.class, lBaaSPoolMemberHandler)).thenReturn(loadBalancerProvider);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(NodeCacheManager.class, lBaaSPoolMemberHandler)).thenReturn(nodeCacheManager);
+
+ lBaaSPoolMemberHandler.setDependencies(mock(BundleContext.class), mock(ServiceReference.class));
+
+ assertEquals("Error, did not return the correct object", lBaaSPoolMemberHandler.eventDispatcher, eventDispatcher);
+ assertEquals("Error, did not return the correct object", getField("loadBalancerProvider"), loadBalancerProvider);
+ assertEquals("Error, did not return the correct object", getField("nodeCacheManager"), nodeCacheManager);
+ }
+
+ @Test
+ public void testSetDependenciesObject() throws Exception{
+ INeutronNetworkCRUD iNeutronNetworkCRUD = mock(INeutronNetworkCRUD.class);
+ lBaaSPoolMemberHandler.setDependencies(iNeutronNetworkCRUD);
+ assertEquals("Error, did not return the correct object", getField("neutronNetworkCache"), iNeutronNetworkCRUD);
+
+ INeutronPortCRUD iNeutronPortCRUD = mock(INeutronPortCRUD.class);
+ lBaaSPoolMemberHandler.setDependencies(iNeutronPortCRUD);
+ assertEquals("Error, did not return the correct object", getField("neutronPortCache"), iNeutronPortCRUD);
+
+ INeutronSubnetCRUD iNeutronSubnetCRUD = mock(INeutronSubnetCRUD.class);
+ lBaaSPoolMemberHandler.setDependencies(iNeutronSubnetCRUD);
+ assertEquals("Error, did not return the correct object", getField("neutronSubnetCache"), iNeutronSubnetCRUD);
+
+ INeutronLoadBalancerCRUD iNeutronLoadBalancerCRUD = mock(INeutronLoadBalancerCRUD.class);
+ lBaaSPoolMemberHandler.setDependencies(iNeutronLoadBalancerCRUD);
+ assertEquals("Error, did not return the correct object", getField("neutronLBCache"), iNeutronLoadBalancerCRUD);
+
+ INeutronLoadBalancerPoolCRUD iNeutronLoadBalancerPoolCRUD = mock(INeutronLoadBalancerPoolCRUD.class);
+ lBaaSPoolMemberHandler.setDependencies(iNeutronLoadBalancerPoolCRUD);
+ assertEquals("Error, did not return the correct object", getField("neutronLBPoolCache"), iNeutronLoadBalancerPoolCRUD);
+
+ LoadBalancerProvider loadBalancerProvider = mock(LoadBalancerProvider.class);
+ lBaaSPoolMemberHandler.setDependencies(loadBalancerProvider);
+ assertEquals("Error, did not return the correct object", getField("loadBalancerProvider"), loadBalancerProvider);
+ }
+
+ private Object getField(String fieldName) throws Exception {
+ Field field = LBaaSPoolMemberHandler.class.getDeclaredField(fieldName);
+ field.setAccessible(true);
+ return field.get(lBaaSPoolMemberHandler);
+ }
}
import static org.junit.Assert.assertEquals;
import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyString;
import static org.mockito.Matchers.same;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import java.lang.reflect.Field;
import java.net.HttpURLConnection;
import java.util.ArrayList;
-import java.util.HashSet;
import java.util.List;
-import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
-import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
import org.opendaylight.neutron.spi.INeutronNetworkCRUD;
import org.opendaylight.neutron.spi.NeutronNetwork;
import org.opendaylight.ovsdb.openstack.netvirt.api.Action;
import org.opendaylight.ovsdb.openstack.netvirt.api.BridgeConfigurationManager;
+import org.opendaylight.ovsdb.openstack.netvirt.api.EventDispatcher;
+import org.opendaylight.ovsdb.openstack.netvirt.api.NodeCacheManager;
+import org.opendaylight.ovsdb.openstack.netvirt.api.Southbound;
import org.opendaylight.ovsdb.openstack.netvirt.api.TenantNetworkManager;
import org.opendaylight.ovsdb.openstack.netvirt.impl.NeutronL3Adapter;
-//import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
+import org.opendaylight.ovsdb.utils.servicehelper.ServiceHelper;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.ServiceReference;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
/**
* Unit test for {@link NetworkHandler}
*/
-@Ignore // TODO SB_MIGRATION
-@RunWith(MockitoJUnitRunner.class)
+@RunWith(PowerMockRunner.class)
+@PrepareForTest(ServiceHelper.class)
public class NetworkHandlerTest {
- @InjectMocks NetworkHandler networkHandler;
+ @InjectMocks private NetworkHandler networkHandler;
- @Mock NeutronNetwork neutronNetwork;
+ @Mock private NeutronNetwork neutronNetwork;
@Mock private NeutronL3Adapter neutronL3Adapter;
@Mock private TenantNetworkManager tenantNetworkManager;
@Mock private INeutronNetworkCRUD neutronNetworkCache;
@Mock private BridgeConfigurationManager bridgeConfigurationManager;
+ @Mock private NodeCacheManager nodeCacheManager;
+ @Mock private Southbound southbound;
/**
* Test method {@link NetworkHandler#canCreateNetwork(NeutronNetwork)}
/**
* Test method {@link NetworkHandler#processEvent(AbstractEvent)}
*/
- /* TODO SB_MIGRATION */ @Ignore
@Test
public void testProcessEvent() {
NetworkHandler networkHandlerSpy = Mockito.spy(networkHandler);
networkHandlerSpy.processEvent(ev);
verify(neutronL3Adapter, times(1)).handleNeutronNetworkEvent(any(NeutronNetwork.class), same(Action.UPDATE));
- /* configuration needed to pass doNeutronNetworkDeleted() function*/
- //Node node = mock(Node.class);
- //List<Node> nodes = new ArrayList();
- //nodes.add(node);
- /* TODO SB_MIGRATION */
- //when(connectionService.getBridgeNodes()).thenReturn(nodes);
- /*
- ConcurrentMap<String, Row> ports = new ConcurrentHashMap<>();
- Row row = mock(Row.class);
- ports.put("key", row);
- //when(ovsdbConfigurationService.getRows(any(Node.class), anyString())).thenReturn(ports);
-
- Port port = mock(Port.class);
- Column<GenericTableSchema, Set<UUID>> portColumns = mock(Column.class);
- Set<UUID> interfaceUUIDs = new HashSet<UUID>();
- UUID uuid = mock(UUID.class);
- interfaceUUIDs.add(uuid);
- when(port.getInterfacesColumn()).thenReturn(portColumns);
- when(portColumns.getData()).thenReturn(interfaceUUIDs);
- //when(ovsdbConfigurationService.getTypedRow(any(Node.class), same(Port.class), any(Row.class))).thenReturn(port);
-
- Interface iface = mock(Interface.class);
- Column<GenericTableSchema, String> ifaceColumns = mock(Column.class);
- when(iface.getTypeColumn()).thenReturn(ifaceColumns);
- when(ifaceColumns.getData()).thenReturn(NetworkHandler.NETWORK_TYPE_VXLAN);
- //when(ovsdbConfigurationService.getTypedRow(any(Node.class), same(Interface.class), any(Row.class))).thenReturn(iface);
- /**/
+ String portName = "portName";
+
+ List<NeutronNetwork> networks = new ArrayList<NeutronNetwork>();
+ when(neutronNetworkCache.getAllNetworks()).thenReturn(networks);
+
+ List<Node> nodes = new ArrayList<Node>();
+ nodes.add(mock(Node.class));
+ when(nodeCacheManager.getNodes()).thenReturn(nodes);
+
+ List<String> phyIfName = new ArrayList<String>();
+ phyIfName.add(portName);
+ when(bridgeConfigurationManager.getAllPhysicalInterfaceNames(any(Node.class))).thenReturn(phyIfName );
+
+ List<OvsdbTerminationPointAugmentation> ports = new ArrayList<OvsdbTerminationPointAugmentation>();
+ OvsdbTerminationPointAugmentation port = mock(OvsdbTerminationPointAugmentation.class);
+ when(port.getName()).thenReturn(portName);
+ ports.add(port);
+ when(southbound.getTerminationPointsOfBridge(any(Node.class))).thenReturn(ports);
+
+ when(southbound.isTunnel(any(OvsdbTerminationPointAugmentation.class))).thenReturn(true, false);
when(ev.getAction()).thenReturn(Action.DELETE);
- networkHandlerSpy.processEvent(ev);
- /* TODO SB_MIGRATION */
- //verify(neutronL3Adapter, times(1)).handleNeutronNetworkEvent(any(NeutronNetwork.class), same(Action.DELETE));
- //verify(tenantNetworkManager, times(1)).networkDeleted(anyString());
+ networkHandlerSpy.processEvent(ev); // test delete with southbound.isTunnel(true)
+ networkHandlerSpy.processEvent(ev); // test delete with southbound.isTunnel(false)
+ // the functions are called once per call to processEvent()
+ verify(neutronL3Adapter, times(2)).handleNeutronNetworkEvent(any(NeutronNetwork.class), same(Action.DELETE));
+ verify(tenantNetworkManager, times(2)).networkDeleted(anyString());
+ // depending on the southbound.isTunnel()
+ verify(southbound, times(2)).deleteTerminationPoint(any(Node.class), anyString());
+ }
+
+ @Test
+ public void testSetDependencies() throws Exception {
+ TenantNetworkManager tenantNetworkManager = mock(TenantNetworkManager.class);
+ BridgeConfigurationManager bridgeConfigurationManager = mock(BridgeConfigurationManager.class);
+ NodeCacheManager nodeCacheManager = mock(NodeCacheManager.class);
+ NeutronL3Adapter neutronL3Adapter = mock(NeutronL3Adapter.class);
+ Southbound southbound = mock(Southbound.class);
+ EventDispatcher eventDispatcher = mock(EventDispatcher.class);
+
+
+ PowerMockito.mockStatic(ServiceHelper.class);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(TenantNetworkManager.class, networkHandler)).thenReturn(tenantNetworkManager);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(BridgeConfigurationManager.class, networkHandler)).thenReturn(bridgeConfigurationManager);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(NodeCacheManager.class, networkHandler)).thenReturn(nodeCacheManager);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(NeutronL3Adapter.class, networkHandler)).thenReturn(neutronL3Adapter);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(Southbound.class, networkHandler)).thenReturn(southbound);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(EventDispatcher.class, networkHandler)).thenReturn(eventDispatcher);
+
+ networkHandler.setDependencies(mock(BundleContext.class), mock(ServiceReference.class));
+
+ assertEquals("Error, did not return the correct object", getField("tenantNetworkManager"), tenantNetworkManager);
+ assertEquals("Error, did not return the correct object", getField("bridgeConfigurationManager"), bridgeConfigurationManager);
+ assertEquals("Error, did not return the correct object", getField("nodeCacheManager"), nodeCacheManager);
+ assertEquals("Error, did not return the correct object", getField("neutronL3Adapter"), neutronL3Adapter);
+ assertEquals("Error, did not return the correct object", getField("southbound"), southbound);
+ assertEquals("Error, did not return the correct object", networkHandler.eventDispatcher, eventDispatcher);
+ }
+
+ @Test
+ public void testSetDependenciesObject() throws Exception{
+ INeutronNetworkCRUD iNeutronNetworkCRUD = mock(INeutronNetworkCRUD.class);
+ networkHandler.setDependencies(iNeutronNetworkCRUD);
+ assertEquals("Error, did not return the correct object", getField("neutronNetworkCache"), iNeutronNetworkCRUD);
+}
+
+ private Object getField(String fieldName) throws Exception {
+ Field field = NetworkHandler.class.getDeclaredField(fieldName);
+ field.setAccessible(true);
+ return field.get(networkHandler);
}
}
Neutron_IPs ip = mock(Neutron_IPs.class);
when(ip.getIpAddress()).thenReturn("ip_address");
when(ip.getSubnetUUID()).thenReturn("subnetUUID");
- List<Neutron_IPs> list_fixedIP = new ArrayList();
+ List<Neutron_IPs> list_fixedIP = new ArrayList<Neutron_IPs>();
list_fixedIP.add(ip);
when(port.getFixedIPs()).thenReturn(list_fixedIP);
when(port.getMacAddress()).thenReturn("mac_address");
- List<NeutronPort> list_port = new ArrayList();
+ List<NeutronPort> list_port = new ArrayList<NeutronPort>();
list_port.add(port);
when(neutronPortsCache.getAllPorts()).thenReturn(list_port);
NeutronSubnet subnet = mock(NeutronSubnet.class);
when(subnet.getID()).thenReturn("subnetUUID");
when(subnet.getNetworkUUID()).thenReturn("networkUUID");
- List<NeutronSubnet> list_subnet = new ArrayList();
+ List<NeutronSubnet> list_subnet = new ArrayList<NeutronSubnet>();
list_subnet.add(subnet);
when(neutronSubnetCache.getAllSubnets()).thenReturn(list_subnet );
when(network.getID()).thenReturn("networkUUID");
when(network.getProviderNetworkType()).thenReturn("network_type_1");
when(network.getProviderSegmentationID()).thenReturn("network_segID");
- List<NeutronNetwork> list_network = new ArrayList();
+ List<NeutronNetwork> list_network = new ArrayList<NeutronNetwork>();
list_network.add(network);
when(neutronNetworkCache.getAllNetworks()).thenReturn(list_network);
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
-import org.junit.Before;
-import org.junit.Ignore;
import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.runners.MockitoJUnitRunner;
import org.opendaylight.ovsdb.openstack.netvirt.api.Action;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
/**
* Unit test for {@link NodeCacheManagerEvent}
*/
-/* TODO SB_MIGRATION */
-@Ignore
-public class NodeCacheManagerEventTest {
- private NodeCacheManagerEvent nodeCacheManagerEvent;
+@RunWith(MockitoJUnitRunner.class)
+public class NodeCacheManagerEventTest {
- @Before
- public void setUp() {
- /* TODO SB_MIGRATION */
- //nodeCacheManagerEvent = new NodeCacheManagerEvent("nodeIdentifier", Action.ADD);
- }
+ @InjectMocks private NodeCacheManagerEvent nodeCacheManagerEvent;
@Test
public void testToString() {
- assertEquals("Error, toString() did not return the correct string", "NodeCacheManagerEvent [action=ADD, nodeIdentifier=nodeIdentifier]", nodeCacheManagerEvent.toString());
+ Node node = mock(Node.class);
+ nodeCacheManagerEvent = new NodeCacheManagerEvent(node, Action.ADD);
+ assertEquals("Error, toString() did not return the correct string", "NodeCacheManagerEvent [action=ADD, node=" + node + "]", nodeCacheManagerEvent.toString());
}
@Test
import static org.junit.Assert.assertEquals;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyString;
-import static org.mockito.Matchers.same;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import java.lang.reflect.Field;
import java.net.HttpURLConnection;
import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.HashSet;
import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
-import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
import org.opendaylight.neutron.spi.NeutronPort;
import org.opendaylight.ovsdb.openstack.netvirt.api.Action;
-import org.opendaylight.ovsdb.openstack.netvirt.api.Constants;
+import org.opendaylight.ovsdb.openstack.netvirt.api.EventDispatcher;
+import org.opendaylight.ovsdb.openstack.netvirt.api.NodeCacheManager;
+import org.opendaylight.ovsdb.openstack.netvirt.api.Southbound;
import org.opendaylight.ovsdb.openstack.netvirt.impl.NeutronL3Adapter;
-//import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
+import org.opendaylight.ovsdb.utils.servicehelper.ServiceHelper;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.ServiceReference;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
/**
* Unit test fort {@link PortHandler}
*/
-@Ignore // TODO SB_MIGRATION
-@RunWith(MockitoJUnitRunner.class)
+@RunWith(PowerMockRunner.class)
+@PrepareForTest(ServiceHelper.class)
public class PortHandlerTest {
- @InjectMocks PortHandler portHandler;
+ @InjectMocks private PortHandler portHandler;
@Mock private NeutronL3Adapter neutronL3Adapter;
+ @Mock private NodeCacheManager nodeCacheManager;
+ @Mock private Southbound southbound;
@Test
public void testCanCreatePort() {
assertEquals("Error, did not return the correct HTTP flag", HttpURLConnection.HTTP_OK, portHandler.canDeletePort(mock(NeutronPort.class)));
}
- @Ignore
@Test
public void testProcessEvent() {
PortHandler portHandlerSpy = Mockito.spy(portHandler);
portHandlerSpy.processEvent(ev);
verify(neutronL3Adapter, times(1)).handleNeutronPortEvent(neutronPort, Action.UPDATE);
+ List<Node> nodes = new ArrayList<Node>();
+ nodes.add(mock(Node.class));
+ when(nodeCacheManager.getNodes()).thenReturn(nodes);
- //Node node = mock(Node.class);
- //List<Node> nodes = new ArrayList();
- //nodes.add(node);
- /* TODO SB_MIGRATION */
- //when(connectionService.getBridgeNodes()).thenReturn(nodes);
-
- //Row row = mock(Row.class);
- //ConcurrentMap<String, Row> portRows = new ConcurrentHashMap();
- //portRows.put("key", row);
- //when(ovsdbConfigurationService.getRows(any(Node.class), anyString())).thenReturn(portRows );
-
- //Port port = mock(Port.class);
- //Column<GenericTableSchema, Set<UUID>> itfaceColumns = mock(Column.class);
- //when(port.getInterfacesColumn()).thenReturn(itfaceColumns);
- //Set<UUID> ifaceUUIDs = new HashSet();
- //ifaceUUIDs.add(mock(UUID.class));
- //when(itfaceColumns.getData()).thenReturn(ifaceUUIDs );
- //when(ovsdbConfigurationService.getTypedRow(any(Node.class), same(Port.class), any(Row.class))).thenReturn(port);
-
- //Interface itface = mock(Interface.class);
- //Column<GenericTableSchema, Map<String, String>> externalIdColumns = mock(Column.class);
- Map<String, String> externalIds = new HashMap();
- externalIds.put(Constants.EXTERNAL_ID_INTERFACE_ID, "portUUID");
- //when(externalIdColumns.getData()).thenReturn(externalIds);
- //when(itface.getExternalIdsColumn()).thenReturn(externalIdColumns);
- //when(ovsdbConfigurationService.getTypedRow(any(Node.class), same(Interface.class), any(Row.class))).thenReturn(itface);
+ List<OvsdbTerminationPointAugmentation> ports = new ArrayList<OvsdbTerminationPointAugmentation>();
+ OvsdbTerminationPointAugmentation port = mock(OvsdbTerminationPointAugmentation.class);
+ ports.add(port);
+ when(southbound.getTerminationPointsOfBridge(any(Node.class))).thenReturn(ports);
+ when(southbound.getInterfaceExternalIdsValue(any(OvsdbTerminationPointAugmentation.class), anyString())).thenReturn("portUUID");
when(ev.getAction()).thenReturn(Action.DELETE);
- //portHandlerSpy.processEvent(ev);
+ portHandlerSpy.processEvent(ev);
verify(neutronL3Adapter, times(1)).handleNeutronPortEvent(neutronPort, Action.DELETE);
+ verify(southbound, times(1)).deleteTerminationPoint(any(Node.class), anyString());
+ }
+
+ @Test
+ public void testSetDependencies() throws Exception {
+ NodeCacheManager nodeCacheManager = mock(NodeCacheManager.class);
+ NeutronL3Adapter neutronL3Adapter = mock(NeutronL3Adapter.class);
+ Southbound southbound = mock(Southbound.class);
+ EventDispatcher eventDispatcher = mock(EventDispatcher.class);
+
+ PowerMockito.mockStatic(ServiceHelper.class);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(NodeCacheManager.class, portHandler)).thenReturn(nodeCacheManager);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(NeutronL3Adapter.class, portHandler)).thenReturn(neutronL3Adapter);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(Southbound.class, portHandler)).thenReturn(southbound);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(EventDispatcher.class, portHandler)).thenReturn(eventDispatcher);
+
+ portHandler.setDependencies(mock(BundleContext.class), mock(ServiceReference.class));
+
+ assertEquals("Error, did not return the correct object", getField("nodeCacheManager"), nodeCacheManager);
+ assertEquals("Error, did not return the correct object", getField("neutronL3Adapter"), neutronL3Adapter);
+ assertEquals("Error, did not return the correct object", getField("southbound"), southbound);
+ assertEquals("Error, did not return the correct object", portHandler.eventDispatcher, eventDispatcher);
+ }
+
+ private Object getField(String fieldName) throws Exception {
+ Field field = PortHandler.class.getDeclaredField(fieldName);
+ field.setAccessible(true);
+ return field.get(portHandler);
}
}
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
+import java.lang.reflect.Field;
import java.net.HttpURLConnection;
import org.junit.Before;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
import org.opendaylight.neutron.spi.NeutronSecurityGroup;
import org.opendaylight.neutron.spi.NeutronSecurityRule;
+import org.opendaylight.ovsdb.openstack.netvirt.api.EventDispatcher;
+import org.opendaylight.ovsdb.utils.servicehelper.ServiceHelper;
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.ServiceReference;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
/**
* Unit test {@link PortSecurityHandler}
*/
-@RunWith(MockitoJUnitRunner.class)
+@RunWith(PowerMockRunner.class)
+@PrepareForTest(ServiceHelper.class)
public class PortSecurityHandlerTest {
@InjectMocks private PortSecurityHandler portSecurityHandler;
// TODO see PortSecurityHandler#processEvent()
}
+ @Test
+ public void testSetDependencies() throws Exception {
+ EventDispatcher eventDispatcher = mock(EventDispatcher.class);
+
+ PowerMockito.mockStatic(ServiceHelper.class);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(EventDispatcher.class, portSecurityHandler)).thenReturn(eventDispatcher);
+
+ portSecurityHandler.setDependencies(mock(BundleContext.class), mock(ServiceReference.class));
+
+ assertEquals("Error, did not return the correct object", portSecurityHandler.eventDispatcher, eventDispatcher);
+ }
+
+
+ private Object getField(String fieldName) throws Exception {
+ Field field = PortSecurityHandler.class.getDeclaredField(fieldName);
+ field.setAccessible(true);
+ return field.get(portSecurityHandler);
+ }
+
}
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import java.lang.reflect.Field;
import java.net.HttpURLConnection;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
-import org.mockito.runners.MockitoJUnitRunner;
import org.opendaylight.neutron.spi.NeutronRouter;
import org.opendaylight.neutron.spi.NeutronRouter_Interface;
import org.opendaylight.ovsdb.openstack.netvirt.api.Action;
+import org.opendaylight.ovsdb.openstack.netvirt.api.EventDispatcher;
import org.opendaylight.ovsdb.openstack.netvirt.impl.NeutronL3Adapter;
+import org.opendaylight.ovsdb.utils.servicehelper.ServiceHelper;
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.ServiceReference;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
/**
* Unit test fort {@link RouterHandler}
*/
-@RunWith(MockitoJUnitRunner.class)
+@RunWith(PowerMockRunner.class)
+@PrepareForTest(ServiceHelper.class)
public class RouterHandlerTest {
@InjectMocks RouterHandler routerHandler;
routerHandler.processEvent(ev);
verify(neutronL3Adapter, times(1)).handleNeutronRouterInterfaceEvent(ev.getRouter(), ev.getRouterInterface(), Action.UPDATE);
}
+
+ @Test
+ public void testSetDependencies() throws Exception {
+ NeutronL3Adapter neutronL3Adapter = mock(NeutronL3Adapter.class);
+ EventDispatcher eventDispatcher = mock(EventDispatcher.class);
+
+ PowerMockito.mockStatic(ServiceHelper.class);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(NeutronL3Adapter.class, routerHandler)).thenReturn(neutronL3Adapter);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(EventDispatcher.class, routerHandler)).thenReturn(eventDispatcher);
+
+ routerHandler.setDependencies(mock(BundleContext.class), mock(ServiceReference.class));
+
+ assertEquals("Error, did not return the correct object", getField("neutronL3Adapter"), neutronL3Adapter);
+ assertEquals("Error, did not return the correct object", routerHandler.eventDispatcher, eventDispatcher);
+ }
+
+ private Object getField(String fieldName) throws Exception {
+ Field field = RouterHandler.class.getDeclaredField(fieldName);
+ field.setAccessible(true);
+ return field.get(routerHandler);
+ }
}
--- /dev/null
+/*
+ * Copyright (c) 2015 Inocybe and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.ovsdb.openstack.netvirt;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.opendaylight.neutron.spi.NeutronNetwork;
+import org.opendaylight.ovsdb.openstack.netvirt.SouthboundEvent.Type;
+import org.opendaylight.ovsdb.openstack.netvirt.api.Action;
+import org.opendaylight.ovsdb.openstack.netvirt.api.BridgeConfigurationManager;
+import org.opendaylight.ovsdb.openstack.netvirt.api.ConfigurationService;
+import org.opendaylight.ovsdb.openstack.netvirt.api.EventDispatcher;
+import org.opendaylight.ovsdb.openstack.netvirt.api.NetworkingProvider;
+import org.opendaylight.ovsdb.openstack.netvirt.api.NetworkingProviderManager;
+import org.opendaylight.ovsdb.openstack.netvirt.api.NodeCacheManager;
+import org.opendaylight.ovsdb.openstack.netvirt.api.OvsdbInventoryListener.OvsdbType;
+import org.opendaylight.ovsdb.openstack.netvirt.api.OvsdbInventoryService;
+import org.opendaylight.ovsdb.openstack.netvirt.api.Southbound;
+import org.opendaylight.ovsdb.openstack.netvirt.api.TenantNetworkManager;
+import org.opendaylight.ovsdb.openstack.netvirt.impl.NeutronL3Adapter;
+import org.opendaylight.ovsdb.utils.servicehelper.ServiceHelper;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.ServiceReference;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+/**
+ * Unit test fort {@link SouthboundHandler}
+ */
+@RunWith(PowerMockRunner.class)
+@PrepareForTest(ServiceHelper.class)
+public class SouthboundHandlerTest {
+
+ @InjectMocks private SouthboundHandler southboundHandler;
+ private SouthboundHandler southboundHandlerSpy;
+
+ @Mock private ConfigurationService configurationService;
+ @Mock private BridgeConfigurationManager bridgeConfigurationManager;
+ @Mock private TenantNetworkManager tenantNetworkManager;
+ @Mock private NetworkingProviderManager networkingProviderManager;
+ @Mock private NeutronL3Adapter neutronL3Adapter;
+ @Mock private NodeCacheManager nodeCacheManager;
+ @Mock private OvsdbInventoryService ovsdbInventoryService;
+ @Mock private Southbound southbound;
+
+ @Before
+ public void setUp() {
+ southboundHandler.eventDispatcher = mock(EventDispatcher.class);
+ southboundHandlerSpy = Mockito.spy(southboundHandler);
+ }
+
+ @Test
+ public void testTriggerUpdates() {
+ Node node = mock(Node.class);
+ when(node.getAugmentation(OvsdbNodeAugmentation.class)).thenReturn(mock(OvsdbNodeAugmentation.class));
+
+ List<Node> nodes = new ArrayList<Node>();
+ nodes.add(mock(Node.class));
+ when(southbound.readOvsdbTopologyNodes()).thenReturn(nodes);
+
+ southboundHandlerSpy.triggerUpdates();
+ verify(southboundHandlerSpy, times(1)).ovsdbUpdate(any(Node.class), any(DataObject.class), any(OvsdbType.class), any(Action.class));;
+ }
+
+ @Test
+ public void testNotifyNode() {
+ when(southbound.getBridge(any(Node.class))).thenReturn(mock(OvsdbBridgeAugmentation.class));
+
+ NetworkingProvider networkingProvider = mock(NetworkingProvider.class);
+ when(networkingProviderManager.getProvider(any(Node.class))).thenReturn(networkingProvider);
+
+ southboundHandlerSpy.notifyNode(mock(Node.class), Action.ADD);
+
+ verify(networkingProvider, times(1)).initializeOFFlowRules(any(Node.class));
+ }
+
+ @Test
+ public void testProcessEvent() {
+ SouthboundEvent ev = mock(SouthboundEvent.class);
+ Node node = mock(Node.class);
+
+ // NODE
+ when(ev.getNode()).thenReturn(node);
+ when(ev.getAugmentationData()).thenReturn(mock(OvsdbNodeAugmentation.class));
+ when(ev.getType()).thenReturn(Type.NODE);
+
+ when(ev.getAction()).thenReturn(Action.ADD);
+ southboundHandler.processEvent(ev);
+ verify(nodeCacheManager, times(1)).nodeAdded(any(Node.class));
+ verify(bridgeConfigurationManager, times(1)).prepareNode(any(Node.class));
+ Mockito.reset(nodeCacheManager);
+
+ when(ev.getAction()).thenReturn(Action.UPDATE);
+ southboundHandler.processEvent(ev);
+ verify(nodeCacheManager, times(1)).nodeAdded(any(Node.class));
+ Mockito.reset(nodeCacheManager);
+
+ when(ev.getAction()).thenReturn(Action.DELETE);
+ southboundHandler.processEvent(ev);
+ verify(nodeCacheManager, times(1)).nodeRemoved(any(Node.class));
+ Mockito.reset(nodeCacheManager);
+
+ Mockito.reset(ev);
+
+ // BRIDGE
+ when(ev.getNode()).thenReturn(node);
+ when(ev.getAugmentationData()).thenReturn(mock(OvsdbBridgeAugmentation.class));
+ when(ev.getType()).thenReturn(Type.BRIDGE);
+
+ when(southbound.getDatapathId(any(OvsdbBridgeAugmentation.class))).thenReturn("45");
+
+ when(ev.getAction()).thenReturn(Action.ADD);
+ southboundHandler.processEvent(ev);
+ verify(nodeCacheManager, times(1)).nodeAdded(any(Node.class));
+ Mockito.reset(nodeCacheManager);
+
+ when(ev.getAction()).thenReturn(Action.UPDATE);
+ southboundHandler.processEvent(ev);
+ verify(nodeCacheManager, times(1)).nodeAdded(any(Node.class));
+ Mockito.reset(nodeCacheManager);
+
+ Mockito.reset(nodeCacheManager);
+ when(ev.getAction()).thenReturn(Action.DELETE);
+ southboundHandler.processEvent(ev);
+ verify(nodeCacheManager, times(1)).nodeRemoved(any(Node.class));
+ verify(southbound, times(1)).deleteBridge(any(Node.class));
+ Mockito.reset(nodeCacheManager);
+ Mockito.reset(southbound);
+
+ Mockito.reset(ev);
+
+ // PORT
+ OvsdbTerminationPointAugmentation ovsdbTerminationPointAugmentation = mock(OvsdbTerminationPointAugmentation.class);
+ when(ovsdbTerminationPointAugmentation.getName()).thenReturn("network");
+// Mockito.<Class<?>>when(ovsdbTerminationPointAugmentation.getInterfaceType()).thenReturn(InterfaceTypeBase.class);
+// when(ovsdbTerminationPointAugmentation.getInterfaceType()).thenReturn(n);
+ when(ev.getNode()).thenReturn(node);
+ when(ev.getAugmentationData()).thenReturn(ovsdbTerminationPointAugmentation);
+ when(ev.getType()).thenReturn(Type.PORT);
+
+ NetworkingProvider networkingProvider = mock(NetworkingProvider.class);
+ NeutronNetwork neutronNetwork = mock(NeutronNetwork.class);
+ when(neutronNetwork.getRouterExternal()).thenReturn(false);
+ when(tenantNetworkManager.getTenantNetwork(any(OvsdbTerminationPointAugmentation.class))).thenReturn(neutronNetwork);
+ when(networkingProviderManager.getProvider(any(Node.class))).thenReturn(networkingProvider);
+ when(bridgeConfigurationManager.createLocalNetwork(any(Node.class), any(NeutronNetwork.class))).thenReturn(true);
+
+ when(ev.getAction()).thenReturn(Action.ADD);
+ southboundHandler.processEvent(ev);
+ verify(neutronL3Adapter, times(1)).handleInterfaceEvent(any(Node.class), any(OvsdbTerminationPointAugmentation.class), any(NeutronNetwork.class), any(Action.class));
+ verify(networkingProvider, times(1)).handleInterfaceUpdate(any(NeutronNetwork.class), any(Node.class), any(OvsdbTerminationPointAugmentation.class));
+ Mockito.reset(neutronL3Adapter);
+ Mockito.reset(networkingProvider);
+
+ when(ev.getAction()).thenReturn(Action.UPDATE);
+ southboundHandler.processEvent(ev);
+ verify(neutronL3Adapter, times(1)).handleInterfaceEvent(any(Node.class), any(OvsdbTerminationPointAugmentation.class), any(NeutronNetwork.class), any(Action.class));
+ verify(networkingProvider, times(1)).handleInterfaceUpdate(any(NeutronNetwork.class), any(Node.class), any(OvsdbTerminationPointAugmentation.class));
+ Mockito.reset(neutronL3Adapter);
+ Mockito.reset(networkingProvider);
+
+// List<String> phyIfName = new ArrayList<String>();
+// phyIfName.add("network");
+// when(bridgeConfigurationManager.getAllPhysicalInterfaceNames(any(Node.class))).thenReturn(phyIfName);
+//
+// when(ev.getAction()).thenReturn(Action.DELETE); //isInterfaceOfIntereset true
+// southboundHandler.processEvent(ev);
+// verify(neutronL3Adapter, times(1)).handleInterfaceEvent(any(Node.class), any(OvsdbTerminationPointAugmentation.class), any(NeutronNetwork.class), any(Action.class));
+// verify(networkingProvider, times(1)).handleInterfaceDelete(anyString(), any(NeutronNetwork.class), any(Node.class), any(OvsdbTerminationPointAugmentation.class), anyBoolean());
+//
+// Mockito.reset(networkingProvider);
+//
+// when(southbound.getBridge(any(Node.class))).thenReturn(mock(OvsdbBridgeAugmentation.class));
+// List<TerminationPoint> terminationPoints = new ArrayList<TerminationPoint>();
+// TerminationPoint terminationPoint = mock(TerminationPoint.class);
+// OvsdbTerminationPointAugmentation ovsdbTerminationPointAugmentation2 = mock(OvsdbTerminationPointAugmentation.class);
+// when(terminationPoint.getAugmentation(any(Class.class))).thenReturn(ovsdbTerminationPointAugmentation);
+// Uuid uuid = mock(Uuid.class);
+// when(ovsdbTerminationPointAugmentation.getInterfaceUuid()).thenReturn(uuid);
+// when(ovsdbTerminationPointAugmentation2.getInterfaceUuid()).thenReturn(uuid);
+// terminationPoints.add(terminationPoint);
+// when(node.getTerminationPoint()).thenReturn(terminationPoints);
+//
+// when(ev.getAction()).thenReturn(Action.DELETE); //isInterfaceOfIntereset false - network != null
+// southboundHandler.processEvent(ev);
+// verify(networkingProvider, times(1)).handleInterfaceDelete(anyString(), any(NeutronNetwork.class), any(Node.class), any(OvsdbTerminationPointAugmentation.class), anyBoolean());
+
+ // OPENVSWITCH
+ when(ev.getNode()).thenReturn(node);
+ when(ev.getAugmentationData()).thenReturn(ovsdbTerminationPointAugmentation);
+ when(ev.getType()).thenReturn(Type.OPENVSWITCH);
+
+ when(ovsdbTerminationPointAugmentation.getName()).thenReturn("network");
+ List<TerminationPoint> terminationPoints = new ArrayList<TerminationPoint>();
+ terminationPoints.add(mock(TerminationPoint.class));
+ when(southbound.extractTerminationPoints(any(Node.class))).thenReturn(terminationPoints);
+
+ when(ev.getAction()).thenReturn(Action.ADD);
+ southboundHandler.processEvent(ev);
+ verify(neutronL3Adapter, times(1)).handleInterfaceEvent(any(Node.class), any(OvsdbTerminationPointAugmentation.class), any(NeutronNetwork.class), any(Action.class));
+ verify(networkingProvider, times(1)).handleInterfaceUpdate(any(NeutronNetwork.class), any(Node.class), any(OvsdbTerminationPointAugmentation.class));
+ Mockito.reset(neutronL3Adapter);
+ Mockito.reset(networkingProvider);
+ }
+
+ @Test
+ public void testSetDependencies() throws Exception {
+ ConfigurationService configurationService = mock(ConfigurationService.class);
+ NetworkingProviderManager networkingProviderManager = mock(NetworkingProviderManager.class);
+ TenantNetworkManager tenantNetworkManager = mock(TenantNetworkManager.class);
+ BridgeConfigurationManager bridgeConfigurationManager = mock(BridgeConfigurationManager.class);
+ NodeCacheManager nodeCacheManager = mock(NodeCacheManager.class);
+ NeutronL3Adapter neutronL3Adapter = mock(NeutronL3Adapter.class);
+ Southbound southbound = mock(Southbound.class);
+ EventDispatcher eventDispatcher = mock(EventDispatcher.class);
+ OvsdbInventoryService ovsdbInventoryService = mock(OvsdbInventoryService.class);
+
+ PowerMockito.mockStatic(ServiceHelper.class);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(ConfigurationService.class, southboundHandler)).thenReturn(configurationService);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(NetworkingProviderManager.class, southboundHandler)).thenReturn(networkingProviderManager);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(TenantNetworkManager.class, southboundHandler)).thenReturn(tenantNetworkManager);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(BridgeConfigurationManager.class, southboundHandler)).thenReturn(bridgeConfigurationManager);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(NodeCacheManager.class, southboundHandler)).thenReturn(nodeCacheManager);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(NeutronL3Adapter.class, southboundHandler)).thenReturn(neutronL3Adapter);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(Southbound.class, southboundHandler)).thenReturn(southbound);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(EventDispatcher.class, southboundHandler)).thenReturn(eventDispatcher);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(OvsdbInventoryService.class, southboundHandler)).thenReturn(ovsdbInventoryService);
+
+ southboundHandler.setDependencies(mock(BundleContext.class), mock(ServiceReference.class));
+ assertEquals("Error, did not return the correct object", getField("configurationService"), configurationService);
+ assertEquals("Error, did not return the correct object", getField("networkingProviderManager"), networkingProviderManager);
+ assertEquals("Error, did not return the correct object", getField("tenantNetworkManager"), tenantNetworkManager);
+ assertEquals("Error, did not return the correct object", getField("bridgeConfigurationManager"), bridgeConfigurationManager);
+ assertEquals("Error, did not return the correct object", getField("nodeCacheManager"), nodeCacheManager);
+ assertEquals("Error, did not return the correct object", getField("neutronL3Adapter"), neutronL3Adapter);
+ assertEquals("Error, did not return the correct object", getField("southbound"), southbound);
+ assertEquals("Error, did not return the correct object", getField("ovsdbInventoryService"), ovsdbInventoryService);
+ assertEquals("Error, did not return the correct object", southboundHandler.eventDispatcher, eventDispatcher);
+ }
+
+ private Object getField(String fieldName) throws Exception {
+ Field field = SouthboundHandler.class.getDeclaredField(fieldName);
+ field.setAccessible(true);
+ return field.get(southboundHandler);
+ }
+}
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import java.lang.reflect.Field;
import java.net.HttpURLConnection;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
-import org.mockito.runners.MockitoJUnitRunner;
import org.opendaylight.neutron.spi.NeutronSubnet;
import org.opendaylight.ovsdb.openstack.netvirt.api.Action;
+import org.opendaylight.ovsdb.openstack.netvirt.api.EventDispatcher;
import org.opendaylight.ovsdb.openstack.netvirt.impl.NeutronL3Adapter;
+import org.opendaylight.ovsdb.utils.servicehelper.ServiceHelper;
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.ServiceReference;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
/**
* Unit test fort {@link SubnetHandler}
*/
-@RunWith(MockitoJUnitRunner.class)
+@RunWith(PowerMockRunner.class)
+@PrepareForTest(ServiceHelper.class)
public class SubnetHandlerTest {
@InjectMocks private SubnetHandler subnetHandler;
subnetHandler.processEvent(ev);
verify(neutronl3Adapter, times(1)).handleNeutronSubnetEvent(ev.getSubnet(), ev.getAction());;
}
+
+ @Test
+ public void testSetDependencies() throws Exception {
+ NeutronL3Adapter neutronL3Adapter = mock(NeutronL3Adapter.class);
+ EventDispatcher eventDispatcher = mock(EventDispatcher.class);
+
+ PowerMockito.mockStatic(ServiceHelper.class);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(NeutronL3Adapter.class, subnetHandler)).thenReturn(neutronL3Adapter);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(EventDispatcher.class, subnetHandler)).thenReturn(eventDispatcher);
+
+ subnetHandler.setDependencies(mock(BundleContext.class), mock(ServiceReference.class));
+
+ assertEquals("Error, did not return the correct object", getField("neutronL3Adapter"), neutronL3Adapter);
+ assertEquals("Error, did not return the correct object", subnetHandler.eventDispatcher, eventDispatcher);
+ }
+
+ private Object getField(String fieldName) throws Exception {
+ Field field = SubnetHandler.class.getDeclaredField(fieldName);
+ field.setAccessible(true);
+ return field.get(subnetHandler);
+ }
}
Code Review / ovsdb.git / commitdiff