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