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

   1 package org.opendaylight.ovsdb.southbound;
   2
   3 import static org.junit.Assert.assertEquals;
   4 import static org.mockito.Mockito.doNothing;
   5 import static org.mockito.Mockito.mock;
   6 import static org.mockito.Mockito.times;
   7 import static org.mockito.Mockito.verify;
   8 import static org.mockito.Matchers.any;
   9 import static org.mockito.Mockito.when;
  10 import static org.mockito.Mockito.reset;
  11
  12 import java.util.ArrayList;
  13 import java.util.HashMap;
  14 import java.util.HashSet;
  15 import java.util.List;
  16 import java.util.Map;
  17 import java.util.Set;
  18
  19 import org.junit.Before;
  20 import org.junit.Test;
  21 import org.junit.runner.RunWith;
  22 import org.mockito.Mock;
  23 import org.mockito.Mockito;
  24 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  25 import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
  26 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
  27 import org.opendaylight.ovsdb.lib.OvsdbClient;
  28 import org.opendaylight.ovsdb.southbound.ovsdb.transact.BridgeOperationalState;
  29 import org.opendaylight.ovsdb.southbound.ovsdb.transact.DataChangesManagedByOvsdbNodeEvent;
  30 import org.opendaylight.ovsdb.southbound.ovsdb.transact.TransactCommandAggregator;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfo;
  34 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  35 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  36 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
  37 import org.opendaylight.yangtools.concepts.ListenerRegistration;
  38 import org.opendaylight.yangtools.yang.binding.DataObject;
  39 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  40 import org.powermock.api.mockito.PowerMockito;
  41 import org.powermock.api.support.membermodification.MemberMatcher;
  42 import org.powermock.api.support.membermodification.MemberModifier;
  43 import org.powermock.core.classloader.annotations.PrepareForTest;
  44 import org.powermock.modules.junit4.PowerMockRunner;
  45 import org.powermock.reflect.Whitebox;
  46
  47 @PrepareForTest({InstanceIdentifier.class, OvsdbDataChangeListener.class, SouthboundMapper.class})
  48 @RunWith(PowerMockRunner.class)
  49 public class OvsdbDataChangeListenerTest {
  50     @Mock private ListenerRegistration<DataChangeListener> registration;
  51     @Mock private OvsdbConnectionManager cm;
  52     @Mock private DataBroker db;
  53     @Mock private OvsdbDataChangeListener ovsdbDataChangeListener;
  54
  55     @Before
  56     public void setUp() throws Exception {
  57         ovsdbDataChangeListener = PowerMockito.mock(OvsdbDataChangeListener.class, Mockito.CALLS_REAL_METHODS);
  58         MemberModifier.field(OvsdbDataChangeListener.class, "cm").set(ovsdbDataChangeListener, cm);
  59         MemberModifier.field(OvsdbDataChangeListener.class, "db").set(ovsdbDataChangeListener, db);
  60         MemberModifier.field(OvsdbDataChangeListener.class, "registration").set(ovsdbDataChangeListener, registration);
  61     }
  62
  63     @Test
  64     public void testClose() throws Exception {
  65         doNothing().when(registration).close();
  66         ovsdbDataChangeListener.close();
  67         verify(registration).close();
  68     }
  69
  70     @SuppressWarnings({ "unchecked" })
  71     @Test
  72     public void testOnDataChanged() throws Exception {
  73         AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes = mock(AsyncDataChangeEvent.class);
  74         Map<InstanceIdentifier<?>, DataObject> map = new HashMap<InstanceIdentifier<?>, DataObject>();
  75         InstanceIdentifier<?> iid1 = mock(InstanceIdentifier.class);
  76         OvsdbNodeAugmentation ovsdbNode = mock(OvsdbNodeAugmentation.class);
  77         map.put(iid1, ovsdbNode);
  78         when(changes.getCreatedData()).thenReturn(map);
  79         ConnectionInfo key = mock(ConnectionInfo.class);
  80         when(ovsdbNode.getConnectionInfo()).thenReturn(key);
  81
  82         //suppress calls to these functions
  83         MemberModifier.suppress(MemberMatcher.method(OvsdbDataChangeListener.class, "connect", AsyncDataChangeEvent.class));
  84         MemberModifier.suppress(MemberMatcher.method(OvsdbDataChangeListener.class, "updateConnections", AsyncDataChangeEvent.class));
  85         MemberModifier.suppress(MemberMatcher.method(OvsdbDataChangeListener.class, "updateData", AsyncDataChangeEvent.class));
  86         MemberModifier.suppress(MemberMatcher.method(OvsdbDataChangeListener.class, "disconnect", AsyncDataChangeEvent.class));
  87         MemberModifier.suppress(MemberMatcher.method(OvsdbDataChangeListener.class, "init", AsyncDataChangeEvent.class));
  88
  89         //iid not null case
  90         InstanceIdentifier<Node> iid = mock(InstanceIdentifier.class);
  91         when(cm.getInstanceIdentifier(any(ConnectionInfo.class))).thenReturn(iid);
  92
  93         ovsdbDataChangeListener.onDataChanged(changes);
  94         verify(changes).getCreatedData();
  95         verify(ovsdbNode).getConnectionInfo();
  96         verify(cm).getInstanceIdentifier(any(ConnectionInfo.class));
  97         PowerMockito.verifyPrivate(ovsdbDataChangeListener, times(0)).invoke("connect", any(AsyncDataChangeEvent.class));
  98
  99         //iid null case
 100         when(cm.getInstanceIdentifier(any(ConnectionInfo.class))).thenReturn(null);
 101         ovsdbDataChangeListener.onDataChanged(changes);
 102
 103         PowerMockito.verifyPrivate(ovsdbDataChangeListener, times(1)).invoke("connect", any(AsyncDataChangeEvent.class));
 104         PowerMockito.verifyPrivate(ovsdbDataChangeListener, times(1)).invoke("updateConnections", any(AsyncDataChangeEvent.class));
 105         PowerMockito.verifyPrivate(ovsdbDataChangeListener, times(1)).invoke("updateData", any(AsyncDataChangeEvent.class));
 106         PowerMockito.verifyPrivate(ovsdbDataChangeListener, times(1)).invoke("disconnect", any(AsyncDataChangeEvent.class));
 107         PowerMockito.verifyPrivate(ovsdbDataChangeListener, times(1)).invoke("init", any(AsyncDataChangeEvent.class));
 108     }
 109
 110     @SuppressWarnings("unchecked")
 111     @Test
 112     public void testUpdateData() throws Exception {
 113         AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes = mock(AsyncDataChangeEvent.class);
 114         Map<InstanceIdentifier<Node>, OvsdbConnectionInstance> map = new HashMap<InstanceIdentifier<Node>, OvsdbConnectionInstance>();
 115         InstanceIdentifier<Node> iid = mock(InstanceIdentifier.class);
 116         OvsdbConnectionInstance connectionInstance = mock(OvsdbConnectionInstance.class);
 117         map.put(iid, connectionInstance);
 118
 119         MemberModifier.suppress(MemberMatcher.method(OvsdbDataChangeListener.class, "connectionInstancesFromChanges", AsyncDataChangeEvent.class));
 120         when(ovsdbDataChangeListener.connectionInstancesFromChanges(any(AsyncDataChangeEvent.class))).thenReturn(map);
 121         TransactCommandAggregator transactCommandAggregator = mock(TransactCommandAggregator.class);
 122         BridgeOperationalState bridgeOperationalState = mock(BridgeOperationalState.class);
 123         DataChangesManagedByOvsdbNodeEvent dataChangesManagedByOvsdbNodeEvent = mock(DataChangesManagedByOvsdbNodeEvent.class);
 124         PowerMockito.whenNew(DataChangesManagedByOvsdbNodeEvent.class).withArguments(any(InstanceIdentifier.class), any(AsyncDataChangeEvent.class)).thenReturn(dataChangesManagedByOvsdbNodeEvent);
 125         PowerMockito.whenNew(BridgeOperationalState.class).withArguments(any(DataBroker.class), any(AsyncDataChangeEvent.class)).thenReturn(bridgeOperationalState);
 126         PowerMockito.whenNew(TransactCommandAggregator.class).withArguments(any(BridgeOperationalState.class), any(AsyncDataChangeEvent.class)).thenReturn(transactCommandAggregator);
 127
 128         when(connectionInstance.getInstanceIdentifier()).thenReturn(iid);
 129         doNothing().when(connectionInstance).transact(transactCommandAggregator);
 130
 131         Whitebox.invokeMethod(ovsdbDataChangeListener, "updateData", changes);
 132         verify(connectionInstance).transact(transactCommandAggregator);
 133         verify(ovsdbDataChangeListener).connectionInstancesFromChanges(changes);
 134     }
 135
 136     @SuppressWarnings({ "rawtypes", "unchecked" })
 137     @Test
 138     public void testDisconnectAndConnectAndInit() throws Exception {
 139         AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes = mock(AsyncDataChangeEvent.class);
 140         Map<InstanceIdentifier<?>, DataObject> originalDataObject = new HashMap<InstanceIdentifier<?>, DataObject>();
 141         Set<InstanceIdentifier<?>> iiD = new HashSet<InstanceIdentifier<?>>();
 142         InstanceIdentifier instanceIdentifier = mock(InstanceIdentifier.class);
 143         OvsdbNodeAugmentation ovsdbNode = mock(OvsdbNodeAugmentation.class);
 144         iiD.add(instanceIdentifier);
 145         originalDataObject.put(instanceIdentifier, ovsdbNode);
 146         when(changes.getRemovedPaths()).thenReturn(iiD);
 147         when(changes.getOriginalData()).thenReturn(originalDataObject);
 148         doNothing().when(cm).disconnect(any(OvsdbNodeAugmentation.class));
 149
 150         //test disconnect()
 151         Whitebox.invokeMethod(ovsdbDataChangeListener, "disconnect", changes);
 152         verify(cm).disconnect(any(OvsdbNodeAugmentation.class));
 153
 154         //test connect()
 155         when(changes.getCreatedData()).thenReturn(originalDataObject);
 156         Whitebox.invokeMethod(ovsdbDataChangeListener, "connect", changes);
 157         verify(cm).disconnect(any(OvsdbNodeAugmentation.class));
 158
 159         //test init
 160         ConnectionInfo connectionInfo = mock(ConnectionInfo.class);
 161         when(ovsdbNode.getConnectionInfo()).thenReturn(connectionInfo);
 162         Whitebox.invokeMethod(ovsdbDataChangeListener, "init", changes);
 163         verify(cm).init(any(ConnectionInfo.class));
 164     }
 165
 166     @SuppressWarnings({ "rawtypes", "unchecked" })
 167     @Test
 168     public void testUpdateConnections() throws Exception {
 169         AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes = mock(AsyncDataChangeEvent.class);
 170         Map<InstanceIdentifier<?>, DataObject> map = new HashMap<InstanceIdentifier<?>, DataObject>();
 171         InstanceIdentifier instanceIdentifier = mock(InstanceIdentifier.class);
 172         OvsdbNodeAugmentation value = mock(OvsdbNodeAugmentation.class);
 173         map.put(instanceIdentifier, value);
 174
 175         when(changes.getUpdatedData()).thenReturn(map);
 176         OvsdbClient client = mock(OvsdbClient.class);
 177         ConnectionInfo connectionInfo = mock(ConnectionInfo.class);
 178         when(value.getConnectionInfo()).thenReturn(connectionInfo);
 179         when(cm.getClient(any(ConnectionInfo.class))).thenReturn(null);
 180
 181         when(changes.getOriginalData()).thenReturn(map);
 182         doNothing().when(cm).disconnect(any(OvsdbNodeAugmentation.class));
 183         when(cm.connect(any(InstanceIdentifier.class), any(OvsdbNodeAugmentation.class))).thenReturn(client);
 184         Whitebox.invokeMethod(ovsdbDataChangeListener, "updateConnections", changes);
 185         verify(cm).connect(any(InstanceIdentifier.class), any(OvsdbNodeAugmentation.class));
 186         verify(cm).disconnect(any(OvsdbNodeAugmentation.class));
 187     }
 188
 189     @SuppressWarnings("unchecked")
 190     @Test
 191     public void testConnectionInstancesFromChanges() throws Exception {
 192         AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes = mock(AsyncDataChangeEvent.class);
 193         Map<InstanceIdentifier<Node>,OvsdbConnectionInstance> testResultMap = new HashMap<InstanceIdentifier<Node>,OvsdbConnectionInstance>();
 194         Map<InstanceIdentifier<Node>,OvsdbConnectionInstance> map1 = new HashMap<InstanceIdentifier<Node>,OvsdbConnectionInstance>();
 195         InstanceIdentifier<Node> key1 = mock(InstanceIdentifier.class);
 196         OvsdbConnectionInstance value1 = mock(OvsdbConnectionInstance.class);
 197         map1.put(key1, value1);
 198
 199         MemberModifier.suppress(MemberMatcher.method(OvsdbDataChangeListener.class, "connectionInstancesFromMap", HashMap.class));
 200         when(ovsdbDataChangeListener.connectionInstancesFromMap(any(HashMap.class))).thenReturn(map1);
 201
 202         testResultMap.put(key1, value1);
 203         reset(ovsdbDataChangeListener);
 204         assertEquals("Error returning correct Map", testResultMap, ovsdbDataChangeListener.connectionInstancesFromChanges(changes));
 205         verify(ovsdbDataChangeListener, times(3)).connectionInstancesFromMap(any(HashMap.class));
 206     }
 207
 208     @SuppressWarnings("unchecked")
 209     @Test
 210     public void testConnectionInstancesFromMap() {
 211         reset(cm);
 212         Map<InstanceIdentifier<?>,DataObject> map = new HashMap<InstanceIdentifier<?>,DataObject>();
 213         Node node = mock(Node.class);
 214         InstanceIdentifier<Node> iid = mock(InstanceIdentifier.class);
 215         map.put(iid, node);
 216         OvsdbConnectionInstance client = mock(OvsdbConnectionInstance.class);
 217
 218         Map<InstanceIdentifier<Node>,OvsdbConnectionInstance> testResultMap = new HashMap<InstanceIdentifier<Node>,OvsdbConnectionInstance>();
 219         testResultMap.put(iid, client);
 220
 221         //bridge and client not null case
 222         when(cm.getConnectionInstance(any(OvsdbBridgeAugmentation.class))).thenReturn(client);
 223         OvsdbBridgeAugmentation bridge = mock(OvsdbBridgeAugmentation.class);
 224         when(node.getAugmentation(OvsdbBridgeAugmentation.class)).thenReturn(bridge);
 225         assertEquals("Error returning correct Map", testResultMap, ovsdbDataChangeListener.connectionInstancesFromMap(map));
 226         verify(cm).getConnectionInstance(any(OvsdbBridgeAugmentation.class));
 227
 228         //bridge null, ovsnode not null and client not null case
 229         when(node.getAugmentation(OvsdbBridgeAugmentation.class)).thenReturn(null);
 230         OvsdbNodeAugmentation ovsNode = mock(OvsdbNodeAugmentation.class);
 231         ConnectionInfo connectionInfo = mock(ConnectionInfo.class);
 232         when(node.getAugmentation(OvsdbNodeAugmentation.class)).thenReturn(ovsNode);
 233         when(ovsNode.getConnectionInfo()).thenReturn(connectionInfo);
 234         when(cm.getConnectionInstance(any(ConnectionInfo.class))).thenReturn(client);
 235         assertEquals("Error returning correct Map", testResultMap, ovsdbDataChangeListener.connectionInstancesFromMap(map));
 236         verify(cm).getConnectionInstance(any(ConnectionInfo.class));
 237
 238         //bridge null, ovsnode null, and client not null case
 239         when(node.getAugmentation(OvsdbNodeAugmentation.class)).thenReturn(null);
 240         List<TerminationPoint> terminationPoint = new ArrayList<TerminationPoint>();
 241         terminationPoint.add(0, mock(TerminationPoint.class));
 242         when(node.getTerminationPoint()).thenReturn(terminationPoint);
 243         PowerMockito.mockStatic(SouthboundMapper.class);
 244         InstanceIdentifier<Node> nodeIid = mock(InstanceIdentifier.class);
 245         when(node.getNodeId()).thenReturn(mock(NodeId.class));
 246         when(SouthboundMapper.createInstanceIdentifier(any(NodeId.class))).thenReturn(nodeIid);
 247         when(cm.getConnectionInstance(any(InstanceIdentifier.class))).thenReturn(client);
 248         assertEquals("Error returning correct Map", testResultMap, ovsdbDataChangeListener.connectionInstancesFromMap(map));
 249         verify(node).getTerminationPoint();
 250         verify(cm).getConnectionInstance(any(InstanceIdentifier.class));
 251     }
 252 }