From 50c5719cefc6e73fdbcbc0a27e9f4e20ed6a14ac Mon Sep 17 00:00:00 2001 From: Konstantin Blagov Date: Thu, 30 Jun 2016 13:44:32 +0200 Subject: [PATCH] Tests for neutron-ovsdb Change-Id: I48e875f5247dc94570b14a00cb1726ec32e030c0 Signed-off-by: Konstantin Blagov --- neutron-ovsdb/pom.xml | 15 +- .../neutron/ovsdb/OvsdbNodeListener.java | 47 ++-- .../ProviderPhysicalNetworkListener.java | 31 ++- .../TerminationPointDataChangeListener.java | 2 +- .../neutron/ovsdb/OvsdbNodeListenerTest.java | 220 ++++++++++++++++++ ...erminationPointDataChangeListenerTest.java | 25 +- .../neutron/ovsdb/util/DataStoreTest.java | 15 +- .../ovsdb/util/EndpointHelperTest.java | 46 ++-- .../ovsdb/util/InventoryHelperTest.java | 193 +++++++-------- .../neutron/ovsdb/util/NeutronHelperTest.java | 18 +- .../util/NeutronOvsdbIidFactoryTest.java | 100 +++++--- .../neutron/ovsdb/util/OvsdbHelperTest.java | 178 +++++++------- 12 files changed, 578 insertions(+), 312 deletions(-) create mode 100644 neutron-ovsdb/src/test/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/OvsdbNodeListenerTest.java diff --git a/neutron-ovsdb/pom.xml b/neutron-ovsdb/pom.xml index 11a3d310f..a8e2fddb6 100644 --- a/neutron-ovsdb/pom.xml +++ b/neutron-ovsdb/pom.xml @@ -63,6 +63,19 @@ mockito-all test + + org.opendaylight.controller + sal-binding-broker-impl + test-jar + test + + + org.opendaylight.groupbasedpolicy + groupbasedpolicy + ${project.version} + test-jar + test + @@ -79,4 +92,4 @@ - \ No newline at end of file + diff --git a/neutron-ovsdb/src/main/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/OvsdbNodeListener.java b/neutron-ovsdb/src/main/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/OvsdbNodeListener.java index c191a1397..f1c182553 100644 --- a/neutron-ovsdb/src/main/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/OvsdbNodeListener.java +++ b/neutron-ovsdb/src/main/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/OvsdbNodeListener.java @@ -7,52 +7,44 @@ */ package org.opendaylight.groupbasedpolicy.neutron.ovsdb; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.Collections; +import javax.annotation.Nonnull; import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; +import java.util.Objects; import java.util.Set; -import javax.annotation.Nonnull; - +import com.google.common.base.Function; +import com.google.common.base.Strings; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.Lists; +import com.google.common.util.concurrent.FutureCallback; +import com.google.common.util.concurrent.Futures; import org.opendaylight.controller.config.yang.config.neutron_ovsdb.impl.IntegrationBridgeSetting; -import org.opendaylight.controller.config.yang.config.neutron_ovsdb.impl.NeutronOvsdbModule; import org.opendaylight.controller.md.sal.binding.api.DataBroker; import org.opendaylight.controller.md.sal.binding.api.DataObjectModification; import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier; 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.groupbasedpolicy.neutron.ovsdb.util.InventoryHelper; import org.opendaylight.groupbasedpolicy.neutron.ovsdb.util.NeutronOvsdbIidFactory; -import org.opendaylight.groupbasedpolicy.neutron.ovsdb.util.OvsdbHelper; -import org.opendaylight.groupbasedpolicy.util.DataStoreHelper; import org.opendaylight.groupbasedpolicy.util.DataTreeChangeHandler; import org.opendaylight.ovsdb.southbound.SouthboundConstants; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Uri; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubnetId; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.Subnet; 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.ovsdb.rev150105.DatapathTypeBase; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.DatapathTypeSystem; 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.OvsdbBridgeAugmentationBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeName; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeProtocolOpenflow13; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeRef; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbFailModeSecure; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeRef; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntry; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntryBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntryKey; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntry; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntryBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntry; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagerEntry; @@ -67,28 +59,16 @@ import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology. 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.DataObject; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; -import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import com.google.common.base.Function; -import com.google.common.base.Predicate; -import com.google.common.base.Predicates; -import com.google.common.base.Strings; -import com.google.common.collect.Collections2; -import com.google.common.collect.ImmutableList; -import com.google.common.collect.Lists; -import com.google.common.util.concurrent.CheckedFuture; -import com.google.common.util.concurrent.FutureCallback; -import com.google.common.util.concurrent.Futures; - public class OvsdbNodeListener extends DataTreeChangeHandler { + static final String BRIDGE_SEPARATOR = "/bridge/"; + static final String NEUTRON_PROVIDER_MAPPINGS_KEY = "provider_mappings"; private static final Logger LOG = LoggerFactory.getLogger(OvsdbNodeListener.class); - public static final String NEUTRON_PROVIDER_MAPPINGS_KEY = "provider_mappings"; private static final String OF_SEPARATOR = ":"; private static final String OF_INVENTORY_PREFIX = "openflow"; - private static final String BRIDGE_SEPARATOR = "/bridge/"; private static IntegrationBridgeSetting intBrSettings; private final Map providerPortNameByBridgeRef = new HashMap<>(); @@ -125,7 +105,7 @@ public class OvsdbNodeListener extends DataTreeChangeHandler { } } } - if (intBrSettings != null && integrationBridgePresent == false) { + if (intBrSettings != null && !integrationBridgePresent) { final Node bridge = createBridge(rootIdentifier, managerToControllerEntries(ovsdbNode.getManagerEntry()), intBrSettings.getName()); InstanceIdentifier bridgeNodeIid = NeutronOvsdbIidFactory.nodeIid( @@ -277,7 +257,8 @@ public class OvsdbNodeListener extends DataTreeChangeHandler { OvsdbTerminationPointAugmentation oldTp = ovsdbTpModification.getDataBefore(); OvsdbTerminationPointAugmentation newTp = ovsdbTpModification.getDataAfter(); if (oldTp != null && newTp != null) { - if (oldTp.getOfport() != null && newTp.getOfport() != null && oldTp.getOfport() != newTp.getOfport()) { + if (oldTp.getOfport() != null && newTp.getOfport() != null && !Objects.equals(oldTp.getOfport(), + newTp.getOfport())) { return true; } if (!(Strings.nullToEmpty(oldTp.getName())).equals(Strings.nullToEmpty(newTp.getName()))) { @@ -388,7 +369,7 @@ public class OvsdbNodeListener extends DataTreeChangeHandler { .setControllerEntry(controllerEntries) .setDatapathType(DatapathTypeSystem.class) .setProtocolEntry( - ImmutableList.of(new ProtocolEntryBuilder().setProtocol( + ImmutableList.of(new ProtocolEntryBuilder().setProtocol( OvsdbBridgeProtocolOpenflow13.class).build())) .build(); NodeKey managerNodeKey = managedByIid.firstKeyOf(Node.class); diff --git a/neutron-ovsdb/src/main/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/ProviderPhysicalNetworkListener.java b/neutron-ovsdb/src/main/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/ProviderPhysicalNetworkListener.java index d0bc88803..4407b402f 100644 --- a/neutron-ovsdb/src/main/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/ProviderPhysicalNetworkListener.java +++ b/neutron-ovsdb/src/main/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/ProviderPhysicalNetworkListener.java @@ -47,27 +47,36 @@ public class ProviderPhysicalNetworkListener extends DataTreeChangeHandler rootNode, InstanceIdentifier rootIdentifier) { - L2FloodDomainId l2FdId = rootNode.getDataAfter().getL2FloodDomainId(); - TenantId tenantId = rootNode.getDataAfter().getTenantId(); - String segmentationId = rootNode.getDataAfter().getSegmentationId(); - augmentSegmentationToFloodDomain(tenantId, l2FdId, segmentationId); + ProviderPhysicalNetworkAsL2FloodDomain dataAfter = rootNode.getDataAfter(); + if (dataAfter != null) { + L2FloodDomainId l2FdId = dataAfter.getL2FloodDomainId(); + TenantId tenantId = dataAfter.getTenantId(); + String segmentationId = dataAfter.getSegmentationId(); + augmentSegmentationToFloodDomain(tenantId, l2FdId, segmentationId); + } } @Override protected void onDelete(DataObjectModification rootNode, InstanceIdentifier rootIdentifier) { - L2FloodDomainId l2FdId = rootNode.getDataBefore().getL2FloodDomainId(); - TenantId tenantId = rootNode.getDataBefore().getTenantId(); - augmentSegmentationToFloodDomain(tenantId, l2FdId, null); + ProviderPhysicalNetworkAsL2FloodDomain dataBefore = rootNode.getDataBefore(); + if (dataBefore != null) { + L2FloodDomainId l2FdId = dataBefore.getL2FloodDomainId(); + TenantId tenantId = dataBefore.getTenantId(); + augmentSegmentationToFloodDomain(tenantId, l2FdId, null); + } } @Override protected void onSubtreeModified(DataObjectModification rootNode, InstanceIdentifier rootIdentifier) { - L2FloodDomainId l2FdId = rootNode.getDataAfter().getL2FloodDomainId(); - TenantId tenantId = rootNode.getDataAfter().getTenantId(); - String segmentationId = rootNode.getDataAfter().getSegmentationId(); - augmentSegmentationToFloodDomain(tenantId, l2FdId, segmentationId); + ProviderPhysicalNetworkAsL2FloodDomain dataAfter = rootNode.getDataAfter(); + if (dataAfter != null) { + L2FloodDomainId l2FdId = dataAfter.getL2FloodDomainId(); + TenantId tenantId = dataAfter.getTenantId(); + String segmentationId = dataAfter.getSegmentationId(); + augmentSegmentationToFloodDomain(tenantId, l2FdId, segmentationId); + } } private void augmentSegmentationToFloodDomain(TenantId tenantId, L2FloodDomainId l2FdId, String segmentationId) { diff --git a/neutron-ovsdb/src/main/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/TerminationPointDataChangeListener.java b/neutron-ovsdb/src/main/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/TerminationPointDataChangeListener.java index 5339e9e1b..2ae7b62c2 100755 --- a/neutron-ovsdb/src/main/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/TerminationPointDataChangeListener.java +++ b/neutron-ovsdb/src/main/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/TerminationPointDataChangeListener.java @@ -210,7 +210,7 @@ public class TerminationPointDataChangeListener implements DataChangeListener, A * OfOverlay augmentation. If it hasn't, go see if the * tunnel ports exist, and if not, go and create them. */ - if (checkOfOverlayConfig(nodeIdString, requiredTunnelTypes, dataBroker) != true) { + if (!checkOfOverlayConfig(nodeIdString, requiredTunnelTypes, dataBroker)) { checkNotNull(nodeIid); /* * Check to see if we need to create a diff --git a/neutron-ovsdb/src/test/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/OvsdbNodeListenerTest.java b/neutron-ovsdb/src/test/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/OvsdbNodeListenerTest.java new file mode 100644 index 000000000..485d1f5cf --- /dev/null +++ b/neutron-ovsdb/src/test/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/OvsdbNodeListenerTest.java @@ -0,0 +1,220 @@ +/* + * Copyright (c) 2016 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; + +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.doNothing; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static org.opendaylight.groupbasedpolicy.neutron.ovsdb.OvsdbNodeListener.BRIDGE_SEPARATOR; + +import java.util.Collection; +import java.util.HashSet; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import com.google.common.util.concurrent.CheckedFuture; +import org.junit.Before; +import org.junit.Test; +import org.opendaylight.controller.config.yang.config.neutron_ovsdb.impl.IntegrationBridgeSetting; +import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.controller.md.sal.binding.api.DataObjectModification; +import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier; +import org.opendaylight.controller.md.sal.binding.api.DataTreeModification; +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.groupbasedpolicy.neutron.ovsdb.util.NeutronOvsdbIidFactory; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Uri; +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.OvsdbBridgeAugmentationBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeName; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeRef; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentationBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentationBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfoBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntry; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntryBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagerEntry; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagerEntryBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchOtherConfigs; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchOtherConfigsBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchOtherConfigsKey; +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.TopologyId; +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.topology.Node; +import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder; +import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey; +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.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class OvsdbNodeListenerTest { + + private static final String OVSDB_BRIDGE_NAME = "ovsdbBridgeName"; + private static final String NODE_ID = "nodeId"; + private static final NodeId nodeId = new NodeId(NODE_ID); + private static final TopologyId topologyId = new TopologyId("topologyId"); + + private DataBroker dataBroker; + private IntegrationBridgeSetting integrationBridgeSetting; + private OvsdbNodeListener listener; + + DataObjectModification rootNode; + InstanceIdentifier rootIdentifier; + private ImmutableSet> changes; + private Node nodeBefore; + private Node nodeAfter; + private WriteTransaction wTx; + private InstanceIdentifier bridgeNodeIid; + private Node bridge; + + @SuppressWarnings("unchecked") + @Before + public void init() { + dataBroker = mock(DataBroker.class); + integrationBridgeSetting = new IntegrationBridgeSetting(); + integrationBridgeSetting.setName("bridgeName"); + integrationBridgeSetting.setOpenflowProtocol("ooofff"); + integrationBridgeSetting.setOpenflowPort(1234); + + rootNode = mock(DataObjectModification.class); + rootIdentifier = NeutronOvsdbIidFactory.nodeIid(topologyId, nodeId); + + DataTreeIdentifier rootPath = + new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, rootIdentifier); + DataTreeModification change = mock(DataTreeModification.class); + + when(change.getRootNode()).thenReturn(rootNode); + when(change.getRootPath()).thenReturn(rootPath); + + changes = ImmutableSet.of(change); + + bridgeNodeIid = NeutronOvsdbIidFactory.nodeIid( + rootIdentifier.firstKeyOf(Topology.class).getTopologyId(), nodeId); + + ManagerEntry managerEntry = new ManagerEntryBuilder() + .setTarget(new Uri("something:192.168.50.9:1234")) + .setConnected(false) + .setNumberOfConnections(0L) + .build(); + + ManagedNodeEntry managedNodeEntry = new ManagedNodeEntryBuilder() + .setBridgeRef(new OvsdbBridgeRef(bridgeNodeIid)) + .build(); + + ConnectionInfoBuilder ciBuilder = new ConnectionInfoBuilder(); + ciBuilder.setRemoteIp(new IpAddress(new Ipv4Address("192.168.50.10"))); + + OvsdbNodeAugmentation ovsdbNode = new OvsdbNodeAugmentationBuilder() + .setConnectionInfo(ciBuilder.build()) + .setManagerEntry(ImmutableList.of(managerEntry)) + .setManagedNodeEntry(ImmutableList.of(managedNodeEntry)) + .build(); + + OvsdbBridgeAugmentation ovsdbBridge = new OvsdbBridgeAugmentationBuilder() + .setBridgeName(new OvsdbBridgeName(OVSDB_BRIDGE_NAME)) + .setDatapathId(new DatapathId("00:01:02:03:04:05:06:07")) + .build(); + + nodeBefore = new NodeBuilder().build(); + nodeAfter = new NodeBuilder() + .setNodeId(new NodeId("node-bridgeId")) + .addAugmentation(OvsdbNodeAugmentation.class, ovsdbNode) + .addAugmentation(OvsdbBridgeAugmentation.class, ovsdbBridge).build(); + + wTx = mock(WriteTransaction.class); + when(dataBroker.newWriteOnlyTransaction()).thenReturn(wTx); + + DataObjectModification modifiedOvsdbNode = mock(DataObjectModification.class); + DataObjectModification ovsOtherConfigModification = mock(DataObjectModification.class); + + OpenvswitchOtherConfigs newConfig = new OpenvswitchOtherConfigsBuilder() + .setOtherConfigKey(OvsdbNodeListener.NEUTRON_PROVIDER_MAPPINGS_KEY) + .setOtherConfigValue("otherConfigValue:" + NODE_ID) + .build(); + when(ovsOtherConfigModification.getDataBefore()).thenReturn(null); + when(ovsOtherConfigModification.getDataAfter()).thenReturn(newConfig); + + when(modifiedOvsdbNode.getModifiedChildListItem(eq(OpenvswitchOtherConfigs.class), + any(OpenvswitchOtherConfigsKey.class))).thenReturn(ovsOtherConfigModification); + + NodeKey managerNodeKey = rootIdentifier.firstKeyOf(Node.class); + NodeId nodeId = new NodeId(managerNodeKey.getNodeId().getValue() + BRIDGE_SEPARATOR + + integrationBridgeSetting.getName()); + + bridge = new NodeBuilder() + .setNodeId(nodeId) + .build(); + //doNothing().when(wTx).merge(LogicalDatastoreType.CONFIGURATION, bridgeNodeIid, bridge, true); + CheckedFuture fut = mock(CheckedFuture.class); + when(wTx.submit()).thenReturn(fut); + + OvsdbTerminationPointAugmentation ovsdbTerminationPointAugmentation = + new OvsdbTerminationPointAugmentationBuilder().build(); + + DataObjectModification modifiedChild = mock(DataObjectModification.class); + DataObjectModification modifiedOvsdbTerminationPointAugmentation = + mock(DataObjectModification.class); + + OvsdbTerminationPointAugmentation newOvsdbTp = new OvsdbTerminationPointAugmentationBuilder() + .setName(NODE_ID) + .setOfport(1234L) + .build(); + when(modifiedOvsdbTerminationPointAugmentation.getDataAfter()).thenReturn(newOvsdbTp); + + when(modifiedChild.getDataType()).thenReturn(TerminationPoint.class); + when(modifiedChild.getModifiedAugmentation(OvsdbTerminationPointAugmentation.class)).thenReturn( + modifiedOvsdbTerminationPointAugmentation); + + Collection> modifiedChildren = new HashSet<>(); + modifiedChildren.add(modifiedChild); + when(rootNode.getModifiedChildren()).thenReturn(modifiedChildren); + + when(rootNode.getDataBefore()).thenReturn(nodeBefore); + when(rootNode.getDataAfter()).thenReturn(nodeAfter); + when(rootNode.getModifiedAugmentation(OvsdbNodeAugmentation.class)).thenReturn(modifiedOvsdbNode); + + listener = new OvsdbNodeListener(dataBroker, integrationBridgeSetting); + } + + @Test + public void testOnWrite() { + when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.WRITE); + + listener.onDataTreeChanged(changes); + + verify(wTx).merge(eq(LogicalDatastoreType.CONFIGURATION), any(InstanceIdentifier.class), any(Node.class), eq(true)); + } + + @Test + public void testOnSubtreeModified() { + listener.onWrite(rootNode, rootIdentifier); + + when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.SUBTREE_MODIFIED); + + listener.onDataTreeChanged(changes); + } + + @Test + public void testOnDelete() { + when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.DELETE); + listener.onDataTreeChanged(changes); + //no op + } + +} diff --git a/neutron-ovsdb/src/test/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/TerminationPointDataChangeListenerTest.java b/neutron-ovsdb/src/test/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/TerminationPointDataChangeListenerTest.java index b928eb5fa..d11819818 100644 --- a/neutron-ovsdb/src/test/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/TerminationPointDataChangeListenerTest.java +++ b/neutron-ovsdb/src/test/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/TerminationPointDataChangeListenerTest.java @@ -14,13 +14,15 @@ import static org.mockito.Mockito.never; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; -import java.util.Arrays; +import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.Map; import java.util.Set; import java.util.UUID; +import com.google.common.base.Optional; +import com.google.common.util.concurrent.CheckedFuture; import org.junit.Before; import org.junit.Test; import org.opendaylight.controller.md.sal.binding.api.DataBroker; @@ -57,9 +59,6 @@ import org.opendaylight.yangtools.concepts.ListenerRegistration; import org.opendaylight.yangtools.yang.binding.DataObject; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; -import com.google.common.base.Optional; -import com.google.common.util.concurrent.CheckedFuture; - public class TerminationPointDataChangeListenerTest { private TerminationPointDataChangeListener listener; @@ -85,7 +84,7 @@ public class TerminationPointDataChangeListenerTest { @SuppressWarnings({"unchecked", "rawtypes"}) @Before - public void initialise() throws Exception { + public void init() throws Exception { dataBroker = mock(DataBroker.class); epService = mock(EndpointService.class); registration = mock(ListenerRegistration.class); @@ -103,13 +102,13 @@ public class TerminationPointDataChangeListenerTest { ovsdbTp = mock(OvsdbTerminationPointAugmentation.class); when(ovsdbTp.getInterfaceType()).thenReturn((Class) Object.class); InterfaceExternalIds externalId = mock(InterfaceExternalIds.class); - when(ovsdbTp.getInterfaceExternalIds()).thenReturn(Arrays.asList(externalId)); + when(ovsdbTp.getInterfaceExternalIds()).thenReturn(Collections.singletonList(externalId)); when(externalId.getExternalIdKey()).thenReturn("iface-id"); when(externalId.getExternalIdValue()).thenReturn(UUID.randomUUID().toString()); - dataMap = new HashMap, DataObject>(); + dataMap = new HashMap<>(); dataMap.put(ovsdbTpIid, ovsdbTp); - dataSet = new HashSet>(Arrays.asList(ovsdbTpIid)); + dataSet = new HashSet>(Collections.singletonList(ovsdbTpIid)); readTransaction = mock(ReadOnlyTransaction.class); when(dataBroker.newReadOnlyTransaction()).thenReturn(readTransaction); @@ -181,14 +180,14 @@ public class TerminationPointDataChangeListenerTest { } @Test - public void constructorTest() throws Exception { + public void testConstructor() throws Exception { listener.close(); verify(registration).close(); } @SuppressWarnings("unchecked") @Test - public void onDataChangedTestCreation() { + public void testOnDataChanged_Creation() { when(change.getCreatedData()).thenReturn(dataMap); when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn( ovsdbBridgeFuture) @@ -204,7 +203,7 @@ public class TerminationPointDataChangeListenerTest { @SuppressWarnings("unchecked") @Test - public void onDataChangedTestCreationExternalIdNull() { + public void testOnDataChanged_CreationExternalIdNull() { when(change.getCreatedData()).thenReturn(dataMap); when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn( ovsdbBridgeFuture).thenReturn(nodeFuture); @@ -216,7 +215,7 @@ public class TerminationPointDataChangeListenerTest { @SuppressWarnings("unchecked") @Test - public void onDataChangedTestUpdate() { + public void testOnDataChanged_Update() { when(change.getUpdatedData()).thenReturn(dataMap); when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn( ovsdbBridgeFuture) @@ -231,7 +230,7 @@ public class TerminationPointDataChangeListenerTest { @SuppressWarnings("unchecked") @Test - public void onDataChangedTestRemoval() { + public void testOnDataChanged_Removal() { when(change.getRemovedPaths()).thenReturn(dataSet); when(change.getOriginalData()).thenReturn(dataMap); when(readWriteTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn( diff --git a/neutron-ovsdb/src/test/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/util/DataStoreTest.java b/neutron-ovsdb/src/test/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/util/DataStoreTest.java index 6f6ebae92..7c9b30222 100644 --- a/neutron-ovsdb/src/test/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/util/DataStoreTest.java +++ b/neutron-ovsdb/src/test/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/util/DataStoreTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved. + * 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, @@ -8,23 +8,18 @@ package org.opendaylight.groupbasedpolicy.neutron.ovsdb.util; -import static org.junit.Assert.assertTrue; +import static org.junit.Assert.assertEquals; import static org.opendaylight.groupbasedpolicy.neutron.ovsdb.util.InventoryHelper.getLongFromDpid; -import org.junit.Before; import org.junit.Test; public class DataStoreTest { - @Before - public void setUp() throws Exception { - } - @Test public void testDpidDecode() throws Exception { - final String testDpid1 = "00:00:aa:bb:cc:dd:ee:ff"; + final String testDpid = "00:00:aa:bb:cc:dd:ee:ff"; - Long resultDpid1 = getLongFromDpid(testDpid1); - assertTrue(resultDpid1 == 187723572702975L); + Long result = getLongFromDpid(testDpid); + assertEquals(Long.valueOf(187723572702975L), result); } } 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 index 134db052e..6c498e4ce 100644 --- 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 @@ -8,12 +8,15 @@ package org.opendaylight.groupbasedpolicy.neutron.ovsdb.util; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; 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 com.google.common.base.Optional; +import com.google.common.util.concurrent.CheckedFuture; import org.junit.Before; import org.junit.Test; import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction; @@ -30,34 +33,31 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.r 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; + private EndpointKey epKey; + private Endpoint endpoint; + private ReadOnlyTransaction readTransaction; + private ReadWriteTransaction writeTransaction; + private Optional readOptional; + private CheckedFuture submitFuture; @SuppressWarnings("unchecked") @Before - public void initialise() throws Exception { + public void init() throws Exception { epKey = mock(EndpointKey.class); OfOverlayContext ofc = mock(OfOverlayContext.class); endpoint = new EndpointBuilder().setL2Context(new L2BridgeDomainId("foo")) - .setMacAddress(new MacAddress("01:23:45:67:89:AB")) - .setTenant(new TenantId("fooTenant")) - .addAugmentation(OfOverlayContext.class, ofc) - .build(); + .setMacAddress(new MacAddress("01:23:45:67:89:AB")) + .setTenant(new TenantId("fooTenant")) + .addAugmentation(OfOverlayContext.class, ofc) + .build(); 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); + when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))) + .thenReturn(readFuture); readOptional = mock(Optional.class); when(readFuture.checkedGet()).thenReturn(readOptional); @@ -66,22 +66,22 @@ public class EndpointHelperTest { } @Test - public void lookupEndpointTest() { + public void testLookupEndpoint() { when(readOptional.isPresent()).thenReturn(true); when(readOptional.get()).thenReturn(endpoint); Endpoint result = EndpointHelper.lookupEndpoint(epKey, readTransaction); - Assert.assertEquals(result, endpoint); + assertEquals(result, endpoint); } @Test - public void lookupEndpointTestNull() { + public void testLookupEndpoint_NotPresent() { when(readOptional.isPresent()).thenReturn(false); Endpoint result = EndpointHelper.lookupEndpoint(epKey, readTransaction); - Assert.assertNull(result); + assertNull(result); } @Test - public void updateEndpointWithLocationTest() throws Exception { + public void testUpdateEndpointWithLocation() throws Exception { String nodeIdString = "nodeIdString"; String nodeConnectorIdString = "nodeConnectorIdString"; EndpointHelper.updateEndpointWithLocation(endpoint, nodeIdString, nodeConnectorIdString, writeTransaction); @@ -89,7 +89,7 @@ public class EndpointHelperTest { } @Test - public void updateEndpointRemoveLocationTest() throws Exception { + public void testUpdateEndpointRemoveLocation() 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 index 70e9dabd5..b20fc2f8d 100644 --- 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 @@ -8,15 +8,20 @@ package org.opendaylight.groupbasedpolicy.neutron.ovsdb.util; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; import static org.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 java.util.Collections; -import org.junit.Assert; +import com.google.common.base.Optional; +import com.google.common.util.concurrent.CheckedFuture; import org.junit.Before; import org.junit.Test; import org.opendaylight.controller.md.sal.binding.api.DataBroker; @@ -45,30 +50,26 @@ import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology. 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; + private CheckedFuture, ReadFailedException> terminationPointFuture; + private CheckedFuture, ReadFailedException> bridgeFuture; + private CheckedFuture, ReadFailedException> nodeConfigFuture; - Optional terminationPointOptional; - Optional bridgeOptional; - Optional nodeConfigOptional; + private Optional terminationPointOptional; + private Optional bridgeOptional; + private 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 { + public void init() throws Exception { dataBroker = mock(DataBroker.class); terminationPointFuture = mock(CheckedFuture.class); @@ -93,13 +94,14 @@ public class InventoryHelperTest { } @Test - public void getLongFromDpidTest() { + public void testGetLongFromDpid() { + String dpid = "FF:FF:FF:FF:FF:FF:FF:FF"; Long result = InventoryHelper.getLongFromDpid(dpid); - Assert.assertEquals(Long.valueOf(281474976710655L), result); + assertEquals(Long.valueOf(281474976710655L), result); } @Test - public void getInventoryNodeIdStringTest() throws Exception { + public void testGetInventoryNodeIdString() throws Exception { OvsdbBridgeAugmentation ovsdbBridge = mock(OvsdbBridgeAugmentation.class); DatapathId datapathId = mock(DatapathId.class); @@ -107,196 +109,196 @@ public class InventoryHelperTest { when(datapathId.getValue()).thenReturn("FF:FF:FF:FF:FF:FF:FF:FF"); String result = InventoryHelper.getInventoryNodeIdString(ovsdbBridge, ovsdbTpIid, dataBroker); - Assert.assertEquals("openflow:281474976710655", result); + assertEquals("openflow:281474976710655", result); } @SuppressWarnings("unchecked") @Test - public void getInventoryNodeIdStringTestDpidNull() throws Exception { + public void testGetInventoryNodeIdString_DpidNull() throws Exception { OvsdbBridgeAugmentation ovsdbBridge = mock(OvsdbBridgeAugmentation.class); - when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn( - bridgeFuture); + 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); + assertNull(result); } @Test - public void getInventoryNodeConnectorIdStringTest() { + public void testGetInventoryNodeConnectorIdString() { 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); + String result = + InventoryHelper.getInventoryNodeConnectorIdString(inventoryNodeId, ovsdbTp, ovsdbTpIid, dataBroker); + assertEquals("openflow:inventoryNodeId:65534", result); } @Test - public void getInventoryNodeConnectorIdStringTestIncorrectFormat() { + public void testGetInventoryNodeConnectorIdString_IncorrectFormat() { String inventoryNodeId = "inventoryNodeId"; OvsdbTerminationPointAugmentation ovsdbTp = mock(OvsdbTerminationPointAugmentation.class); when(ovsdbTp.getOfport()).thenReturn(65534L); - String result = InventoryHelper.getInventoryNodeConnectorIdString(inventoryNodeId, ovsdbTp, ovsdbTpIid, - dataBroker); - Assert.assertNull(result); + String result = + InventoryHelper.getInventoryNodeConnectorIdString(inventoryNodeId, ovsdbTp, ovsdbTpIid, dataBroker); + assertNull(result); } @Test - public void getInventoryNodeConnectorIdStringTestOfportNull() throws Exception { + public void testGetInventoryNodeConnectorIdString_OfportNull() 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); + String result = + InventoryHelper.getInventoryNodeConnectorIdString(inventoryNodeId, ovsdbTp, ovsdbTpIid, dataBroker); + assertNull(result); } @SuppressWarnings("unchecked") @Test - public void getInventoryNodeConnectorIdStringTestOfportOver() throws Exception { + public void testGetInventoryNodeConnectorIdString_OfportOver() 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(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); + String result = + InventoryHelper.getInventoryNodeConnectorIdString(inventoryNodeId, ovsdbTp, ovsdbTpIid, dataBroker); + assertEquals("openflow:inventoryNodeId:65534", result); } @SuppressWarnings("unchecked") @Test - public void getInventoryNodeConnectorIdStringTestOfportNullAugmentationOfportNull() throws Exception { + public void testGetInventoryNodeConnectorIdString_OfportNull_AugmentationOfportNull() 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(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); + String result = + InventoryHelper.getInventoryNodeConnectorIdString(inventoryNodeId, ovsdbTp, ovsdbTpIid, dataBroker); + assertNull(result); } @SuppressWarnings("unchecked") @Test - public void getInventoryNodeConnectorIdStringTestOfportNullAugmentationOfportOver() throws Exception { + public void testGetInventoryNodeConnectorIdString_OfportNull_AugmentationOfportOver() 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(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); + String result = + InventoryHelper.getInventoryNodeConnectorIdString(inventoryNodeId, ovsdbTp, ovsdbTpIid, dataBroker); + assertNull(result); } @SuppressWarnings({"unchecked", "rawtypes"}) @Test - public void checkOfOverlayConfigTest() throws Exception { + public void testCheckOfOverlayConfig() throws Exception { AbstractTunnelType abstractTunnelType = mock(AbstractTunnelType.class); - when(writeTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn( - nodeConfigFuture); + 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(overlayConfig.getTunnel()).thenReturn(Collections.singletonList(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); + boolean result = InventoryHelper.checkOfOverlayConfig(nodeIdString, + Collections.singletonList(abstractTunnelType), dataBroker); + assertTrue(result); } @SuppressWarnings({"unchecked", "rawtypes"}) @Test - public void checkOfOverlayConfigTestTunnelTypeEqualsFalse() throws Exception { + public void testCheckOfOverlayConfig_TunnelTypeEqualsFalse() throws Exception { AbstractTunnelType abstractTunnelType = mock(AbstractTunnelType.class); - when(writeTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn( - nodeConfigFuture); + 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(overlayConfig.getTunnel()).thenReturn(Collections.singletonList(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); + boolean result = InventoryHelper.checkOfOverlayConfig(nodeIdString, + Collections.singletonList(abstractTunnelType), dataBroker); + assertFalse(result); } @SuppressWarnings({"unchecked", "unused"}) @Test - public void checkOfOverlayConfigTestConfigNull() throws Exception { + public void testCheckOfOverlayConfig_ConfigNull() throws Exception { AbstractTunnelType abstractTunnelType = mock(AbstractTunnelType.class); - when(writeTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn( - nodeConfigFuture); + 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); + boolean result = InventoryHelper.checkOfOverlayConfig(nodeIdString, + Collections.singletonList(abstractTunnelType), dataBroker); + assertFalse(result); } @SuppressWarnings("unchecked") @Test - public void checkOfOverlayConfigTestTunnelNull() throws Exception { + public void testCheckOfOverlayConfig_TunnelNull() throws Exception { AbstractTunnelType abstractTunnelType = mock(AbstractTunnelType.class); - when(writeTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn( - nodeConfigFuture); + 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); + boolean result = InventoryHelper.checkOfOverlayConfig(nodeIdString, + Collections.singletonList(abstractTunnelType), dataBroker); + assertFalse(result); } @SuppressWarnings("unchecked") @Test - public void addOfOverlayExternalPortTest() throws Exception { + public void testAddOfOverlayExternalPort() throws Exception { NodeId nodeId = mock(NodeId.class); NodeConnectorId ncId = mock(NodeConnectorId.class); ReadWriteTransaction transaction = mock(ReadWriteTransaction.class); @@ -310,31 +312,31 @@ public class InventoryHelperTest { @SuppressWarnings("unchecked") @Test - public void getOfOverlayConfigTest() throws Exception { - when(writeTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn( - nodeConfigFuture); + public void testGetOfOverlayConfig() 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)); + assertEquals(overlayConfig, InventoryHelper.getOfOverlayConfig(nodeIdString, dataBroker)); } @SuppressWarnings({"unchecked", "rawtypes"}) @Test - public void updateOfOverlayConfigTest() throws Exception { + public void testUpdateOfOverlayConfig() 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(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(overlayConfig.getTunnel()).thenReturn(Collections.singletonList(tunnel)); when(tunnelType.getTunnelType()).thenReturn((Class) TunnelTypeVxlan.class); when(tunnel.getTunnelType()).thenReturn((Class) TunnelTypeVxlan.class); when(tunnel.getKey()).thenReturn(mock(TunnelKey.class)); @@ -347,7 +349,7 @@ public class InventoryHelperTest { } @Test - public void updateOfOverlayConfigTestNullParameters() throws Exception { + public void testUpdateOfOverlayConfig_NullParameters() throws Exception { IpAddress ip = mock(IpAddress.class); String nodeConnectorIdString = "nodeConnectorIdString"; AbstractTunnelType tunnelType = mock(AbstractTunnelType.class); @@ -360,13 +362,13 @@ public class InventoryHelperTest { @SuppressWarnings("unchecked") @Test - public void updateOfOverlayConfigTestOfConfigNull() throws Exception { + public void testUpdateOfOverlayConfig_OfConfigNull() 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(writeTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))) + .thenReturn(nodeConfigFuture); when(nodeConfigOptional.isPresent()).thenReturn(false); CheckedFuture submitFuture = mock(CheckedFuture.class); @@ -378,13 +380,14 @@ public class InventoryHelperTest { @SuppressWarnings({"unchecked", "rawtypes"}) @Test - public void removeTunnelsOfOverlayConfigTestTunnelTypeEqualsFalse() throws Exception { + public void testRemoveTunnelsOfOverlayConfig_TunnelTypeEqualsFalse() 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); + 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); @@ -392,11 +395,11 @@ public class InventoryHelperTest { when(optionalOverlayConfig.get()).thenReturn(overlayConfig); Tunnel overlayTunnel = mock(Tunnel.class); - when(overlayConfig.getTunnel()).thenReturn(Arrays.asList(overlayTunnel)); + when(overlayConfig.getTunnel()).thenReturn(Collections.singletonList(overlayTunnel)); when(tunnelType.getTunnelType()).thenReturn((Class) TunnelTypeVxlan.class); when(overlayTunnel.getTunnelType()).thenReturn(null); - InventoryHelper.removeTunnelsOfOverlayConfig(nodeIdString, Arrays.asList(tunnelType), dataBroker); - verify(writeTransaction,never()).submit(); + InventoryHelper.removeTunnelsOfOverlayConfig(nodeIdString, Collections.singletonList(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 index ad8d41268..cd7bc63de 100644 --- 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 @@ -8,11 +8,14 @@ package org.opendaylight.groupbasedpolicy.neutron.ovsdb.util; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; import static org.mockito.Matchers.any; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; -import org.junit.Assert; +import com.google.common.base.Optional; +import com.google.common.util.concurrent.CheckedFuture; import org.junit.Before; import org.junit.Test; import org.opendaylight.controller.md.sal.binding.api.DataBroker; @@ -25,9 +28,6 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev 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 UniqueId externalId; @@ -36,7 +36,7 @@ public class NeutronHelperTest { @SuppressWarnings("unchecked") @Before - public void initialise() throws Exception { + public void init() throws Exception { externalId = mock(UniqueId.class); dataBroker = mock(DataBroker.class); @@ -49,20 +49,20 @@ public class NeutronHelperTest { } @Test - public void getEpKeyFromNeutronMapperTest() throws Exception { + public void testGetEpKeyFromNeutronMapper() 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)); + assertNotNull(NeutronHelper.getEpKeyFromNeutronMapper(externalId, dataBroker)); } @Test - public void getEpKeyFromNeutronMapperTestPresentFalse() throws Exception { + public void testGetEpKeyFromNeutronMapper_PresentFalse() throws Exception { when(optionalEp.isPresent()).thenReturn(false); - Assert.assertNull(NeutronHelper.getEpKeyFromNeutronMapper(externalId, dataBroker)); + assertNull(NeutronHelper.getEpKeyFromNeutronMapper(externalId, dataBroker)); } } diff --git a/neutron-ovsdb/src/test/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/util/NeutronOvsdbIidFactoryTest.java b/neutron-ovsdb/src/test/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/util/NeutronOvsdbIidFactoryTest.java index da90f4ce5..442bd6e44 100644 --- a/neutron-ovsdb/src/test/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/util/NeutronOvsdbIidFactoryTest.java +++ b/neutron-ovsdb/src/test/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/util/NeutronOvsdbIidFactoryTest.java @@ -24,8 +24,10 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gb 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.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.ExternalGatewaysAsL3Endpoints; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.external.gateways.as.l3.endpoints.ExternalGatewayAsL3Endpoint; +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation; import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology; +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.TopologyId; 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.topology.Node; @@ -34,50 +36,82 @@ import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument; public class NeutronOvsdbIidFactoryTest { + private static final String OVSDB_TOPOLOGY_ID = "topologyId"; + private static final String UUID = "e0bb2cf8-8855-434e-839b-d2e59e045218"; + @Test - public void ovsdbNodeAugmentationIidTest() { - final String ovsdbTopologyId = "topologyId"; - InstanceIdentifier id = NeutronOvsdbIidFactory.ovsdbNodeAugmentationIid(new TopologyId(ovsdbTopologyId)); - assertNotNull(id); + public void test_OvsdbNodeAugmentationIid() { + InstanceIdentifier iid = + NeutronOvsdbIidFactory.ovsdbNodeAugmentationIid(new TopologyId(OVSDB_TOPOLOGY_ID)); + assertNotNull(iid); + Class[] expectedTypes = {NetworkTopology.class, Topology.class, Node.class, OvsdbNodeAugmentation.class}; - assertPathArgumentTypes(id.getPathArguments(), expectedTypes); - assertEquals(OvsdbNodeAugmentation.class, id.getTargetType()); - assertTrue(id.isWildcarded()); - assertEquals(ovsdbTopologyId, id.firstKeyOf(Topology.class).getTopologyId().getValue()); + assertPathArgumentTypes(iid.getPathArguments(), expectedTypes); + assertEquals(OvsdbNodeAugmentation.class, iid.getTargetType()); + assertTrue(iid.isWildcarded()); + assertEquals(OVSDB_TOPOLOGY_ID, iid.firstKeyOf(Topology.class).getTopologyId().getValue()); } @Test - public void neutronGbpExternalGatewayIidWildcardTest() { - InstanceIdentifier id = NeutronOvsdbIidFactory.neutronGbpExternalGatewayIidWildcard(); - assertNotNull(id); - Class[] expectedTypes = {Mappings.class, NeutronByGbpMappings.class, - ExternalGatewaysAsL3Endpoints.class, ExternalGatewayAsL3Endpoint.class}; - assertPathArgumentTypes(id.getPathArguments(), expectedTypes); - assertEquals(ExternalGatewayAsL3Endpoint.class, id.getTargetType()); - assertTrue(id.isWildcarded()); + public void test_NeutronGbpExternalGatewayIidWildcard() { + InstanceIdentifier iid = + NeutronOvsdbIidFactory.neutronGbpExternalGatewayIidWildcard(); + assertNotNull(iid); + Class[] expectedTypes = {Mappings.class, NeutronByGbpMappings.class, ExternalGatewaysAsL3Endpoints.class, + ExternalGatewayAsL3Endpoint.class}; + assertPathArgumentTypes(iid.getPathArguments(), expectedTypes); + assertEquals(ExternalGatewayAsL3Endpoint.class, iid.getTargetType()); + assertTrue(iid.isWildcarded()); } @Test - public void endpointByPortIidTest() { - final String portId = "e0bb2cf8-8855-434e-839b-d2e59e045218"; - InstanceIdentifier id = NeutronOvsdbIidFactory.endpointByPortIid(new UniqueId(portId)); - assertNotNull(id); - Class[] expectedTypes = {Mappings.class, GbpByNeutronMappings.class, - EndpointsByPorts.class, EndpointByPort.class}; - assertPathArgumentTypes(id.getPathArguments(), expectedTypes); - assertEquals(EndpointByPort.class, id.getTargetType()); - assertFalse(id.isWildcarded()); - assertEquals(portId, id.firstKeyOf(EndpointByPort.class).getPortId().getValue()); + public void test_EndpointByPortIid() { + String portId = UUID; + InstanceIdentifier iid = NeutronOvsdbIidFactory.endpointByPortIid(new UniqueId(portId)); + assertNotNull(iid); + Class[] expectedTypes = + {Mappings.class, GbpByNeutronMappings.class, EndpointsByPorts.class, EndpointByPort.class}; + assertPathArgumentTypes(iid.getPathArguments(), expectedTypes); + assertEquals(EndpointByPort.class, iid.getTargetType()); + assertFalse(iid.isWildcarded()); + assertEquals(portId, iid.firstKeyOf(EndpointByPort.class).getPortId().getValue()); } @Test - public void neutronGbpMappingsIidWildcardTest() { - InstanceIdentifier id = NeutronOvsdbIidFactory.neutronGbpMappingsIidWildcard(); - assertNotNull(id); + public void test_NeutronGbpMappingsIidWildcard() { + InstanceIdentifier iid = NeutronOvsdbIidFactory.neutronGbpMappingsIidWildcard(); + assertNotNull(iid); + Class[] expectedTypes = {Mappings.class, NeutronByGbpMappings.class}; - assertPathArgumentTypes(id.getPathArguments(), expectedTypes); - assertEquals(NeutronByGbpMappings.class, id.getTargetType()); - assertFalse(id.isWildcarded()); + assertPathArgumentTypes(iid.getPathArguments(), expectedTypes); + assertEquals(NeutronByGbpMappings.class, iid.getTargetType()); + assertFalse(iid.isWildcarded()); + } + + @Test + public void test_NodeIid_topology() { + InstanceIdentifier iid = + NeutronOvsdbIidFactory.nodeIid(new TopologyId(OVSDB_TOPOLOGY_ID), new NodeId(UUID)); + assertNotNull(iid); + Class[] expectedTypes = {NetworkTopology.class, Topology.class, Node.class}; + assertPathArgumentTypes(iid.getPathArguments(), expectedTypes); + assertEquals(Node.class, iid.getTargetType()); + assertFalse(iid.isWildcarded()); + } + + @Test + public void test_NodeIid_inventory() { + org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId nodeId = + new org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId(UUID); + InstanceIdentifier iid = + NeutronOvsdbIidFactory.nodeIid(nodeId); + assertNotNull(iid); + Class[] expectedTypes = + {Nodes.class, org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node.class}; + assertPathArgumentTypes(iid.getPathArguments(), expectedTypes); + assertEquals(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node.class, + iid.getTargetType()); + assertFalse(iid.isWildcarded()); } private static void assertPathArgumentTypes(Iterable pathArguments, Class[] expectedTypes) { @@ -85,7 +119,7 @@ public class NeutronOvsdbIidFactoryTest { Iterator it = pathArguments.iterator(); for (int i = 0; i < expectedTypes.length; ++i) { assertTrue("Next path argument expected.", it.hasNext()); - assertEquals("Unexpected path argument type.", expectedTypes[i] , it.next().getType()); + assertEquals("Unexpected path argument type.", expectedTypes[i], it.next().getType()); } } } diff --git a/neutron-ovsdb/src/test/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/util/OvsdbHelperTest.java b/neutron-ovsdb/src/test/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/util/OvsdbHelperTest.java index 92eea1d75..933447cd0 100644 --- a/neutron-ovsdb/src/test/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/util/OvsdbHelperTest.java +++ b/neutron-ovsdb/src/test/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/util/OvsdbHelperTest.java @@ -19,9 +19,11 @@ import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import java.util.ArrayList; -import java.util.Arrays; +import java.util.Collections; import java.util.List; +import com.google.common.base.Optional; +import com.google.common.util.concurrent.CheckedFuture; import org.junit.Before; import org.junit.Test; import org.opendaylight.controller.md.sal.binding.api.DataBroker; @@ -34,10 +36,6 @@ 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.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address; -import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey; -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.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeVxlan; 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.OvsdbBridgeAugmentationBuilder; @@ -50,21 +48,26 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.re import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntry; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfoBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Options; -import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder; -import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey; 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.NodeId; import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId; 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.NodeBuilder; +import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey; import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint; +import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder; +import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; -import com.google.common.base.Optional; -import com.google.common.util.concurrent.CheckedFuture; - public class OvsdbHelperTest { private static final String TUNNEL_PREFIX = "tunnelPrefix"; + private static final String KEY_1 = "key1"; + private static final String VALUE_1 = "value1"; + private static final String KEY_2 = "key2"; + private static final String VALUE_2 = "value2"; private DataBroker dataBroker; private InstanceIdentifier tpIid; @@ -83,7 +86,7 @@ public class OvsdbHelperTest { @SuppressWarnings({"unchecked", "rawtypes"}) @Before - public void setUp() throws Exception { + public void init() throws Exception { dataBroker = mock(DataBroker.class); tpIid = InstanceIdentifier.create(NetworkTopology.class) .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID)) @@ -135,18 +138,18 @@ public class OvsdbHelperTest { @SuppressWarnings("unchecked") @Test - public void getOvsdbBridgeFromTerminationPointTest() { - when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn( - ovsdbBridgeFuture); + public void testGetOvsdbBridgeFromTerminationPoint() { + when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))) + .thenReturn(ovsdbBridgeFuture); assertNotNull(OvsdbHelper.getOvsdbBridgeFromTerminationPoint(tpIid, dataBroker)); verify(readTransaction).read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)); } @SuppressWarnings("unchecked") @Test - public void getOvsdbBridgeFromTerminationPointTestPresentFalse() { - when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn( - ovsdbBridgeFuture); + public void testGetOvsdbBridgeFromTerminationPoint_PresentFalse() { + when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))) + .thenReturn(ovsdbBridgeFuture); when(ovsdbBridgeOptional.isPresent()).thenReturn(false); assertNull(OvsdbHelper.getOvsdbBridgeFromTerminationPoint(tpIid, dataBroker)); verify(readTransaction).read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)); @@ -154,28 +157,31 @@ public class OvsdbHelperTest { @SuppressWarnings("unchecked") @Test - public void getOvsdbBridgeFromTerminationPointTestInvalidIid() { - InstanceIdentifier invalidIid = InstanceIdentifier.create(OvsdbTerminationPointAugmentation.class); + public void testGetOvsdbBridgeFromTerminationPoint_InvalidIid() { + InstanceIdentifier invalidIid = + InstanceIdentifier.create(OvsdbTerminationPointAugmentation.class); assertNull(OvsdbHelper.getOvsdbBridgeFromTerminationPoint(invalidIid, dataBroker)); verify(readTransaction, never()).read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)); } @SuppressWarnings({"unchecked", "rawtypes"}) @Test - public void getNodeFromBridgeRefTest() { + public void testGetNodeFromBridgeRef() { OvsdbBridgeRef bridgeRef = mock(OvsdbBridgeRef.class); when(bridgeRef.getValue()).thenReturn((InstanceIdentifier) tpIid); - when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(nodeFuture); + when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))) + .thenReturn(nodeFuture); assertNotNull(OvsdbHelper.getNodeFromBridgeRef(bridgeRef, dataBroker)); verify(readTransaction).read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)); } @SuppressWarnings({"unchecked", "rawtypes"}) @Test - public void getNodeFromBridgeRefTestPresentFalse() { + public void testGetNodeFromBridgeRef_PresentFalse() { OvsdbBridgeRef bridgeRef = mock(OvsdbBridgeRef.class); when(bridgeRef.getValue()).thenReturn((InstanceIdentifier) tpIid); - when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(nodeFuture); + when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))) + .thenReturn(nodeFuture); when(nodeOptional.isPresent()).thenReturn(false); assertNull(OvsdbHelper.getNodeFromBridgeRef(bridgeRef, dataBroker)); verify(readTransaction).read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)); @@ -183,25 +189,25 @@ public class OvsdbHelperTest { @SuppressWarnings("unchecked") @Test - public void getOvsdbTerminationPointTest() { - when(readTransaction.read(any(LogicalDatastoreType.class), - any(InstanceIdentifier.class))).thenReturn(ovsdbTerminationPointFuture); + public void testGetOvsdbTerminationPoint() { + when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))) + .thenReturn(ovsdbTerminationPointFuture); assertNotNull(OvsdbHelper.getOvsdbTerminationPoint(tpIid, dataBroker)); verify(readTransaction).read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)); } @SuppressWarnings("unchecked") @Test - public void getOvsdbTerminationPointTestPresentFalse() { - when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn( - ovsdbTerminationPointFuture); + public void testGetOvsdbTerminationPoint_PresentFalse() { + when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))) + .thenReturn(ovsdbTerminationPointFuture); when(ovsdbTerminationPointOptional.isPresent()).thenReturn(false); assertNull(OvsdbHelper.getOvsdbTerminationPoint(tpIid, dataBroker)); verify(readTransaction).read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)); } @Test - public void getNodeTest() { + public void testGetNode() { NodeBuilder nodeBuilder = new NodeBuilder(); nodeBuilder.setKey(new NodeKey(new NodeId("nodeId"))); @@ -211,7 +217,8 @@ public class OvsdbHelperTest { OvsdbBridgeAugmentationBuilder augmentationBuilder = new OvsdbBridgeAugmentationBuilder(); augmentationBuilder.setBridgeName(new OvsdbBridgeName("bridgeName")); - Node node = OvsdbHelper.getNode(nodeBuilder.build(), Arrays.asList(tpBuilder.build()), augmentationBuilder.build()); + Node node = OvsdbHelper.getNode(nodeBuilder.build(), Collections.singletonList(tpBuilder.build()), + augmentationBuilder.build()); assertNotNull(node); assertEquals("nodeId", node.getKey().getNodeId().getValue()); assertEquals(1, node.getTerminationPoint().size()); @@ -222,10 +229,11 @@ public class OvsdbHelperTest { } @Test - public void buildOvsdbBridgeAugmentationTest() { + public void testBuildOvsdbBridgeAugmentation() { final InstanceIdentifier nodeIid = InstanceIdentifier.builder(NetworkTopology.class) - .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID)) - .child(Node.class).build(); + .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID)) + .child(Node.class) + .build(); OvsdbBridgeAugmentationBuilder bridgeAugmentationBuilder = new OvsdbBridgeAugmentationBuilder(); bridgeAugmentationBuilder.setBridgeName(new OvsdbBridgeName("bridgeName")); @@ -237,8 +245,8 @@ public class OvsdbHelperTest { ciBuilder.setLocalIp(new IpAddress(new Ipv4Address("127.0.0.1"))); nodeAugmentationBuilder.setConnectionInfo(ciBuilder.build()); - OvsdbBridgeAugmentation augmentation = OvsdbHelper.buildOvsdbBridgeAugmentation( - bridgeAugmentationBuilder.build(), nodeAugmentationBuilder.build()); + OvsdbBridgeAugmentation augmentation = OvsdbHelper + .buildOvsdbBridgeAugmentation(bridgeAugmentationBuilder.build(), nodeAugmentationBuilder.build()); assertNotNull(augmentation); assertNotNull("bridgeName", augmentation.getBridgeName().getValue()); assertEquals(nodeIid, augmentation.getManagedBy().getValue()); @@ -249,10 +257,11 @@ public class OvsdbHelperTest { } @Test - public void buildOvsdbBridgeAugmentationTestManagerIpNull() { + public void testBuildOvsdbBridgeAugmentation_ManagerIpNull() { final InstanceIdentifier nodeIid = InstanceIdentifier.builder(NetworkTopology.class) - .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID)) - .child(Node.class).build(); + .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID)) + .child(Node.class) + .build(); OvsdbBridgeAugmentationBuilder bridgeAugmentationBuilder = new OvsdbBridgeAugmentationBuilder(); bridgeAugmentationBuilder.setBridgeName(new OvsdbBridgeName("bridgeName")); @@ -260,8 +269,8 @@ public class OvsdbHelperTest { OvsdbNodeAugmentationBuilder nodeAugmentationBuilder = new OvsdbNodeAugmentationBuilder(); - OvsdbBridgeAugmentation augmentation = OvsdbHelper.buildOvsdbBridgeAugmentation( - bridgeAugmentationBuilder.build(), nodeAugmentationBuilder.build()); + OvsdbBridgeAugmentation augmentation = OvsdbHelper + .buildOvsdbBridgeAugmentation(bridgeAugmentationBuilder.build(), nodeAugmentationBuilder.build()); assertNotNull(augmentation); assertNotNull("bridgeName", augmentation.getBridgeName().getValue()); assertEquals(nodeIid, augmentation.getManagedBy().getValue()); @@ -269,26 +278,25 @@ public class OvsdbHelperTest { } @Test - public void buildTerminationPointsTest() { + public void testBuildTerminationPoints() { OvsdbBridgeAugmentationBuilder bridgeAugmentationBuilder = new OvsdbBridgeAugmentationBuilder(); bridgeAugmentationBuilder.setBridgeName(new OvsdbBridgeName("bridgeName")); - List options = new ArrayList(); + List options = new ArrayList<>(); OvsdbHelper.setOption(options, "optionKey", "optionValue"); - OvsdbTerminationPointAugmentation terminationPointAugmentation = - OvsdbHelper.buildOvsdbTerminationPointAugmentation(bridgeAugmentationBuilder.build(), - options, abstractTunnelType); + OvsdbTerminationPointAugmentation terminationPointAugmentation = OvsdbHelper + .buildOvsdbTerminationPointAugmentation(bridgeAugmentationBuilder.build(), options, abstractTunnelType); - List terminationPoints = OvsdbHelper.buildTerminationPoints( - bridgeAugmentationBuilder.build(), terminationPointAugmentation, abstractTunnelType); + List terminationPoints = OvsdbHelper.buildTerminationPoints(bridgeAugmentationBuilder.build(), + terminationPointAugmentation, abstractTunnelType); assertNotNull(terminationPoints); assertEquals(1, terminationPoints.size()); TerminationPoint terminationPoint = terminationPoints.get(0); assertNotNull(terminationPoint); assertEquals(TUNNEL_PREFIX + "bridgeName", terminationPoint.getTpId().getValue()); - OvsdbTerminationPointAugmentation tpAugmentation = terminationPoint.getAugmentation( - OvsdbTerminationPointAugmentation.class); + OvsdbTerminationPointAugmentation tpAugmentation = + terminationPoint.getAugmentation(OvsdbTerminationPointAugmentation.class); assertNotNull(tpAugmentation); assertEquals(TUNNEL_PREFIX + "bridgeName", tpAugmentation.getName()); assertEquals(1, tpAugmentation.getOptions().size()); @@ -300,10 +308,10 @@ public class OvsdbHelperTest { } @Test - public void buildOvsdbTerminationPointAugmentationTest() { + public void testBuildOvsdbTerminationPointAugmentation() { OvsdbBridgeAugmentationBuilder bridgeAugmentationBuilder = new OvsdbBridgeAugmentationBuilder(); bridgeAugmentationBuilder.setBridgeName(new OvsdbBridgeName("bridgeName")); - List expectedOptions = new ArrayList(); + List expectedOptions = new ArrayList<>(); OvsdbHelper.setOption(expectedOptions, "optionKey", "optionValue"); OvsdbTerminationPointAugmentation augmentation = OvsdbHelper.buildOvsdbTerminationPointAugmentation( bridgeAugmentationBuilder.build(), expectedOptions, abstractTunnelType); @@ -318,31 +326,35 @@ public class OvsdbHelperTest { } @Test - public void setOptionTest() { - List options = new ArrayList(); - OvsdbHelper.setOption(options, "key1", "value1"); + public void testSetOption() { + List options = new ArrayList<>(); + OvsdbHelper.setOption(options, KEY_1, VALUE_1); assertEquals(1, options.size()); + Options option = options.get(0); assertNotNull(option); - assertEquals("key1", option.getOption()); - assertEquals("key1", option.getKey().getOption()); - assertEquals("value1", option.getValue()); - OvsdbHelper.setOption(options, "key2", "value2"); + assertEquals(KEY_1, option.getOption()); + assertEquals(KEY_1, option.getKey().getOption()); + assertEquals(VALUE_1, option.getValue()); + + OvsdbHelper.setOption(options, KEY_2, VALUE_2); assertEquals(2, options.size()); + option = options.get(0); assertNotNull(option); - assertEquals("key1", option.getOption()); - assertEquals("key1", option.getKey().getOption()); - assertEquals("value1", option.getValue()); + assertEquals(KEY_1, option.getOption()); + assertEquals(KEY_1, option.getKey().getOption()); + assertEquals(VALUE_1, option.getValue()); + option = options.get(1); assertNotNull(option); - assertEquals("key2", option.getOption()); - assertEquals("key2", option.getKey().getOption()); - assertEquals("value2", option.getValue()); + assertEquals(KEY_2, option.getOption()); + assertEquals(KEY_2, option.getKey().getOption()); + assertEquals(VALUE_2, option.getValue()); } @Test - public void getNodeIpTest() { + public void testGetNodeIp() { OvsdbNodeAugmentationBuilder nodeAugmentationBuilder = new OvsdbNodeAugmentationBuilder(); ConnectionInfoBuilder ciBuilder = new ConnectionInfoBuilder(); ciBuilder.setRemoteIp(new IpAddress(new Ipv4Address("192.168.50.10"))); @@ -354,25 +366,25 @@ public class OvsdbHelperTest { } @Test - public void getNodeIpTestIpNotSet() { + public void testGetNodeIp_IpNotSet() { OvsdbNodeAugmentationBuilder nodeAugmentationBuilder = new OvsdbNodeAugmentationBuilder(); nodeAugmentationBuilder.setConnectionInfo(new ConnectionInfoBuilder().build()); assertNull(OvsdbHelper.getNodeIp(nodeAugmentationBuilder.build())); } @Test - public void getNodeIpTestConnectionInfoNull() { + public void testGetNodeIp_ConnectionInfoNull() { assertNull(OvsdbHelper.getNodeIp(new OvsdbNodeAugmentationBuilder().build())); } @Test - public void getManagedNodeTestManagedByNotSet() { + public void testGetManagedNode_ManagedByNotSet() { assertNull(OvsdbHelper.getManagerNode(new OvsdbBridgeAugmentationBuilder().build(), dataBroker)); } @SuppressWarnings("unchecked") @Test - public void getManagedNodeTestInvalidTargetTypeForManagedBy() { + public void getManagedNode_InvalidTargetTypeForManagedBy() { final InstanceIdentifier nodeIid = InstanceIdentifier.builder(NetworkTopology.class).build(); OvsdbBridgeAugmentationBuilder bridgeAugmentationBuilder = new OvsdbBridgeAugmentationBuilder(); bridgeAugmentationBuilder.setManagedBy(new OvsdbNodeRef(nodeIid)); @@ -382,20 +394,20 @@ public class OvsdbHelperTest { @SuppressWarnings("unchecked") @Test - public void getTopologyNodeTest() { + public void testGetTopologyNode() { InstanceIdentifier nodeIid = InstanceIdentifier.create(Node.class); - when(readTransaction.read(any(LogicalDatastoreType.class), - any(InstanceIdentifier.class))).thenReturn(nodeFuture); + when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))) + .thenReturn(nodeFuture); assertEquals(node, OvsdbHelper.getTopologyNode(nodeIid, dataBroker)); verify(readTransaction).read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)); } @SuppressWarnings("unchecked") @Test - public void getTopologyNodeTestPresentFalse() { + public void testGetTopologyNode_PresentFalse() { InstanceIdentifier nodeIid = InstanceIdentifier.create(Node.class); - when(readTransaction.read(any(LogicalDatastoreType.class), - any(InstanceIdentifier.class))).thenReturn(nodeFuture); + when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))) + .thenReturn(nodeFuture); when(nodeOptional.isPresent()).thenReturn(false); assertNull(OvsdbHelper.getTopologyNode(nodeIid, dataBroker)); verify(readTransaction).read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)); @@ -403,17 +415,17 @@ public class OvsdbHelperTest { @SuppressWarnings("unchecked") @Test - public void createTunnelPortTest() { + public void testCreateTunnelPort() { InstanceIdentifier nodeIid = InstanceIdentifier.create(Node.class); - when(readWriteTransaction.read(any(LogicalDatastoreType.class), - any(InstanceIdentifier.class))).thenReturn(nodeFuture); + when(readWriteTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))) + .thenReturn(nodeFuture); OvsdbHelper.createTunnelPort(nodeIid, node, abstractTunnelType, dataBroker); verify(readWriteTransaction).read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)); verify(readWriteTransaction).submit(); } @Test - public void createTunnelPortTestBridgeNull() { + public void testCreateTunnelPort_BridgeNull() { InstanceIdentifier nodeIid = InstanceIdentifier.create(Node.class); when(node.getAugmentation(OvsdbBridgeAugmentation.class)).thenReturn(null); OvsdbHelper.createTunnelPort(nodeIid, node, abstractTunnelType, dataBroker); @@ -422,10 +434,10 @@ public class OvsdbHelperTest { @SuppressWarnings("unchecked") @Test - public void createTunnelPortTestManagerNodeNull() { + public void testCreateTunnelPort_ManagerNodeNull() { InstanceIdentifier nodeIid = InstanceIdentifier.create(Node.class); - when(readWriteTransaction.read(any(LogicalDatastoreType.class), - any(InstanceIdentifier.class))).thenReturn(nodeFuture); + when(readWriteTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))) + .thenReturn(nodeFuture); when(nodeOptional.isPresent()).thenReturn(false); OvsdbHelper.createTunnelPort(nodeIid, node, abstractTunnelType, dataBroker); verify(readWriteTransaction).read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)); -- 2.36.6