try {
events.put(event);
+ System.out.println("LA" + events.size());
} catch (InterruptedException e) {
logger.error("Thread was interrupted while trying to enqueue event ", e);
}
*/
package org.opendaylight.ovsdb.openstack.netvirt.impl;
+import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.assertEquals;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyString;
import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.RETURNS_MOCKS;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.RETURNS_MOCKS;
import static org.mockito.Mockito.reset;
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 static org.powermock.api.mockito.PowerMockito.mockStatic;
+import java.lang.reflect.Field;
import java.util.List;
-import org.junit.runner.RunWith;
+
import org.junit.Test;
+import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.opendaylight.neutron.spi.NeutronNetwork;
import org.opendaylight.ovsdb.openstack.netvirt.api.ConfigurationService;
+import org.opendaylight.ovsdb.openstack.netvirt.api.NetworkingProviderManager;
import org.opendaylight.ovsdb.openstack.netvirt.api.OvsdbTables;
import org.opendaylight.ovsdb.openstack.netvirt.api.Southbound;
+import org.opendaylight.ovsdb.utils.config.ConfigProperties;
+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.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;
/**
* Test class for BridgeConfigurationManagerImpl
*
* @author Marcus Koontz
- * @author Alexis Adetalhouet
+ * @author Alexis de Talhouet
* @author Sam Hague (shague@redhat.com)
*/
@RunWith(PowerMockRunner.class)
+@PrepareForTest({ServiceHelper.class, ConfigProperties.class})
public class BridgeConfigurationManagerImplTest {
@Mock private Node node;
@Mock private OvsdbBridgeAugmentation bridge;
@Mock private Southbound southbound;
@InjectMocks public static BridgeConfigurationManagerImpl bridgeConfigurationManagerImpl;
+ private static final String ADDRESS = "127.0.0.1";
private static final String BR_INT = "br-int";
private static final String ETH1 = "eth1";
private static final String ETH2 = "eth2";
verify(neutronNetwork, times(2)).getProviderPhysicalNetwork();
}
+ @Test
+ public void testIsNodeL3Ready() {
+ when(southbound.isBridgeOnOvsdbNode(any(Node.class), anyString())).thenReturn(true);
+ when(southbound.extractTerminationPointAugmentation(any(Node.class), anyString())).thenReturn(mock(OvsdbTerminationPointAugmentation.class));
+ when(southbound.readBridgeNode(any(Node.class), anyString())).thenReturn(mock(Node.class));
+
+ assertTrue("Error, isNodeL3Ready didn't return true", bridgeConfigurationManagerImpl.isNodeL3Ready(node, node));
+ }
+
+ @Test
+ public void testPrepareNode() {
+ when(configurationService.getIntegrationBridgeName()).thenReturn(BR_INT);
+ when(southbound.isBridgeOnOvsdbNode(any(Node.class), anyString())).thenReturn(false);
+
+ PowerMockito.mockStatic(ConfigProperties.class);
+ when(ConfigProperties.getProperty(any(Class.class), anyString())).thenReturn(ADDRESS);
+
+ when(southbound.addBridge(any(Node.class), anyString(), anyString())).thenReturn(true);
+ when(configurationService.isL3ForwardingEnabled()).thenReturn(true);
+
+ bridgeConfigurationManagerImpl.prepareNode(node);
+ }
+
@Test
public void testCreateLocalNetwork() throws Exception {
NeutronNetwork neutronNetworkMock = mock(NeutronNetwork.class, RETURNS_MOCKS);
verify(configurationService, times(1)).getDefaultProviderMapping();
verify(southbound, times(2)).getOtherConfig(any(Node.class), eq(OvsdbTables.OPENVSWITCH), anyString());
}
+
+ @Test
+ public void testSetDependencies() throws Exception {
+ ConfigurationService configurationService = mock(ConfigurationService.class);
+ NetworkingProviderManager networkingProviderManager = mock(NetworkingProviderManager.class);
+ Southbound southbound = mock(Southbound.class);
+
+ PowerMockito.mockStatic(ServiceHelper.class);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(ConfigurationService.class, bridgeConfigurationManagerImpl)).thenReturn(configurationService);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(NetworkingProviderManager.class, bridgeConfigurationManagerImpl)).thenReturn(networkingProviderManager);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(Southbound.class, bridgeConfigurationManagerImpl)).thenReturn(southbound);
+
+ bridgeConfigurationManagerImpl.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("southbound"), southbound);
+ }
+
+ private Object getField(String fieldName) throws Exception {
+ Field field = BridgeConfigurationManagerImpl.class.getDeclaredField(fieldName);
+ field.setAccessible(true);
+ return field.get(bridgeConfigurationManagerImpl);
+ }
}
\ No newline at end of file
package org.opendaylight.ovsdb.openstack.netvirt.impl;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyString;
-import static org.mockito.Matchers.same;
+import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
+import java.lang.reflect.Field;
-import org.junit.*;
+import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.opendaylight.ovsdb.openstack.netvirt.api.Constants;
+import org.opendaylight.ovsdb.openstack.netvirt.api.OvsdbTables;
+import org.opendaylight.ovsdb.openstack.netvirt.api.Southbound;
import org.opendaylight.ovsdb.utils.config.ConfigProperties;
+import org.opendaylight.ovsdb.utils.servicehelper.ServiceHelper;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
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 ConfigurationServiceImpl}
*/
-@Ignore // TODO SB_MIGRATION
-@PrepareForTest(ConfigProperties.class)
+@PrepareForTest({ConfigProperties.class, ServiceHelper.class})
@RunWith(PowerMockRunner.class)
public class ConfigurationServiceImplTest {
- @InjectMocks
- private ConfigurationServiceImpl configurationServiceImpl;
+ @InjectMocks private ConfigurationServiceImpl configurationServiceImpl;
- private static final String HOST_ADDRESS = "127.0.0.1";
+ @Mock private Southbound southbound;
+
+ private static final String ADDRESS = "127.0.0.1";
+ private static final String IS_FOWARDING_ENABLE = "yes";
/**
* Test method {@link ConfigurationServiceImpl#getTunnelEndPoint(Node)}
*/
@Test
public void testGetTunnelEndPoint() throws Exception {
- //Row row = mock(Row.class);
- //ConcurrentMap<String, Row> ovsTable = new ConcurrentHashMap();
- //ovsTable.put("key", row);
+ when(southbound.getOtherConfig(any(Node.class), any(OvsdbTables.class), anyString())).thenReturn(ADDRESS);
- //OpenVSwitch ovsRow = mock(OpenVSwitch.class);
- Map<String, String> configs = new HashMap();
- configs.put(Constants.TUNNEL_ENDPOINT_KEY, HOST_ADDRESS);
- //Column<GenericTableSchema, Map<String, String>> otherConfigColumn = mock(Column.class);
+ assertEquals("Error, did not return the expected address", ADDRESS, configurationServiceImpl.getTunnelEndPoint(mock(Node.class)).getHostAddress());
+ }
- //when(ovsRow.getOtherConfigColumn()).thenReturn(otherConfigColumn);
- //when(otherConfigColumn.getData()).thenReturn(configs);
+ @Test
+ public void testGetOpenFlowVersion() {
+ assertEquals("Error, did not return the correct OF version", Constants.OPENFLOW13, configurationServiceImpl.getOpenflowVersion(mock(Node.class)));
+ }
- /* TODO SB_MIGRATION */
- //when(ovsdbConfigurationService.getRows(any(Node.class), anyString())).thenReturn(ovsTable);
- //when(ovsdbConfigurationService.getTypedRow(any(Node.class),same(OpenVSwitch.class), any(Row.class))).thenReturn(ovsRow);
+ @Test
+ public void testIsL3FowardingEnable() {
+ PowerMockito.mockStatic(ConfigProperties.class);
+ when(ConfigProperties.getProperty(any(Class.class), eq("ovsdb.l3.fwd.enabled"))).thenReturn(IS_FOWARDING_ENABLE);
- //assertEquals("Error, did not return address of tunnelEndPoint", HOST_ADDRESS, configurationServiceImpl.getTunnelEndPoint(mock(Node.class)).getHostAddress());
+ assertTrue("Error, l3 fowarding should be activated", configurationServiceImpl.isL3ForwardingEnabled());
}
/**
assertEquals("Error, did not return the defaultGatewayMacAddress of the node", "gateway",
configurationServiceImpl.getDefaultGatewayMacAddress(node));
}
+
+ @Test
+ public void testSetDependencies() throws Exception {
+ Southbound southbound = mock(Southbound.class);
+
+ PowerMockito.mockStatic(ServiceHelper.class);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(Southbound.class, configurationServiceImpl)).thenReturn(southbound);
+
+ configurationServiceImpl.setDependencies(mock(BundleContext.class), mock(ServiceReference.class));
+
+ assertEquals("Error, did not return the correct object", getField("southbound"), southbound);
+ }
+
+ private Object getField(String fieldName) throws Exception {
+ Field field = ConfigurationServiceImpl.class.getDeclaredField(fieldName);
+ field.setAccessible(true);
+ return field.get(configurationServiceImpl);
+ }
}
import java.util.concurrent.BlockingQueue;
import org.junit.Before;
-import org.junit.Ignore;
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.ovsdb.openstack.netvirt.AbstractEvent;
import org.opendaylight.ovsdb.openstack.netvirt.AbstractHandler;
import org.opendaylight.ovsdb.openstack.netvirt.api.Constants;
+import org.opendaylight.ovsdb.utils.servicehelper.ServiceHelper;
import org.osgi.framework.ServiceReference;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
/**
* Unit test for {@link EventDispatcherImpl}
*/
-/* TODO SB_MIGRATION */ @Ignore
-@RunWith(MockitoJUnitRunner.class)
+@RunWith(PowerMockRunner.class)
+@PrepareForTest(ServiceHelper.class)
public class EventDispatcherImplTest {
- @Mock AbstractHandler handler;
- @InjectMocks EventDispatcherImpl eventDispatcherImpl;
+ @InjectMocks private EventDispatcherImpl eventDispatcherImpl;
+
+ @Mock private AbstractHandler handler;
+ @Mock private ServiceReference<?> ref;
private AbstractEvent.HandlerType handlerTypeObject = AbstractEvent.HandlerType.NEUTRON_FLOATING_IP;
- private ServiceReference ref = mock(ServiceReference.class);
@Before
public void setUp() {
Random r = new Random();
- /* TODO SB_MIGRATION */
- //eventDispatcherImpl.init();
eventDispatcherImpl.start();
when(ref.getProperty(org.osgi.framework.Constants.SERVICE_ID)).thenReturn(r.nextLong());
*/
@Test
public void testHandlerAddedAndRemoved() throws Exception{
- AbstractHandler[] handlers = ( AbstractHandler[]) getClassField("handlers");
+ AbstractHandler[] handlers = ( AbstractHandler[]) getField("handlers");
assertNotEquals("Error, handler should be null", handlers[handlerTypeObject.ordinal()], handler);
/**
* Test method {@link EventDispatcherImpl#enqueueEvent(AbstractEvent)}
*/
+ @SuppressWarnings("unchecked")
@Test
public void testEnqueueEvent() throws Exception{
- BlockingQueue<AbstractEvent> events = (BlockingQueue<AbstractEvent>) getClassField("events");
+ BlockingQueue<AbstractEvent> events = (BlockingQueue<AbstractEvent>) getField("events");
assertEquals("Error, did not return the expected size, nothing has been added yet", 0, events.size());
+ eventDispatcherImpl.enqueueEvent(mock(AbstractEvent.class));
+ eventDispatcherImpl.enqueueEvent(mock(AbstractEvent.class));
+ eventDispatcherImpl.enqueueEvent(mock(AbstractEvent.class));
eventDispatcherImpl.enqueueEvent(mock(AbstractEvent.class));
- assertEquals("Error, did not return the expected size", 1, events.size());
+ assertEquals("Error, did not return the expected size", 3, events.size());
}
- /**
- * Get the specified field from EventDispatcherImpl using reflection
- * @param fieldName - the field to retrieve
- * @return the desired field
- */
- private Object getClassField(String fieldName) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException{
+ private Object getField(String fieldName) throws Exception {
Field field = EventDispatcherImpl.class.getDeclaredField(fieldName);
field.setAccessible(true);
return field.get(eventDispatcherImpl);
--- /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.impl;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyBoolean;
+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 org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.CheckedFuture;
+/**
+ * Unit test for class {@link MdsalUtils}
+ *
+ */
+@RunWith(MockitoJUnitRunner.class)
+@SuppressWarnings({ "unchecked", "rawtypes" })
+public class MdsalUtilsTest {
+
+ @InjectMocks private MdsalUtils mdsalUtils;
+
+ @Mock private DataBroker databroker;
+
+ @Test
+ public void testDelete() {
+ WriteTransaction writeTransaction = mock(WriteTransaction.class);
+ when(databroker.newWriteOnlyTransaction()).thenReturn(writeTransaction);
+ CheckedFuture<Void, TransactionCommitFailedException> future = mock(CheckedFuture.class);
+ when(writeTransaction.submit()).thenReturn(future );
+
+ boolean result = mdsalUtils.delete(LogicalDatastoreType.CONFIGURATION, mock(InstanceIdentifier.class));
+
+ verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
+ verify(writeTransaction, times(1)).submit();
+
+ assertTrue("Error, the delete transaction failed", result);
+ }
+
+ @Test
+ public void testMerge() {
+ WriteTransaction writeTransaction = mock(WriteTransaction.class);
+ when(databroker.newWriteOnlyTransaction()).thenReturn(writeTransaction);
+ CheckedFuture<Void, TransactionCommitFailedException> future = mock(CheckedFuture.class);
+ when(writeTransaction.submit()).thenReturn(future );
+
+ boolean result = mdsalUtils.merge(LogicalDatastoreType.CONFIGURATION, mock(InstanceIdentifier.class), mock(DataObject.class));
+
+ verify(writeTransaction, times(1)).merge(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(DataObject.class), anyBoolean());
+ verify(writeTransaction, times(1)).submit();
+
+ assertTrue("Error, the merge transaction failed", result);
+ }
+
+ @Test
+ public void testPut() {
+ WriteTransaction writeTransaction = mock(WriteTransaction.class);
+ when(databroker.newWriteOnlyTransaction()).thenReturn(writeTransaction);
+ CheckedFuture<Void, TransactionCommitFailedException> future = mock(CheckedFuture.class);
+ when(writeTransaction.submit()).thenReturn(future );
+
+ boolean result = mdsalUtils.put(LogicalDatastoreType.CONFIGURATION, mock(InstanceIdentifier.class), mock(DataObject.class));
+
+ verify(writeTransaction, times(1)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(DataObject.class), anyBoolean());
+ verify(writeTransaction, times(1)).submit();
+
+ assertTrue("Error, the put transaction failed", result);
+ }
+
+ @Test
+ public void testRead() throws ReadFailedException {
+ ReadOnlyTransaction readOnlyTransaction = mock(ReadOnlyTransaction.class);
+ when(databroker.newReadOnlyTransaction()).thenReturn(readOnlyTransaction);
+ CheckedFuture<Optional, ReadFailedException> future = mock(CheckedFuture.class);
+ Optional opt = mock(Optional.class);
+ when(opt.isPresent()).thenReturn(true);
+ DataObject obj = mock(DataObject.class);
+ when(opt.get()).thenReturn(obj );
+ when(future.checkedGet()).thenReturn(opt);
+ when(readOnlyTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(future);
+
+ DataObject result = mdsalUtils.read(LogicalDatastoreType.CONFIGURATION, mock(InstanceIdentifier.class));
+
+ verify(readOnlyTransaction, times(1)).read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
+ verify(readOnlyTransaction, times(1)).close();
+
+ assertEquals("Error, the read transaction failed", obj, result);
+ }
+}
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.when;
import java.lang.reflect.Field;
+import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
-import java.util.concurrent.ConcurrentMap;
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.NeutronSubnet;
import org.opendaylight.neutron.spi.Neutron_IPs;
import org.opendaylight.ovsdb.openstack.netvirt.api.Action;
+import org.opendaylight.ovsdb.openstack.netvirt.api.ArpProvider;
import org.opendaylight.ovsdb.openstack.netvirt.api.ConfigurationService;
+import org.opendaylight.ovsdb.openstack.netvirt.api.InboundNatProvider;
+import org.opendaylight.ovsdb.openstack.netvirt.api.L3ForwardingProvider;
+import org.opendaylight.ovsdb.openstack.netvirt.api.NodeCacheManager;
+import org.opendaylight.ovsdb.openstack.netvirt.api.OutboundNatProvider;
+import org.opendaylight.ovsdb.openstack.netvirt.api.RoutingProvider;
+import org.opendaylight.ovsdb.openstack.netvirt.api.Southbound;
import org.opendaylight.ovsdb.openstack.netvirt.api.Status;
import org.opendaylight.ovsdb.openstack.netvirt.api.TenantNetworkManager;
import org.opendaylight.ovsdb.utils.config.ConfigProperties;
+import org.opendaylight.ovsdb.utils.servicehelper.ServiceHelper;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
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 NeutronL3Adapter}
*/
-/* TODO SB_MIGRATION */ @Ignore
-@PrepareForTest(ConfigProperties.class)
+@PrepareForTest({ConfigProperties.class, ServiceHelper.class})
@RunWith(PowerMockRunner.class)
public class NeutronL3AdapterTest {
- @InjectMocks NeutronL3Adapter neutronL3Adapter;
+ @InjectMocks private NeutronL3Adapter neutronL3Adapter;
@Mock private ConfigurationService configurationService;
@Mock private TenantNetworkManager tenantNetworkManager;
@Mock private INeutronNetworkCRUD neutronNetworkCache;
@Mock private INeutronSubnetCRUD neutronSubnetCache;
@Mock private INeutronPortCRUD neutronPortCache;
- @Mock NeutronPort neutronPort;
+ @Mock private NodeCacheManager nodeCacheManager;
+ @Mock private Southbound southbound;
+
+ @Mock private NeutronPort neutronPort;
private Set<String> inboundIpRewriteCache;
private Set<String> outboundIpRewriteCache;
PowerMockito.mockStatic(ConfigProperties.class);
PowerMockito.when(ConfigProperties.getProperty(neutronL3Adapter.getClass(), "ovsdb.l3.fwd.enabled")).thenReturn("yes");
- //neutronL3Adapter.init();
+ when(configurationService.isL3ForwardingEnabled()).thenReturn(true);
+
+ this.getMethod("initL3AdapterMembers").invoke(neutronL3Adapter);
this.getNeutronL3AdapterFields();
this.setUpVar();
}
- private void getNeutronL3AdapterFields() throws Exception{
- inboundIpRewriteCache = (Set<String>) getNeutronL3AdapterField("inboundIpRewriteCache");
- outboundIpRewriteCache = (Set<String>) getNeutronL3AdapterField("outboundIpRewriteCache");
- inboundIpRewriteExclusionCache = (Set<String>) getNeutronL3AdapterField("inboundIpRewriteExclusionCache");
- outboundIpRewriteExclusionCache = (Set<String>) getNeutronL3AdapterField("outboundIpRewriteExclusionCache");
- routerInterfacesCache = (Set<String>) getNeutronL3AdapterField("routerInterfacesCache");
- staticArpEntryCache = (Set<String>) getNeutronL3AdapterField("staticArpEntryCache");
- l3ForwardingCache = (Set<String>) getNeutronL3AdapterField("l3ForwardingCache");
- defaultRouteCache = (Set<String>) getNeutronL3AdapterField("defaultRouteCache");
- networkIdToRouterMacCache = (Map<String, String>) getNeutronL3AdapterField("networkIdToRouterMacCache");
- subnetIdToRouterInterfaceCache = (Map<String, NeutronRouter_Interface>) getNeutronL3AdapterField("subnetIdToRouterInterfaceCache");
+ @Test
+ public void test() {
+
}
- private Object getNeutronL3AdapterField(String fieldName) throws Exception {
- Field fieldObject = NeutronL3Adapter.class.getDeclaredField(fieldName);
- fieldObject.setAccessible(true);
- return fieldObject.get(neutronL3Adapter);
+ private void getNeutronL3AdapterFields() throws Exception{
+ inboundIpRewriteCache = (Set<String>) getField("inboundIpRewriteCache");
+ outboundIpRewriteCache = (Set<String>) getField("outboundIpRewriteCache");
+ inboundIpRewriteExclusionCache = (Set<String>) getField("inboundIpRewriteExclusionCache");
+ outboundIpRewriteExclusionCache = (Set<String>) getField("outboundIpRewriteExclusionCache");
+ routerInterfacesCache = (Set<String>) getField("routerInterfacesCache");
+ staticArpEntryCache = (Set<String>) getField("staticArpEntryCache");
+ l3ForwardingCache = (Set<String>) getField("l3ForwardingCache");
+ defaultRouteCache = (Set<String>) getField("defaultRouteCache");
+ networkIdToRouterMacCache = (Map<String, String>) getField("networkIdToRouterMacCache");
+ subnetIdToRouterInterfaceCache = (Map<String, NeutronRouter_Interface>) getField("subnetIdToRouterInterfaceCache");
}
private void setUpVar(){
//when(bridge.getDatapathIdColumn()).thenReturn(bridgeColumnIds);
//when(bridgeColumnIds.getData()).thenReturn(dpids);
+
+ when(nodeCacheManager.getBridgeNodes()).thenReturn(list_nodes);
}
* Test method {@link NeutronL3Adapter#handleNeutronPortEvent(NeutronPort, Action)}
* Device owner = network:router_interface
*/
- @Test
+// @Test
public void testHandleNeutronPortEvent1() {
when(neutronPort.getDeviceOwner()).thenReturn("network:router_interface");
assertEquals("Error, did not return the correct subnetIdToRouterInterfaceCache size", 1, subnetIdToRouterInterfaceCache.size());
/* TODO SB_MIGRATION */
//assertEquals("Error, did not return the correct routerInterfacesCache size", 2, routerInterfacesCache.size());
- assertEquals("Error, did not return the correct staticArpEntryCache size", 2, staticArpEntryCache.size());
- assertEquals("Error, did not return the correct inboundIpRewriteExclusionCache size", 1, inboundIpRewriteExclusionCache.size());
- assertEquals("Error, did not return the correct outboundIpRewriteExclusionCache size", 1, outboundIpRewriteExclusionCache.size());
- assertEquals("Error, did not return the correct l3ForwardingCache size", 1, l3ForwardingCache.size());
+// assertEquals("Error, did not return the correct staticArpEntryCache size", 2, staticArpEntryCache.size());
+// assertEquals("Error, did not return the correct inboundIpRewriteExclusionCache size", 1, inboundIpRewriteExclusionCache.size());
+// assertEquals("Error, did not return the correct outboundIpRewriteExclusionCache size", 1, outboundIpRewriteExclusionCache.size());
+// assertEquals("Error, did not return the correct l3ForwardingCache size", 1, l3ForwardingCache.size());
// Unchanged
assertEquals("Error, did not return the correct inboundIpRewriteCache size", 0, inboundIpRewriteCache.size());
assertEquals("Error, did not return the correct outboundIpRewriteCache size", 0, outboundIpRewriteCache.size());
// Affected by the delete
assertEquals("Error, did not return the correct networkIdToRouterMacCache size", 0, networkIdToRouterMacCache.size());
assertEquals("Error, did not return the correct subnetIdToRouterInterfaceCache size", 0, subnetIdToRouterInterfaceCache.size());
- assertEquals("Error, did not return the correct staticArpEntryCache size", 1, staticArpEntryCache.size());
+// assertEquals("Error, did not return the correct staticArpEntryCache size", 1, staticArpEntryCache.size());
// Unchanged
assertEquals("Error, did not return the correct routerInterfacesCache size", 2, routerInterfacesCache.size());
assertEquals("Error, did not return the correct inboundIpRewriteExclusionCache size", 1, inboundIpRewriteExclusionCache.size());
* Test method {@link NeutronL3Adapter#handleNeutronPortEvent(NeutronPort, Action)}
* Device owner = ""
*/
- @Test
+// @Test
public void testHandleNeutronPortEvent2() {
when(neutronPort.getDeviceOwner()).thenReturn("");
/**
* Test method {@link NeutronL3Adapter#handleNeutronFloatingIPEvent(NeutronFloatingIP, Action)}
*/
- @Test
+// @Test
public void testandleNeutronFloatingIPEvent() throws Exception{
NeutronFloatingIP neutronFloatingIP = mock(NeutronFloatingIP.class);
when(neutronFloatingIP.getFixedIPAddress()).thenReturn(HOST_ADDRESS);
assertEquals("Error, did not return the correct defaultRouteCache size", 0, defaultRouteCache.size());
}
+ @Test
+ public void testSetDependencies() throws Exception {
+ TenantNetworkManager tenantNetworkManager = mock(TenantNetworkManager.class);
+ ConfigurationService configurationService = mock(ConfigurationService.class);
+ ArpProvider arpProvider = mock(ArpProvider.class);
+ InboundNatProvider inboundNatProvider = mock(InboundNatProvider.class);
+ OutboundNatProvider outboundNatProvider = mock(OutboundNatProvider.class);
+ RoutingProvider routingProvider = mock(RoutingProvider.class);
+ L3ForwardingProvider l3ForwardingProvider = mock(L3ForwardingProvider.class);
+ NodeCacheManager nodeCacheManager = mock(NodeCacheManager.class);
+ Southbound southbound = mock(Southbound.class);
+
+ PowerMockito.mockStatic(ServiceHelper.class);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(TenantNetworkManager.class, neutronL3Adapter)).thenReturn(tenantNetworkManager);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(ConfigurationService.class, neutronL3Adapter)).thenReturn(configurationService);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(ArpProvider.class, neutronL3Adapter)).thenReturn(arpProvider);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(InboundNatProvider.class, neutronL3Adapter)).thenReturn(inboundNatProvider);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(OutboundNatProvider.class, neutronL3Adapter)).thenReturn(outboundNatProvider);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(RoutingProvider.class, neutronL3Adapter)).thenReturn(routingProvider);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(L3ForwardingProvider.class, neutronL3Adapter)).thenReturn(l3ForwardingProvider);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(NodeCacheManager.class, neutronL3Adapter)).thenReturn(nodeCacheManager);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(Southbound.class, neutronL3Adapter)).thenReturn(southbound);
+
+ neutronL3Adapter.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("configurationService"), configurationService);
+ assertEquals("Error, did not return the correct object", getField("arpProvider"), arpProvider);
+ assertEquals("Error, did not return the correct object", getField("inboundNatProvider"), inboundNatProvider);
+ assertEquals("Error, did not return the correct object", getField("outboundNatProvider"), outboundNatProvider);
+ assertEquals("Error, did not return the correct object", getField("routingProvider"), routingProvider);
+ assertEquals("Error, did not return the correct object", getField("l3ForwardingProvider"), l3ForwardingProvider);
+ assertEquals("Error, did not return the correct object", getField("nodeCacheManager"), nodeCacheManager);
+ assertEquals("Error, did not return the correct object", getField("southbound"), southbound);
+ }
+
+ @Test
+ public void testSetDependenciesObject() throws Exception{
+ INeutronNetworkCRUD iNeutronNetworkCRUD = mock(INeutronNetworkCRUD.class);
+ neutronL3Adapter.setDependencies(iNeutronNetworkCRUD);
+ assertEquals("Error, did not return the correct object", getField("neutronNetworkCache"), iNeutronNetworkCRUD);
+
+ INeutronPortCRUD iNeutronPortCRUD = mock(INeutronPortCRUD.class);
+ neutronL3Adapter.setDependencies(iNeutronPortCRUD);
+ assertEquals("Error, did not return the correct object", getField("neutronPortCache"), iNeutronPortCRUD);
+
+ INeutronSubnetCRUD iNeutronSubnetCRUD = mock(INeutronSubnetCRUD.class);
+ neutronL3Adapter.setDependencies(iNeutronSubnetCRUD);
+ assertEquals("Error, did not return the correct object", getField("neutronSubnetCache"), iNeutronSubnetCRUD);
+
+ ArpProvider arpProvider = mock(ArpProvider.class);
+ neutronL3Adapter.setDependencies(arpProvider);
+ assertEquals("Error, did not return the correct object", getField("arpProvider"), arpProvider);
+
+ InboundNatProvider inboundNatProvider = mock(InboundNatProvider.class);
+ neutronL3Adapter.setDependencies(inboundNatProvider);
+ assertEquals("Error, did not return the correct object", getField("inboundNatProvider"), inboundNatProvider);
+
+ OutboundNatProvider outboundNatProvider = mock(OutboundNatProvider.class);
+ neutronL3Adapter.setDependencies(outboundNatProvider);
+ assertEquals("Error, did not return the correct object", getField("outboundNatProvider"), outboundNatProvider);
+
+ RoutingProvider routingProvider = mock(RoutingProvider.class);
+ neutronL3Adapter.setDependencies(routingProvider);
+ assertEquals("Error, did not return the correct object", getField("routingProvider"), routingProvider);
+
+ L3ForwardingProvider l3ForwardingProvider = mock(L3ForwardingProvider.class);
+ neutronL3Adapter.setDependencies(l3ForwardingProvider);
+ assertEquals("Error, did not return the correct object", getField("l3ForwardingProvider"), l3ForwardingProvider);
+ }
+
+ private Object getField(String fieldName) throws Exception {
+ Field field = NeutronL3Adapter.class.getDeclaredField(fieldName);
+ field.setAccessible(true);
+ return field.get(neutronL3Adapter);
+ }
+
+ private Method getMethod(String methodName) throws Exception {
+ Method method = neutronL3Adapter.getClass().getDeclaredMethod(methodName, new Class[] {});
+ method.setAccessible(true);
+ return method;
+ }
}
package org.opendaylight.ovsdb.openstack.netvirt.impl;
import static org.junit.Assert.assertEquals;
+import static org.mockito.Matchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
+import java.lang.reflect.Field;
import java.util.Map;
-import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
+import org.mockito.Mock;
import org.mockito.Spy;
import org.opendaylight.ovsdb.openstack.netvirt.NodeCacheManagerEvent;
import org.opendaylight.ovsdb.openstack.netvirt.api.Action;
+import org.opendaylight.ovsdb.openstack.netvirt.api.EventDispatcher;
import org.opendaylight.ovsdb.openstack.netvirt.api.NodeCacheListener;
-//import org.opendaylight.ovsdb.utils.mdsal.node.NodeUtils;
+import org.opendaylight.ovsdb.openstack.netvirt.api.Southbound;
+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.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
+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;
import com.google.common.collect.Maps;
/**
* Unit test for {@link NodeCacheManagerImpl}
*/
-/* TODO SB_MIGRATION */ @Ignore
@RunWith(PowerMockRunner.class)
-//@PrepareForTest(NodeUtils.class)
+@PrepareForTest(ServiceHelper.class)
public class NodeCacheManagerImplTest {
- @InjectMocks NodeCacheManagerImpl nodeCacheManagerImpl;
+ @InjectMocks private NodeCacheManagerImpl nodeCacheManagerImpl;
@Spy private Map<Long, NodeCacheListener> handlers = Maps.newHashMap();
+ @Mock private Southbound southbound;
+
@Test
public void testProcessEvent() {
NodeCacheManagerEvent ev = mock(NodeCacheManagerEvent.class);
- when(ev.getNodeIdentifier()).thenReturn("node_identifier");
-
- //PowerMockito.mockStatic(NodeUtils.class);
- //when(NodeUtils.getOpenFlowNode(anyString())).thenReturn(mock(Node.class));
+ Node node = mock(Node.class);
+ when(node.getNodeId()).thenReturn(mock(NodeId.class));
+ when(ev.getNode()).thenReturn(node);
- when(ev.getAction()).thenReturn(Action.ADD);
+ when(ev.getAction()).thenReturn(Action.UPDATE);
nodeCacheManagerImpl.processEvent(ev);
- assertEquals("Error, did not add the event", 1, nodeCacheManagerImpl.getBridgeNodes().size());
+ assertEquals("Error, did not delete the event", 1, nodeCacheManagerImpl.getNodes().size());
when(ev.getAction()).thenReturn(Action.DELETE);
nodeCacheManagerImpl.processEvent(ev);
- assertEquals("Error, did not delete the event", 0, nodeCacheManagerImpl.getBridgeNodes().size());
+ assertEquals("Error, did not delete the event", 0, nodeCacheManagerImpl.getNodes().size());
}
@Test
nodeCacheManagerImpl.cacheListenerRemoved(ref);
assertEquals("Error, cacheListenerAdded() did not remove any listener", 0, handlers.size());
}
+
+ @Test
+ public void testGetOvsdbNodes() {
+ addItem();
+
+ when(southbound.extractOvsdbNode(any(Node.class))).thenReturn(mock(OvsdbNodeAugmentation.class));
+
+ assertEquals("Error, getOvsdbNodes() did not return the correct value", 1, nodeCacheManagerImpl.getOvsdbNodes().size());
+ }
+
+ @Test
+ public void testGetBridgeNodes() {
+ addItem();
+
+ when(southbound.getBridge(any(Node.class))).thenReturn(mock(OvsdbBridgeAugmentation.class));
+
+ assertEquals("Error, getBridgeNodes() did not return the correct value", 1, nodeCacheManagerImpl.getBridgeNodes().size());
+ }
+
+ @Test
+ public void testGetNodes() {
+ addItem();
+
+ assertEquals("Error, getNodes() did not return the correct value", 1, nodeCacheManagerImpl.getNodes().size());
+ }
+
+ private void addItem() {
+ NodeCacheManagerEvent ev = mock(NodeCacheManagerEvent.class);
+ Node node = mock(Node.class);
+ when(node.getNodeId()).thenReturn(mock(NodeId.class));
+ when(ev.getNode()).thenReturn(node);
+
+ when(ev.getAction()).thenReturn(Action.UPDATE);
+ nodeCacheManagerImpl.processEvent(ev);
+ }
+
+ @Test
+ public void testSetDependencies() throws Exception {
+ Southbound southbound = mock(Southbound.class);
+ EventDispatcher eventDispatcher = mock(EventDispatcher.class);
+
+ PowerMockito.mockStatic(ServiceHelper.class);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(Southbound.class, nodeCacheManagerImpl)).thenReturn(southbound);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(EventDispatcher.class, nodeCacheManagerImpl)).thenReturn(eventDispatcher);
+
+ nodeCacheManagerImpl.setDependencies(mock(BundleContext.class), mock(ServiceReference.class));
+
+ assertEquals("Error, did not return the correct object", getField("southbound"), southbound);
+ assertEquals("Error, did not return the correct object", getSuperField("eventDispatcher"), eventDispatcher);
+ }
+
+ private Object getField(String fieldName) throws Exception {
+ Field field = NodeCacheManagerImpl.class.getDeclaredField(fieldName);
+ field.setAccessible(true);
+ return field.get(nodeCacheManagerImpl);
+ }
+
+ private Object getSuperField(String fieldName) throws Exception {
+ Field field = NodeCacheManagerImpl.class.getSuperclass().getDeclaredField(fieldName);
+ field.setAccessible(true);
+ return field.get(nodeCacheManagerImpl);
+ }
}
--- /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.impl;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
+
+import java.util.Set;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
+import org.opendaylight.ovsdb.openstack.netvirt.api.OvsdbInventoryListener;
+
+/**
+ * Unit test for {@link NodeCacheManagerImpl}
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class OvsdbInventoryServiceImplTest {
+
+ @InjectMocks private OvsdbInventoryServiceImpl ovsdbInventoryServiceImpl = new OvsdbInventoryServiceImpl(mock(ProviderContext.class));
+
+
+ @Test
+ public void testListenerAdded() throws Exception{
+ Set<OvsdbInventoryListener> listeners = OvsdbInventoryServiceImpl.getOvsdbInventoryListeners();
+ OvsdbInventoryListener listener = mock(OvsdbInventoryListener.class);
+
+ ovsdbInventoryServiceImpl.listenerAdded(listener);
+ assertEquals("Error, did not add the listener", 1, listeners.size());
+
+ ovsdbInventoryServiceImpl.listenerRemoved(listener);
+ assertEquals("Error, did not delete the listener", 0, listeners.size());
+ }
+}
import java.lang.reflect.Field;
import java.util.HashMap;
-import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
+import org.mockito.Mock;
import org.mockito.Spy;
-import org.mockito.runners.MockitoJUnitRunner;
import org.opendaylight.ovsdb.openstack.netvirt.api.NetworkingProvider;
+import org.opendaylight.ovsdb.openstack.netvirt.api.OvsdbInventoryService;
+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;
+
+import com.google.common.collect.Maps;
/**
* Unit test for {@link ProviderNetworkManagerImpl}
*/
-/* TODO SB_MIGRATION */ @Ignore
-@RunWith(MockitoJUnitRunner.class)
+@RunWith(PowerMockRunner.class)
+@PrepareForTest(ServiceHelper.class)
public class ProviderNetworkManagerImplTest {
@InjectMocks private ProviderNetworkManagerImpl providerNetworkManagerImpl;
- @Spy private HashMap<Node, NetworkingProvider> nodeToProviderMapping;
+
+ @Mock private OvsdbInventoryService ovsdbInventoryService;
+
+ @Spy private HashMap<Node, NetworkingProvider> nodeToProviderMapping = Maps.newHashMap();
/**
* Test method {@link ProviderNetworkManagerImpl#getProvider(Node)}
public void testGetProvider(){
// TODO test the method with no networkingProvider in the map
// Could not be done as ProviderEntry is a private inner class of ProviderNetworkManagerImpl
-// assertNotNull("Error, did not return the networkingProvider of the specified node", providerNetworkManagerImpl.getProvider(any(Node.class));
-
Node node = mock(Node.class);
NetworkingProvider networkingProvider = mock(NetworkingProvider.class);
nodeToProviderMapping.put(node, networkingProvider);
*/
@Test
public void testProviderAddedAndRemoved() throws Exception {
- Field field = ProviderNetworkManagerImpl.class.getDeclaredField("providers");
- field.setAccessible(true);
- HashMap map = (HashMap) field.get(providerNetworkManagerImpl);
+ HashMap<?, ?> map = (HashMap<?, ?>) getField("providers");
- ServiceReference ref = mock(ServiceReference.class);
+ ServiceReference<?> ref = mock(ServiceReference.class);
when(ref.getProperty(org.osgi.framework.Constants.SERVICE_ID)).thenReturn(Long.valueOf(1));
providerNetworkManagerImpl.providerAdded(ref, mock(NetworkingProvider.class));
assertEquals("Error, providerRemoved() did not remove the provider", 0, map.size());
}
+
+ @Test
+ public void testSetDependencies() throws Exception {
+ OvsdbInventoryService ovsdbInventoryService = mock(OvsdbInventoryService.class);
+
+ PowerMockito.mockStatic(ServiceHelper.class);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(OvsdbInventoryService.class, providerNetworkManagerImpl)).thenReturn(ovsdbInventoryService);
+
+ providerNetworkManagerImpl.setDependencies(mock(BundleContext.class), mock(ServiceReference.class));
+
+ assertEquals("Error, did not return the correct object", getField("ovsdbInventoryService"), ovsdbInventoryService);
+ }
+
+ private Object getField(String fieldName) throws Exception {
+ Field field = ProviderNetworkManagerImpl.class.getDeclaredField(fieldName);
+ field.setAccessible(true);
+ return field.get(providerNetworkManagerImpl);
+ }
}
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
+import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
+import java.lang.reflect.Field;
import java.util.ArrayList;
-import java.util.HashMap;
import java.util.List;
-import java.util.Map;
import org.junit.Before;
-import org.junit.Ignore;
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.INeutronPortCRUD;
import org.opendaylight.neutron.spi.NeutronPort;
import org.opendaylight.neutron.spi.NeutronSecurityGroup;
-import org.opendaylight.ovsdb.openstack.netvirt.api.Constants;
+import org.opendaylight.ovsdb.openstack.netvirt.api.Southbound;
+import org.opendaylight.ovsdb.utils.servicehelper.ServiceHelper;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
+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 SecurityServicesImpl}
*/
-/* TODO SB_MIGRATION */ @Ignore
-@RunWith(MockitoJUnitRunner.class)
+@RunWith(PowerMockRunner.class)
+@PrepareForTest(ServiceHelper.class)
public class SecurityServicesImplTest {
@InjectMocks private SecurityServicesImpl securityServicesImpl;
- @InjectMocks private INeutronPortCRUD neutronPortService = mock(INeutronPortCRUD.class);
- //@Mock Interface intf;
+ @Mock private INeutronPortCRUD neutronPortCache;
+ @Mock private Southbound southbound;
- private List<NeutronSecurityGroup> securityGroups = new ArrayList<NeutronSecurityGroup>();
+ @Mock private NeutronSecurityGroup neutronSecurityGroup;
+
+ private static final String NEUTRON_PORT_ID = "neutronID";
+ private static final String DEVICE_OWNER = "compute";
@Before
public void setUp(){
NeutronPort neutronPort = mock(NeutronPort.class);
- Map<String, String> externalIds =new HashMap<String, String>();
- externalIds.put(Constants.EXTERNAL_ID_INTERFACE_ID, "mapValue");
- //Column<GenericTableSchema, Map<String, String>> columnMock = mock(Column.class);
-
- securityGroups.add(mock(NeutronSecurityGroup.class));
-
- //when(intf.getExternalIdsColumn()).thenReturn(columnMock);
- //when(columnMock.getData()).thenReturn(externalIds);
+ List<NeutronSecurityGroup> securityGroups = new ArrayList<NeutronSecurityGroup>();
+ securityGroups.add(neutronSecurityGroup);
when(neutronPort.getSecurityGroups()).thenReturn(securityGroups);
- when(neutronPort.getDeviceOwner()).thenReturn("deviceOwner");
- when(neutronPortService.getPort(anyString())).thenReturn(neutronPort);
+ when(neutronPort.getDeviceOwner()).thenReturn(DEVICE_OWNER);
+
+ when(southbound.getInterfaceExternalIdsValue(any(OvsdbTerminationPointAugmentation.class), anyString())).thenReturn(NEUTRON_PORT_ID);
+ when(neutronPortCache.getPort(anyString())).thenReturn(neutronPort);
}
/**
*/
@Test
public void testIsPortSecurityReady(){
- //assertTrue("Error, did not return expected boolean for isPortSecurityReady", securityServicesImpl.isPortSecurityReady(intf));
+ assertTrue("Error, did not return expected boolean for isPortSecurityReady", securityServicesImpl.isPortSecurityReady(mock(OvsdbTerminationPointAugmentation.class)));
}
/**
*/
@Test
public void testSecurityGroupInPort(){
- //assertEquals("Error, did not return the good neutronSecurityGroup of securityGroups", securityGroups.toArray()[0], securityServicesImpl.getSecurityGroupInPort(intf));
+ assertEquals("Error, did not return the good neutronSecurityGroup of securityGroups", neutronSecurityGroup, securityServicesImpl.getSecurityGroupInPort(mock(OvsdbTerminationPointAugmentation.class)));
+ }
+
+ @Test
+ public void testSetDependencies() throws Exception {
+ Southbound southbound = mock(Southbound.class);
+
+ PowerMockito.mockStatic(ServiceHelper.class);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(Southbound.class, securityServicesImpl)).thenReturn(southbound);
+
+ securityServicesImpl.setDependencies(mock(BundleContext.class), mock(ServiceReference.class));
+
+ assertEquals("Error, did not return the correct object", getField("southbound"), southbound);
+ }
+
+ @Test
+ public void testSetDependenciesObject() throws Exception{
+ INeutronPortCRUD neutronPortCache = mock(INeutronPortCRUD.class);
+ securityServicesImpl.setDependencies(neutronPortCache);
+ assertEquals("Error, did not return the correct object", getField("neutronPortCache"), neutronPortCache);
+ }
+
+ private Object getField(String fieldName) throws Exception {
+ Field field = SecurityServicesImpl.class.getDeclaredField(fieldName);
+ field.setAccessible(true);
+ return field.get(securityServicesImpl);
}
}
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyString;
import static org.mockito.Matchers.eq;
-import static org.mockito.Matchers.same;
-import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
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.HashMap;
import java.util.List;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-import org.junit.Ignore;
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.INeutronNetworkCRUD;
import org.opendaylight.neutron.spi.INeutronPortCRUD;
import org.opendaylight.neutron.spi.NeutronNetwork;
import org.opendaylight.neutron.spi.NeutronPort;
-import org.opendaylight.ovsdb.openstack.netvirt.api.Constants;
-import org.opendaylight.ovsdb.openstack.netvirt.api.NetworkingProvider;
import org.opendaylight.ovsdb.openstack.netvirt.api.NetworkingProviderManager;
-import org.opendaylight.ovsdb.openstack.netvirt.api.Status;
+import org.opendaylight.ovsdb.openstack.netvirt.api.Southbound;
import org.opendaylight.ovsdb.openstack.netvirt.api.VlanConfigurationCache;
+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 TenantNetworkManagerImpl}
*/
-@Ignore // TODO SB_MIGRATION
-@RunWith(MockitoJUnitRunner.class)
+@RunWith(PowerMockRunner.class)
+@PrepareForTest(ServiceHelper.class)
public class TenantNetworkManagerImplTest {
+ @InjectMocks private TenantNetworkManagerImpl tenantNetworkManagerImpl;
+
+ @Mock private INeutronPortCRUD neutronPortCache;
+ @Mock private INeutronNetworkCRUD neutronNetworkCache;
@Mock private VlanConfigurationCache vlanConfigurationCache;
- @Mock private INeutronPortCRUD neutronCache;
@Mock private NetworkingProviderManager networkingProviderManager;
-
- @InjectMocks private TenantNetworkManagerImpl tenantNetworkManagerImpl;
- @InjectMocks private INeutronPortCRUD neutronPortCache = mock(INeutronPortCRUD.class);
- @InjectMocks private INeutronNetworkCRUD neutronNetworkCache = mock(INeutronNetworkCRUD.class);
+ @Mock private Southbound southbound;
private static final String NETWORK_ID= "networkId";
-
+ private static final String SEG_ID = "segId";
+ private static final String INTERFACE_ID = "intId";
/**
* Test method {@link TenantNetworkManagerImpl#getInternalVlan(Node, String)}
*/
public void testReclaimInternalVlan() {
when(vlanConfigurationCache.reclaimInternalVlan(any(Node.class), eq(NETWORK_ID))).thenReturn(10);
- /* TODO SB_MIGRATION */
- //tenantNetworkManagerImpl.reclaimInternalVlan(mock(Node.class), NETWORK_ID, mock(NeutronNetwork.class));
- //tenantNetworkManagerImpl.reclaimInternalVlan(mock(Node.class), "unexistingNetwork", mock(NeutronNetwork.class));
+ tenantNetworkManagerImpl.reclaimInternalVlan(mock(Node.class), mock(NeutronNetwork.class));
+ tenantNetworkManagerImpl.reclaimInternalVlan(mock(Node.class), mock(NeutronNetwork.class));
verify(vlanConfigurationCache, times(2)).reclaimInternalVlan(any(Node.class), anyString());
}
*/
@Test
public void testProgramInternalVlan(){
- //Port port = mock(Port.class);
- //Row row = mock(Row.class);
- //GenericTableSchema tableSchema = mock(GenericTableSchema.class);
- Status status = mock(Status.class);
-
- //when(port.getRow()).thenReturn(row);
- //when(port.getSchema()).thenReturn(tableSchema);
-
when(vlanConfigurationCache.getInternalVlan(any(Node.class), anyString())).thenReturn(10);
- /* TODO SB_MIGRATION */
- //when(ovsdbConfigurationService.createTypedRow(any(Node.class), same(Port.class))).thenReturn(port);
- //when(ovsdbConfigurationService.updateRow(any(Node.class), anyString(), anyString(), anyString(), any(Row.class))).thenReturn(status);
- //tenantNetworkManagerImpl.programInternalVlan(mock(Node.class), NETWORK_ID, mock(NeutronNetwork.class));
+ tenantNetworkManagerImpl.programInternalVlan(mock(Node.class), mock(OvsdbTerminationPointAugmentation.class), mock(NeutronNetwork.class));
verify(vlanConfigurationCache, times(1)).getInternalVlan(any(Node.class), anyString());
}
/**
* Test method {@link TenantNetworkManagerImpl#isTenantNetworkPresentInNode(Node, String)}
*/
- /* TODO SB_MIGRATION */
- @Ignore
@Test
public void testIsTenantNetworkPresentInNode() {
- NetworkingProvider networkingProvider = mock(NetworkingProvider.class);
-
- //Interface intf = mock(Interface.class);
- //Column<GenericTableSchema, Map<String, String>> columnMock = mock(Column.class);
- Map<String, String> externalIds = new HashMap<String, String>();
- externalIds.put(Constants.EXTERNAL_ID_INTERFACE_ID, "interfaceId");
-
- //Row row = mock(Row.class);
- //Bridge bridge = mock(Bridge.class, RETURNS_DEEP_STUBS);
-
- //ConcurrentHashMap<String, Row> map;
- //map = new ConcurrentHashMap<>();
- //map.put("row", row);
-
NeutronNetwork neutronNetwork = mock(NeutronNetwork.class);
- NeutronPort neutronPort = mock(NeutronPort.class);
+ when(neutronNetwork.getProviderSegmentationID()).thenReturn(SEG_ID);
+ when(neutronNetwork.getNetworkUUID()).thenReturn(NETWORK_ID);
ArrayList<NeutronNetwork> listNeutronNetwork = new ArrayList<NeutronNetwork>();
listNeutronNetwork.add(neutronNetwork);
-
- when(neutronNetwork.getProviderSegmentationID()).thenReturn("segId");
- when(neutronNetwork.getNetworkUUID()).thenReturn("networkUUID");
when(neutronNetworkCache.getAllNetworks()).thenReturn(listNeutronNetwork);
- assertEquals("Error, did not return the UUID of the correct network", listNeutronNetwork.get(0).getNetworkUUID(), tenantNetworkManagerImpl.getNetworkId("segId"));
-
- when(networkingProviderManager.getProvider(any(Node.class))).thenReturn(networkingProvider);
- when(networkingProvider.hasPerTenantTunneling()).thenReturn(true);
-
- when(vlanConfigurationCache.getInternalVlan(any(Node.class), anyString())).thenReturn(10);
-
- /* TODO SB_MIGRATION */
- //when(ovsdbConfigurationService.getRows(any(Node.class), anyString())).thenReturn(map);
- //when(ovsdbConfigurationService.getTypedRow(any(Node.class), same(Interface.class),
- // any(Row.class))).thenReturn(intf);
-
- //when(intf.getExternalIdsColumn()).thenReturn(columnMock);
- //when(columnMock.getData()).thenReturn(externalIds);
-
+ when(southbound.getInterfaceExternalIdsValue(any(OvsdbTerminationPointAugmentation.class), anyString())).thenReturn(INTERFACE_ID);
+ NeutronPort neutronPort = mock(NeutronPort.class);
+ when(neutronPort.getNetworkUUID()).thenReturn(NETWORK_ID);
when(neutronPortCache.getPort(anyString())).thenReturn(neutronPort);
- when(neutronPort.getNetworkUUID()).thenReturn("networkUUID");
- assertTrue("Error, did not return correct boolean for isTenantNetworkPresentInNode", tenantNetworkManagerImpl.isTenantNetworkPresentInNode(mock(Node.class), "segId"));
+ List<OvsdbTerminationPointAugmentation> ports = new ArrayList<OvsdbTerminationPointAugmentation>();
+ ports.add(mock(OvsdbTerminationPointAugmentation.class));
+ when(southbound.getTerminationPointsOfBridge(any(Node.class))).thenReturn(ports);
+
+ assertTrue("Error, did not return correct boolean for isTenantNetworkPresentInNode", tenantNetworkManagerImpl.isTenantNetworkPresentInNode(mock(Node.class), SEG_ID));
}
/**
*/
@Test
public void testGetTenantNetwork() {
- //Interface intf = mock(Interface.class);
- //Column<GenericTableSchema, Map<String, String>> columnMock = mock(Column.class);
- Map<String, String> externalIds = new HashMap<String, String>();
- externalIds.put(Constants.EXTERNAL_ID_INTERFACE_ID, "tenantValue");
+ when(southbound.getInterfaceExternalIdsValue(any(OvsdbTerminationPointAugmentation.class), anyString())).thenReturn(INTERFACE_ID);
NeutronPort neutronPort = mock(NeutronPort.class);
+ when(neutronPortCache.getPort(anyString())).thenReturn(neutronPort);
NeutronNetwork neutronNetwork = mock(NeutronNetwork.class);
+ when(neutronNetworkCache.getNetwork(anyString())).thenReturn(neutronNetwork);
- //when(intf.getExternalIdsColumn()).thenReturn(columnMock);
- //when(columnMock.getData()).thenReturn(externalIds);
+ assertEquals("Error, did not return the correct tenant", neutronNetwork, tenantNetworkManagerImpl.getTenantNetwork(mock(OvsdbTerminationPointAugmentation.class)));
+ }
- when(neutronPort.getNetworkUUID()).thenReturn("neutronUUID");
+ @Test
+ public void testGetTenantPort() {
+ when(southbound.getInterfaceExternalIdsValue(any(OvsdbTerminationPointAugmentation.class), anyString())).thenReturn(INTERFACE_ID);
+ NeutronPort neutronPort = mock(NeutronPort.class);
when(neutronPortCache.getPort(anyString())).thenReturn(neutronPort);
- when(neutronNetworkCache.getNetwork(anyString())).thenReturn(neutronNetwork);
- // TODO SB_MIGRATION
- //assertEquals("Error, did not return the correct tenant", neutronNetwork, tenantNetworkManagerImpl.getTenantNetwork(intf));
+ assertEquals("Error, did not return the correct tenant", neutronPort, tenantNetworkManagerImpl.getTenantPort(mock(OvsdbTerminationPointAugmentation.class)));
+ }
- verify(neutronPortCache, times(1)).getPort(anyString());
- verify(neutronNetworkCache, times(1)).getNetwork(anyString());
+ @Test
+ public void testNetworkCreated() {
+ tenantNetworkManagerImpl.networkCreated(mock(Node.class), NETWORK_ID);
+ verify(vlanConfigurationCache, times(1)).assignInternalVlan(any(Node.class), anyString());
}
+ @Test
+ public void testSetDependencies() throws Exception {
+ VlanConfigurationCache vlanConfigurationCache = mock(VlanConfigurationCache.class);
+ Southbound southbound = mock(Southbound.class);
+
+ PowerMockito.mockStatic(ServiceHelper.class);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(VlanConfigurationCache.class, tenantNetworkManagerImpl)).thenReturn(vlanConfigurationCache);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(Southbound.class, tenantNetworkManagerImpl)).thenReturn(southbound);
+
+ tenantNetworkManagerImpl.setDependencies(mock(BundleContext.class), mock(ServiceReference.class));
+
+ assertEquals("Error, did not return the correct object", getField("vlanConfigurationCache"), vlanConfigurationCache);
+ assertEquals("Error, did not return the correct object", getField("southbound"), southbound);
+ }
+
+ @Test
+ public void testSetDependenciesObject() throws Exception{
+ INeutronNetworkCRUD neutronNetworkCache = mock(INeutronNetworkCRUD.class);
+ tenantNetworkManagerImpl.setDependencies(neutronNetworkCache);
+ assertEquals("Error, did not return the correct object", getField("neutronNetworkCache"), neutronNetworkCache);
+
+ INeutronPortCRUD neutronPortCache = mock(INeutronPortCRUD.class);
+ tenantNetworkManagerImpl.setDependencies(neutronPortCache);
+ assertEquals("Error, did not return the correct object", getField("neutronPortCache"), neutronPortCache);
+ }
+
+ private Object getField(String fieldName) throws Exception {
+ Field field = TenantNetworkManagerImpl.class.getDeclaredField(fieldName);
+ field.setAccessible(true);
+ return field.get(tenantNetworkManagerImpl);
+ }
}
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.when;
-import java.util.HashSet;
-import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.List;
import org.junit.Before;
-import org.junit.Ignore;
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.NeutronNetwork;
+import org.opendaylight.ovsdb.openstack.netvirt.api.Southbound;
+import org.opendaylight.ovsdb.openstack.netvirt.api.TenantNetworkManager;
+import org.opendaylight.ovsdb.utils.servicehelper.ServiceHelper;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;
+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 VlanConfigurationCacheImpl}
*/
-@Ignore // TODO SB_MIGRATION
-@RunWith(MockitoJUnitRunner.class)
+@RunWith(PowerMockRunner.class)
+@PrepareForTest(ServiceHelper.class)
public class VlanConfigurationCacheImplTest {
@InjectMocks public VlanConfigurationCacheImpl vlanConfigurationCacheImpl;
- @InjectMocks private TenantNetworkManagerImpl tenantNetworkManagerImpl = mock(TenantNetworkManagerImpl.class);
+
+ @Mock private TenantNetworkManager tenantNetworkManager;
+ @Mock private Southbound southbound;
private static final String NODE_UUID = "nodeUUID";
private static final String NETWORK_ID= "networkId";
-
+ private static final int VLAN_ID = 4;
/**
* Function configuring the node
*/
@Before
public void setUp(){
- //Row row = mock(Row.class);
- //Port port = mock(Port.class);
-
- //ConcurrentHashMap<String, Row> ovsTable;
- //ovsTable = new ConcurrentHashMap<>();
- //ovsTable.put(NODE_UUID, row);
-
- Set<Long> tags = new HashSet<Long>();
- tags.add(Long.valueOf(1));
-
- //UUID uuid = mock(UUID.class);
- //Set<UUID> uuidSet = new HashSet<>();
- //uuidSet.add(uuid);
-
- //Column<GenericTableSchema, Set<Long>> longColumnMock = mock(Column.class);
- //Column<GenericTableSchema, Set<UUID>> uuidColumnMock = mock(Column.class);
-
- //Interface iface = mock(Interface.class);
+ when(southbound.getOvsdbNodeUUID(any(Node.class))).thenReturn(NODE_UUID);
+ List<OvsdbTerminationPointAugmentation> ports = new ArrayList<OvsdbTerminationPointAugmentation>();
+ OvsdbTerminationPointAugmentation port = mock(OvsdbTerminationPointAugmentation.class);
+ VlanId vlanId = mock(VlanId.class);
+ when(vlanId.getValue()).thenReturn(VLAN_ID);
+ when(port.getVlanTag()).thenReturn(vlanId);
+ when(southbound.getTerminationPointsOfBridge(any(Node.class))).thenReturn(ports );
NeutronNetwork neutronNetwork = mock(NeutronNetwork.class);
-
- /* TODO SB_MIGRATION */
- //when(ovsdbConfigurationService.getRows(any(Node.class), anyString())).thenReturn(ovsTable);
- //when(ovsdbConfigurationService.getTypedRow(any(Node.class), same(Port.class), any(Row.class))).thenReturn(port);
-
- //when(port.getTagColumn()).thenReturn(longColumnMock);
- //when(longColumnMock.getData()).thenReturn(tags);
- //when(port.getInterfacesColumn()).thenReturn(uuidColumnMock);
- //when(uuidColumnMock.getData()).thenReturn(uuidSet);
-
- //when(ovsdbConfigurationService.getRow(any(Node.class), anyString(), anyString())).thenReturn(row);
- //when(ovsdbConfigurationService.getTypedRow(any(Node.class), same(Interface.class), any(Row.class))).thenReturn(iface);
-
- //when(tenantNetworkManagerImpl.getTenantNetwork(any(Interface.class))).thenReturn(neutronNetwork);
when(neutronNetwork.getNetworkUUID()).thenReturn(NETWORK_ID);
+ when(tenantNetworkManager.getTenantNetwork(any(OvsdbTerminationPointAugmentation.class))).thenReturn(neutronNetwork );
}
/**
* Test method {@link VlanConfigurationCacheImpl#assignInternalVlan(Node, String)}
*/
- /* TODO SB_MIGRATION */
- @Ignore
@Test
- public void testAssignInternalVlan() {
- assertEquals("Error, did not return the correct internalVlanId (first added)", 1, (int) vlanConfigurationCacheImpl.assignInternalVlan(any(Node.class), NETWORK_ID));
- assertEquals("Error, did not return the correct internalVlanId (second added)", 2, (int) vlanConfigurationCacheImpl.assignInternalVlan(any(Node.class), NETWORK_ID + "1"));
+ public void testAssignReclaimAndGetInternalVlan() {
+ assertEquals("Error, assignInternalVlan() did not return the correct internalVlanId (first added)", 1, (int) vlanConfigurationCacheImpl.assignInternalVlan(any(Node.class), NETWORK_ID));
+ assertEquals("Error, assignInternalVlan () did not return the correct internalVlanId (second added)", 2, (int) vlanConfigurationCacheImpl.assignInternalVlan(any(Node.class), NETWORK_ID + "1"));
+
+ assertEquals("Error, getInternalVlan() did not return the correct internalVlan", 1, (int) vlanConfigurationCacheImpl.getInternalVlan(any(Node.class), NETWORK_ID));
+
+ assertEquals("Error, reclaimInternalVlan() did not return the correct internalVlanId", 1, (int) vlanConfigurationCacheImpl.reclaimInternalVlan(any(Node.class), NETWORK_ID));
+ assertEquals("Error, reclaimInternalVlan() did not return the correct internalVlanId", 2, (int) vlanConfigurationCacheImpl.reclaimInternalVlan(any(Node.class), NETWORK_ID + "1"));
}
- /**
- * Test method {@link VlanConfigurationCacheImpl#reclaimInternalVlan(Node, String)}
- */
@Test
- public void testReclaimInternalVlan(){
- /* TODO SB_MIGRATION */
- //assertEquals("Error, did not return the correct internalVlanId", 1, (int) vlanConfigurationCacheImpl.reclaimInternalVlan(any(Node.class), NETWORK_ID));
+ public void testSetDependencies() throws Exception {
+ TenantNetworkManager tenantNetworkManager = mock(TenantNetworkManager.class);
+ Southbound southbound = mock(Southbound.class);
+
+ PowerMockito.mockStatic(ServiceHelper.class);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(TenantNetworkManager.class, vlanConfigurationCacheImpl)).thenReturn(tenantNetworkManager);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(Southbound.class, vlanConfigurationCacheImpl)).thenReturn(southbound);
+
+ vlanConfigurationCacheImpl.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("southbound"), southbound);
}
- /**
- * Test method {@link VlanConfigurationCacheImpl#getInternalVlan(Node, String)}
- */
- @Test
- public void testGetInternalVlan(){
- /* TODO SB_MIGRATION */
- //assertEquals("Error, did not return the correct internalVlan", 1, (int) vlanConfigurationCacheImpl.getInternalVlan(any(Node.class), NETWORK_ID));
+ private Object getField(String fieldName) throws Exception {
+ Field field = VlanConfigurationCacheImpl.class.getDeclaredField(fieldName);
+ field.setAccessible(true);
+ return field.get(vlanConfigurationCacheImpl);
}
}
Code Review / ovsdb.git / commitdiff