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.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.lib.notation.Column;
-import org.opendaylight.ovsdb.lib.notation.Row;
-import org.opendaylight.ovsdb.lib.notation.UUID;
-import org.opendaylight.ovsdb.lib.schema.GenericTableSchema;
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.ovsdb.plugin.api.OvsdbConfigurationService;
-import org.opendaylight.ovsdb.plugin.api.OvsdbConnectionService;
-import org.opendaylight.ovsdb.schema.openvswitch.Interface;
-import org.opendaylight.ovsdb.schema.openvswitch.Port;
-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}
*/
-@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 OvsdbConnectionService connectionService;
@Mock private BridgeConfigurationManager bridgeConfigurationManager;
- @Mock private OvsdbConfigurationService ovsdbConfigurationService;
+ @Mock private NodeCacheManager nodeCacheManager;
+ @Mock private Southbound southbound;
/**
* Test method {@link NetworkHandler#canCreateNetwork(NeutronNetwork)}
.thenReturn(true)
.thenReturn(false);
assertEquals("Error, did not return the correct HTTP flag", HttpURLConnection.HTTP_NOT_ACCEPTABLE, networkHandler.canCreateNetwork(neutronNetwork));
- assertEquals("Error, did not return the correct HTTP flag", HttpURLConnection.HTTP_CREATED, networkHandler.canCreateNetwork(neutronNetwork));
+ assertEquals("Error, did not return the correct HTTP flag", HttpURLConnection.HTTP_OK, networkHandler.canCreateNetwork(neutronNetwork));
}
/**
*/
@Test
public void testCanUpdateNetwork() {
+ when(neutronNetwork.isShared())
+ .thenReturn(true)
+ .thenReturn(false);
+ assertEquals("Error, did not return the correct HTTP flag", HttpURLConnection.HTTP_NOT_ACCEPTABLE, networkHandler.canUpdateNetwork(neutronNetwork, neutronNetwork));
assertEquals("Error, did not return the correct HTTP flag", HttpURLConnection.HTTP_OK, networkHandler.canUpdateNetwork(neutronNetwork, neutronNetwork));
}
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);
- when(connectionService.getNodes()).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);
- verify(neutronL3Adapter, times(1)).handleNeutronNetworkEvent(any(NeutronNetwork.class), same(Action.DELETE));
- verify(networkHandlerSpy, times(1)).canDeleteNetwork(any(NeutronNetwork.class));
- 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);
}
}
Code Review / ovsdb.git / blobdiff