southbound/southbound-impl/src/test/java/org/opendaylight/ovsdb/southbound/OvsdbConnectionInstanceTest.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.junit.Assert.assertNull;
  13 import static org.mockito.Matchers.any;
  14 import static org.mockito.Matchers.anyString;
  15 import static org.mockito.Matchers.eq;
  16 import static org.mockito.Mockito.doNothing;
  17 import static org.mockito.Mockito.doReturn;
  18 import static org.mockito.Mockito.mock;
  19 import static org.mockito.Mockito.times;
  20 import static org.mockito.Mockito.verify;
  21 import static org.mockito.Mockito.when;
  22 import static org.powermock.reflect.Whitebox.getField;
  23
  24 import com.google.common.util.concurrent.ListenableFuture;
  25 import java.util.ArrayList;
  26 import java.util.HashMap;
  27 import java.util.HashSet;
  28 import java.util.List;
  29 import java.util.Map;
  30 import java.util.Set;
  31 import org.junit.Before;
  32 import org.junit.Test;
  33 import org.junit.runner.RunWith;
  34 import org.mockito.Mock;
  35 import org.mockito.Mockito;
  36 import org.mockito.runners.MockitoJUnitRunner;
  37 import org.opendaylight.ovsdb.lib.LockAquisitionCallback;
  38 import org.opendaylight.ovsdb.lib.LockStolenCallback;
  39 import org.opendaylight.ovsdb.lib.MonitorCallBack;
  40 import org.opendaylight.ovsdb.lib.MonitorHandle;
  41 import org.opendaylight.ovsdb.lib.OvsdbClient;
  42 import org.opendaylight.ovsdb.lib.OvsdbConnectionInfo;
  43 import org.opendaylight.ovsdb.lib.message.TableUpdates;
  44 import org.opendaylight.ovsdb.lib.operations.OperationResult;
  45 import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
  46 import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
  47 import org.opendaylight.ovsdb.lib.schema.GenericTableSchema;
  48 import org.opendaylight.ovsdb.southbound.ovsdb.transact.BridgeOperationalState;
  49 import org.opendaylight.ovsdb.southbound.ovsdb.transact.DataChangeEvent;
  50 import org.opendaylight.ovsdb.southbound.ovsdb.transact.TransactCommand;
  51 import org.opendaylight.ovsdb.southbound.ovsdb.transact.TransactInvoker;
  52 import org.opendaylight.ovsdb.southbound.transactions.md.TransactionInvoker;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfo;
  54 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  55 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  56 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
  57 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  58 import org.powermock.reflect.Whitebox;
  59
  60 @RunWith(MockitoJUnitRunner.class)
  61 public class OvsdbConnectionInstanceTest {
  62
  63     @Mock private OvsdbConnectionInstance ovsdbConnectionInstance;
  64     @Mock private OvsdbClient client;
  65     @Mock private ConnectionInfo connectionInfo;
  66     @Mock private TransactionInvoker txInvoker;
  67     @Mock private MonitorCallBack callback;
  68     @Mock private ConnectionInfo key;
  69     @Mock private InstanceIdentifier<Node> instanceIdentifier;
  70     private Map<DatabaseSchema,TransactInvoker> transactInvokers;
  71
  72     @Before
  73     public void setUp() throws Exception {
  74         ovsdbConnectionInstance = mock(OvsdbConnectionInstance.class, Mockito.CALLS_REAL_METHODS);
  75         getField(OvsdbConnectionInstance.class, "txInvoker").set(ovsdbConnectionInstance, txInvoker);
  76         getField(OvsdbConnectionInstance.class, "connectionInfo").set(ovsdbConnectionInstance, key);
  77         getField(OvsdbConnectionInstance.class, "instanceIdentifier").set(ovsdbConnectionInstance, instanceIdentifier);
  78         getField(OvsdbConnectionInstance.class, "hasDeviceOwnership").set(ovsdbConnectionInstance, false);
  79     }
  80
  81     @Test
  82     @SuppressWarnings({ "unchecked", "rawtypes" })
  83     public void testTransact() throws Exception {
  84         transactInvokers = new HashMap();
  85
  86         // init instance variables
  87         TransactInvoker transactInvoker1 = mock(TransactInvoker.class);
  88         TransactInvoker transactInvoker2 = mock(TransactInvoker.class);
  89         transactInvokers.put(mock(DatabaseSchema.class), transactInvoker1);
  90         transactInvokers.put(mock(DatabaseSchema.class), transactInvoker2);
  91         getField(OvsdbConnectionInstance.class, "transactInvokers").set(ovsdbConnectionInstance , transactInvokers);
  92
  93         TransactCommand command = mock(TransactCommand.class);
  94         ovsdbConnectionInstance.transact(command, mock(BridgeOperationalState.class), mock(DataChangeEvent.class),
  95                 mock(InstanceIdentifierCodec.class));
  96         verify(transactInvoker1).invoke(any(TransactCommand.class), any(BridgeOperationalState.class),
  97                 any(DataChangeEvent.class), any(InstanceIdentifierCodec.class));
  98         verify(transactInvoker2).invoke(any(TransactCommand.class), any(BridgeOperationalState.class),
  99                 any(DataChangeEvent.class), any(InstanceIdentifierCodec.class));
 100     }
 101
 102     @Test
 103     @SuppressWarnings("unchecked")
 104     public void testRegisterCallbacks() throws Exception {
 105         InstanceIdentifierCodec instanceIdentifierCodec = mock(InstanceIdentifierCodec.class);
 106
 107         // callback not null case
 108         getField(OvsdbConnectionInstance.class, "callback").set(ovsdbConnectionInstance , callback);
 109         ovsdbConnectionInstance.registerCallbacks(instanceIdentifierCodec);
 110         verify(ovsdbConnectionInstance, times(0)).getDatabases();
 111
 112         // callback null case
 113         getField(OvsdbConnectionInstance.class, "callback").set(ovsdbConnectionInstance , null);
 114         ListenableFuture<List<String>> listenableFuture = mock(ListenableFuture.class);
 115         List<String> databases = new ArrayList<>();
 116         databases.add("Open_vSwitch");
 117         databases.add("");
 118         doReturn(listenableFuture).when(ovsdbConnectionInstance).getDatabases();
 119         when(listenableFuture.get()).thenReturn(databases);
 120
 121         ListenableFuture<DatabaseSchema> listenableDbSchema = mock(ListenableFuture.class);
 122         DatabaseSchema dbSchema = mock(DatabaseSchema.class);
 123         doReturn(listenableDbSchema).when(ovsdbConnectionInstance).getSchema(anyString());
 124         when(listenableDbSchema.get()).thenReturn(dbSchema);
 125
 126         doNothing().when(ovsdbConnectionInstance).monitorTables(anyString(), any(DatabaseSchema.class));
 127         ovsdbConnectionInstance.registerCallbacks(instanceIdentifierCodec);
 128         verify(ovsdbConnectionInstance, times(1)).monitorTables(anyString(), any(DatabaseSchema.class));
 129     }
 130
 131     @Test
 132     @SuppressWarnings({ "unchecked", "rawtypes" })
 133     public void testCreateTransactInvokers() throws Exception {
 134         // transactInvokers not null case
 135         transactInvokers = new HashMap();
 136         getField(OvsdbConnectionInstance.class, "transactInvokers").set(ovsdbConnectionInstance , transactInvokers);
 137         ovsdbConnectionInstance.createTransactInvokers();
 138         verify(ovsdbConnectionInstance, times(0)).getSchema(anyString());
 139
 140         // transactInvokers null case
 141         getField(OvsdbConnectionInstance.class, "transactInvokers").set(ovsdbConnectionInstance , null);
 142
 143         ListenableFuture<DatabaseSchema> listenableDbSchema = mock(ListenableFuture.class);
 144         DatabaseSchema dbSchema = mock(DatabaseSchema.class);
 145         doReturn(listenableDbSchema).when(ovsdbConnectionInstance).getSchema(anyString());
 146         when(listenableDbSchema.get()).thenReturn(dbSchema);
 147
 148         ovsdbConnectionInstance.createTransactInvokers();
 149         verify(ovsdbConnectionInstance).getSchema(anyString());
 150
 151         Map<DatabaseSchema, TransactInvoker> testTransactInvokers = Whitebox.getInternalState(ovsdbConnectionInstance,
 152                 "transactInvokers");
 153         assertEquals("Error, size of the hashmap is incorrect", 1, testTransactInvokers.size());
 154     }
 155
 156     @Test
 157     @SuppressWarnings("unchecked")
 158     public void testMonitorAllTables() throws Exception {
 159         Set<String> tables = new HashSet<>();
 160         tables.add("Open_vSwitch");
 161         tables.add("Port");
 162         DatabaseSchema dbSchema = mock(DatabaseSchema.class);
 163         when(dbSchema.getName()).thenReturn(SouthboundConstants.OPEN_V_SWITCH);
 164         when(dbSchema.getTables()).thenReturn(tables);
 165         GenericTableSchema tableSchema = mock(GenericTableSchema.class);
 166         when(dbSchema.table(anyString(), eq(GenericTableSchema.class))).thenReturn(tableSchema);
 167
 168         Set<String> columns = new HashSet<>();
 169         columns.add("columnName1");
 170         columns.add("columnName2");
 171         columns.add("_version");
 172         columns.add("statistics");
 173         when(tableSchema.getColumns()).thenReturn(columns);
 174
 175         TableUpdates tableUpdates = mock(TableUpdates.class);
 176         doReturn(tableUpdates).when(ovsdbConnectionInstance).monitor(any(DatabaseSchema.class), any(List.class),
 177             any(MonitorCallBack.class));
 178         getField(OvsdbConnectionInstance.class, "callback").set(ovsdbConnectionInstance, callback);
 179         doNothing().when(callback).update(any(TableUpdates.class), any(DatabaseSchema.class));
 180
 181         Whitebox.invokeMethod(ovsdbConnectionInstance, "monitorTables", "database", dbSchema);
 182         verify(ovsdbConnectionInstance, times(1)).monitorTables(anyString(), any(DatabaseSchema.class));
 183     }
 184
 185     @SuppressWarnings({ "unchecked" })
 186     @Test
 187     public void testOvsdbConnectionInstance() throws Exception {
 188         getField(OvsdbConnectionInstance.class, "client").set(ovsdbConnectionInstance, client);
 189
 190         // test getDatabases()
 191         ListenableFuture<List<String>> listenableFuture = mock(ListenableFuture.class);
 192         when(client.getDatabases()).thenReturn(listenableFuture);
 193         assertEquals("Error, did not return correct ListenableFuture<List<String>> object", listenableFuture,
 194                 ovsdbConnectionInstance.getDatabases());
 195         verify(client).getDatabases();
 196
 197         // test getSchema()
 198         ListenableFuture<DatabaseSchema> futureDatabaseSchema = mock(ListenableFuture.class);
 199         when(client.getSchema(anyString())).thenReturn(futureDatabaseSchema);
 200         assertEquals("Error, did not return correct ListenableFuture<DatabaseSchema> object", futureDatabaseSchema,
 201                 ovsdbConnectionInstance.getSchema(anyString()));
 202         verify(client).getSchema(anyString());
 203
 204         // test transactBuilder()
 205         TransactionBuilder transactionBuilder = mock(TransactionBuilder.class);
 206         when(client.transactBuilder(any(DatabaseSchema.class))).thenReturn(transactionBuilder);
 207         assertEquals("Error, did not return correct TransactionBuilder object", transactionBuilder,
 208                 ovsdbConnectionInstance.transactBuilder(any(DatabaseSchema.class)));
 209         verify(client).transactBuilder(any(DatabaseSchema.class));
 210
 211         // test transact()
 212         ListenableFuture<List<OperationResult>> futureOperationResult = mock(ListenableFuture.class);
 213         when(client.transact(any(DatabaseSchema.class), any(List.class))).thenReturn(futureOperationResult);
 214         assertEquals("Error, did not return correct ListenableFuture<List<OperationResult>> object",
 215                 futureOperationResult, ovsdbConnectionInstance.transact(any(DatabaseSchema.class), any(List.class)));
 216         verify(client).transact(any(DatabaseSchema.class), any(List.class));
 217
 218         // test monitor()
 219         TableUpdates tableUpdates = mock(TableUpdates.class);
 220         when(client.monitor(any(DatabaseSchema.class), any(List.class), any(MonitorCallBack.class)))
 221                 .thenReturn(tableUpdates);
 222         assertEquals("Error, did not return correct TableUpdates object", tableUpdates, ovsdbConnectionInstance
 223                 .monitor(any(DatabaseSchema.class), any(List.class), any(MonitorCallBack.class)));
 224         verify(client).monitor(any(DatabaseSchema.class), any(List.class), any(MonitorCallBack.class));
 225
 226         // test cancelMonitor()
 227         doNothing().when(client).cancelMonitor(any(MonitorHandle.class));
 228         MonitorHandle monitorHandle = mock(MonitorHandle.class);
 229         ovsdbConnectionInstance.cancelMonitor(monitorHandle);
 230         verify(client).cancelMonitor(any(MonitorHandle.class));
 231
 232         // test lock()
 233         doNothing().when(client).lock(anyString(), any(LockAquisitionCallback.class), any(LockStolenCallback.class));
 234         LockAquisitionCallback lockAquisitionCallback = mock(LockAquisitionCallback.class);
 235         LockStolenCallback lockStolenCallback = mock(LockStolenCallback.class);
 236         ovsdbConnectionInstance.lock("lockId", lockAquisitionCallback, lockStolenCallback);
 237         verify(client).lock(anyString(), any(LockAquisitionCallback.class), any(LockStolenCallback.class));
 238
 239         // test steal()
 240         ListenableFuture<Boolean> futureBoolean = mock(ListenableFuture.class);
 241         when(client.steal(anyString())).thenReturn(futureBoolean);
 242         assertEquals("Error, did not return correct ListenableFuture<Boolean> object", futureBoolean,
 243                 ovsdbConnectionInstance.steal(anyString()));
 244         verify(client).steal(anyString());
 245
 246         // test unLock()
 247         when(client.unLock(anyString())).thenReturn(futureBoolean);
 248         assertEquals("Error, did not return correct ListenableFuture<Boolean> object", futureBoolean,
 249                 ovsdbConnectionInstance.unLock(anyString()));
 250         verify(client).unLock(anyString());
 251
 252         // test isActive()
 253         when(client.isActive()).thenReturn(true);
 254         assertEquals("Error, does not match isActive()", true, ovsdbConnectionInstance.isActive());
 255         verify(client).isActive();
 256
 257         // test disconnect()
 258         doNothing().when(client).disconnect();
 259         ovsdbConnectionInstance.disconnect();
 260         verify(client).disconnect();
 261
 262         // test getDatabaseSchema()
 263         DatabaseSchema databaseSchema = mock(DatabaseSchema.class);
 264         when(client.getDatabaseSchema(anyString())).thenReturn(databaseSchema);
 265         assertEquals("Error, did not return correct DatabaseSchema object", databaseSchema,
 266                 ovsdbConnectionInstance.getDatabaseSchema(anyString()));
 267         verify(client).getDatabaseSchema(anyString());
 268
 269         // test getConnectionInfo()
 270         OvsdbConnectionInfo ovsdbConnectionInfo = mock(OvsdbConnectionInfo.class);
 271         when(client.getConnectionInfo()).thenReturn(ovsdbConnectionInfo);
 272         assertEquals("Error, did not return correct OvsdbConnectionInfo object", ovsdbConnectionInfo,
 273                 ovsdbConnectionInstance.getConnectionInfo());
 274         verify(client).getConnectionInfo();
 275
 276         // test getMDConnectionInfo()
 277         assertEquals("Error, incorrect connectionInfo", key, ovsdbConnectionInstance.getMDConnectionInfo());
 278
 279         // test setMDConnectionInfo()
 280         ovsdbConnectionInstance.setMDConnectionInfo(key);
 281         assertEquals("Error, incorrect ConnectionInfo", key,
 282                 Whitebox.getInternalState(ovsdbConnectionInstance, "connectionInfo"));
 283
 284         // test getInstanceIdentifier()
 285         assertEquals("Error, incorrect instanceIdentifier", instanceIdentifier,
 286                 ovsdbConnectionInstance.getInstanceIdentifier());
 287
 288         // test getNodeId()
 289         NodeId nodeId = mock(NodeId.class);
 290         NodeKey nodeKey = new NodeKey(nodeId);
 291         doReturn(nodeKey).when(ovsdbConnectionInstance).getNodeKey();
 292         when(ovsdbConnectionInstance.getNodeKey()).thenReturn(nodeKey);
 293         assertEquals("Error, incorrect NodeId object", nodeId, ovsdbConnectionInstance.getNodeId());
 294
 295         // test setInstanceIdentifier()
 296         ovsdbConnectionInstance.setInstanceIdentifier(instanceIdentifier);
 297         assertEquals("Error, incorrect instanceIdentifier", instanceIdentifier,
 298                 Whitebox.getInternalState(ovsdbConnectionInstance, "instanceIdentifier"));
 299
 300         // test monitor()
 301         when(ovsdbConnectionInstance.monitor(any(DatabaseSchema.class), any(List.class), any(MonitorHandle.class),
 302                 any(MonitorCallBack.class))).thenReturn(null);
 303         assertNull(ovsdbConnectionInstance.monitor(any(DatabaseSchema.class), any(List.class), any(MonitorHandle.class),
 304                 any(MonitorCallBack.class)));
 305     }
 306 }