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.Before;
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.translator.NeutronNetwork;
+import org.opendaylight.ovsdb.openstack.netvirt.translator.crud.INeutronNetworkCRUD;
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.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 sharedNeutronNetwork;
+ @Mock private NeutronNetwork nonSharedNeutronNetwork;
@Mock private NeutronL3Adapter neutronL3Adapter;
@Mock private TenantNetworkManager tenantNetworkManager;
@Mock private INeutronNetworkCRUD neutronNetworkCache;
@Mock private BridgeConfigurationManager bridgeConfigurationManager;
+ @Mock private NodeCacheManager nodeCacheManager;
+ @Mock private Southbound southbound;
+
+ @Before
+ public void setup() {
+ when(sharedNeutronNetwork.isShared()).thenReturn(true);
+ when(nonSharedNeutronNetwork.isShared()).thenReturn(false);
+ }
/**
* Test method {@link NetworkHandler#canCreateNetwork(NeutronNetwork)}
*/
@Test
public void testCanCreateNetwork() {
- when(neutronNetwork.isShared())
- .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_OK, networkHandler.canCreateNetwork(neutronNetwork));
+ assertEquals("Error, did not return the correct HTTP flag", HttpURLConnection.HTTP_NOT_ACCEPTABLE, networkHandler.canCreateNetwork(sharedNeutronNetwork));
+ assertEquals("Error, did not return the correct HTTP flag", HttpURLConnection.HTTP_OK, networkHandler.canCreateNetwork(nonSharedNeutronNetwork));
}
/**
*/
@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));
+ assertEquals("Error, did not return the correct HTTP flag", HttpURLConnection.HTTP_NOT_ACCEPTABLE, networkHandler.canUpdateNetwork(sharedNeutronNetwork, sharedNeutronNetwork));
+ assertEquals("Error, did not return the correct HTTP flag", HttpURLConnection.HTTP_OK, networkHandler.canUpdateNetwork(nonSharedNeutronNetwork, nonSharedNeutronNetwork));
}
/**
*/
@Test
public void testCanDeleteNetwork() {
- assertEquals("Error, did not return the correct HTTP flag", HttpURLConnection.HTTP_OK, networkHandler.canDeleteNetwork(neutronNetwork));
+ assertEquals("Error, did not return the correct HTTP flag", HttpURLConnection.HTTP_OK, networkHandler.canDeleteNetwork(nonSharedNeutronNetwork));
}
/**
* Test method {@link NetworkHandler#processEvent(AbstractEvent)}
*/
- /* TODO SB_MIGRATION */ @Ignore
@Test
public void testProcessEvent() {
NetworkHandler networkHandlerSpy = Mockito.spy(networkHandler);
NorthboundEvent ev = mock(NorthboundEvent.class);
- when(ev.getNeutronNetwork()).thenReturn(neutronNetwork);
+ when(ev.getNeutronNetwork()).thenReturn(nonSharedNeutronNetwork);
when(ev.getAction()).thenReturn(Action.ADD);
networkHandlerSpy.processEvent(ev);
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<>();
+ when(neutronNetworkCache.getAllNetworks()).thenReturn(networks);
+
+ List<Node> nodes = new ArrayList<>();
+ nodes.add(mock(Node.class));
+ when(nodeCacheManager.getNodes()).thenReturn(nodes);
+
+ List<String> phyIfName = new ArrayList<>();
+ phyIfName.add(portName);
+ when(bridgeConfigurationManager.getAllPhysicalInterfaceNames(any(Node.class))).thenReturn(phyIfName );
+
+ List<OvsdbTerminationPointAugmentation> ports = new ArrayList<>();
+ OvsdbTerminationPointAugmentation port = mock(OvsdbTerminationPointAugmentation.class);
+ when(port.getName()).thenReturn(portName);
+ ports.add(port);
+ when(southbound.getTerminationPointsOfBridge(any(Node.class))).thenReturn(ports);
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());
+ when(southbound.isTunnel(any(OvsdbTerminationPointAugmentation.class))).thenReturn(true);
+ networkHandlerSpy.processEvent(ev); // test delete with southbound.isTunnel(true)
+ when(southbound.isTunnel(any(OvsdbTerminationPointAugmentation.class))).thenReturn(false);
+ 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(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);
}
}