neutron-ovsdb/src/test/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/util/InventoryHelperTest.java

   1 /*
   2  * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.groupbasedpolicy.neutron.ovsdb.util;
  10
  11 import static org.mockito.Matchers.any;
  12 import static org.mockito.Mockito.mock;
  13 import static org.mockito.Mockito.never;
  14 import static org.mockito.Mockito.verify;
  15 import static org.mockito.Mockito.when;
  16
  17 import java.util.Arrays;
  18
  19 import org.junit.Assert;
  20 import org.junit.Before;
  21 import org.junit.Test;
  22 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  23 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  24 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
  25 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  26 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  27 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  28 import org.opendaylight.groupbasedpolicy.neutron.ovsdb.AbstractTunnelType;
  29 import org.opendaylight.ovsdb.southbound.SouthboundConstants;
  30 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayNodeConfig;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.nodes.node.Tunnel;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.nodes.node.TunnelKey;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.overlay.rev150105.TunnelTypeBase;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.overlay.rev150105.TunnelTypeVxlan;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.DatapathId;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
  41 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
  42 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
  43 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
  44 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  45 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
  46 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  47
  48 import com.google.common.base.Optional;
  49 import com.google.common.util.concurrent.CheckedFuture;
  50
  51 public class InventoryHelperTest {
  52
  53     private DataBroker dataBroker;
  54     private ReadOnlyTransaction readTransaction;
  55     private ReadWriteTransaction writeTransaction;
  56
  57     CheckedFuture<Optional<OvsdbTerminationPointAugmentation>, ReadFailedException> terminationPointFuture;
  58     CheckedFuture<Optional<OvsdbBridgeAugmentation>, ReadFailedException> bridgeFuture;
  59     CheckedFuture<Optional<OfOverlayNodeConfig>, ReadFailedException> nodeConfigFuture;
  60
  61     Optional<OvsdbTerminationPointAugmentation> terminationPointOptional;
  62     Optional<OvsdbBridgeAugmentation> bridgeOptional;
  63     Optional<OfOverlayNodeConfig> nodeConfigOptional;
  64
  65     private InstanceIdentifier<OvsdbTerminationPointAugmentation> ovsdbTpIid;
  66     private String dpid = "FF:FF:FF:FF:FF:FF:FF:FF";
  67     private String nodeIdString = "nodeIdString";
  68
  69     @SuppressWarnings("unchecked")
  70     @Before
  71     public void initialise() throws Exception {
  72         dataBroker = mock(DataBroker.class);
  73
  74         terminationPointFuture = mock(CheckedFuture.class);
  75         terminationPointOptional = mock(Optional.class);
  76         when(terminationPointFuture.checkedGet()).thenReturn(terminationPointOptional);
  77         bridgeFuture = mock(CheckedFuture.class);
  78         bridgeOptional = mock(Optional.class);
  79         when(bridgeFuture.checkedGet()).thenReturn(bridgeOptional);
  80         nodeConfigFuture = mock(CheckedFuture.class);
  81         nodeConfigOptional = mock(Optional.class);
  82         when(nodeConfigFuture.checkedGet()).thenReturn(nodeConfigOptional);
  83
  84         readTransaction = mock(ReadOnlyTransaction.class);
  85         writeTransaction = mock(ReadWriteTransaction.class);
  86         when(dataBroker.newReadOnlyTransaction()).thenReturn(readTransaction);
  87         when(dataBroker.newReadWriteTransaction()).thenReturn(writeTransaction);
  88         ovsdbTpIid = InstanceIdentifier.create(NetworkTopology.class)
  89             .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
  90             .child(Node.class)
  91             .child(TerminationPoint.class)
  92             .augmentation(OvsdbTerminationPointAugmentation.class);
  93     }
  94
  95     @Test
  96     public void getLongFromDpidTest() {
  97         Long result = InventoryHelper.getLongFromDpid(dpid);
  98         Assert.assertEquals(Long.valueOf(281474976710655L), result);
  99     }
 100
 101     @Test
 102     public void getInventoryNodeIdStringTest() throws Exception {
 103         OvsdbBridgeAugmentation ovsdbBridge = mock(OvsdbBridgeAugmentation.class);
 104
 105         DatapathId datapathId = mock(DatapathId.class);
 106         when(ovsdbBridge.getDatapathId()).thenReturn(datapathId);
 107         when(datapathId.getValue()).thenReturn("FF:FF:FF:FF:FF:FF:FF:FF");
 108
 109         String result = InventoryHelper.getInventoryNodeIdString(ovsdbBridge, ovsdbTpIid, dataBroker);
 110         Assert.assertEquals("openflow:281474976710655", result);
 111     }
 112
 113     @SuppressWarnings("unchecked")
 114     @Test
 115     public void getInventoryNodeIdStringTestDpidNull() throws Exception {
 116         OvsdbBridgeAugmentation ovsdbBridge = mock(OvsdbBridgeAugmentation.class);
 117
 118         when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(
 119                 bridgeFuture);
 120         when(bridgeOptional.isPresent()).thenReturn(true);
 121         OvsdbBridgeAugmentation bridge = mock(OvsdbBridgeAugmentation.class);
 122         when(bridgeOptional.get()).thenReturn(bridge);
 123         when(bridge.getDatapathId()).thenReturn(null);
 124
 125         String result = InventoryHelper.getInventoryNodeIdString(ovsdbBridge, ovsdbTpIid, dataBroker);
 126         Assert.assertNull(result);
 127     }
 128
 129     @Test
 130     public void getInventoryNodeConnectorIdStringTest() {
 131         String inventoryNodeId = "openflow:inventoryNodeId";
 132         OvsdbTerminationPointAugmentation ovsdbTp = mock(OvsdbTerminationPointAugmentation.class);
 133         when(ovsdbTp.getOfport()).thenReturn(65534L);
 134
 135         String result = InventoryHelper.getInventoryNodeConnectorIdString(inventoryNodeId, ovsdbTp, ovsdbTpIid,
 136                 dataBroker);
 137         Assert.assertEquals("openflow:inventoryNodeId:65534", result);
 138     }
 139
 140     @Test
 141     public void getInventoryNodeConnectorIdStringTestIncorrectFormat() {
 142         String inventoryNodeId = "inventoryNodeId";
 143         OvsdbTerminationPointAugmentation ovsdbTp = mock(OvsdbTerminationPointAugmentation.class);
 144         when(ovsdbTp.getOfport()).thenReturn(65534L);
 145
 146         String result = InventoryHelper.getInventoryNodeConnectorIdString(inventoryNodeId, ovsdbTp, ovsdbTpIid,
 147                 dataBroker);
 148         Assert.assertNull(result);
 149     }
 150
 151     @Test
 152     public void getInventoryNodeConnectorIdStringTestOfportNull() throws Exception {
 153         String inventoryNodeId = "openflow:inventoryNodeId";
 154         OvsdbTerminationPointAugmentation ovsdbTp = mock(OvsdbTerminationPointAugmentation.class);
 155         when(ovsdbTp.getOfport()).thenReturn(65535L);
 156
 157         String result = InventoryHelper.getInventoryNodeConnectorIdString(inventoryNodeId, ovsdbTp, ovsdbTpIid,
 158                 dataBroker);
 159         Assert.assertNull(result);
 160     }
 161
 162     @SuppressWarnings("unchecked")
 163     @Test
 164     public void getInventoryNodeConnectorIdStringTestOfportOver() throws Exception {
 165         String inventoryNodeId = "openflow:inventoryNodeId";
 166         OvsdbTerminationPointAugmentation ovsdbTp = mock(OvsdbTerminationPointAugmentation.class);
 167         when(ovsdbTp.getOfport()).thenReturn(null);
 168
 169         when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(
 170                 terminationPointFuture);
 171         when(terminationPointOptional.isPresent()).thenReturn(true);
 172         OvsdbTerminationPointAugmentation readOvsdbTp = mock(OvsdbTerminationPointAugmentation.class);
 173         when(terminationPointOptional.get()).thenReturn(readOvsdbTp);
 174
 175         when(readOvsdbTp.getOfport()).thenReturn(65534L);
 176
 177         String result = InventoryHelper.getInventoryNodeConnectorIdString(inventoryNodeId, ovsdbTp, ovsdbTpIid,
 178                 dataBroker);
 179         Assert.assertEquals("openflow:inventoryNodeId:65534", result);
 180     }
 181
 182     @SuppressWarnings("unchecked")
 183     @Test
 184     public void getInventoryNodeConnectorIdStringTestOfportNullAugmentationOfportNull() throws Exception {
 185         String inventoryNodeId = "openflow:inventoryNodeId";
 186         OvsdbTerminationPointAugmentation ovsdbTp = mock(OvsdbTerminationPointAugmentation.class);
 187         when(ovsdbTp.getOfport()).thenReturn(null);
 188
 189         when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(
 190                 terminationPointFuture);
 191         when(terminationPointOptional.isPresent()).thenReturn(true);
 192         OvsdbTerminationPointAugmentation readOvsdbTp = mock(OvsdbTerminationPointAugmentation.class);
 193         when(terminationPointOptional.get()).thenReturn(readOvsdbTp);
 194         when(readOvsdbTp.getOfport()).thenReturn(null);
 195
 196         String result = InventoryHelper.getInventoryNodeConnectorIdString(inventoryNodeId, ovsdbTp, ovsdbTpIid,
 197                 dataBroker);
 198         Assert.assertNull(result);
 199     }
 200
 201     @SuppressWarnings("unchecked")
 202     @Test
 203     public void getInventoryNodeConnectorIdStringTestOfportNullAugmentationOfportOver() throws Exception {
 204         String inventoryNodeId = "openflow:inventoryNodeId";
 205         OvsdbTerminationPointAugmentation ovsdbTp = mock(OvsdbTerminationPointAugmentation.class);
 206         when(ovsdbTp.getOfport()).thenReturn(null);
 207
 208         when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(
 209                 terminationPointFuture);
 210         OvsdbTerminationPointAugmentation readOvsdbTp = mock(OvsdbTerminationPointAugmentation.class);
 211         when(terminationPointOptional.get()).thenReturn(readOvsdbTp);
 212         when(readOvsdbTp.getOfport()).thenReturn(65535L);
 213
 214         String result = InventoryHelper.getInventoryNodeConnectorIdString(inventoryNodeId, ovsdbTp, ovsdbTpIid,
 215                 dataBroker);
 216         Assert.assertNull(result);
 217     }
 218
 219     @SuppressWarnings({"unchecked", "rawtypes"})
 220     @Test
 221     public void checkOfOverlayConfigTest() throws Exception {
 222         AbstractTunnelType abstractTunnelType = mock(AbstractTunnelType.class);
 223
 224         when(writeTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(
 225                 nodeConfigFuture);
 226         when(nodeConfigOptional.isPresent()).thenReturn(true);
 227         OfOverlayNodeConfig overlayConfig = mock(OfOverlayNodeConfig.class);
 228         when(nodeConfigOptional.get()).thenReturn(overlayConfig);
 229
 230         Tunnel tunnel = mock(Tunnel.class);
 231         when(overlayConfig.getTunnel()).thenReturn(Arrays.asList(tunnel));
 232
 233         when(abstractTunnelType.getTunnelType()).thenReturn((Class) TunnelTypeVxlan.class);
 234         when(tunnel.getTunnelType()).thenReturn((Class) TunnelTypeVxlan.class);
 235
 236         boolean result = InventoryHelper.checkOfOverlayConfig(nodeIdString, Arrays.asList(abstractTunnelType),
 237                 dataBroker);
 238         Assert.assertTrue(result);
 239     }
 240
 241     @SuppressWarnings({"unchecked", "rawtypes"})
 242     @Test
 243     public void checkOfOverlayConfigTestTunnelTypeEqualsFalse() throws Exception {
 244         AbstractTunnelType abstractTunnelType = mock(AbstractTunnelType.class);
 245
 246         when(writeTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(
 247                 nodeConfigFuture);
 248         when(nodeConfigOptional.isPresent()).thenReturn(true);
 249         OfOverlayNodeConfig overlayConfig = mock(OfOverlayNodeConfig.class);
 250         when(nodeConfigOptional.get()).thenReturn(overlayConfig);
 251
 252         Tunnel tunnel = mock(Tunnel.class);
 253         when(overlayConfig.getTunnel()).thenReturn(Arrays.asList(tunnel));
 254
 255         when(abstractTunnelType.getTunnelType()).thenReturn((Class) TunnelTypeVxlan.class);
 256         when(tunnel.getTunnelType()).thenReturn((Class) TunnelTypeBase.class);
 257
 258         boolean result = InventoryHelper.checkOfOverlayConfig(nodeIdString, Arrays.asList(abstractTunnelType),
 259                 dataBroker);
 260         Assert.assertFalse(result);
 261     }
 262
 263     @SuppressWarnings({"unchecked", "unused"})
 264     @Test
 265     public void checkOfOverlayConfigTestConfigNull() throws Exception {
 266         AbstractTunnelType abstractTunnelType = mock(AbstractTunnelType.class);
 267
 268         when(writeTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(
 269                 nodeConfigFuture);
 270         when(nodeConfigOptional.isPresent()).thenReturn(true);
 271         OfOverlayNodeConfig overlayConfig = mock(OfOverlayNodeConfig.class);
 272         when(nodeConfigOptional.get()).thenReturn(null);
 273
 274         boolean result = InventoryHelper.checkOfOverlayConfig(nodeIdString, Arrays.asList(abstractTunnelType),
 275                 dataBroker);
 276         Assert.assertFalse(result);
 277     }
 278
 279     @SuppressWarnings("unchecked")
 280     @Test
 281     public void checkOfOverlayConfigTestTunnelNull() throws Exception {
 282         AbstractTunnelType abstractTunnelType = mock(AbstractTunnelType.class);
 283
 284         when(writeTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(
 285                 nodeConfigFuture);
 286         when(nodeConfigOptional.isPresent()).thenReturn(true);
 287         OfOverlayNodeConfig overlayConfig = mock(OfOverlayNodeConfig.class);
 288         when(nodeConfigOptional.get()).thenReturn(overlayConfig);
 289
 290         when(overlayConfig.getTunnel()).thenReturn(null);
 291
 292         boolean result = InventoryHelper.checkOfOverlayConfig(nodeIdString, Arrays.asList(abstractTunnelType),
 293                 dataBroker);
 294         Assert.assertFalse(result);
 295     }
 296
 297     @SuppressWarnings("unchecked")
 298     @Test
 299     public void addOfOverlayExternalPortTest() throws Exception {
 300         NodeId nodeId = mock(NodeId.class);
 301         NodeConnectorId ncId = mock(NodeConnectorId.class);
 302         ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
 303         when(dataBroker.newReadWriteTransaction()).thenReturn(transaction);
 304         CheckedFuture<Void, TransactionCommitFailedException> submitFuture = mock(CheckedFuture.class);
 305         when(transaction.submit()).thenReturn(submitFuture);
 306
 307         InventoryHelper.addOfOverlayExternalPort(nodeId, ncId, dataBroker);
 308         verify(submitFuture).checkedGet();
 309     }
 310
 311     @SuppressWarnings("unchecked")
 312     @Test
 313     public void getOfOverlayConfigTest() throws Exception {
 314         when(writeTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(
 315                 nodeConfigFuture);
 316         when(nodeConfigOptional.isPresent()).thenReturn(true);
 317         OfOverlayNodeConfig overlayConfig = mock(OfOverlayNodeConfig.class);
 318         when(nodeConfigOptional.get()).thenReturn(overlayConfig);
 319
 320         Assert.assertEquals(overlayConfig, InventoryHelper.getOfOverlayConfig(nodeIdString, dataBroker));
 321     }
 322
 323     @SuppressWarnings({"unchecked", "rawtypes"})
 324     @Test
 325     public void updateOfOverlayConfigTest() throws Exception {
 326         IpAddress ip = mock(IpAddress.class);
 327         String nodeConnectorIdString = "nodeConnectorIdString";
 328         AbstractTunnelType tunnelType = mock(AbstractTunnelType.class);
 329
 330         when(writeTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(
 331                 nodeConfigFuture);
 332         when(nodeConfigOptional.isPresent()).thenReturn(true);
 333         OfOverlayNodeConfig overlayConfig = mock(OfOverlayNodeConfig.class);
 334         when(nodeConfigOptional.get()).thenReturn(overlayConfig);
 335
 336         Tunnel tunnel = mock(Tunnel.class);
 337         when(overlayConfig.getTunnel()).thenReturn(Arrays.asList(tunnel));
 338         when(tunnelType.getTunnelType()).thenReturn((Class) TunnelTypeVxlan.class);
 339         when(tunnel.getTunnelType()).thenReturn((Class) TunnelTypeVxlan.class);
 340         when(tunnel.getKey()).thenReturn(mock(TunnelKey.class));
 341
 342         CheckedFuture<Void, TransactionCommitFailedException> submitFuture = mock(CheckedFuture.class);
 343         when(writeTransaction.submit()).thenReturn(submitFuture);
 344
 345         InventoryHelper.updateOfOverlayConfig(ip, nodeIdString, nodeConnectorIdString, tunnelType, dataBroker);
 346         verify(writeTransaction).submit();
 347     }
 348
 349     @Test
 350     public void updateOfOverlayConfigTestNullParameters() throws Exception {
 351         IpAddress ip = mock(IpAddress.class);
 352         String nodeConnectorIdString = "nodeConnectorIdString";
 353         AbstractTunnelType tunnelType = mock(AbstractTunnelType.class);
 354
 355         InventoryHelper.updateOfOverlayConfig(null, nodeIdString, nodeConnectorIdString, tunnelType, dataBroker);
 356         InventoryHelper.updateOfOverlayConfig(ip, null, nodeConnectorIdString, tunnelType, dataBroker);
 357         InventoryHelper.updateOfOverlayConfig(ip, nodeIdString, null, tunnelType, dataBroker);
 358         verify(writeTransaction, never()).submit();
 359     }
 360
 361     @SuppressWarnings("unchecked")
 362     @Test
 363     public void updateOfOverlayConfigTestOfConfigNull() throws Exception {
 364         IpAddress ip = mock(IpAddress.class);
 365         String nodeConnectorIdString = "nodeConnectorIdString";
 366         AbstractTunnelType tunnelType = mock(AbstractTunnelType.class);
 367
 368         when(writeTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(
 369                 nodeConfigFuture);
 370         when(nodeConfigOptional.isPresent()).thenReturn(false);
 371
 372         CheckedFuture<Void, TransactionCommitFailedException> submitFuture = mock(CheckedFuture.class);
 373         when(writeTransaction.submit()).thenReturn(submitFuture);
 374
 375         InventoryHelper.updateOfOverlayConfig(ip, nodeIdString, nodeConnectorIdString, tunnelType, dataBroker);
 376         verify(writeTransaction).submit();
 377     }
 378
 379     @SuppressWarnings({"unchecked", "rawtypes"})
 380     @Test
 381     public void removeTunnelsOfOverlayConfigTestTunnelTypeEqualsFalse() throws Exception {
 382         AbstractTunnelType tunnelType = mock(AbstractTunnelType.class);
 383
 384         ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
 385         when(dataBroker.newReadWriteTransaction()).thenReturn(transaction);
 386         CheckedFuture<Optional<OfOverlayNodeConfig>, ReadFailedException> checkedFuture = mock(CheckedFuture.class);
 387         when(transaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(checkedFuture);
 388         Optional<OfOverlayNodeConfig> optionalOverlayConfig = mock(Optional.class);
 389         when(checkedFuture.checkedGet()).thenReturn(optionalOverlayConfig);
 390         when(optionalOverlayConfig.isPresent()).thenReturn(true);
 391         OfOverlayNodeConfig overlayConfig = mock(OfOverlayNodeConfig.class);
 392         when(optionalOverlayConfig.get()).thenReturn(overlayConfig);
 393
 394         Tunnel overlayTunnel = mock(Tunnel.class);
 395         when(overlayConfig.getTunnel()).thenReturn(Arrays.<Tunnel>asList(overlayTunnel));
 396         when(tunnelType.getTunnelType()).thenReturn((Class) TunnelTypeVxlan.class);
 397         when(overlayTunnel.getTunnelType()).thenReturn(null);
 398
 399         InventoryHelper.removeTunnelsOfOverlayConfig(nodeIdString, Arrays.asList(tunnelType), dataBroker);
 400         verify(writeTransaction,never()).submit();
 401     }
 402 }