From f1adb9b21f9c8eacc534bc99fe704661625f0c2e Mon Sep 17 00:00:00 2001 From: Kinsey Nietzsche Date: Mon, 27 Jul 2015 11:30:17 +0200 Subject: [PATCH] Bug 3695 - UT GBP - 6 - neutron/ovsdb NeutronHelper (93.2%) EndpointHelper (97.0%) InventoryHelper (90.0%) Change-Id: Ibc373d7c250db3855a92181627220ce328b7f320 Signed-off-by: Kinsey Nietzsche --- neutron-ovsdb/pom.xml | 5 + .../ovsdb/util/EndpointHelperTest.java | 91 ++++ .../ovsdb/util/InventoryHelperTest.java | 402 ++++++++++++++++++ .../neutron/ovsdb/util/NeutronHelperTest.java | 68 +++ 4 files changed, 566 insertions(+) create mode 100644 neutron-ovsdb/src/test/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/util/EndpointHelperTest.java create mode 100644 neutron-ovsdb/src/test/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/util/InventoryHelperTest.java create mode 100644 neutron-ovsdb/src/test/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/util/NeutronHelperTest.java diff --git a/neutron-ovsdb/pom.xml b/neutron-ovsdb/pom.xml index 2d519ede0..37f2fb8d4 100644 --- a/neutron-ovsdb/pom.xml +++ b/neutron-ovsdb/pom.xml @@ -60,6 +60,11 @@ junit test + + org.mockito + mockito-all + test + org.codehaus.sonar-plugins.java diff --git a/neutron-ovsdb/src/test/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/util/EndpointHelperTest.java b/neutron-ovsdb/src/test/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/util/EndpointHelperTest.java new file mode 100644 index 000000000..e8e6b7a89 --- /dev/null +++ b/neutron-ovsdb/src/test/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/util/EndpointHelperTest.java @@ -0,0 +1,91 @@ +/* + * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.groupbasedpolicy.neutron.ovsdb.util; + +import static org.mockito.Matchers.any; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction; +import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException; +import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.Endpoint; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayContext; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +import com.google.common.base.Optional; +import com.google.common.util.concurrent.CheckedFuture; + +public class EndpointHelperTest { + + EndpointKey epKey; + Endpoint endpoint; + ReadOnlyTransaction readTransaction; + ReadWriteTransaction writeTransaction; + Optional readOptional; + CheckedFuture submitFuture; + + @SuppressWarnings("unchecked") + @Before + public void initialise() throws Exception { + epKey = mock(EndpointKey.class); + endpoint = mock(Endpoint.class); + readTransaction = mock(ReadOnlyTransaction.class); + writeTransaction = mock(ReadWriteTransaction.class); + + CheckedFuture, ReadFailedException> readFuture = mock(CheckedFuture.class); + when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn( + readFuture); + readOptional = mock(Optional.class); + when(readFuture.checkedGet()).thenReturn(readOptional); + + OfOverlayContext ofc = mock(OfOverlayContext.class); + when(endpoint.getAugmentation(OfOverlayContext.class)).thenReturn(ofc); + + submitFuture = mock(CheckedFuture.class); + when(writeTransaction.submit()).thenReturn(submitFuture); + } + + @Test + public void lookupEndpointTest() { + when(readOptional.isPresent()).thenReturn(true); + when(readOptional.get()).thenReturn(endpoint); + Endpoint result = EndpointHelper.lookupEndpoint(epKey, readTransaction); + Assert.assertEquals(result, endpoint); + } + + @Test + public void lookupEndpointTestNull() { + when(readOptional.isPresent()).thenReturn(false); + Endpoint result = EndpointHelper.lookupEndpoint(epKey, readTransaction); + Assert.assertNull(result); + } + + @Test + public void updateEndpointWithLocationTest() throws Exception { + String nodeIdString = "nodeIdString"; + String nodeConnectorIdString = "nodeConnectorIdString"; + EndpointHelper.updateEndpointWithLocation(endpoint, nodeIdString, nodeConnectorIdString, writeTransaction); + verify(submitFuture).checkedGet(); + } + + @Test + public void updateEndpointRemoveLocationTest() throws Exception { + EndpointHelper.updateEndpointRemoveLocation(endpoint, writeTransaction); + verify(submitFuture).checkedGet(); + } + +} diff --git a/neutron-ovsdb/src/test/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/util/InventoryHelperTest.java b/neutron-ovsdb/src/test/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/util/InventoryHelperTest.java new file mode 100644 index 000000000..638d27581 --- /dev/null +++ b/neutron-ovsdb/src/test/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/util/InventoryHelperTest.java @@ -0,0 +1,402 @@ +/* + * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.groupbasedpolicy.neutron.ovsdb.util; + +import static org.mockito.Matchers.any; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import java.util.Arrays; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +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.common.api.data.LogicalDatastoreType; +import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException; +import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException; +import org.opendaylight.groupbasedpolicy.neutron.ovsdb.AbstractTunnelType; +import org.opendaylight.ovsdb.southbound.SouthboundConstants; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayNodeConfig; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.nodes.node.Tunnel; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.nodes.node.TunnelKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId; +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.overlay.rev150105.TunnelTypeBase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.overlay.rev150105.TunnelTypeVxlan; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.DatapathId; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation; +import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology; +import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology; +import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey; +import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node; +import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +import com.google.common.base.Optional; +import com.google.common.util.concurrent.CheckedFuture; + +public class InventoryHelperTest { + + private DataBroker dataBroker; + private ReadOnlyTransaction readTransaction; + private ReadWriteTransaction writeTransaction; + + CheckedFuture, ReadFailedException> terminationPointFuture; + CheckedFuture, ReadFailedException> bridgeFuture; + CheckedFuture, ReadFailedException> nodeConfigFuture; + + Optional terminationPointOptional; + Optional bridgeOptional; + Optional nodeConfigOptional; + + private InstanceIdentifier ovsdbTpIid; + private String dpid = "FF:FF:FF:FF:FF:FF:FF:FF"; + private String nodeIdString = "nodeIdString"; + + @SuppressWarnings("unchecked") + @Before + public void initialise() throws Exception { + dataBroker = mock(DataBroker.class); + + terminationPointFuture = mock(CheckedFuture.class); + terminationPointOptional = mock(Optional.class); + when(terminationPointFuture.checkedGet()).thenReturn(terminationPointOptional); + bridgeFuture = mock(CheckedFuture.class); + bridgeOptional = mock(Optional.class); + when(bridgeFuture.checkedGet()).thenReturn(bridgeOptional); + nodeConfigFuture = mock(CheckedFuture.class); + nodeConfigOptional = mock(Optional.class); + when(nodeConfigFuture.checkedGet()).thenReturn(nodeConfigOptional); + + readTransaction = mock(ReadOnlyTransaction.class); + writeTransaction = mock(ReadWriteTransaction.class); + when(dataBroker.newReadOnlyTransaction()).thenReturn(readTransaction); + when(dataBroker.newReadWriteTransaction()).thenReturn(writeTransaction); + ovsdbTpIid = InstanceIdentifier.create(NetworkTopology.class) + .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID)) + .child(Node.class) + .child(TerminationPoint.class) + .augmentation(OvsdbTerminationPointAugmentation.class); + } + + @Test + public void getLongFromDpidTest() { + Long result = InventoryHelper.getLongFromDpid(dpid); + Assert.assertEquals(Long.valueOf(281474976710655L), result); + } + + @Test + public void getInventoryNodeIdStringTest() throws Exception { + OvsdbBridgeAugmentation ovsdbBridge = mock(OvsdbBridgeAugmentation.class); + + DatapathId datapathId = mock(DatapathId.class); + when(ovsdbBridge.getDatapathId()).thenReturn(datapathId); + when(datapathId.getValue()).thenReturn("FF:FF:FF:FF:FF:FF:FF:FF"); + + String result = InventoryHelper.getInventoryNodeIdString(ovsdbBridge, ovsdbTpIid, dataBroker); + Assert.assertEquals("openflow:281474976710655", result); + } + + @SuppressWarnings("unchecked") + @Test + public void getInventoryNodeIdStringTestDpidNull() throws Exception { + OvsdbBridgeAugmentation ovsdbBridge = mock(OvsdbBridgeAugmentation.class); + + when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn( + bridgeFuture); + when(bridgeOptional.isPresent()).thenReturn(true); + OvsdbBridgeAugmentation bridge = mock(OvsdbBridgeAugmentation.class); + when(bridgeOptional.get()).thenReturn(bridge); + when(bridge.getDatapathId()).thenReturn(null); + + String result = InventoryHelper.getInventoryNodeIdString(ovsdbBridge, ovsdbTpIid, dataBroker); + Assert.assertNull(result); + } + + @Test + public void getInventoryNodeConnectorIdStringTest() { + String inventoryNodeId = "openflow:inventoryNodeId"; + OvsdbTerminationPointAugmentation ovsdbTp = mock(OvsdbTerminationPointAugmentation.class); + when(ovsdbTp.getOfport()).thenReturn(65534L); + + String result = InventoryHelper.getInventoryNodeConnectorIdString(inventoryNodeId, ovsdbTp, ovsdbTpIid, + dataBroker); + Assert.assertEquals("openflow:inventoryNodeId:65534", result); + } + + @Test + public void getInventoryNodeConnectorIdStringTestIncorrectFormat() { + String inventoryNodeId = "inventoryNodeId"; + OvsdbTerminationPointAugmentation ovsdbTp = mock(OvsdbTerminationPointAugmentation.class); + when(ovsdbTp.getOfport()).thenReturn(65534L); + + String result = InventoryHelper.getInventoryNodeConnectorIdString(inventoryNodeId, ovsdbTp, ovsdbTpIid, + dataBroker); + Assert.assertNull(result); + } + + @Test + public void getInventoryNodeConnectorIdStringTestOfportNull() throws Exception { + String inventoryNodeId = "openflow:inventoryNodeId"; + OvsdbTerminationPointAugmentation ovsdbTp = mock(OvsdbTerminationPointAugmentation.class); + when(ovsdbTp.getOfport()).thenReturn(65535L); + + String result = InventoryHelper.getInventoryNodeConnectorIdString(inventoryNodeId, ovsdbTp, ovsdbTpIid, + dataBroker); + Assert.assertNull(result); + } + + @SuppressWarnings("unchecked") + @Test + public void getInventoryNodeConnectorIdStringTestOfportOver() throws Exception { + String inventoryNodeId = "openflow:inventoryNodeId"; + OvsdbTerminationPointAugmentation ovsdbTp = mock(OvsdbTerminationPointAugmentation.class); + when(ovsdbTp.getOfport()).thenReturn(null); + + when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn( + terminationPointFuture); + when(terminationPointOptional.isPresent()).thenReturn(true); + OvsdbTerminationPointAugmentation readOvsdbTp = mock(OvsdbTerminationPointAugmentation.class); + when(terminationPointOptional.get()).thenReturn(readOvsdbTp); + + when(readOvsdbTp.getOfport()).thenReturn(65534L); + + String result = InventoryHelper.getInventoryNodeConnectorIdString(inventoryNodeId, ovsdbTp, ovsdbTpIid, + dataBroker); + Assert.assertEquals("openflow:inventoryNodeId:65534", result); + } + + @SuppressWarnings("unchecked") + @Test + public void getInventoryNodeConnectorIdStringTestOfportNullAugmentationOfportNull() throws Exception { + String inventoryNodeId = "openflow:inventoryNodeId"; + OvsdbTerminationPointAugmentation ovsdbTp = mock(OvsdbTerminationPointAugmentation.class); + when(ovsdbTp.getOfport()).thenReturn(null); + + when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn( + terminationPointFuture); + when(terminationPointOptional.isPresent()).thenReturn(true); + OvsdbTerminationPointAugmentation readOvsdbTp = mock(OvsdbTerminationPointAugmentation.class); + when(terminationPointOptional.get()).thenReturn(readOvsdbTp); + when(readOvsdbTp.getOfport()).thenReturn(null); + + String result = InventoryHelper.getInventoryNodeConnectorIdString(inventoryNodeId, ovsdbTp, ovsdbTpIid, + dataBroker); + Assert.assertNull(result); + } + + @SuppressWarnings("unchecked") + @Test + public void getInventoryNodeConnectorIdStringTestOfportNullAugmentationOfportOver() throws Exception { + String inventoryNodeId = "openflow:inventoryNodeId"; + OvsdbTerminationPointAugmentation ovsdbTp = mock(OvsdbTerminationPointAugmentation.class); + when(ovsdbTp.getOfport()).thenReturn(null); + + when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn( + terminationPointFuture); + OvsdbTerminationPointAugmentation readOvsdbTp = mock(OvsdbTerminationPointAugmentation.class); + when(terminationPointOptional.get()).thenReturn(readOvsdbTp); + when(readOvsdbTp.getOfport()).thenReturn(65535L); + + String result = InventoryHelper.getInventoryNodeConnectorIdString(inventoryNodeId, ovsdbTp, ovsdbTpIid, + dataBroker); + Assert.assertNull(result); + } + + @SuppressWarnings({"unchecked", "rawtypes"}) + @Test + public void checkOfOverlayConfigTest() throws Exception { + AbstractTunnelType abstractTunnelType = mock(AbstractTunnelType.class); + + when(writeTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn( + nodeConfigFuture); + when(nodeConfigOptional.isPresent()).thenReturn(true); + OfOverlayNodeConfig overlayConfig = mock(OfOverlayNodeConfig.class); + when(nodeConfigOptional.get()).thenReturn(overlayConfig); + + Tunnel tunnel = mock(Tunnel.class); + when(overlayConfig.getTunnel()).thenReturn(Arrays.asList(tunnel)); + + when(abstractTunnelType.getTunnelType()).thenReturn((Class) TunnelTypeVxlan.class); + when(tunnel.getTunnelType()).thenReturn((Class) TunnelTypeVxlan.class); + + boolean result = InventoryHelper.checkOfOverlayConfig(nodeIdString, Arrays.asList(abstractTunnelType), + dataBroker); + Assert.assertTrue(result); + } + + @SuppressWarnings({"unchecked", "rawtypes"}) + @Test + public void checkOfOverlayConfigTestTunnelTypeEqualsFalse() throws Exception { + AbstractTunnelType abstractTunnelType = mock(AbstractTunnelType.class); + + when(writeTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn( + nodeConfigFuture); + when(nodeConfigOptional.isPresent()).thenReturn(true); + OfOverlayNodeConfig overlayConfig = mock(OfOverlayNodeConfig.class); + when(nodeConfigOptional.get()).thenReturn(overlayConfig); + + Tunnel tunnel = mock(Tunnel.class); + when(overlayConfig.getTunnel()).thenReturn(Arrays.asList(tunnel)); + + when(abstractTunnelType.getTunnelType()).thenReturn((Class) TunnelTypeVxlan.class); + when(tunnel.getTunnelType()).thenReturn((Class) TunnelTypeBase.class); + + boolean result = InventoryHelper.checkOfOverlayConfig(nodeIdString, Arrays.asList(abstractTunnelType), + dataBroker); + Assert.assertFalse(result); + } + + @SuppressWarnings({"unchecked", "unused"}) + @Test + public void checkOfOverlayConfigTestConfigNull() throws Exception { + AbstractTunnelType abstractTunnelType = mock(AbstractTunnelType.class); + + when(writeTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn( + nodeConfigFuture); + when(nodeConfigOptional.isPresent()).thenReturn(true); + OfOverlayNodeConfig overlayConfig = mock(OfOverlayNodeConfig.class); + when(nodeConfigOptional.get()).thenReturn(null); + + boolean result = InventoryHelper.checkOfOverlayConfig(nodeIdString, Arrays.asList(abstractTunnelType), + dataBroker); + Assert.assertFalse(result); + } + + @SuppressWarnings("unchecked") + @Test + public void checkOfOverlayConfigTestTunnelNull() throws Exception { + AbstractTunnelType abstractTunnelType = mock(AbstractTunnelType.class); + + when(writeTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn( + nodeConfigFuture); + when(nodeConfigOptional.isPresent()).thenReturn(true); + OfOverlayNodeConfig overlayConfig = mock(OfOverlayNodeConfig.class); + when(nodeConfigOptional.get()).thenReturn(overlayConfig); + + when(overlayConfig.getTunnel()).thenReturn(null); + + boolean result = InventoryHelper.checkOfOverlayConfig(nodeIdString, Arrays.asList(abstractTunnelType), + dataBroker); + Assert.assertFalse(result); + } + + @SuppressWarnings("unchecked") + @Test + public void addOfOverlayExternalPortTest() throws Exception { + NodeId nodeId = mock(NodeId.class); + NodeConnectorId ncId = mock(NodeConnectorId.class); + ReadWriteTransaction transaction = mock(ReadWriteTransaction.class); + when(dataBroker.newReadWriteTransaction()).thenReturn(transaction); + CheckedFuture submitFuture = mock(CheckedFuture.class); + when(transaction.submit()).thenReturn(submitFuture); + + InventoryHelper.addOfOverlayExternalPort(nodeId, ncId, dataBroker); + verify(submitFuture).checkedGet(); + } + + @SuppressWarnings("unchecked") + @Test + public void getOfOverlayConfigTest() throws Exception { + when(writeTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn( + nodeConfigFuture); + when(nodeConfigOptional.isPresent()).thenReturn(true); + OfOverlayNodeConfig overlayConfig = mock(OfOverlayNodeConfig.class); + when(nodeConfigOptional.get()).thenReturn(overlayConfig); + + Assert.assertEquals(overlayConfig, InventoryHelper.getOfOverlayConfig(nodeIdString, dataBroker)); + } + + @SuppressWarnings({"unchecked", "rawtypes"}) + @Test + public void updateOfOverlayConfigTest() throws Exception { + IpAddress ip = mock(IpAddress.class); + String nodeConnectorIdString = "nodeConnectorIdString"; + AbstractTunnelType tunnelType = mock(AbstractTunnelType.class); + + when(writeTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn( + nodeConfigFuture); + when(nodeConfigOptional.isPresent()).thenReturn(true); + OfOverlayNodeConfig overlayConfig = mock(OfOverlayNodeConfig.class); + when(nodeConfigOptional.get()).thenReturn(overlayConfig); + + Tunnel tunnel = mock(Tunnel.class); + when(overlayConfig.getTunnel()).thenReturn(Arrays.asList(tunnel)); + when(tunnelType.getTunnelType()).thenReturn((Class) TunnelTypeVxlan.class); + when(tunnel.getTunnelType()).thenReturn((Class) TunnelTypeVxlan.class); + when(tunnel.getKey()).thenReturn(mock(TunnelKey.class)); + + CheckedFuture submitFuture = mock(CheckedFuture.class); + when(writeTransaction.submit()).thenReturn(submitFuture); + + InventoryHelper.updateOfOverlayConfig(ip, nodeIdString, nodeConnectorIdString, tunnelType, dataBroker); + verify(writeTransaction).submit(); + } + + @Test + public void updateOfOverlayConfigTestNullParameters() throws Exception { + IpAddress ip = mock(IpAddress.class); + String nodeConnectorIdString = "nodeConnectorIdString"; + AbstractTunnelType tunnelType = mock(AbstractTunnelType.class); + + InventoryHelper.updateOfOverlayConfig(null, nodeIdString, nodeConnectorIdString, tunnelType, dataBroker); + InventoryHelper.updateOfOverlayConfig(ip, null, nodeConnectorIdString, tunnelType, dataBroker); + InventoryHelper.updateOfOverlayConfig(ip, nodeIdString, null, tunnelType, dataBroker); + verify(writeTransaction, never()).submit(); + } + + @SuppressWarnings("unchecked") + @Test + public void updateOfOverlayConfigTestOfConfigNull() throws Exception { + IpAddress ip = mock(IpAddress.class); + String nodeConnectorIdString = "nodeConnectorIdString"; + AbstractTunnelType tunnelType = mock(AbstractTunnelType.class); + + when(writeTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn( + nodeConfigFuture); + when(nodeConfigOptional.isPresent()).thenReturn(false); + + CheckedFuture submitFuture = mock(CheckedFuture.class); + when(writeTransaction.submit()).thenReturn(submitFuture); + + InventoryHelper.updateOfOverlayConfig(ip, nodeIdString, nodeConnectorIdString, tunnelType, dataBroker); + verify(writeTransaction).submit(); + } + + @SuppressWarnings({"unchecked", "rawtypes"}) + @Test + public void removeTunnelsOfOverlayConfigTestTunnelTypeEqualsFalse() throws Exception { + AbstractTunnelType tunnelType = mock(AbstractTunnelType.class); + + ReadWriteTransaction transaction = mock(ReadWriteTransaction.class); + when(dataBroker.newReadWriteTransaction()).thenReturn(transaction); + CheckedFuture, ReadFailedException> checkedFuture = mock(CheckedFuture.class); + when(transaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(checkedFuture); + Optional optionalOverlayConfig = mock(Optional.class); + when(checkedFuture.checkedGet()).thenReturn(optionalOverlayConfig); + when(optionalOverlayConfig.isPresent()).thenReturn(true); + OfOverlayNodeConfig overlayConfig = mock(OfOverlayNodeConfig.class); + when(optionalOverlayConfig.get()).thenReturn(overlayConfig); + + Tunnel overlayTunnel = mock(Tunnel.class); + when(overlayConfig.getTunnel()).thenReturn(Arrays.asList(overlayTunnel)); + when(tunnelType.getTunnelType()).thenReturn((Class) TunnelTypeVxlan.class); + when(overlayTunnel.getTunnelType()).thenReturn(null); + + InventoryHelper.removeTunnelsOfOverlayConfig(nodeIdString, Arrays.asList(tunnelType), dataBroker); + verify(writeTransaction,never()).submit(); + } +} diff --git a/neutron-ovsdb/src/test/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/util/NeutronHelperTest.java b/neutron-ovsdb/src/test/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/util/NeutronHelperTest.java new file mode 100644 index 000000000..73cbb5ffc --- /dev/null +++ b/neutron-ovsdb/src/test/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/util/NeutronHelperTest.java @@ -0,0 +1,68 @@ +/* + * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.groupbasedpolicy.neutron.ovsdb.util; + +import static org.mockito.Matchers.any; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.MacAddress; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L2BridgeDomainId; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.Uuid; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.endpoints.by.ports.EndpointByPort; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +import com.google.common.base.Optional; +import com.google.common.util.concurrent.CheckedFuture; + +public class NeutronHelperTest { + + private Uuid externalId; + private DataBroker dataBroker; + private Optional optionalEp; + + @SuppressWarnings("unchecked") + @Before + public void initialise() throws Exception { + externalId = mock(Uuid.class); + dataBroker = mock(DataBroker.class); + + ReadWriteTransaction transaction = mock(ReadWriteTransaction.class); + when(dataBroker.newReadWriteTransaction()).thenReturn(transaction); + CheckedFuture, ReadFailedException> resultFuture = mock(CheckedFuture.class); + when(transaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(resultFuture); + optionalEp = mock(Optional.class); + when(resultFuture.checkedGet()).thenReturn(optionalEp); + } + + @Test + public void getEpKeyFromNeutronMapperTest() throws Exception { + when(optionalEp.isPresent()).thenReturn(true); + EndpointByPort epByPort = mock(EndpointByPort.class); + when(optionalEp.get()).thenReturn(epByPort); + when(epByPort.getL2Context()).thenReturn(mock(L2BridgeDomainId.class)); + when(epByPort.getMacAddress()).thenReturn(mock(MacAddress.class)); + + Assert.assertNotNull(NeutronHelper.getEpKeyFromNeutronMapper(externalId, dataBroker)); + } + + @Test + public void getEpKeyFromNeutronMapperTestPresentFalse() throws Exception { + when(optionalEp.isPresent()).thenReturn(false); + + Assert.assertNull(NeutronHelper.getEpKeyFromNeutronMapper(externalId, dataBroker)); + } +} -- 2.36.6