X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=openflowplugin-impl%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fopenflowplugin%2Fimpl%2Fregistry%2Fflow%2FDeviceFlowRegistryImplTest.java;h=250d13615c08833ec81a3b51801357d4ef807639;hb=d1af0fd5a4053a10917f631bae42970c1960fd20;hp=6ee4a3c4ce43d9f82b658fafddaee60ac9f77f29;hpb=1c87fc796ca5ad53676b25bb5ff5a6f963d1c5cd;p=openflowplugin.git diff --git a/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/registry/flow/DeviceFlowRegistryImplTest.java b/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/registry/flow/DeviceFlowRegistryImplTest.java index 6ee4a3c4ce..250d13615c 100644 --- a/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/registry/flow/DeviceFlowRegistryImplTest.java +++ b/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/registry/flow/DeviceFlowRegistryImplTest.java @@ -8,27 +8,43 @@ package org.opendaylight.openflowplugin.impl.registry.flow; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; import static org.mockito.Matchers.any; +import static org.mockito.Mockito.inOrder; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import com.google.common.base.Optional; import com.google.common.util.concurrent.Futures; +import java.math.BigInteger; +import java.util.Collections; +import java.util.Map; +import java.util.regex.Matcher; +import java.util.regex.Pattern; import org.junit.Assert; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; +import org.mockito.InOrder; 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.common.api.data.LogicalDatastoreType; +import org.opendaylight.openflowplugin.api.OFConstants; import org.opendaylight.openflowplugin.api.openflow.registry.flow.FlowDescriptor; import org.opendaylight.openflowplugin.api.openflow.registry.flow.FlowRegistryKey; import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowId; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableBuilder; +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.statistics.rev130819.flow.and.statistics.map.list.FlowAndStatisticsMapList; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.FlowCookie; import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId; import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes; import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node; @@ -42,6 +58,9 @@ import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier; @RunWith(MockitoJUnitRunner.class) public class DeviceFlowRegistryImplTest { private static final String NODE_ID = "openflow:1"; + private static final Pattern INDEX_PATTERN = Pattern.compile("^#UF\\$TABLE\\*1-([0-9]+)$"); + private static final Short DUMMY_TABLE_ID = 1; + private DeviceFlowRegistryImpl deviceFlowRegistry; private FlowRegistryKey key; private FlowDescriptor descriptor; @@ -55,10 +74,9 @@ public class DeviceFlowRegistryImplTest { public void setUp() throws Exception { nodeInstanceIdentifier = InstanceIdentifier.create(Nodes.class).child(Node.class, new NodeKey(new NodeId(NODE_ID))); when(dataBroker.newReadOnlyTransaction()).thenReturn(readOnlyTransaction); - when(readOnlyTransaction.read(any(), any())).thenReturn(Futures.immediateCheckedFuture(Optional.absent())); - deviceFlowRegistry = new DeviceFlowRegistryImpl(dataBroker, nodeInstanceIdentifier); + deviceFlowRegistry = new DeviceFlowRegistryImpl(OFConstants.OFP_VERSION_1_3, dataBroker, nodeInstanceIdentifier); final FlowAndStatisticsMapList flowStats = TestFlowHelper.createFlowAndStatisticsMapListBuilder(1).build(); - key = FlowRegistryKeyFactory.create(flowStats); + key = FlowRegistryKeyFactory.create(OFConstants.OFP_VERSION_1_3, flowStats); descriptor = FlowDescriptorFactory.create(key.getTableId(), new FlowId("ut:1")); Assert.assertEquals(0, deviceFlowRegistry.getAllFlowDescriptors().size()); @@ -70,11 +88,80 @@ public class DeviceFlowRegistryImplTest { public void testFill() throws Exception { final InstanceIdentifier path = nodeInstanceIdentifier.augmentation(FlowCapableNode.class); - deviceFlowRegistry.fill().get(); + final Flow flow = new FlowBuilder() + .setTableId((short)1) + .setPriority(10) + .setCookie(new FlowCookie(BigInteger.TEN)) + .setId(new FlowId("HELLO")) + .build(); + + final Table table = new TableBuilder() + .setFlow(Collections.singletonList(flow)) + .build(); + + final FlowCapableNode flowCapableNode = new FlowCapableNodeBuilder() + .setTable(Collections.singletonList(table)) + .build(); + + final Map allFlowDescriptors = testFill(path, flowCapableNode); + final FlowRegistryKey key = FlowRegistryKeyFactory.create(OFConstants.OFP_VERSION_1_3, flow); + + InOrder order = inOrder(dataBroker, readOnlyTransaction); + order.verify(dataBroker).newReadOnlyTransaction(); + order.verify(readOnlyTransaction).read(LogicalDatastoreType.CONFIGURATION, path); + order.verify(dataBroker).newReadOnlyTransaction(); + order.verify(readOnlyTransaction).read(LogicalDatastoreType.OPERATIONAL, path); + assertTrue(allFlowDescriptors.containsKey(key)); + + deviceFlowRegistry.removeDescriptor(key); + } + + @Test + public void testFailedFill() throws Exception { + final InstanceIdentifier path = nodeInstanceIdentifier.augmentation(FlowCapableNode.class); + + testFill(path, null); + + testFill(path, new FlowCapableNodeBuilder() + .setTable(null) + .build()); + + testFill(path, new FlowCapableNodeBuilder() + .setTable(Collections.singletonList(null)) + .build()); + + testFill(path, new FlowCapableNodeBuilder() + .setTable(Collections.singletonList(new TableBuilder() + .setFlow(null) + .build())) + .build()); + + testFill(path, new FlowCapableNodeBuilder() + .setTable(Collections.singletonList(new TableBuilder() + .setFlow(Collections.singletonList(null)) + .build())) + .build()); + + testFill(path, new FlowCapableNodeBuilder() + .setTable(Collections.singletonList(new TableBuilder() + .setFlow(Collections.singletonList(new FlowBuilder() + .setId(null) + .build())) + .build())) + .build()); + + verify(dataBroker, times(12)).newReadOnlyTransaction(); + verify(readOnlyTransaction, times(6)).read(LogicalDatastoreType.CONFIGURATION, path); + verify(readOnlyTransaction, times(6)).read(LogicalDatastoreType.OPERATIONAL, path); - verify(dataBroker, times(2)).newReadOnlyTransaction(); - verify(readOnlyTransaction).read(LogicalDatastoreType.CONFIGURATION, path); - verify(readOnlyTransaction).read(LogicalDatastoreType.OPERATIONAL, path); + Assert.assertEquals(1, deviceFlowRegistry.getAllFlowDescriptors().size()); + } + + private Map testFill(final InstanceIdentifier path, + final FlowCapableNode flowCapableNode) throws Exception { + when(readOnlyTransaction.read(any(), any())).thenReturn(Futures.immediateCheckedFuture(Optional.fromNullable(flowCapableNode))); + deviceFlowRegistry.fill().get(); + return deviceFlowRegistry.getAllFlowDescriptors(); } @Test @@ -92,7 +179,7 @@ public class DeviceFlowRegistryImplTest { // store new key with old value final FlowAndStatisticsMapList flowStats = TestFlowHelper.createFlowAndStatisticsMapListBuilder(2).build(); - final FlowRegistryKey key2 = FlowRegistryKeyFactory.create(flowStats); + final FlowRegistryKey key2 = FlowRegistryKeyFactory.create(OFConstants.OFP_VERSION_1_3, flowStats); deviceFlowRegistry.store(key2, descriptor); Assert.assertEquals(2, deviceFlowRegistry.getAllFlowDescriptors().size()); Assert.assertEquals("ut:1", deviceFlowRegistry.retrieveIdForFlow(key2).getFlowId().getValue()); @@ -111,7 +198,7 @@ public class DeviceFlowRegistryImplTest { //store new key final String alienPrefix = "#UF$TABLE*2-"; - final FlowRegistryKey key2 = FlowRegistryKeyFactory.create(TestFlowHelper.createFlowAndStatisticsMapListBuilder(2).build()); + final FlowRegistryKey key2 = FlowRegistryKeyFactory.create(OFConstants.OFP_VERSION_1_3, TestFlowHelper.createFlowAndStatisticsMapListBuilder(2).build()); newFlowId = deviceFlowRegistry.storeIfNecessary(key2); Assert.assertTrue(newFlowId.getValue().startsWith(alienPrefix)); @@ -120,30 +207,36 @@ public class DeviceFlowRegistryImplTest { } @Test - public void testRemoveMarked() throws Exception { - deviceFlowRegistry.markToBeremoved(key); - deviceFlowRegistry.removeMarked(); + public void testRemoveDescriptor() throws Exception { + deviceFlowRegistry.removeDescriptor(key); Assert.assertEquals(0, deviceFlowRegistry.getAllFlowDescriptors().size()); } - @Test - public void testRemoveMarkedNegative() throws Exception { - final FlowAndStatisticsMapList flowStats = TestFlowHelper.createFlowAndStatisticsMapListBuilder(2).build(); - FlowRegistryKey key2 = FlowRegistryKeyFactory.create(flowStats); - deviceFlowRegistry.markToBeremoved(key2); - deviceFlowRegistry.removeMarked(); - Assert.assertEquals(1, deviceFlowRegistry.getAllFlowDescriptors().size()); - } - @Test public void testClose() throws Exception { - deviceFlowRegistry.markToBeremoved(key); deviceFlowRegistry.close(); Assert.assertEquals(0, deviceFlowRegistry.getAllFlowDescriptors().size()); + } - deviceFlowRegistry.store(key, descriptor); - Assert.assertEquals(1, deviceFlowRegistry.getAllFlowDescriptors().size()); - deviceFlowRegistry.removeMarked(); - Assert.assertEquals(1, deviceFlowRegistry.getAllFlowDescriptors().size()); + @Test + public void createAlienFlowIdTest() throws Exception { + final String alienFlowId1 = DeviceFlowRegistryImpl.createAlienFlowId(DUMMY_TABLE_ID).getValue(); + final Integer index1 = parseIndex(alienFlowId1); + final String alienFlowId2 = DeviceFlowRegistryImpl.createAlienFlowId(DUMMY_TABLE_ID).getValue(); + final Integer index2 = parseIndex(alienFlowId2); + + assertNotNull("index1 parsing failed: " + alienFlowId1, index1); + assertNotNull("index2 parsing failed: " + alienFlowId2, index2); + assertTrue(index1 < index2); + } + + private static Integer parseIndex(String alienFlowIdValue) { + final Matcher mach = INDEX_PATTERN.matcher(alienFlowIdValue); + + if (mach.find()) { + return Integer.valueOf(mach.group(1)); + } + + return null; } -} \ No newline at end of file +}