southbound/southbound-impl/src/test/java/org/opendaylight/ovsdb/southbound/OvsdbConnectionManagerTest.java

   1 /*
   2  * Copyright (c) 2015 Inocybe Technologies 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.ovsdb.southbound;
  10
  11 import static org.junit.Assert.assertEquals;
  12 import static org.mockito.Matchers.any;
  13 import static org.mockito.Matchers.anyInt;
  14 import static org.mockito.Mockito.doNothing;
  15 import static org.mockito.Mockito.mock;
  16 import static org.mockito.Mockito.times;
  17 import static org.mockito.Mockito.verify;
  18 import static org.mockito.Mockito.when;
  19 import static org.powermock.api.support.membermodification.MemberMatcher.field;
  20 import static org.powermock.api.support.membermodification.MemberModifier.suppress;
  21
  22 import com.google.common.base.Optional;
  23 import com.google.common.util.concurrent.CheckedFuture;
  24 import java.net.InetAddress;
  25 import java.util.Arrays;
  26 import java.util.List;
  27 import java.util.Map;
  28 import java.util.concurrent.ConcurrentHashMap;
  29 import java.util.concurrent.TimeUnit;
  30 import org.junit.Before;
  31 import org.junit.Ignore;
  32 import org.junit.Test;
  33 import org.junit.runner.RunWith;
  34 import org.mockito.Mock;
  35 import org.mockito.Mockito;
  36 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  37 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  38 import org.opendaylight.controller.md.sal.common.api.clustering.Entity;
  39 import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipChange;
  40 import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipService;
  41 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  42 import org.opendaylight.ovsdb.lib.OvsdbClient;
  43 import org.opendaylight.ovsdb.lib.OvsdbConnection;
  44 import org.opendaylight.ovsdb.lib.impl.OvsdbConnectionService;
  45 import org.opendaylight.ovsdb.southbound.reconciliation.ReconciliationManager;
  46 import org.opendaylight.ovsdb.southbound.transactions.md.TransactionCommand;
  47 import org.opendaylight.ovsdb.southbound.transactions.md.TransactionInvoker;
  48 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
  49 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAttributes;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfo;
  53 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  54 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  55 import org.powermock.api.mockito.PowerMockito;
  56 import org.powermock.api.support.membermodification.MemberMatcher;
  57 import org.powermock.api.support.membermodification.MemberModifier;
  58 import org.powermock.core.classloader.annotations.PrepareForTest;
  59 import org.powermock.modules.junit4.PowerMockRunner;
  60 import org.powermock.reflect.Whitebox;
  61
  62 @RunWith(PowerMockRunner.class)
  63 @PrepareForTest({ SouthboundMapper.class, OvsdbConnectionManager.class, OvsdbConnectionService.class,
  64         InstanceIdentifier.class, SouthboundUtil.class, Optional.class })
  65 public class OvsdbConnectionManagerTest {
  66
  67     @Mock private OvsdbConnectionManager ovsdbConnManager;
  68     @Mock private DataBroker db;
  69     @Mock private TransactionInvoker txInvoker;
  70     @Mock private EntityOwnershipService entityOwnershipService;
  71     @Mock private OvsdbConnection ovsdbConnection;
  72     @Mock private OvsdbClient externalClient;
  73     @Mock private ReconciliationManager reconciliationManager;
  74     private Map<ConnectionInfo,OvsdbConnectionInstance> clients;
  75     private Map<ConnectionInfo,InstanceIdentifier<Node>> instanceIdentifiers;
  76     private Map<Entity, OvsdbConnectionInstance> entityConnectionMap;
  77
  78     @Mock private InstanceIdentifier<Node> iid;
  79
  80     @Before
  81     public void setUp() throws Exception {
  82         ovsdbConnManager = PowerMockito.mock(OvsdbConnectionManager.class, Mockito.CALLS_REAL_METHODS);
  83         field(OvsdbConnectionManager.class, "db").set(ovsdbConnManager, db);
  84         field(OvsdbConnectionManager.class, "txInvoker").set(ovsdbConnManager, txInvoker);
  85         field(OvsdbConnectionManager.class, "entityOwnershipService").set(ovsdbConnManager, entityOwnershipService);
  86         field(OvsdbConnectionManager.class, "reconciliationManager").set(ovsdbConnManager, reconciliationManager);
  87         field(OvsdbConnectionManager.class, "ovsdbConnection").set(ovsdbConnManager, ovsdbConnection);
  88         entityConnectionMap = new ConcurrentHashMap<>();
  89
  90         externalClient = mock(OvsdbClient.class, Mockito.RETURNS_DEEP_STUBS);
  91         when(externalClient.getConnectionInfo().getRemoteAddress()).thenReturn(mock(InetAddress.class));
  92         when(externalClient.getConnectionInfo().getRemotePort()).thenReturn(8080);
  93         when(externalClient.getConnectionInfo().getLocalAddress()).thenReturn(mock(InetAddress.class));
  94         when(externalClient.getConnectionInfo().getLocalPort()).thenReturn(8080);
  95         List<String> databases = Arrays.asList("Open_vSwitch");
  96         when(externalClient.getDatabases().get(1000, TimeUnit.MILLISECONDS)).thenReturn(databases);
  97
  98         PowerMockito.mockStatic(SouthboundUtil.class);
  99         when(SouthboundUtil.connectionInfoToString(any(ConnectionInfo.class))).thenReturn("192.18.120.31:8080");
 100     }
 101
 102     @Test
 103     public void testConnected() throws Exception {
 104         OvsdbConnectionInstance client = mock(OvsdbConnectionInstance.class);
 105         suppress(MemberMatcher.method(OvsdbConnectionManager.class, "connectedButCallBacksNotRegistered",
 106                 OvsdbClient.class));
 107         when(ovsdbConnManager.connectedButCallBacksNotRegistered(any(OvsdbClient.class))).thenReturn(client);
 108         doNothing().when(client).registerCallbacks();
 109
 110         //TODO: Write unit tests for EntityOwnershipService
 111         InstanceIdentifier<Node> iid = mock(InstanceIdentifier.class);
 112         when(client.getInstanceIdentifier()).thenReturn(iid);
 113         field(OvsdbConnectionManager.class, "entityConnectionMap").set(ovsdbConnManager, entityConnectionMap);
 114         suppress(MemberMatcher.method(OvsdbConnectionManager.class, "getEntityFromConnectionInstance",
 115                 OvsdbConnectionInstance.class));
 116
 117         //TODO: Write unit tests for entity ownership service related code.
 118         suppress(MemberMatcher.method(OvsdbConnectionManager.class, "registerEntityForOwnership",
 119                 OvsdbConnectionInstance.class));
 120
 121         ReadOnlyTransaction tx = mock(ReadOnlyTransaction.class);
 122         when(db.newReadOnlyTransaction()).thenReturn(tx);
 123         when(tx.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)))
 124                 .thenReturn(mock(CheckedFuture.class));
 125         when(client.getInstanceIdentifier()).thenReturn(mock(InstanceIdentifier.class));
 126
 127         ovsdbConnManager.connected(externalClient);
 128     }
 129
 130     @SuppressWarnings("unchecked")
 131     @Test
 132     public void testConnectedButCallBacksNotRegistered() throws Exception {
 133         ConnectionInfo key = mock(ConnectionInfo.class);
 134
 135         PowerMockito.mockStatic(SouthboundMapper.class);
 136         when(SouthboundMapper.createConnectionInfo(any(OvsdbClient.class))).thenReturn(key);
 137
 138         suppress(MemberMatcher.method(OvsdbConnectionManager.class, "getInstanceIdentifier", ConnectionInfo.class));
 139         InstanceIdentifier<Node> iid = mock(InstanceIdentifier.class);
 140         when(ovsdbConnManager.getInstanceIdentifier(key)).thenReturn(iid);
 141
 142         suppress(MemberMatcher.method(OvsdbConnectionManager.class, "getConnectionInstance", ConnectionInfo.class));
 143         when(ovsdbConnManager.getConnectionInstance(key)).thenReturn(null);
 144
 145         OvsdbConnectionInstance client = mock(OvsdbConnectionInstance.class);
 146         suppress(MemberMatcher.method(OvsdbConnectionManager.class, "putConnectionInstance", ConnectionInfo.class,
 147                 OvsdbConnectionInstance.class));
 148         doNothing().when(client).createTransactInvokers();
 149         PowerMockito.whenNew(OvsdbConnectionInstance.class).withArguments(any(ConnectionInfo.class),
 150                 any(OvsdbClient.class), any(TransactionInvoker.class), any(InstanceIdentifier.class))
 151                 .thenReturn(client);
 152
 153         assertEquals("Error, did not receive correct OvsdbConnectionInstance object", client,
 154                 ovsdbConnManager.connectedButCallBacksNotRegistered(externalClient));
 155     }
 156
 157     @Test
 158     public void testDisconnected() throws Exception {
 159         ConnectionInfo key = mock(ConnectionInfo.class);
 160         PowerMockito.mockStatic(SouthboundMapper.class);
 161         when(SouthboundMapper.createConnectionInfo(any(OvsdbClient.class))).thenReturn(key);
 162
 163         OvsdbConnectionInstance ovsdbConnectionInstance = mock(OvsdbConnectionInstance.class);
 164         clients = new ConcurrentHashMap<>();
 165         clients.put(key, ovsdbConnectionInstance);
 166         MemberModifier.field(OvsdbConnectionManager.class, "clients").set(ovsdbConnManager, clients);
 167
 168         suppress(MemberMatcher.method(OvsdbConnectionManager.class, "getConnectionInstance", ConnectionInfo.class));
 169         when(ovsdbConnManager.getConnectionInstance(any(ConnectionInfo.class))).thenReturn(ovsdbConnectionInstance);
 170         doNothing().when(txInvoker).invoke(any(TransactionCommand.class));
 171
 172         when(SouthboundMapper.suppressLocalIpPort(any(ConnectionInfo.class))).thenReturn(key);
 173
 174         // TODO: Write unit tests for EntityOwnershipService
 175         suppress(MemberMatcher.method(OvsdbConnectionManager.class, "unregisterEntityForOwnership",
 176                 OvsdbConnectionInstance.class));
 177         instanceIdentifiers = new ConcurrentHashMap<>();
 178         field(OvsdbConnectionManager.class, "instanceIdentifiers").set(ovsdbConnManager, instanceIdentifiers);
 179
 180         MemberModifier.suppress(MemberMatcher.method(OvsdbConnectionManager.class, "reconcileConnection",
 181                 InstanceIdentifier.class, OvsdbNodeAugmentation.class));
 182         ReadOnlyTransaction tx = mock(ReadOnlyTransaction.class);
 183         when(db.newReadOnlyTransaction()).thenReturn(tx);
 184         when(tx.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)))
 185                 .thenReturn(mock(CheckedFuture.class));
 186         when(ovsdbConnectionInstance.getInstanceIdentifier()).thenReturn(mock(InstanceIdentifier.class));
 187         ovsdbConnManager.disconnected(externalClient);
 188         Map<ConnectionInfo, OvsdbConnectionInstance> testClients = Whitebox.getInternalState(ovsdbConnManager,
 189                 "clients");
 190         assertEquals("Error, size of the hashmap is incorrect", 0, testClients.size());
 191     }
 192
 193     @Test
 194     public void testDisconnect() throws Exception {
 195         OvsdbNodeAugmentation ovsdbNode = mock(OvsdbNodeAugmentation.class);
 196         ConnectionInfo connectionInfo = mock(ConnectionInfo.class);
 197         when(ovsdbNode.getConnectionInfo()).thenReturn(connectionInfo);
 198         suppress(MemberMatcher.method(OvsdbConnectionManager.class, "getConnectionInstance", ConnectionInfo.class));
 199         OvsdbConnectionInstance ovsdbConnectionInstance = mock(OvsdbConnectionInstance.class);
 200         when(ovsdbConnManager.getConnectionInstance(any(ConnectionInfo.class))).thenReturn(ovsdbConnectionInstance);
 201         when(ovsdbConnectionInstance.getInstanceIdentifier()).thenReturn(mock(InstanceIdentifier.class));
 202
 203         suppress(MemberMatcher.method(OvsdbConnectionManager.class, "removeInstanceIdentifier", ConnectionInfo.class));
 204
 205         // TODO: Write unit tests for entity ownership service related code.
 206         suppress(MemberMatcher.method(OvsdbConnectionManager.class, "unregisterEntityForOwnership",
 207                 OvsdbConnectionInstance.class));
 208         ovsdbConnManager.disconnect(ovsdbNode);
 209         verify((OvsdbClient)ovsdbConnectionInstance).disconnect();
 210     }
 211
 212     @Test
 213     @Ignore
 214     public void testInit() {
 215         mock(ConnectionInfo.class);
 216         suppress(MemberMatcher.method(OvsdbConnectionManager.class, "getConnectionInstance", ConnectionInfo.class));
 217         OvsdbConnectionInstance ovsdbConnectionInstance = mock(OvsdbConnectionInstance.class);
 218         when(ovsdbConnManager.getConnectionInstance(any(ConnectionInfo.class))).thenReturn(ovsdbConnectionInstance);
 219
 220         // client not null
 221         // ovsdbConnectionManager.init(key);
 222         verify(ovsdbConnectionInstance).registerCallbacks();
 223     }
 224
 225     @Test
 226     public void testClose() throws Exception {
 227         ConnectionInfo key1 = mock(ConnectionInfo.class);
 228         ConnectionInfo key2 = mock(ConnectionInfo.class);
 229         OvsdbConnectionInstance ovsdbConnectionInstance1 = mock(OvsdbConnectionInstance.class);
 230         OvsdbConnectionInstance ovsdbConnectionInstance2 = mock(OvsdbConnectionInstance.class);
 231         clients = new ConcurrentHashMap<>();
 232         clients.put(key1, ovsdbConnectionInstance1);
 233         clients.put(key2, ovsdbConnectionInstance2);
 234         MemberModifier.field(OvsdbConnectionManager.class, "clients").set(ovsdbConnManager, clients);
 235         ovsdbConnManager.close();
 236         verify(ovsdbConnectionInstance1).disconnect();
 237         verify(ovsdbConnectionInstance2).disconnect();
 238     }
 239
 240     @Test
 241     public void testPutAndGetConnectionInstance() throws Exception {
 242         ConnectionInfo key = mock(ConnectionInfo.class);
 243         ConnectionInfo connectionInfo = mock(ConnectionInfo.class);
 244         PowerMockito.mockStatic(SouthboundMapper.class);
 245         when(SouthboundMapper.suppressLocalIpPort(key)).thenReturn(connectionInfo);
 246
 247         clients = new ConcurrentHashMap<>();
 248         MemberModifier.field(OvsdbConnectionManager.class, "clients").set(ovsdbConnManager, clients);
 249
 250         // Test putConnectionInstance()
 251         OvsdbConnectionInstance instance = mock(OvsdbConnectionInstance.class);
 252         Whitebox.invokeMethod(ovsdbConnManager, "putConnectionInstance", key, instance);
 253         Map<ConnectionInfo, OvsdbConnectionInstance> testClients = Whitebox.getInternalState(ovsdbConnManager,
 254                 "clients");
 255         assertEquals("Error, size of the hashmap is incorrect", 1, testClients.size());
 256
 257         // Test getConnectionInstance(ConnectionInfo key)
 258         assertEquals("Error, returned incorrect OvsdbConnectionInstance object", instance,
 259                 ovsdbConnManager.getConnectionInstance(key));
 260     }
 261
 262     @Test
 263     @SuppressWarnings("unchecked")
 264     public void testPutandGetInstanceIdentifier() throws Exception {
 265         ConnectionInfo key = mock(ConnectionInfo.class);
 266         ConnectionInfo connectionInfo = mock(ConnectionInfo.class);
 267         PowerMockito.mockStatic(SouthboundMapper.class);
 268         when(SouthboundMapper.suppressLocalIpPort(key)).thenReturn(connectionInfo);
 269
 270         instanceIdentifiers = new ConcurrentHashMap<>();
 271         field(OvsdbConnectionManager.class, "instanceIdentifiers").set(ovsdbConnManager, instanceIdentifiers);
 272
 273         //Test putInstanceIdentifier()
 274         Whitebox.invokeMethod(ovsdbConnManager, "putInstanceIdentifier", key, iid);
 275         Map<ConnectionInfo, OvsdbConnectionInstance> testIids = Whitebox.getInternalState(ovsdbConnManager,
 276                 "instanceIdentifiers");
 277         assertEquals("Error, size of the hashmap is incorrect", 1, testIids.size());
 278
 279         //Test getInstanceIdentifier()
 280         assertEquals("Error returning correct InstanceIdentifier object", iid,
 281                 ovsdbConnManager.getInstanceIdentifier(key));
 282
 283         //Test removeInstanceIdentifier()
 284         Whitebox.invokeMethod(ovsdbConnManager, "removeInstanceIdentifier", key);
 285         Map<ConnectionInfo, OvsdbConnectionInstance> testRemoveIids = Whitebox.getInternalState(ovsdbConnManager,
 286                 "instanceIdentifiers");
 287         assertEquals("Error, size of the hashmap is incorrect", 0, testRemoveIids.size());
 288     }
 289
 290     @Test
 291     public void testGetClient() {
 292         OvsdbClient ovsdbClient = mock(OvsdbConnectionInstance.class);
 293
 294         //Test getClient(ConnectionInfo connectionInfo)
 295         ConnectionInfo key = mock(ConnectionInfo.class);
 296         suppress(MemberMatcher.method(OvsdbConnectionManager.class, "getConnectionInstance", ConnectionInfo.class));
 297         when(ovsdbConnManager.getConnectionInstance(key)).thenReturn((OvsdbConnectionInstance)ovsdbClient);
 298         assertEquals("Error getting correct OvsdbClient object", ovsdbClient, ovsdbConnManager.getClient(key));
 299
 300         //Test getClient(OvsdbBridgeAttributes mn)
 301         OvsdbBridgeAttributes mn = mock(OvsdbBridgeAttributes.class);
 302         suppress(MemberMatcher.method(OvsdbConnectionManager.class, "getConnectionInstance",
 303                 OvsdbBridgeAttributes.class));
 304         when(ovsdbConnManager.getConnectionInstance(mn)).thenReturn((OvsdbConnectionInstance)ovsdbClient);
 305         assertEquals("Error getting correct OvsdbClient object", ovsdbClient, ovsdbConnManager.getClient(mn));
 306
 307         //Test getClient(Node node)
 308         Node node = mock(Node.class);
 309         suppress(MemberMatcher.method(OvsdbConnectionManager.class, "getConnectionInstance", Node.class));
 310         when(ovsdbConnManager.getConnectionInstance(node)).thenReturn((OvsdbConnectionInstance)ovsdbClient);
 311         assertEquals("Error getting correct OvsdbClient object", ovsdbClient, ovsdbConnManager.getClient(node));
 312     }
 313
 314     @SuppressWarnings("unchecked")
 315     @Test
 316     public void testConnect() throws Exception {
 317         OvsdbNodeAugmentation ovsdbNode = mock(OvsdbNodeAugmentation.class);
 318         ConnectionInfo connectionInfo = mock(ConnectionInfo.class);
 319         when(ovsdbNode.getConnectionInfo()).thenReturn(connectionInfo);
 320         IpAddress ipAddr = mock(IpAddress.class);
 321         when(connectionInfo.getRemoteIp()).thenReturn(ipAddr);
 322
 323         PowerMockito.mockStatic(SouthboundMapper.class);
 324         InetAddress ip = mock(InetAddress.class);
 325         when(SouthboundMapper.createInetAddress(any(IpAddress.class))).thenReturn(ip);
 326
 327         PowerMockito.mockStatic(OvsdbConnectionService.class);
 328         when(OvsdbConnectionService.getService()).thenReturn(ovsdbConnection);
 329         PortNumber port = mock(PortNumber.class);
 330         when(connectionInfo.getRemotePort()).thenReturn(port);
 331         when(port.getValue()).thenReturn(8080);
 332         OvsdbClient client = mock(OvsdbClient.class);
 333         when(ovsdbConnection.connect(any(InetAddress.class), anyInt())).thenReturn(client);
 334
 335         //client not null case
 336         suppress(MemberMatcher.method(OvsdbConnectionManager.class, "putInstanceIdentifier", ConnectionInfo.class,
 337                 InstanceIdentifier.class));
 338         suppress(MemberMatcher.method(OvsdbConnectionManager.class, "connectedButCallBacksNotRegistered",
 339                 OvsdbClient.class));
 340
 341         PowerMockito.doNothing().when(ovsdbConnManager, "putInstanceIdentifier", any(ConnectionInfo.class),
 342                 any(InstanceIdentifier.class));
 343
 344         OvsdbConnectionInstance ovsdbConnectionInstance = mock(OvsdbConnectionInstance.class);
 345         when(ovsdbConnManager.connectedButCallBacksNotRegistered(any(OvsdbClient.class)))
 346                 .thenReturn(ovsdbConnectionInstance);
 347
 348         InstanceIdentifier<Node> iid = mock(InstanceIdentifier.class);
 349         when(ovsdbConnectionInstance.getInstanceIdentifier()).thenReturn(iid);
 350         field(OvsdbConnectionManager.class, "entityConnectionMap").set(ovsdbConnManager, entityConnectionMap);
 351         suppress(MemberMatcher.method(OvsdbConnectionManager.class, "getEntityFromConnectionInstance",
 352                 OvsdbConnectionInstance.class));
 353         //TODO: Write unit tests for entity ownership service related code.
 354         suppress(MemberMatcher.method(OvsdbConnectionManager.class, "registerEntityForOwnership",
 355                 OvsdbConnectionInstance.class));
 356         assertEquals("ERROR", client, ovsdbConnManager.connect(PowerMockito.mock(InstanceIdentifier.class), ovsdbNode));
 357     }
 358
 359     @Test
 360     public void testHandleOwnershipChanged() throws Exception {
 361         Entity entity = new Entity("entityType", "entityName");
 362         ConnectionInfo key = mock(ConnectionInfo.class);
 363
 364         OvsdbConnectionInstance ovsdbConnInstance = new OvsdbConnectionInstance(key, externalClient, txInvoker, iid);
 365         entityConnectionMap.put(entity, ovsdbConnInstance);
 366
 367         field(OvsdbConnectionManager.class, "entityConnectionMap").set(ovsdbConnManager, entityConnectionMap);
 368         suppress(MemberMatcher.method(OvsdbConnectionManager.class, "putConnectionInstance", ConnectionInfo.class,
 369                 OvsdbConnectionInstance.class));
 370         EntityOwnershipChange ownershipChange = new EntityOwnershipChange(entity, true, false, false);
 371         Whitebox.invokeMethod(ovsdbConnManager, "handleOwnershipChanged", ownershipChange);
 372         PowerMockito.verifyPrivate(ovsdbConnManager, times(1)).invoke("putConnectionInstance", key, ovsdbConnInstance);
 373     }
 374 }