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.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-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 java.lang.reflect.Field;
-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.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
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.TransactionCommitFailedException;
import org.opendaylight.ovsdb.openstack.netvirt.api.Constants;
-import org.opendaylight.ovsdb.utils.mdsal.openflow.InstructionUtils;
+import org.opendaylight.ovsdb.openstack.netvirt.api.Southbound;
+import org.opendaylight.ovsdb.utils.servicehelper.ServiceHelper;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.osgi.framework.ServiceReference;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.modules.junit4.PowerMockRunner;
import com.google.common.base.Optional;
import com.google.common.util.concurrent.CheckedFuture;
/**
* Unit test for {@link AbstractServiceInstance}
*/
-@Ignore // TODO SB_MIGRATION
-@RunWith(MockitoJUnitRunner.class)
+//@PrepareForTest(ServiceHelper.class)
+@RunWith(PowerMockRunner.class)
+@SuppressWarnings("unchecked")
public class AbstractServiceInstanceTest {
- @InjectMocks AbstractServiceInstance abstractServiceInstance = mock(AbstractServiceInstance.class, Mockito.CALLS_REAL_METHODS);
+ @InjectMocks private AbstractServiceInstance abstractServiceInstance = mock(AbstractServiceInstance.class, Mockito.CALLS_REAL_METHODS);
- /* TODO SB_MIGRATION */
- //@Mock private OvsdbConnectionService connectionService;
+ @Mock private DataBroker dataBroker;
@Mock private PipelineOrchestrator orchestrator;
+ @Mock private Southbound southbound;
private Service service = Service.L3_FORWARDING;
private final String ID = "5710881121";
private final String NODE_ID = Constants.INTEGRATION_BRIDGE + ":" + ID;
- private final String DPID = "154652161";
/**
* Test method {@link AbstractServiceInstance#isBridgeInPipeline(String)}
*/
@Test
public void testIsBridgeInPipeline() {
- Node node = mock(Node.class);
- when(node.getId()).thenReturn(mock(NodeId.class));
-
- List<Node> nodes = new ArrayList();
- nodes.add(node);
- /* TODO SB_MIGRATION */
- //when(connectionService.getBridgeNodes()).thenReturn(nodes);
-
- //ConcurrentMap<String, Row> bridges = new ConcurrentHashMap();
- //bridges.put("key", mock(Row.class));
- //when(ovsdbConfigService.getRows(any(Node.class), anyString())).thenReturn(bridges);
-
- //Bridge bridge = mock(Bridge.class);
- //Column<GenericTableSchema, Set<String>> datapathIdColumn = mock(Column.class);
- //when(bridge.getDatapathIdColumn()).thenReturn(datapathIdColumn);
- //when(bridge.getName()).thenReturn(Constants.INTEGRATION_BRIDGE);
- Set<String> dpids = new HashSet();
- dpids.add(DPID);
- //when(datapathIdColumn.getData()).thenReturn(dpids);
- //when(ovsdbConfigService.getTypedRow(any(Node.class), same(Bridge.class), any(Row.class))).thenReturn(bridge);
-
- /* TODO SB_MIGRATION */
- //assertTrue("Error, isBridgeInPipeline() did not return the correct value", abstractServiceInstance.isBridgeInPipeline(NODE_ID));
+ when(southbound.getBridgeName(any(Node.class))).thenReturn(Constants.INTEGRATION_BRIDGE);
+ assertTrue("Error, isBridgeInPipeline() did not return the correct value", abstractServiceInstance.isBridgeInPipeline(mock(Node.class)));
}
/**
assertEquals("Error, getTable() did not return the correct value", 70, abstractServiceInstance.getTable());
}
+ @Test
+ public void testGetService() {
+ abstractServiceInstance.setService(service);
+ assertEquals("Error, getService() did not return the correct value", service, abstractServiceInstance.getService());
+ }
+
/**
* Test method {@link AbstractServiceInstance#createNodeBuilder(String)}
*/
@Test
public void testCreateNodeBuilder() {
- NodeId id = new NodeId(NODE_ID);
+ NodeId nodeId = mock(NodeId.class);
+ when(nodeId.getValue()).thenReturn(NODE_ID);
NodeBuilder nodeBuilder = abstractServiceInstance.createNodeBuilder(NODE_ID);
assertNotNull("Error, createNodeBuilder() did not return the correct value", nodeBuilder);
- assertEquals("Error, createNodeBuilder() did not return the correct ID", id, nodeBuilder.getId());
- assertEquals("Error, createNodeBuilder() did not return the correct Key", new NodeKey(id), nodeBuilder.getKey());
+ assertEquals("Error, createNodeBuilder() did not return the correct ID", NODE_ID, nodeBuilder.getId().getValue());
+ assertEquals("Error, createNodeBuilder() did not return the correct Key", new NodeKey(nodeBuilder.getId()), nodeBuilder.getKey());
}
/**
*/
@Test
public void testWriteFlow() throws Exception {
- DataBroker dataBrocker = mock(DataBroker.class);
- ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
- when(dataBrocker.newReadWriteTransaction()).thenReturn(transaction);
- ///when(mdsalConsumer.getDataBroker()).thenReturn(dataBrocker);
+ WriteTransaction transaction = mock(WriteTransaction.class);
+ when(dataBroker.newWriteOnlyTransaction()).thenReturn(transaction);
CheckedFuture<Void, TransactionCommitFailedException> commitFuture = mock(CheckedFuture.class);
when(transaction.submit()).thenReturn(commitFuture);
*/
@Test
public void testRemoveFlow() throws Exception {
- DataBroker dataBrocker = mock(DataBroker.class);
WriteTransaction transaction = mock(WriteTransaction.class);
- when(dataBrocker.newWriteOnlyTransaction()).thenReturn(transaction);
- //when(mdsalConsumer.getDataBroker()).thenReturn(dataBrocker);
+ when(dataBroker.newWriteOnlyTransaction()).thenReturn(transaction);
CheckedFuture<Void, TransactionCommitFailedException> commitFuture = mock(CheckedFuture.class);
when(transaction.submit()).thenReturn(commitFuture);
*/
@Test
public void testGetFlow() throws Exception {
- DataBroker dataBrocker = mock(DataBroker.class);
ReadOnlyTransaction transaction = mock(ReadOnlyTransaction.class);
- when(dataBrocker.newReadOnlyTransaction()).thenReturn(transaction);
+ when(dataBroker.newReadOnlyTransaction()).thenReturn(transaction);
//when(mdsalConsumer.getDataBroker()).thenReturn(dataBrocker);
NodeBuilder nodeBuilder = mock(NodeBuilder.class);
*/
@Test
public void testProgramDefaultPipelineRule() {
- Node node = mock(Node.class);
- when(node.getId()).thenReturn(mock(NodeId.class));
-
- List<Node> nodes = new ArrayList();
- nodes.add(node);
- /* TODO SB_MIGRATION */
- //when(connectionService.getBridgeNodes()).thenReturn(nodes);
-
- //ConcurrentMap<String, Row> bridges = new ConcurrentHashMap();
- //bridges.put("key", mock(Row.class));
- //when(ovsdbConfigService.getRows(any(Node.class), anyString())).thenReturn(bridges);
-
- //Bridge bridge = mock(Bridge.class);
- //Column<GenericTableSchema, Set<String>> datapathIdColumn = mock(Column.class);
- //when(bridge.getDatapathIdColumn()).thenReturn(datapathIdColumn);
- //when(bridge.getName()).thenReturn(Constants.INTEGRATION_BRIDGE);
- Set<String> dpids = new HashSet();
- dpids.add(DPID);
- //when(datapathIdColumn.getData()).thenReturn(dpids);
- /* TODO SB_MIGRATION */
- //when(ovsdbConfigService.getTypedRow(any(Node.class), same(Bridge.class), any(Row.class))).thenReturn(bridge);
+ when(southbound.getBridgeName(any(Node.class))).thenReturn(Constants.INTEGRATION_BRIDGE);
+ when(southbound.getDataPathId(any(Node.class))).thenReturn(Long.valueOf(261));
+
+ when(orchestrator.getNextServiceInPipeline(any(Service.class))).thenReturn(Service.ARP_RESPONDER);
abstractServiceInstance.setService(service);
- /* TODO SB_MIGRATION */ // Need topology Node rather than the NODE_ID
- //abstractServiceInstance.programDefaultPipelineRule(NODE_ID);
+ WriteTransaction transaction = mock(WriteTransaction.class);
+ when(dataBroker.newWriteOnlyTransaction()).thenReturn(transaction);
+ CheckedFuture<Void, TransactionCommitFailedException> commitFuture = mock(CheckedFuture.class);
+ when(transaction.submit()).thenReturn(commitFuture);
+
+ NodeBuilder nodeBuilder = mock(NodeBuilder.class);
+ when(nodeBuilder.getKey()).thenReturn(mock(NodeKey.class));
+
+ FlowBuilder flowBuilder = mock(FlowBuilder.class);
+ when(flowBuilder.getKey()).thenReturn(mock(FlowKey.class));
+
+ abstractServiceInstance.programDefaultPipelineRule(mock(Node.class));
+
+ verify(abstractServiceInstance, times(1)).isBridgeInPipeline(any(Node.class));
+ verify(abstractServiceInstance, times(1)).createNodeBuilder(anyString());
+ verify(abstractServiceInstance, times(1)).writeFlow(any(FlowBuilder.class), any(NodeBuilder.class));
+ }
+
+// @Test TODO - re-activate test
+ public void testSetDependencies() throws Exception {
+ PipelineOrchestrator pipelineOrchestrator = mock(PipelineOrchestrator.class);
+ Southbound southbound = mock(Southbound.class);
+
+ PowerMockito.mockStatic(ServiceHelper.class);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(PipelineOrchestrator.class, abstractServiceInstance)).thenReturn(pipelineOrchestrator);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(Southbound.class, abstractServiceInstance)).thenReturn(southbound);
+
+ abstractServiceInstance.setDependencies(mock(ServiceReference.class), mock(AbstractServiceInstance.class));
+
+ assertEquals("Error, did not return the correct object", getField("pipelineOrchestrator"), pipelineOrchestrator);
+ assertEquals("Error, did not return the correct object", getField("southbound"), southbound);
+ }
- /* TODO SB_MIGRATION */
- //verify(abstractServiceInstance, times(1)).isBridgeInPipeline(NODE_ID);
- //verify(abstractServiceInstance, times(1)).writeFlow(any(FlowBuilder.class), any(NodeBuilder.class));
+ private Object getField(String fieldName) throws Exception {
+ Field field = AbstractServiceInstance.class.getDeclaredField(fieldName);
+ field.setAccessible(true);
+ return field.get(abstractServiceInstance);
}
}
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
+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.concurrent.ExecutorService;
-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.opendaylight.ovsdb.openstack.netvirt.api.NodeCacheManager;
+import org.opendaylight.ovsdb.openstack.netvirt.api.Southbound;
+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 PipelineOrchestratorImplTest}
*/
-@Ignore //TODO SB_MIGRATION
-@PrepareForTest(PipelineOrchestratorImpl.class)
+@PrepareForTest(ServiceHelper.class)
@RunWith(PowerMockRunner.class)
public class PipelineOrchestratorImplTest {
+ @InjectMocks private PipelineOrchestratorImpl orchestrator;
- @Mock
- private ServiceReference ref;
- @Mock
- private ServiceReference ref2;
- @Mock
- private AbstractServiceInstance serviceInstance;
- @Mock
- private AbstractServiceInstance serviceInstance2;
-
- @InjectMocks
- private PipelineOrchestratorImpl orchestrator;
-
- @Before
- public void setUp() {
- //Random r = new Random();
-
- orchestrator = new PipelineOrchestratorImpl();
- // TODO SB_MIGRATION
- //orchestrator.init();
- orchestrator.start();
-
- /*when(ref.getProperty(org.osgi.framework.Constants.SERVICE_ID))
- .thenReturn(r.nextLong());
- when(ref.getProperty(Constants.EVENT_HANDLER_TYPE_PROPERTY))
- .thenReturn(handlerTypeObject);
- when(ref.getProperty(AbstractServiceInstance.SERVICE_PROPERTY))
- .thenReturn(Service.CLASSIFIER);
-
- when(ref2.getProperty(org.osgi.framework.Constants.SERVICE_ID))
- .thenReturn(r.nextLong());
- when(ref2.getProperty(Constants.EVENT_HANDLER_TYPE_PROPERTY))
- .thenReturn(handlerTypeObject);
- when(ref2.getProperty(AbstractServiceInstance.SERVICE_PROPERTY))
- .thenReturn(Service.INBOUND_NAT);
-
- when(serviceInstance.getService()).thenReturn(Service.CLASSIFIER);
- when(serviceInstance2.getService()).thenReturn(Service.INBOUND_NAT);*/
- }
+ @Mock private ExecutorService eventHandler;
+ @Mock private Southbound southbound;
/***
* Registers a mock service and verifies the registration by asking the
* registry
*/
@Test
- public void testRegisterService() {
- orchestrator.registerService(ref, serviceInstance);
- assertEquals("Error, registerService() service registration fails",
- serviceInstance,
- orchestrator.getServiceInstance(Service.CLASSIFIER));
- }
-
- /***
- * Test method {@link PipelineOrchestratorImplr#registerService(Service)}
- *
- * Unregisters a mock service and verifies the process by asking the
- * pipeline orchestrator to return the associated service from its internal
- * registry
- */
- @Test
- public void testUnRegisterService() {
+ public void testRegisterAndUnregisterService() {
+ Service service = Service.CLASSIFIER;
+ ServiceReference<?> serviceReference = mock(ServiceReference.class);
+ when(serviceReference.getProperty(anyString())).thenReturn(service);
- orchestrator = new PipelineOrchestratorImpl();
- //orchestrator.init();
- orchestrator.start();
- orchestrator.registerService(ref, serviceInstance);
- orchestrator.unregisterService(ref);
+ AbstractServiceInstance abstractServiceInstance = mock(AbstractServiceInstance.class);
- assertEquals("Error, unregisterService() service registration fails",
- null, orchestrator.getServiceInstance(Service.CLASSIFIER));
+ orchestrator.registerService(serviceReference, abstractServiceInstance);
+ assertEquals("Error, registerService() service registration fails",
+ abstractServiceInstance,
+ orchestrator.getServiceInstance(service));
+ orchestrator.unregisterService(serviceReference);
+ assertNull("Error, unregisterService() didn't delete the service", orchestrator.getServiceInstance(service));
}
/**
orchestrator.getNextServiceInPipeline(Service.OUTBOUND_NAT),
Service.L2_FORWARDING);
assertNull(orchestrator.getNextServiceInPipeline(Service.L2_FORWARDING));
-
}
- /**
- * Test method {@link PipelineOrchestratorImpl#getServiceInstance(Service)}
- */
- @Test
- public void testGetServiceInstance() {
+ @Test
+ public void testSetDependencies() throws Exception {
+ NodeCacheManager nodeCacheManager = mock(NodeCacheManager.class);
+ Southbound southbound = mock(Southbound.class);
- orchestrator = new PipelineOrchestratorImpl();
- //orchestrator.init();
- orchestrator.start();
- orchestrator.registerService(ref, serviceInstance);
- orchestrator.registerService(ref2, serviceInstance2);
+ PowerMockito.mockStatic(ServiceHelper.class);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(NodeCacheManager.class, orchestrator)).thenReturn(nodeCacheManager);
+ PowerMockito.when(ServiceHelper.getGlobalInstance(Southbound.class, orchestrator)).thenReturn(southbound);
- assertEquals(
- "Error, getServiceInstance() fails to return an instance of a registered service",
- serviceInstance,
- orchestrator.getServiceInstance(Service.CLASSIFIER));
+ orchestrator.setDependencies(mock(BundleContext.class), mock(ServiceReference.class));
- assertEquals(
- "Error, getServiceInstance() returned an instance of a service that wasn't registered.",
- null, orchestrator.getServiceInstance(Service.DIRECTOR));
- }
+// assertEquals("Error, did not return the correct object", getField("nodeCacheManager"), nodeCacheManager);
+ assertEquals("Error, did not return the correct object", getField("southbound"), southbound);
+ }
+ private Object getField(String fieldName) throws Exception {
+ Field field = PipelineOrchestratorImpl.class.getDeclaredField(fieldName);
+ field.setAccessible(true);
+ return field.get(orchestrator);
+ }
}
import java.net.InetAddress;
-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.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
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.TransactionCommitFailedException;
import org.opendaylight.ovsdb.openstack.netvirt.api.Action;
import org.opendaylight.ovsdb.openstack.netvirt.api.Status;
import org.opendaylight.ovsdb.openstack.netvirt.api.StatusCode;
+import org.opendaylight.ovsdb.openstack.netvirt.providers.openflow13.Service;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import com.google.common.util.concurrent.CheckedFuture;
/**
* Unit test for {@link ArpResponderService}
*/
-@Ignore // TODO SB_MIGRATION
@RunWith(MockitoJUnitRunner.class)
+@SuppressWarnings("unchecked")
public class ArpResponderServiceTest {
@InjectMocks private ArpResponderService arpResponderService = new ArpResponderService();
- //@Mock private MdsalConsumer mdsalConsumer;
+ @Mock private DataBroker dataBroker;
private static final String HOST_ADDRESS = "121.0.0.1";
private static final String MAC_ADDRESS = "87:1D:5E:02:40:B7";
@Test
public void testProgramStaticArpEntry() throws Exception {
+ arpResponderService.setService(Service.ARP_RESPONDER);
+
InetAddress ipAddress = mock(InetAddress.class);
when(ipAddress.getHostAddress()).thenReturn(HOST_ADDRESS);
+ WriteTransaction transaction = mock(WriteTransaction.class);
+ when(dataBroker.newWriteOnlyTransaction()).thenReturn(transaction);
CheckedFuture<Void, TransactionCommitFailedException> commitFuture = mock(CheckedFuture.class);
+ when(transaction.submit()).thenReturn(commitFuture);
- ReadWriteTransaction readWriteTransaction = mock(ReadWriteTransaction.class);
- when(readWriteTransaction.submit()).thenReturn(commitFuture);
-
- WriteTransaction writeTransaction = mock(WriteTransaction.class);
- when(writeTransaction.submit()).thenReturn(commitFuture);
+ NodeBuilder nodeBuilder = mock(NodeBuilder.class);
+ when(nodeBuilder.getKey()).thenReturn(mock(NodeKey.class));
- DataBroker dataBroker = mock(DataBroker.class);
- when(dataBroker.newReadWriteTransaction()).thenReturn(readWriteTransaction);
- when(dataBroker.newWriteOnlyTransaction()).thenReturn(writeTransaction);
+ FlowBuilder flowBuilder = mock(FlowBuilder.class);
+ when(flowBuilder.getKey()).thenReturn(mock(FlowKey.class));
- //when(mdsalConsumer.getDataBroker()).thenReturn(dataBroker);
-
- // test for Action.ADD
+ // test Action.ADD
assertEquals("Error, did not return the expected StatusCode", new Status(StatusCode.SUCCESS), arpResponderService.programStaticArpEntry(Long.valueOf(12), "2", MAC_ADDRESS, ipAddress, Action.ADD));
- verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(1)).submit();
+ verify(transaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(transaction, times(1)).submit();
verify(commitFuture, times(1)).get();
- // test other Action, here Action.DELETE
+ // test Action.DELETE
assertEquals("Error, did not return the expected StatusCode", new Status(StatusCode.SUCCESS), arpResponderService.programStaticArpEntry(Long.valueOf(12), "2", MAC_ADDRESS, ipAddress, Action.DELETE));
- verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
+ verify(transaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
verify(commitFuture, times(2)).get(); // 1 + 1 above
}
-
}
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.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.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
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.TransactionCommitFailedException;
/**
* Unit test for {@link ClassifierService}
*/
-@Ignore // TODO SB_MIGRATION
@RunWith(MockitoJUnitRunner.class)
+@SuppressWarnings("unchecked")
public class ClassifierServiceTest {
- @InjectMocks ClassifierService classifierService = new ClassifierService(Service.ARP_RESPONDER);
+ @InjectMocks private ClassifierService classifierService = new ClassifierService(Service.ARP_RESPONDER);
+
+ @Mock private DataBroker dataBroker;
private static final String MAC_ADDRESS = "87:1D:5E:02:40:B7";
- //@Mock private MdsalConsumer mdsalConsumer;
@Mock private PipelineOrchestrator orchestrator;
- @Mock private ReadWriteTransaction readWriteTransaction;
@Mock private WriteTransaction writeTransaction;
@Mock private CheckedFuture<Void, TransactionCommitFailedException> commitFuture;
@Before
public void setUp() {
- when(readWriteTransaction.submit()).thenReturn(commitFuture);
+ when(writeTransaction.submit()).thenReturn(commitFuture);
when(writeTransaction.submit()).thenReturn(commitFuture);
- DataBroker dataBroker = mock(DataBroker.class);
- when(dataBroker.newReadWriteTransaction()).thenReturn(readWriteTransaction);
when(dataBroker.newWriteOnlyTransaction()).thenReturn(writeTransaction);
- //when(mdsalConsumer.getDataBroker()).thenReturn(dataBroker);
-
when(orchestrator.getNextServiceInPipeline(any(Service.class))).thenReturn(Service.ARP_RESPONDER);
}
public void testProgramLocalInPort() throws Exception {
// write
classifierService.programLocalInPort(Long.valueOf(1212), "2", Long.valueOf(455), MAC_ADDRESS, true);
- verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(1)).submit();
verify(commitFuture, times(1)).get();
// remove
public void testProgramLocalInPortSetVlan() throws Exception {
// write
classifierService.programLocalInPortSetVlan(Long.valueOf(1212), "2", Long.valueOf(455), MAC_ADDRESS, true);
- verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(1)).submit();
verify(commitFuture, times(1)).get();
// remove
public void testProgramDropSrcIface() throws Exception {
// write
classifierService.programDropSrcIface(Long.valueOf(1212), Long.valueOf(455), true);
- verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(1)).submit();
verify(commitFuture, times(1)).get();
// remove
public void testProgramTunnelIn() throws Exception {
// write
classifierService.programTunnelIn(Long.valueOf(1212), "2", Long.valueOf(455), true);
- verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(1)).submit();
verify(commitFuture, times(1)).get();
// remove
public void testProgramVlanIn() throws Exception {
// write
classifierService.programVlanIn(Long.valueOf(1212), "2", Long.valueOf(455), true);
- verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(1)).submit();
verify(commitFuture, times(1)).get();
// remove
public void testProgramLLDPPuntRule() throws Exception {
// write
classifierService.programLLDPPuntRule(Long.valueOf(1212));
- verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(1)).submit();
verify(commitFuture, times(1)).get();
}
}
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.Spy;
import org.mockito.runners.MockitoJUnitRunner;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
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.TransactionCommitFailedException;
/**
* Unit test for {@link EgressAclService}
*/
-@Ignore // TODO SB_MIGRATION
@RunWith(MockitoJUnitRunner.class)
+@SuppressWarnings("unchecked")
public class EgressAclServiceTest {
@InjectMocks private EgressAclService egressAclService = new EgressAclService();
@Spy private EgressAclService egressAclServiceSpy;
- //@Mock private MdsalConsumer mdsalConsumer;
+ @Mock private DataBroker dataBroker;
@Mock private PipelineOrchestrator orchestrator;
- @Mock private ReadWriteTransaction readWriteTransaction;
@Mock private WriteTransaction writeTransaction;
@Mock private CheckedFuture<Void, TransactionCommitFailedException> commitFuture;
public void setUp() {
egressAclServiceSpy = Mockito.spy(egressAclService);
- when(readWriteTransaction.submit()).thenReturn(commitFuture);
when(writeTransaction.submit()).thenReturn(commitFuture);
- DataBroker dataBroker = mock(DataBroker.class);
- when(dataBroker.newReadWriteTransaction()).thenReturn(readWriteTransaction);
when(dataBroker.newWriteOnlyTransaction()).thenReturn(writeTransaction);
- //when(mdsalConsumer.getDataBroker()).thenReturn(dataBroker);
-
when(orchestrator.getNextServiceInPipeline(any(Service.class))).thenReturn(Service.ARP_RESPONDER);
portSecurityRule = mock(NeutronSecurityRule.class);
when(portSecurityRule.getSecurityRuleEthertype()).thenReturn("IPv4");
when(portSecurityRule.getSecurityRuleDirection()).thenReturn("egress");
- List<NeutronSecurityRule> portSecurityList = new ArrayList();
+ List<NeutronSecurityRule> portSecurityList = new ArrayList<NeutronSecurityRule>();
portSecurityList.add(portSecurityRule);
when(securityGroup.getSecurityRules()).thenReturn(portSecurityList);
egressAclServiceSpy.programPortSecurityACL(Long.valueOf(1554), "2", MAC_ADDRESS, 124, securityGroup);
verify(egressAclServiceSpy, times(1)).egressACLDefaultTcpDrop(anyLong(), anyString(), anyString(), anyInt(), anyBoolean());
verify(egressAclServiceSpy, times(1)).egressACLTcpPortWithPrefix(anyLong(), anyString(), anyString(), anyBoolean(), anyInt(), anyString(), anyInt());
- verify(readWriteTransaction, times(4)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(2)).submit();
+ verify(writeTransaction, times(4)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get();
}
egressAclServiceSpy.programPortSecurityACL(Long.valueOf(1554), "2", MAC_ADDRESS, 124, securityGroup);
verify(egressAclServiceSpy, times(1)).egressACLDefaultTcpDrop(anyLong(), anyString(), anyString(), anyInt(), anyBoolean());
verify(egressAclServiceSpy, times(1)).egressACLTcpPortWithPrefix(anyLong(), anyString(), anyString(), anyBoolean(), anyInt(), anyString(), anyInt());
- verify(readWriteTransaction, times(4)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(2)).submit();
+ verify(writeTransaction, times(4)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get();
}
egressAclServiceSpy.programPortSecurityACL(Long.valueOf(1554), "2", MAC_ADDRESS, 124, securityGroup);
verify(egressAclServiceSpy, times(1)).egressACLDefaultTcpDrop(anyLong(), anyString(), anyString(), anyInt(), anyBoolean());
verify(egressAclServiceSpy, times(1)).egressACLPermitAllProto(anyLong(), anyString(), anyString(), anyBoolean(), anyString(), anyInt());
- verify(readWriteTransaction, times(4)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(2)).submit();
+ verify(writeTransaction, times(4)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get();
}
egressAclServiceSpy.programPortSecurityACL(Long.valueOf(1554), "2", MAC_ADDRESS, 124, securityGroup);
verify(egressAclServiceSpy, times(1)).egressACLDefaultTcpDrop(anyLong(), anyString(), anyString(), anyInt(), anyBoolean());
verify(egressAclServiceSpy, times(1)).egressACLPermitAllProto(anyLong(), anyString(), anyString(), anyBoolean(), anyString(), anyInt());
- verify(readWriteTransaction, times(4)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(2)).submit();
+ verify(writeTransaction, times(4)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get();
}
egressAclServiceSpy.programPortSecurityACL(Long.valueOf(1554), "2", MAC_ADDRESS, 124, securityGroup);
verify(egressAclServiceSpy, times(1)).egressACLDefaultTcpDrop(anyLong(), anyString(), anyString(), anyInt(), anyBoolean());
verify(egressAclServiceSpy, times(1)).egressACLTcpSyn(anyLong(), anyString(), anyString(), anyBoolean(), anyInt(), anyInt());
- verify(readWriteTransaction, times(4)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(2)).submit();
+ verify(writeTransaction, times(4)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get();
}
egressAclServiceSpy.programPortSecurityACL(Long.valueOf(1554), "2", MAC_ADDRESS, 124, securityGroup);
verify(egressAclServiceSpy, times(1)).egressACLDefaultTcpDrop(anyLong(), anyString(), anyString(), anyInt(), anyBoolean());
verify(egressAclServiceSpy, times(1)).egressACLTcpSyn(anyLong(), anyString(), anyString(), anyBoolean(), anyInt(), anyInt());
- verify(readWriteTransaction, times(4)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(2)).submit();
+ verify(writeTransaction, times(4)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get();
}
egressAclServiceSpy.programPortSecurityACL(Long.valueOf(1554), "2", MAC_ADDRESS, 124, securityGroup);
verify(egressAclServiceSpy, times(1)).egressAllowProto(anyLong(), anyString(), anyString(), anyBoolean(), anyString(), anyInt());
- verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(1)).submit();
verify(commitFuture, times(1)).get();
}
@Test
public void testEgressACLDefaultTcpDrop() throws Exception {
egressAclService.egressACLDefaultTcpDrop(Long.valueOf(123), "2", MAC_ADDRESS, 1, true);
- verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(1)).submit();
verify(commitFuture, times(1)).get();
egressAclService.egressACLDefaultTcpDrop(Long.valueOf(123), "2", MAC_ADDRESS, 1, false);
verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get(); // 1 + 1 above
}
@Test
public void testEgressACLTcpPortWithPrefix() throws Exception {
egressAclService.egressACLTcpPortWithPrefix(Long.valueOf(123), "2", MAC_ADDRESS, true, 1, HOST_ADDRESS, 1);
- verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(1)).submit();
verify(commitFuture, times(1)).get();
egressAclService.egressACLTcpPortWithPrefix(Long.valueOf(123), "2", MAC_ADDRESS, false, 1, HOST_ADDRESS, 1);
verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get(); // 1 + 1 above
}
@Test
public void testEgressAllowProto() throws Exception {
egressAclService.egressAllowProto(Long.valueOf(123), "2", MAC_ADDRESS, true, HOST_ADDRESS, 1);
- verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(1)).submit();
verify(commitFuture, times(1)).get();
egressAclService.egressAllowProto(Long.valueOf(123), "2", MAC_ADDRESS, false, HOST_ADDRESS, 1);
verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get(); // 1 + 1 above
}
@Test
public void testEgressACLPermitAllProto() throws Exception {
egressAclService.egressACLPermitAllProto(Long.valueOf(123), "2", MAC_ADDRESS, true, HOST_ADDRESS, 1);
- verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(1)).submit();
verify(commitFuture, times(1)).get();
egressAclService.egressACLPermitAllProto(Long.valueOf(123), "2", MAC_ADDRESS, false, HOST_ADDRESS, 1);
verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get(); // 1 + 1 above
}
@Test
public void testEgressACLTcpSyn() throws Exception {
egressAclService.egressACLTcpSyn(Long.valueOf(123), "2", MAC_ADDRESS, true, 1, 1);
- verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(1)).submit();
verify(commitFuture, times(1)).get();
egressAclService.egressACLTcpSyn(Long.valueOf(123), "2", MAC_ADDRESS, false, 1, 1);
verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get(); // 1 + 1 above
}
}
import java.net.InetAddress;
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.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
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.TransactionCommitFailedException;
/**
* Unit test for {@link InboundNatService}
*/
-@Ignore // TODO SB_MIGRATION
@RunWith(MockitoJUnitRunner.class)
+@SuppressWarnings("unchecked")
public class InboundNatServiceTest {
@InjectMocks private InboundNatService inboundNatService = new InboundNatService(Service.ARP_RESPONDER);
- //@Mock private MdsalConsumer mdsalConsumer;
+ @Mock private DataBroker dataBroker;
@Mock private PipelineOrchestrator orchestrator;
- @Mock private ReadWriteTransaction readWriteTransaction;
@Mock private WriteTransaction writeTransaction;
@Mock private CheckedFuture<Void, TransactionCommitFailedException> commitFuture;
@Before
public void setUp() {
- when(readWriteTransaction.submit()).thenReturn(commitFuture);
when(writeTransaction.submit()).thenReturn(commitFuture);
- DataBroker dataBroker = mock(DataBroker.class);
- when(dataBroker.newReadWriteTransaction()).thenReturn(readWriteTransaction);
when(dataBroker.newWriteOnlyTransaction()).thenReturn(writeTransaction);
- //when(mdsalConsumer.getDataBroker()).thenReturn(dataBroker);
-
when(orchestrator.getNextServiceInPipeline(any(Service.class))).thenReturn(Service.ARP_RESPONDER);
}
new Status(StatusCode.SUCCESS),
inboundNatService.programIpRewriteRule(Long.valueOf(123), "2",
matchAddress, rewriteAddress, Action.ADD));
- verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(1)).submit();
verify(commitFuture, times(1)).get();
assertEquals("Error, did not return the expected StatusCode",
inboundNatService.programIpRewriteRule(Long.valueOf(123), "2",
matchAddress, rewriteAddress, Action.DELETE));
verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get(); // 1 + 1 above
}
assertEquals("Error, did not return the expected StatusCode",
new Status(StatusCode.SUCCESS),
inboundNatService.programIpRewriteExclusion(Long.valueOf(123), "2", HOST_ADDRESS_PREFIX, Action.ADD));
- verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class),
+ verify(writeTransaction, times(2)).put(any(LogicalDatastoreType.class),
any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(1)).submit();
verify(commitFuture, times(1)).get();
assertEquals("Error, did not return the expected StatusCode",
inboundNatService.programIpRewriteExclusion(Long.valueOf(123), "2",
HOST_ADDRESS_PREFIX, Action.DELETE));
verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get(); // 1 + 1 above
}
}
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.Spy;
import org.mockito.runners.MockitoJUnitRunner;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
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.TransactionCommitFailedException;
/**
* Unit test fort {@link IngressAclService}
*/
-@Ignore // TODO SB_MIGRATION
@RunWith(MockitoJUnitRunner.class)
+@SuppressWarnings("unchecked")
public class IngressAclServiceTest {
@InjectMocks private IngressAclService ingressAclService = new IngressAclService();
@Spy private IngressAclService ingressAclServiceSpy;
- //@Mock private MdsalConsumer mdsalConsumer;
+ @Mock private DataBroker dataBroker;
@Mock private PipelineOrchestrator orchestrator;
- @Mock private ReadWriteTransaction readWriteTransaction;
@Mock private WriteTransaction writeTransaction;
@Mock private CheckedFuture<Void, TransactionCommitFailedException> commitFuture;
public void setUp() {
ingressAclServiceSpy = Mockito.spy(ingressAclService);
- when(readWriteTransaction.submit()).thenReturn(commitFuture);
when(writeTransaction.submit()).thenReturn(commitFuture);
- DataBroker dataBroker = mock(DataBroker.class);
- when(dataBroker.newReadWriteTransaction()).thenReturn(readWriteTransaction);
when(dataBroker.newWriteOnlyTransaction()).thenReturn(writeTransaction);
- //when(mdsalConsumer.getDataBroker()).thenReturn(dataBroker);
-
when(orchestrator.getNextServiceInPipeline(any(Service.class))).thenReturn(Service.ARP_RESPONDER);
portSecurityRule = mock(NeutronSecurityRule.class);
when(portSecurityRule.getSecurityRuleEthertype()).thenReturn("IPv4");
when(portSecurityRule.getSecurityRuleDirection()).thenReturn("ingress");
- List<NeutronSecurityRule> portSecurityList = new ArrayList();
+ List<NeutronSecurityRule> portSecurityList = new ArrayList<NeutronSecurityRule>();
portSecurityList.add(portSecurityRule);
when(securityGroup.getSecurityRules()).thenReturn(portSecurityList);
ingressAclServiceSpy.programPortSecurityACL(Long.valueOf(1554), SEGMENTATION_ID, MAC_ADDRESS, 124, securityGroup);
verify(ingressAclServiceSpy, times(1)).ingressACLDefaultTcpDrop(anyLong(), anyString(), anyString(), anyInt(), anyBoolean());
verify(ingressAclServiceSpy, times(1)).ingressACLTcpPortWithPrefix(anyLong(), anyString(), anyString(), anyBoolean(), anyInt(), anyString(), anyInt());
- verify(readWriteTransaction, times(4)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(2)).submit();
+ verify(writeTransaction, times(4)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get();
}
ingressAclServiceSpy.programPortSecurityACL(Long.valueOf(1554), SEGMENTATION_ID, MAC_ADDRESS, 124, securityGroup);
verify(ingressAclServiceSpy, times(1)).ingressACLDefaultTcpDrop(anyLong(), anyString(), anyString(), anyInt(), anyBoolean());
verify(ingressAclServiceSpy, times(1)).ingressACLTcpPortWithPrefix(anyLong(), anyString(), anyString(), anyBoolean(), anyInt(), anyString(), anyInt());
- verify(readWriteTransaction, times(4)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(2)).submit();
+ verify(writeTransaction, times(4)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get();
}
ingressAclServiceSpy.programPortSecurityACL(Long.valueOf(1554), SEGMENTATION_ID, MAC_ADDRESS, 124, securityGroup);
verify(ingressAclServiceSpy, times(1)).ingressACLDefaultTcpDrop(anyLong(), anyString(), anyString(), anyInt(), anyBoolean());
verify(ingressAclServiceSpy, times(1)).ingressACLPermitAllProto(anyLong(), anyString(), anyString(), anyBoolean(), anyString(), anyInt());
- verify(readWriteTransaction, times(4)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(2)).submit();
+ verify(writeTransaction, times(4)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get();
}
ingressAclServiceSpy.programPortSecurityACL(Long.valueOf(1554), SEGMENTATION_ID, MAC_ADDRESS, 124, securityGroup);
verify(ingressAclServiceSpy, times(1)).ingressACLDefaultTcpDrop(anyLong(), anyString(), anyString(), anyInt(), anyBoolean());
verify(ingressAclServiceSpy, times(1)).ingressACLPermitAllProto(anyLong(), anyString(), anyString(), anyBoolean(), anyString(), anyInt());
- verify(readWriteTransaction, times(4)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(2)).submit();
+ verify(writeTransaction, times(4)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get();
}
ingressAclServiceSpy.programPortSecurityACL(Long.valueOf(1554), SEGMENTATION_ID, MAC_ADDRESS, 124, securityGroup);
verify(ingressAclServiceSpy, times(1)).ingressACLDefaultTcpDrop(anyLong(), anyString(), anyString(), anyInt(), anyBoolean());
verify(ingressAclServiceSpy, times(1)).ingressACLTcpSyn(anyLong(), anyString(), anyString(), anyBoolean(), anyInt(), anyInt());
- verify(readWriteTransaction, times(4)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(2)).submit();
+ verify(writeTransaction, times(4)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get();
}
ingressAclServiceSpy.programPortSecurityACL(Long.valueOf(1554), SEGMENTATION_ID, MAC_ADDRESS, 124, securityGroup);
verify(ingressAclServiceSpy, times(1)).ingressACLDefaultTcpDrop(anyLong(), anyString(), anyString(), anyInt(), anyBoolean());
verify(ingressAclServiceSpy, times(1)).ingressACLTcpSyn(anyLong(), anyString(), anyString(), anyBoolean(), anyInt(), anyInt());
- verify(readWriteTransaction, times(4)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(2)).submit();
+ verify(writeTransaction, times(4)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get();
}
ingressAclServiceSpy.programPortSecurityACL(Long.valueOf(1554), SEGMENTATION_ID, MAC_ADDRESS, 124, securityGroup);
verify(ingressAclServiceSpy, times(1)).handleIngressAllowProto(anyLong(), anyString(), anyString(), anyBoolean(), anyString(), anyInt());
- verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(1)).submit();
verify(commitFuture, times(1)).get();
}
@Test
public void testIgressACLDefaultTcpDrop() throws Exception {
ingressAclService.ingressACLDefaultTcpDrop(Long.valueOf(123), SEGMENTATION_ID, MAC_ADDRESS, PRIORITY, true);
- verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(1)).submit();
verify(commitFuture, times(1)).get();
ingressAclService.ingressACLDefaultTcpDrop(Long.valueOf(123), SEGMENTATION_ID, MAC_ADDRESS, PRIORITY, false);
verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get(); // 1 + 1 above
}
@Test
public void testIngressACLTcpPortWithPrefix() throws Exception {
ingressAclService.ingressACLTcpPortWithPrefix(Long.valueOf(123), SEGMENTATION_ID, MAC_ADDRESS, true, 1, HOST_ADDRESS, PRIORITY);
- verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(1)).submit();
verify(commitFuture, times(1)).get();
ingressAclService.ingressACLTcpPortWithPrefix(Long.valueOf(123), SEGMENTATION_ID, MAC_ADDRESS, false, 1, HOST_ADDRESS, PRIORITY);
verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get(); // 1 + 1 above
}
@Test
public void testIngressAllowProto() throws Exception {
ingressAclService.handleIngressAllowProto(Long.valueOf(123), SEGMENTATION_ID, MAC_ADDRESS, true, HOST_ADDRESS, PRIORITY);
- verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(1)).submit();
verify(commitFuture, times(1)).get();
ingressAclService.handleIngressAllowProto(Long.valueOf(123), SEGMENTATION_ID, MAC_ADDRESS, false, HOST_ADDRESS, PRIORITY);
verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get(); // 1 + 1 above
}
@Test
public void testIngressACLPermitAllProto() throws Exception {
ingressAclService.ingressACLPermitAllProto(Long.valueOf(123), SEGMENTATION_ID, MAC_ADDRESS, true, HOST_ADDRESS, PRIORITY);
- verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(1)).submit();
verify(commitFuture, times(1)).get();
ingressAclService.ingressACLPermitAllProto(Long.valueOf(123), SEGMENTATION_ID, MAC_ADDRESS, false, HOST_ADDRESS, PRIORITY);
verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get(); // 1 + 1 above
}
@Test
public void testIngressACLTcpSyn() throws Exception {
ingressAclService.ingressACLTcpSyn(Long.valueOf(123), SEGMENTATION_ID, MAC_ADDRESS, true, 1, PRIORITY);
- verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(1)).submit();
verify(commitFuture, times(1)).get();
ingressAclService.ingressACLTcpSyn(Long.valueOf(123), SEGMENTATION_ID, MAC_ADDRESS, false, 1, PRIORITY);
verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get(); // 1 + 1 above
}
}
import static org.mockito.Mockito.when;
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.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
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.TransactionCommitFailedException;
/**
* Unit test fort {@link L2ForwardingService}
*/
-@Ignore // TODO SB_MIGRATION
@RunWith(MockitoJUnitRunner.class)
+@SuppressWarnings("unchecked")
public class L2FowardingServiceTest {
@InjectMocks private L2ForwardingService l2ForwardingService = new L2ForwardingService(Service.ARP_RESPONDER);
- //@Mock private MdsalConsumer mdsalConsumer;
+ @Mock private DataBroker dataBroker;
@Mock private PipelineOrchestrator orchestrator;
- @Mock private ReadWriteTransaction readWriteTransaction;
@Mock private WriteTransaction writeTransaction;
@Mock private ReadOnlyTransaction readOnlyTransaction;
@Mock private CheckedFuture<Void, TransactionCommitFailedException> commitFuture;
@Before
public void setUp() throws Exception {
- when(readWriteTransaction.submit()).thenReturn(commitFuture);
when(writeTransaction.submit()).thenReturn(commitFuture);
- DataBroker dataBroker = mock(DataBroker.class);
- when(dataBroker.newReadWriteTransaction()).thenReturn(readWriteTransaction);
when(dataBroker.newWriteOnlyTransaction()).thenReturn(writeTransaction);
when(dataBroker.newReadOnlyTransaction()).thenReturn(readOnlyTransaction);
@Test
public void testProgramLoacalUcastOut() throws Exception {
l2ForwardingService.programLocalUcastOut(DPID, SEGMENTATION_ID, LOCAL_PORT, MAC_ADDRESS, true);
- verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(1)).submit();
verify(commitFuture, times(1)).get();
l2ForwardingService.programLocalUcastOut(DPID, SEGMENTATION_ID, LOCAL_PORT, MAC_ADDRESS, false);
verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get(); // 1 + 1 above
}
@Test
public void testProgramLocalVlanUcastOut() throws Exception {
l2ForwardingService.programLocalVlanUcastOut(DPID, SEGMENTATION_ID, Long.valueOf(124), MAC_ADDRESS, true);
- verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(1)).submit();
verify(commitFuture, times(1)).get();
l2ForwardingService.programLocalVlanUcastOut(DPID, SEGMENTATION_ID, LOCAL_PORT, MAC_ADDRESS, false);
verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get(); // 1 + 1 above
}
@Test
public void testProgramLocalBcastOut() throws Exception {
l2ForwardingService.programLocalBcastOut(DPID, SEGMENTATION_ID, LOCAL_PORT, true);
- verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(1)).submit();
verify(commitFuture, times(1)).get();
l2ForwardingService.programLocalBcastOut(DPID, SEGMENTATION_ID, LOCAL_PORT, false);
verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get(); // 1 + 1 above
}
@Test
public void testProgramLocalVlanBcastOut() throws Exception {
l2ForwardingService.programLocalVlanBcastOut(DPID, SEGMENTATION_ID, LOCAL_PORT, ETH_PORT, true);
- verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(1)).submit();
verify(commitFuture, times(1)).get();
l2ForwardingService.programLocalVlanBcastOut(DPID, SEGMENTATION_ID, LOCAL_PORT, ETH_PORT, false);
verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get(); // 1 + 1 above
}
@Test
public void testProgramLocalTableMiss() throws Exception {
l2ForwardingService.programLocalTableMiss(DPID, SEGMENTATION_ID, true);
- verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(1)).submit();
verify(commitFuture, times(1)).get();
l2ForwardingService.programLocalTableMiss(DPID, SEGMENTATION_ID, false);
verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get(); // 1 + 1 above
}
@Test
public void testProgramLocalVlanTableMiss() throws Exception {
l2ForwardingService.programLocalVlanTableMiss(DPID, SEGMENTATION_ID, true);
- verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(1)).submit();
verify(commitFuture, times(1)).get();
l2ForwardingService.programLocalVlanTableMiss(DPID, SEGMENTATION_ID, false);
verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get(); // 1 + 1 above
}
@Test
public void testProgramTunnelOut() throws Exception {
l2ForwardingService.programTunnelOut(DPID, SEGMENTATION_ID, OF_PORT_OUT, MAC_ADDRESS, true);
- verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(1)).submit();
verify(commitFuture, times(1)).get();
l2ForwardingService.programTunnelOut(DPID, SEGMENTATION_ID, OF_PORT_OUT, MAC_ADDRESS, false);
verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get(); // 1 + 1 above
}
@Test
public void testProgramVlanOut() throws Exception {
l2ForwardingService.programVlanOut(DPID, SEGMENTATION_ID, ETH_PORT, MAC_ADDRESS, true);
- verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(1)).submit();
verify(commitFuture, times(1)).get();
l2ForwardingService.programVlanOut(DPID, SEGMENTATION_ID, ETH_PORT, MAC_ADDRESS, false);
verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get(); // 1 + 1 above
}
@Test
public void testProgramTunnelFloodOut() throws Exception {
l2ForwardingService.programTunnelFloodOut(DPID, SEGMENTATION_ID, OF_PORT_OUT, true);
- verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(1)).submit();
verify(commitFuture, times(1)).get();
l2ForwardingService.programTunnelFloodOut(DPID, SEGMENTATION_ID, OF_PORT_OUT, false);
verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get(); // 1 + 1 above
}
@Test
public void testProgramVlanFloodOut() throws Exception {
l2ForwardingService.programVlanFloodOut(DPID, SEGMENTATION_ID, ETH_PORT, true);
- verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(1)).submit();
verify(commitFuture, times(1)).get();
l2ForwardingService.programVlanFloodOut(DPID, SEGMENTATION_ID, ETH_PORT, false);
verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get(); // 1 + 1 above
}
@Test
public void testProgramTunnelMiss() throws Exception {
l2ForwardingService.programTunnelMiss(DPID, SEGMENTATION_ID, true);
- verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(1)).submit();
verify(commitFuture, times(1)).get();
l2ForwardingService.programTunnelMiss(DPID, SEGMENTATION_ID, false);
verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get(); // 1 + 1 above
}
@Test
public void testProgramVlanMiss() throws Exception {
l2ForwardingService.programTunnelMiss(DPID, SEGMENTATION_ID, true);
- verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(1)).submit();
verify(commitFuture, times(1)).get();
l2ForwardingService.programTunnelMiss(DPID, SEGMENTATION_ID, false);
verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get(); // 1 + 1 above
}
}
import java.net.InetAddress;
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.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
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.TransactionCommitFailedException;
/**
* Unit test fort {@link L3ForwardingService}
*/
-@Ignore // TODO SB_MIGRATION
@RunWith(MockitoJUnitRunner.class)
+@SuppressWarnings("unchecked")
public class L3FowardingServiceTest {
@InjectMocks private L3ForwardingService l3ForwardingService = new L3ForwardingService();
- //@Mock private MdsalConsumer mdsalConsumer;
+ @Mock private DataBroker dataBroker;
@Mock private PipelineOrchestrator orchestrator;
- @Mock private ReadWriteTransaction readWriteTransaction;
@Mock private WriteTransaction writeTransaction;
@Mock private CheckedFuture<Void, TransactionCommitFailedException> commitFuture;
@Before
public void setUp() throws Exception {
- when(readWriteTransaction.submit()).thenReturn(commitFuture);
when(writeTransaction.submit()).thenReturn(commitFuture);
- DataBroker dataBroker = mock(DataBroker.class);
- when(dataBroker.newReadWriteTransaction()).thenReturn(readWriteTransaction);
when(dataBroker.newWriteOnlyTransaction()).thenReturn(writeTransaction);
- //when(mdsalConsumer.getDataBroker()).thenReturn(dataBroker);
-
when(orchestrator.getNextServiceInPipeline(any(Service.class))).thenReturn(Service.ARP_RESPONDER);
}
new Status(StatusCode.SUCCESS),
l3ForwardingService.programForwardingTableEntry(Long.valueOf(123),
SEGMENTATION_ID, address, MAC_ADDRESS, Action.ADD));
- verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class),
+ verify(writeTransaction, times(2)).put(any(LogicalDatastoreType.class),
any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(1)).submit();
verify(commitFuture, times(1)).get();
assertEquals("Error, did not return the expected StatusCode",
l3ForwardingService.programForwardingTableEntry(Long.valueOf(123),
SEGMENTATION_ID, address, MAC_ADDRESS, Action.DELETE));
verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get(); // 1 + 1 above
}
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.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
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.TransactionCommitFailedException;
import org.opendaylight.ovsdb.openstack.netvirt.NetworkHandler;
import org.opendaylight.ovsdb.openstack.netvirt.api.Action;
-import org.opendaylight.ovsdb.openstack.netvirt.api.Status;
-import org.opendaylight.ovsdb.openstack.netvirt.api.StatusCode;
import org.opendaylight.ovsdb.openstack.netvirt.api.LoadBalancerConfiguration;
import org.opendaylight.ovsdb.openstack.netvirt.api.LoadBalancerConfiguration.LoadBalancerPoolMember;
+import org.opendaylight.ovsdb.openstack.netvirt.api.Status;
+import org.opendaylight.ovsdb.openstack.netvirt.api.StatusCode;
import org.opendaylight.ovsdb.openstack.netvirt.providers.openflow13.PipelineOrchestrator;
import org.opendaylight.ovsdb.openstack.netvirt.providers.openflow13.Service;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
+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.opendaylight.yangtools.yang.binding.InstanceIdentifier;
/**
* Unit test fort {@link LoadBalancerService}
*/
-/* TODO SB_MIGRATION */
-@Ignore
@RunWith(MockitoJUnitRunner.class)
+@SuppressWarnings("unchecked")
public class LoadBalancerServiceTest {
@InjectMocks private LoadBalancerService loadBalancerService = new LoadBalancerService(Service.ARP_RESPONDER);
- //@Mock private MdsalConsumer mdsalConsumer;
+ @Mock private DataBroker dataBroker;
@Mock private PipelineOrchestrator orchestrator;
- @Mock private ReadWriteTransaction readWriteTransaction;
@Mock private WriteTransaction writeTransaction;
@Mock private CheckedFuture<Void, TransactionCommitFailedException> commitFuture;
@Before
public void setUp() throws Exception {
- when(readWriteTransaction.submit()).thenReturn(commitFuture);
when(writeTransaction.submit()).thenReturn(commitFuture);
- DataBroker dataBroker = mock(DataBroker.class);
- when(dataBroker.newReadWriteTransaction()).thenReturn(readWriteTransaction);
when(dataBroker.newWriteOnlyTransaction()).thenReturn(writeTransaction);
- //when(mdsalConsumer.getDataBroker()).thenReturn(dataBroker);
-
when(orchestrator.getNextServiceInPipeline(any(Service.class))).thenReturn(Service.ARP_RESPONDER);
Map<String, LoadBalancerPoolMember> members = new HashMap<String, LoadBalancerPoolMember>();
NodeId nodeId = mock(NodeId.class);
when(nodeId.getValue()).thenReturn("id");
- /* TODO SB_MIGRATION */ // use Topology Node NodeId
- //when(node.getNodeId()).thenReturn(nodeId);
+ when(node.getNodeId()).thenReturn(nodeId);
}
/**
* Test method {@link LoadBalancerService#programLoadBalancerPoolMemberRules(Node, LoadBalancerConfiguration, LoadBalancerPoolMember, Action)}
assertEquals("Error, did not return the expected StatusCode", new Status(StatusCode.BADREQUEST), loadBalancerService.programLoadBalancerPoolMemberRules(node, null, null, Action.ADD));
assertEquals("Error, did not return the expected StatusCode", new Status(StatusCode.NOTIMPLEMENTED), loadBalancerService.programLoadBalancerPoolMemberRules(node, lbConfig, member, Action.DELETE));
- verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(1)).submit();
verify(commitFuture, times(1)).get();
assertEquals("Error, did not return the expected StatusCode", new Status(StatusCode.SUCCESS), loadBalancerService.programLoadBalancerPoolMemberRules(node, lbConfig, member, Action.ADD));
- verify(readWriteTransaction, times(8)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(4)).submit();
+ verify(writeTransaction, times(8)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(4)).submit();
verify(commitFuture, times(4)).get();
}
assertEquals("Error, did not return the expected StatusCode", new Status(StatusCode.NOTIMPLEMENTED), loadBalancerService.programLoadBalancerRules(node, lbConfig, Action.UPDATE));
assertEquals("Error, did not return the expected StatusCode", new Status(StatusCode.SUCCESS), loadBalancerService.programLoadBalancerRules(node, lbConfig, Action.ADD));
- verify(readWriteTransaction, times(6)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(3)).submit();
+ verify(writeTransaction, times(6)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(3)).submit();
verify(commitFuture, times(3)).get();
assertEquals("Error, did not return the expected StatusCode", new Status(StatusCode.SUCCESS), loadBalancerService.programLoadBalancerRules(node, lbConfig, Action.DELETE));
verify(writeTransaction, times(3)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
- verify(writeTransaction, times(3)).submit();
+ verify(writeTransaction, times(6)).submit();
verify(commitFuture, times(6)).get(); // 3 + 3 before
}
}
import java.net.InetAddress;
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.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
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.TransactionCommitFailedException;
/**
* Unit test fort {@link OutboundNatService}
*/
-@Ignore // TODO SB_MIGRATION
@RunWith(MockitoJUnitRunner.class)
+@SuppressWarnings("unchecked")
public class OutboundNatServiceTest {
@InjectMocks private OutboundNatService outboundNatService = new OutboundNatService();
- //@Mock private MdsalConsumer mdsalConsumer;
+ @Mock private DataBroker dataBroker;
@Mock private PipelineOrchestrator orchestrator;
- @Mock private ReadWriteTransaction readWriteTransaction;
@Mock private WriteTransaction writeTransaction;
@Mock private CheckedFuture<Void, TransactionCommitFailedException> commitFuture;
@Before
public void setUp() throws Exception {
- when(readWriteTransaction.submit()).thenReturn(commitFuture);
+ when(writeTransaction.submit()).thenReturn(commitFuture);
when(writeTransaction.submit()).thenReturn(commitFuture);
- DataBroker dataBroker = mock(DataBroker.class);
- when(dataBroker.newReadWriteTransaction()).thenReturn(readWriteTransaction);
when(dataBroker.newWriteOnlyTransaction()).thenReturn(writeTransaction);
- //when(mdsalConsumer.getDataBroker()).thenReturn(dataBroker);
-
when(orchestrator.getNextServiceInPipeline(any(Service.class))).thenReturn(Service.ARP_RESPONDER);
}
when(address.getHostAddress()).thenReturn(HOST_ADDRESS);
assertEquals("Error, did not return the expected StatusCode", new Status(StatusCode.SUCCESS), outboundNatService.programIpRewriteRule(Long.valueOf(123), SEGMENTATION_ID, address, address, Action.ADD));
- verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(1)).submit();
verify(commitFuture, times(1)).get();
assertEquals("Error, did not return the expected StatusCode", new Status(StatusCode.SUCCESS), outboundNatService.programIpRewriteRule(Long.valueOf(123), SEGMENTATION_ID, address, address, Action.DELETE));
verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get(); // 1 + 1 above
}
@Test
public void testProgramIpRewriteExclusion() throws Exception {
assertEquals("Error, did not return the expected StatusCode", new Status(StatusCode.SUCCESS), outboundNatService.programIpRewriteExclusion(Long.valueOf(123), SEGMENTATION_ID, HOST_ADDRESS_PREFIX, Action.ADD));
- verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(1)).submit();
verify(commitFuture, times(1)).get();
assertEquals("Error, did not return the expected StatusCode", new Status(StatusCode.SUCCESS), outboundNatService.programIpRewriteExclusion(Long.valueOf(123), SEGMENTATION_ID, HOST_ADDRESS_PREFIX, Action.DELETE));
verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get(); // 1 + 1 above
}
}
import java.net.InetAddress;
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.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
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.TransactionCommitFailedException;
/**
* Unit test fort {@link RoutingService}
*/
-@Ignore // TODO SB_MIGRATION
@RunWith(MockitoJUnitRunner.class)
+@SuppressWarnings("unchecked")
public class RoutingServiceTest {
@InjectMocks private RoutingService routingService = new RoutingService();
- //@Mock private MdsalConsumer mdsalConsumer;
+ @Mock private DataBroker dataBroker;
@Mock private PipelineOrchestrator orchestrator;
- @Mock private ReadWriteTransaction readWriteTransaction;
@Mock private WriteTransaction writeTransaction;
@Mock private CheckedFuture<Void, TransactionCommitFailedException> commitFuture;
@Before
public void setUp() throws Exception {
- when(readWriteTransaction.submit()).thenReturn(commitFuture);
when(writeTransaction.submit()).thenReturn(commitFuture);
- DataBroker dataBroker = mock(DataBroker.class);
- when(dataBroker.newReadWriteTransaction()).thenReturn(readWriteTransaction);
when(dataBroker.newWriteOnlyTransaction()).thenReturn(writeTransaction);
- //when(mdsalConsumer.getDataBroker()).thenReturn(dataBroker);
-
when(orchestrator.getNextServiceInPipeline(any(Service.class))).thenReturn(Service.ARP_RESPONDER);
}
new Status(StatusCode.SUCCESS),
routingService.programRouterInterface(Long.valueOf(123),
SEGMENTATION_ID, SEGMENTATION_ID, MAC_ADDRESS, address, 1, Action.ADD));
- verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class), anyBoolean());
+ verify(writeTransaction, times(1)).submit();
verify(commitFuture, times(1)).get();
assertEquals("Error, did not return the expected StatusCode",
routingService.programRouterInterface(Long.valueOf(123),
SEGMENTATION_ID, SEGMENTATION_ID, MAC_ADDRESS, address, 1, Action.DELETE));
verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get(); // 1 + 1 above
}
new Status(StatusCode.SUCCESS),
routingService.programDefaultRouteEntry(Long.valueOf(123),
SEGMENTATION_ID, MAC_ADDRESS, address, Action.ADD));
- verify(readWriteTransaction, times(2)).put(any(LogicalDatastoreType.class),
+ verify(writeTransaction, times(2)).put(any(LogicalDatastoreType.class),
any(InstanceIdentifier.class), any(Node.class), anyBoolean());
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(1)).submit();
verify(commitFuture, times(1)).get();
assertEquals("Error, did not return the expected StatusCode",
routingService.programDefaultRouteEntry(Long.valueOf(123),
SEGMENTATION_ID, MAC_ADDRESS, address, Action.DELETE));
verify(writeTransaction, times(1)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
- verify(readWriteTransaction, times(1)).submit();
+ verify(writeTransaction, times(2)).submit();
verify(commitFuture, times(2)).get(); // 1 + 1 above
}
}
Code Review / ovsdb.git / commitdiff