<artifactId>mockito-all</artifactId>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>sal-binding-broker-impl</artifactId>
+ <type>test-jar</type>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.groupbasedpolicy</groupId>
+ <artifactId>groupbasedpolicy</artifactId>
+ <version>${project.version}</version>
+ <type>test-jar</type>
+ <scope>test</scope>
+ </dependency>
</dependencies>
<build>
</plugin>
</plugins>
</build>
-</project>
\ No newline at end of file
+</project>
*/
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;
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<Node> {
+ 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<OvsdbBridgeRef, String> providerPortNameByBridgeRef = new HashMap<>();
}
}
}
- if (intBrSettings != null && integrationBridgePresent == false) {
+ if (intBrSettings != null && !integrationBridgePresent) {
final Node bridge = createBridge(rootIdentifier,
managerToControllerEntries(ovsdbNode.getManagerEntry()), intBrSettings.getName());
InstanceIdentifier<Node> bridgeNodeIid = NeutronOvsdbIidFactory.nodeIid(
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()))) {
.setControllerEntry(controllerEntries)
.setDatapathType(DatapathTypeSystem.class)
.setProtocolEntry(
- ImmutableList.<ProtocolEntry>of(new ProtocolEntryBuilder().setProtocol(
+ ImmutableList.of(new ProtocolEntryBuilder().setProtocol(
OvsdbBridgeProtocolOpenflow13.class).build()))
.build();
NodeKey managerNodeKey = managedByIid.firstKeyOf(Node.class);
@Override
protected void onWrite(DataObjectModification<ProviderPhysicalNetworkAsL2FloodDomain> rootNode,
InstanceIdentifier<ProviderPhysicalNetworkAsL2FloodDomain> 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<ProviderPhysicalNetworkAsL2FloodDomain> rootNode,
InstanceIdentifier<ProviderPhysicalNetworkAsL2FloodDomain> 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<ProviderPhysicalNetworkAsL2FloodDomain> rootNode,
InstanceIdentifier<ProviderPhysicalNetworkAsL2FloodDomain> 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) {
* 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
--- /dev/null
+/*
+ * 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<Node> rootNode;
+ InstanceIdentifier<Node> rootIdentifier;
+ private ImmutableSet<DataTreeModification<Node>> changes;
+ private Node nodeBefore;
+ private Node nodeAfter;
+ private WriteTransaction wTx;
+ private InstanceIdentifier<Node> 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<Node> rootPath =
+ new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, rootIdentifier);
+ DataTreeModification<Node> 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<OvsdbNodeAugmentation> modifiedOvsdbNode = mock(DataObjectModification.class);
+ DataObjectModification<OpenvswitchOtherConfigs> 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<Void, TransactionCommitFailedException> fut = mock(CheckedFuture.class);
+ when(wTx.submit()).thenReturn(fut);
+
+ OvsdbTerminationPointAugmentation ovsdbTerminationPointAugmentation =
+ new OvsdbTerminationPointAugmentationBuilder().build();
+
+ DataObjectModification<TerminationPoint> modifiedChild = mock(DataObjectModification.class);
+ DataObjectModification<OvsdbTerminationPointAugmentation> 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<DataObjectModification<? extends DataObject>> 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
+ }
+
+}
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;
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;
@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);
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<InstanceIdentifier<?>, DataObject>();
+ dataMap = new HashMap<>();
dataMap.put(ovsdbTpIid, ovsdbTp);
- dataSet = new HashSet<InstanceIdentifier<?>>(Arrays.asList(ovsdbTpIid));
+ dataSet = new HashSet<InstanceIdentifier<?>>(Collections.singletonList(ovsdbTpIid));
readTransaction = mock(ReadOnlyTransaction.class);
when(dataBroker.newReadOnlyTransaction()).thenReturn(readTransaction);
}
@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)
@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);
@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)
@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(
/*
- * 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,
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);
}
}
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;
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<Endpoint> readOptional;
- CheckedFuture<Void, TransactionCommitFailedException> submitFuture;
+ private EndpointKey epKey;
+ private Endpoint endpoint;
+ private ReadOnlyTransaction readTransaction;
+ private ReadWriteTransaction writeTransaction;
+ private Optional<Endpoint> readOptional;
+ private CheckedFuture<Void, TransactionCommitFailedException> 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<Optional<Endpoint>, 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);
}
@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);
}
@Test
- public void updateEndpointRemoveLocationTest() throws Exception {
+ public void testUpdateEndpointRemoveLocation() throws Exception {
EndpointHelper.updateEndpointRemoveLocation(endpoint, writeTransaction);
verify(submitFuture).checkedGet();
}
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;
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<Optional<OvsdbTerminationPointAugmentation>, ReadFailedException> terminationPointFuture;
- CheckedFuture<Optional<OvsdbBridgeAugmentation>, ReadFailedException> bridgeFuture;
- CheckedFuture<Optional<OfOverlayNodeConfig>, ReadFailedException> nodeConfigFuture;
+ private CheckedFuture<Optional<OvsdbTerminationPointAugmentation>, ReadFailedException> terminationPointFuture;
+ private CheckedFuture<Optional<OvsdbBridgeAugmentation>, ReadFailedException> bridgeFuture;
+ private CheckedFuture<Optional<OfOverlayNodeConfig>, ReadFailedException> nodeConfigFuture;
- Optional<OvsdbTerminationPointAugmentation> terminationPointOptional;
- Optional<OvsdbBridgeAugmentation> bridgeOptional;
- Optional<OfOverlayNodeConfig> nodeConfigOptional;
+ private Optional<OvsdbTerminationPointAugmentation> terminationPointOptional;
+ private Optional<OvsdbBridgeAugmentation> bridgeOptional;
+ private Optional<OfOverlayNodeConfig> nodeConfigOptional;
private InstanceIdentifier<OvsdbTerminationPointAugmentation> 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);
}
@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);
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);
@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));
}
@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);
@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<Void, TransactionCommitFailedException> submitFuture = mock(CheckedFuture.class);
@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<Optional<OfOverlayNodeConfig>, 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<OfOverlayNodeConfig> optionalOverlayConfig = mock(Optional.class);
when(checkedFuture.checkedGet()).thenReturn(optionalOverlayConfig);
when(optionalOverlayConfig.isPresent()).thenReturn(true);
when(optionalOverlayConfig.get()).thenReturn(overlayConfig);
Tunnel overlayTunnel = mock(Tunnel.class);
- when(overlayConfig.getTunnel()).thenReturn(Arrays.<Tunnel>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();
}
}
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;
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;
@SuppressWarnings("unchecked")
@Before
- public void initialise() throws Exception {
+ public void init() throws Exception {
externalId = mock(UniqueId.class);
dataBroker = mock(DataBroker.class);
}
@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));
}
}
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;
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<OvsdbNodeAugmentation> id = NeutronOvsdbIidFactory.ovsdbNodeAugmentationIid(new TopologyId(ovsdbTopologyId));
- assertNotNull(id);
+ public void test_OvsdbNodeAugmentationIid() {
+ InstanceIdentifier<OvsdbNodeAugmentation> 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<ExternalGatewayAsL3Endpoint> 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<ExternalGatewayAsL3Endpoint> 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<EndpointByPort> 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<EndpointByPort> 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<NeutronByGbpMappings> id = NeutronOvsdbIidFactory.neutronGbpMappingsIidWildcard();
- assertNotNull(id);
+ public void test_NeutronGbpMappingsIidWildcard() {
+ InstanceIdentifier<NeutronByGbpMappings> 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<Node> 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<org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node> 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<PathArgument> pathArguments, Class<?>[] expectedTypes) {
Iterator<PathArgument> 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());
}
}
}
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;
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;
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<OvsdbTerminationPointAugmentation> tpIid;
@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))
@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));
@SuppressWarnings("unchecked")
@Test
- public void getOvsdbBridgeFromTerminationPointTestInvalidIid() {
- InstanceIdentifier<OvsdbTerminationPointAugmentation> invalidIid = InstanceIdentifier.create(OvsdbTerminationPointAugmentation.class);
+ public void testGetOvsdbBridgeFromTerminationPoint_InvalidIid() {
+ InstanceIdentifier<OvsdbTerminationPointAugmentation> 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));
@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")));
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());
}
@Test
- public void buildOvsdbBridgeAugmentationTest() {
+ public void testBuildOvsdbBridgeAugmentation() {
final InstanceIdentifier<Node> 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"));
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());
}
@Test
- public void buildOvsdbBridgeAugmentationTestManagerIpNull() {
+ public void testBuildOvsdbBridgeAugmentation_ManagerIpNull() {
final InstanceIdentifier<Node> 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"));
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());
}
@Test
- public void buildTerminationPointsTest() {
+ public void testBuildTerminationPoints() {
OvsdbBridgeAugmentationBuilder bridgeAugmentationBuilder = new OvsdbBridgeAugmentationBuilder();
bridgeAugmentationBuilder.setBridgeName(new OvsdbBridgeName("bridgeName"));
- List<Options> options = new ArrayList<Options>();
+ List<Options> 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<TerminationPoint> terminationPoints = OvsdbHelper.buildTerminationPoints(
- bridgeAugmentationBuilder.build(), terminationPointAugmentation, abstractTunnelType);
+ List<TerminationPoint> 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());
}
@Test
- public void buildOvsdbTerminationPointAugmentationTest() {
+ public void testBuildOvsdbTerminationPointAugmentation() {
OvsdbBridgeAugmentationBuilder bridgeAugmentationBuilder = new OvsdbBridgeAugmentationBuilder();
bridgeAugmentationBuilder.setBridgeName(new OvsdbBridgeName("bridgeName"));
- List<Options> expectedOptions = new ArrayList<Options>();
+ List<Options> expectedOptions = new ArrayList<>();
OvsdbHelper.setOption(expectedOptions, "optionKey", "optionValue");
OvsdbTerminationPointAugmentation augmentation = OvsdbHelper.buildOvsdbTerminationPointAugmentation(
bridgeAugmentationBuilder.build(), expectedOptions, abstractTunnelType);
}
@Test
- public void setOptionTest() {
- List<Options> options = new ArrayList<Options>();
- OvsdbHelper.setOption(options, "key1", "value1");
+ public void testSetOption() {
+ List<Options> 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")));
}
@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<NetworkTopology> nodeIid = InstanceIdentifier.builder(NetworkTopology.class).build();
OvsdbBridgeAugmentationBuilder bridgeAugmentationBuilder = new OvsdbBridgeAugmentationBuilder();
bridgeAugmentationBuilder.setManagedBy(new OvsdbNodeRef(nodeIid));
@SuppressWarnings("unchecked")
@Test
- public void getTopologyNodeTest() {
+ public void testGetTopologyNode() {
InstanceIdentifier<Node> 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<Node> 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));
@SuppressWarnings("unchecked")
@Test
- public void createTunnelPortTest() {
+ public void testCreateTunnelPort() {
InstanceIdentifier<Node> 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<Node> nodeIid = InstanceIdentifier.create(Node.class);
when(node.getAugmentation(OvsdbBridgeAugmentation.class)).thenReturn(null);
OvsdbHelper.createTunnelPort(nodeIid, node, abstractTunnelType, dataBroker);
@SuppressWarnings("unchecked")
@Test
- public void createTunnelPortTestManagerNodeNull() {
+ public void testCreateTunnelPort_ManagerNodeNull() {
InstanceIdentifier<Node> 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));
Code Review / groupbasedpolicy.git / commitdiff