southbound/southbound-impl/src/test/java/org/opendaylight/ovsdb/southbound/SouthboundMapperTest.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.assertNotNull;
  13 import static org.junit.Assert.assertNull;
  14 import static org.junit.Assert.assertTrue;
  15 import static org.mockito.Matchers.any;
  16 import static org.mockito.Matchers.anyString;
  17 import static org.mockito.Matchers.eq;
  18 import static org.mockito.Mockito.mock;
  19 import static org.mockito.Mockito.times;
  20 import static org.mockito.Mockito.when;
  21
  22 import java.net.Inet4Address;
  23 import java.net.Inet6Address;
  24 import java.net.InetAddress;
  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
  32 import org.junit.Before;
  33 import org.junit.Test;
  34 import org.junit.runner.RunWith;
  35 import org.mockito.Mockito;
  36 import org.mockito.invocation.InvocationOnMock;
  37 import org.mockito.stubbing.Answer;
  38 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  39 import org.opendaylight.ovsdb.lib.OvsdbClient;
  40 import org.opendaylight.ovsdb.lib.notation.Column;
  41 import org.opendaylight.ovsdb.lib.notation.UUID;
  42 import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
  43 import org.opendaylight.ovsdb.lib.schema.GenericTableSchema;
  44 import org.opendaylight.ovsdb.lib.schema.typed.TyperUtils;
  45 import org.opendaylight.ovsdb.schema.openvswitch.Bridge;
  46 import org.opendaylight.ovsdb.schema.openvswitch.Controller;
  47 import org.opendaylight.ovsdb.schema.openvswitch.Manager;
  48 import org.opendaylight.ovsdb.schema.openvswitch.OpenVSwitch;
  49 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
  50 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address;
  51 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv6Address;
  52 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.PortNumber;
  53 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Uri;
  54 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.DatapathId;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.DatapathTypeBase;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.DatapathTypeNetdev;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.DatapathTypeSystem;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeInternal;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeVxlan;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeProtocolBase;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeProtocolOpenflow10;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntry;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntryBuilder;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntry;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntryBuilder;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfo;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfoBuilder;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagerEntry;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagerEntryBuilder;
  73 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
  74 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  75 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
  76 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
  77 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  78 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
  79 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  80 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
  81 import org.powermock.api.mockito.PowerMockito;
  82 import org.powermock.core.classloader.annotations.PrepareForTest;
  83 import org.powermock.modules.junit4.PowerMockRunner;
  84 import org.powermock.reflect.Whitebox;
  85
  86 @PrepareForTest({SouthboundMapper.class, InstanceIdentifier.class, Inet4Address.class,  Inet6Address.class, SouthboundUtil.class, SouthboundConstants.class, TyperUtils.class})
  87 @RunWith(PowerMockRunner.class)
  88 public class SouthboundMapperTest {
  89
  90
  91     @Before
  92     public void setUp() {
  93         PowerMockito.mockStatic(SouthboundMapper.class, Mockito.CALLS_REAL_METHODS);
  94     }
  95
  96     @Test
  97     public void testCreateManagedNodeId() throws Exception {
  98         PowerMockito.mockStatic(SouthboundMapper.class, Mockito.RETURNS_MOCKS);
  99         assertTrue("Returned value is not an NodeId", SouthboundMapper.createManagedNodeId(null) instanceof NodeId);
 100     }
 101
 102     @Test
 103     public void testCreateIpAddress() throws Exception {
 104         IpAddress ip = mock(IpAddress.class);
 105
 106         //test for createIpAddress(Inet4Address address)
 107         InetAddress addressInet4 = PowerMockito.mock(Inet4Address.class);
 108         when(addressInet4.getHostAddress()).thenReturn("127.0.0.1");
 109         Ipv4Address ipv4Add = mock(Ipv4Address.class);
 110         PowerMockito.whenNew(Ipv4Address.class).withAnyArguments().thenReturn(ipv4Add);
 111         PowerMockito.whenNew(IpAddress.class).withAnyArguments().thenReturn(ip);
 112         assertEquals("Incorrect IP address received", ip, SouthboundMapper.createIpAddress(addressInet4));
 113     }
 114
 115     @Test
 116     public void testCreateInstanceIdentifier() throws Exception {
 117         assertTrue(SouthboundMapper.createInstanceIdentifier(mock(NodeId.class)) instanceof InstanceIdentifier);
 118     }
 119
 120     @SuppressWarnings("unchecked")
 121     @Test
 122     public void testCreateInstanceIdentifier1() throws Exception {
 123         OvsdbConnectionInstance client = mock(OvsdbConnectionInstance.class, Mockito.RETURNS_DEEP_STUBS);
 124         Bridge bridge = mock(Bridge.class);
 125         InstanceIdentifier<Node> iid = mock(InstanceIdentifier.class);
 126
 127         //when bridge is not empty
 128         Column<GenericTableSchema, Map<String, String>> column = mock(Column.class);
 129         when(bridge.getExternalIdsColumn()).thenReturn(column);
 130         Map<String, String> map = new HashMap<>();
 131         map.put(SouthboundConstants.IID_EXTERNAL_ID_KEY, "IID_EXTERNAL_ID_KEY");
 132         when(column.getData()).thenReturn(map);
 133         PowerMockito.mockStatic(SouthboundUtil.class);
 134         when((InstanceIdentifier<Node>) SouthboundUtil.deserializeInstanceIdentifier(anyString())).thenReturn(iid);
 135         assertEquals("Incorrect Instance Identifier received", iid, SouthboundMapper.createInstanceIdentifier(client, bridge));
 136
 137         //when bridge is empty
 138         when(bridge.getExternalIdsColumn()).thenReturn(null);
 139         when(client.getNodeKey().getNodeId().getValue()).thenReturn("uri");
 140         when(bridge.getName()).thenReturn("bridgeName");
 141         PowerMockito.whenNew(Uri.class).withArguments(anyString()).thenReturn(mock(Uri.class));
 142         PowerMockito.whenNew(NodeId.class).withAnyArguments().thenReturn(mock(NodeId.class));
 143         PowerMockito.mockStatic(InstanceIdentifier.class);
 144         InstanceIdentifierBuilder<NetworkTopology> iidNetTopo = mock(InstanceIdentifierBuilder.class);
 145         InstanceIdentifierBuilder<Topology> iidTopo = mock(InstanceIdentifierBuilder.class);
 146         InstanceIdentifierBuilder<Node> iidNode = mock(InstanceIdentifierBuilder.class);
 147         PowerMockito.when(InstanceIdentifier.builder(NetworkTopology.class)).thenReturn(iidNetTopo);
 148         PowerMockito.whenNew(TopologyKey.class).withAnyArguments().thenReturn(mock(TopologyKey.class));
 149         when(iidNetTopo.child(eq(Topology.class), any(TopologyKey.class))).thenReturn(iidTopo);
 150         when(iidTopo.child(eq(Node.class), any(NodeKey.class))).thenReturn(iidNode);
 151         when(iidNode.build()).thenReturn(iid);
 152         assertEquals("Incorrect Instance Identifier received", iid, SouthboundMapper.createInstanceIdentifier(client, bridge));
 153     }
 154
 155     @SuppressWarnings("unchecked")
 156     @Test
 157     public void testCreateInstanceIdentifier2() throws Exception {
 158         OvsdbConnectionInstance client = mock(OvsdbConnectionInstance.class, Mockito.RETURNS_DEEP_STUBS);
 159         Controller controller = mock(Controller.class);
 160         InstanceIdentifier<Node> iid = mock(InstanceIdentifier.class);
 161
 162         //when controller is not empty
 163         Column<GenericTableSchema, Map<String, String>> column = mock(Column.class);
 164         when(controller.getExternalIdsColumn()).thenReturn(column);
 165         Map<String, String> map = new HashMap<>();
 166         map.put(SouthboundConstants.IID_EXTERNAL_ID_KEY, "IID_EXTERNAL_ID_KEY");
 167         when(column.getData()).thenReturn(map);
 168         PowerMockito.mockStatic(SouthboundUtil.class);
 169         when((InstanceIdentifier<Node>) SouthboundUtil.deserializeInstanceIdentifier(anyString())).thenReturn(iid);
 170         assertEquals("Incorrect Instance Identifier received", iid, SouthboundMapper.createInstanceIdentifier(client, controller, "bridgeName"));
 171
 172         //when controller is empty
 173         when(controller.getExternalIdsColumn()).thenReturn(null);
 174         when(client.getNodeKey().getNodeId().getValue()).thenReturn("uri");
 175         PowerMockito.whenNew(Uri.class).withArguments(anyString()).thenReturn(mock(Uri.class));
 176         PowerMockito.whenNew(NodeId.class).withAnyArguments().thenReturn(mock(NodeId.class));
 177         PowerMockito.mockStatic(InstanceIdentifier.class);
 178         InstanceIdentifierBuilder<NetworkTopology> iidNetTopo = mock(InstanceIdentifierBuilder.class);
 179         InstanceIdentifierBuilder<Topology> iidTopo = mock(InstanceIdentifierBuilder.class);
 180         InstanceIdentifierBuilder<Node> iidNode = mock(InstanceIdentifierBuilder.class);
 181         PowerMockito.when(InstanceIdentifier.builder(NetworkTopology.class)).thenReturn(iidNetTopo);
 182         PowerMockito.whenNew(TopologyKey.class).withAnyArguments().thenReturn(mock(TopologyKey.class));
 183         when(iidNetTopo.child(eq(Topology.class), any(TopologyKey.class))).thenReturn(iidTopo);
 184         when(iidTopo.child(eq(Node.class), any(NodeKey.class))).thenReturn(iidNode);
 185         when(iidNode.build()).thenReturn(iid);
 186         assertEquals("Incorrect Instance Identifier received", iid, SouthboundMapper.createInstanceIdentifier(client, controller, "bridgeName"));
 187     }
 188
 189     @Test
 190     public void testCreateInetAddress() throws Exception {
 191         IpAddress ip = mock(IpAddress.class, Mockito.RETURNS_DEEP_STUBS);
 192         when(ip.getIpv4Address()).thenReturn(mock(Ipv4Address.class));
 193         when(ip.getIpv4Address().getValue()).thenReturn("99.99.99.99");
 194         PowerMockito.mockStatic(InetAddress.class);
 195         InetAddress inetAddress = mock(InetAddress.class);
 196         when(InetAddress.getByName(anyString())).thenReturn(inetAddress);
 197
 198         //Ipv4Address not null
 199         assertEquals("Incorrect InetAddress received", inetAddress, SouthboundMapper.createInetAddress(ip));
 200
 201         //Ipv4Address null, Ipv6Address not null
 202         when(ip.getIpv4Address()).thenReturn(null);
 203         when(ip.getIpv6Address()).thenReturn(mock(Ipv6Address.class));
 204         when(ip.getIpv6Address().getValue()).thenReturn("0000:0000:0000:0000:0000:9999:FE1E:8329");
 205         assertEquals("Incorrect InetAddress received", inetAddress, SouthboundMapper.createInetAddress(ip));
 206     }
 207
 208     @SuppressWarnings("unchecked")
 209     @Test
 210     public void testCreateDatapathId() throws Exception {
 211         Bridge bridge = mock(Bridge.class);
 212         when(bridge.getDatapathIdColumn()).thenReturn(null);
 213         assertNull(SouthboundMapper.createDatapathId(bridge));
 214
 215         Column<GenericTableSchema, Set<String>> column = mock(Column.class);
 216         when(bridge.getDatapathIdColumn()).thenReturn(column);
 217         Set<String> set = new HashSet<>();
 218         set.add("dpid");
 219         when(column.getData()).thenReturn(set);
 220         assertNotNull(column.getData());
 221
 222         DatapathId dataPathId = mock(DatapathId.class);
 223
 224         //test createDatapathId(Set<String> dpids) and createDatapathId(String dpid)
 225         PowerMockito.whenNew(DatapathId.class).withAnyArguments().thenReturn(dataPathId);
 226         assertEquals(dataPathId, SouthboundMapper.createDatapathId(bridge));
 227     }
 228
 229     @Test
 230     public void testCreateDatapathType() throws Exception {
 231         OvsdbBridgeAugmentation mdsalbridge = mock(OvsdbBridgeAugmentation.class);
 232         PowerMockito.mockStatic(SouthboundConstants.class, Mockito.RETURNS_DEEP_STUBS);
 233         when(mdsalbridge.getDatapathType()).thenAnswer(new Answer<Class<? extends DatapathTypeBase>>() {
 234             public Class<? extends DatapathTypeBase> answer(
 235                     InvocationOnMock invocation) throws Throwable {
 236                 return DatapathTypeNetdev.class;
 237             }
 238         });
 239         assertEquals("netdev", SouthboundMapper.createDatapathType(mdsalbridge));
 240
 241         when(mdsalbridge.getDatapathType()).thenAnswer(new Answer<Class<? extends DatapathTypeBase>>() {
 242             public Class<? extends DatapathTypeBase> answer(
 243                     InvocationOnMock invocation) throws Throwable {
 244                 return DatapathTypeSystem.class;
 245             }
 246         });
 247         assertEquals("system", SouthboundMapper.createDatapathType(mdsalbridge));
 248     }
 249
 250     @Test
 251     public void testCreateDatapathType1() {
 252         assertEquals(DatapathTypeSystem.class, SouthboundMapper.createDatapathType(""));
 253         assertEquals(DatapathTypeSystem.class, SouthboundMapper.createDatapathType("system"));
 254         assertEquals(DatapathTypeNetdev.class, SouthboundMapper.createDatapathType("netdev"));
 255     }
 256
 257     @Test
 258     public void testCreateOvsdbBridgeProtocols() {
 259         OvsdbBridgeAugmentation ovsdbBridgeNode = mock(OvsdbBridgeAugmentation.class);
 260         List<ProtocolEntry> protocolList = new ArrayList<>();
 261         ProtocolEntry protocolEntry = mock(ProtocolEntry.class);
 262         protocolList.add(protocolEntry);
 263         when(ovsdbBridgeNode.getProtocolEntry()).thenReturn(protocolList);
 264         when(protocolEntry.getProtocol()).thenAnswer(new Answer<Class<? extends OvsdbBridgeProtocolBase>>() {
 265             public Class<? extends OvsdbBridgeProtocolBase> answer(
 266                     InvocationOnMock invocation) throws Throwable {
 267                 return OvsdbBridgeProtocolOpenflow10.class;
 268             }
 269         });
 270         Set<String> protocols = new HashSet<>();
 271         protocols.add("OpenFlow10");
 272         assertEquals(protocols, SouthboundMapper.createOvsdbBridgeProtocols(ovsdbBridgeNode));
 273     }
 274
 275     @Test
 276     public void testCreateInterfaceType() {
 277         assertEquals(InterfaceTypeInternal.class, SouthboundMapper.createInterfaceType("internal"));
 278         assertEquals(InterfaceTypeVxlan.class, SouthboundMapper.createInterfaceType("vxlan"));
 279     }
 280
 281     @Test
 282     public void testCreateOvsdbInterfaceType() {
 283         assertEquals("internal", SouthboundMapper.createOvsdbInterfaceType(InterfaceTypeInternal.class));
 284         assertEquals("vxlan", SouthboundMapper.createOvsdbInterfaceType(InterfaceTypeVxlan.class));
 285     }
 286
 287     @SuppressWarnings("unchecked")
 288     @Test
 289     public void testCreateMdsalProtocols() throws Exception {
 290         Bridge bridge = mock(Bridge.class);
 291         Set<String> value = new HashSet<>();
 292         value.add("OpenFlow10");
 293         Column<GenericTableSchema, Set<String>> column = mock(Column.class);
 294         when(bridge.getProtocolsColumn()).thenReturn(column);
 295         when(column.getData()).thenReturn(value);
 296
 297         List<ProtocolEntry> protocolList = new ArrayList<>();
 298         ProtocolEntry protoEntry = mock(ProtocolEntry.class);
 299         ProtocolEntryBuilder protocolEntryBuilder = mock(ProtocolEntryBuilder.class);
 300         PowerMockito.whenNew(ProtocolEntryBuilder.class).withNoArguments().thenReturn(protocolEntryBuilder);
 301         when(protocolEntryBuilder.setProtocol(any(Class.class))).thenReturn(protocolEntryBuilder);
 302         when(protocolEntryBuilder.build()).thenReturn(protoEntry);
 303         protocolList.add(protoEntry);
 304         assertEquals(protocolList, SouthboundMapper.createMdsalProtocols(bridge));
 305     }
 306
 307     @SuppressWarnings("unchecked")
 308     @Test
 309     public void testCreateControllerEntries() throws Exception {
 310         Bridge bridge = mock(Bridge.class);
 311         Map<UUID, Controller> updatedControllerRows = new HashMap<>();
 312         Column<GenericTableSchema, Set<UUID>> column = mock(Column.class);
 313         when(bridge.getControllerColumn()).thenReturn(column);
 314         Set<UUID> controllerUUIDs = new HashSet<>();
 315         UUID uuid = mock(UUID.class);
 316         controllerUUIDs.add(uuid);
 317         Controller controller = mock(Controller.class);
 318         updatedControllerRows.put(uuid, controller);
 319         when(column.getData()).thenReturn(controllerUUIDs);
 320         List<ControllerEntry> controllerEntries = new ArrayList<>();
 321         ControllerEntry controllerEntry = mock(ControllerEntry.class);
 322         controllerEntries.add(controllerEntry);
 323
 324         //Test addControllerEntries()
 325         Column<GenericTableSchema, String> value = mock(Column.class);
 326         when(controller.getTargetColumn()).thenReturn(value);
 327         when(value.getData()).thenReturn("targetString");
 328         when(controller.getUuid()).thenReturn(uuid);
 329         org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid testUuid = mock(Uuid.class);
 330         PowerMockito.whenNew(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid.class).withAnyArguments().thenReturn(testUuid);
 331         ControllerEntryBuilder controllerEntryBuilder = mock(ControllerEntryBuilder.class);
 332         PowerMockito.whenNew(ControllerEntryBuilder.class).withAnyArguments().thenReturn(controllerEntryBuilder);
 333         Uri uri = mock(Uri.class);
 334         PowerMockito.whenNew(Uri.class).withAnyArguments().thenReturn(uri);
 335         when(controllerEntryBuilder.setTarget(any(Uri.class))).thenReturn(controllerEntryBuilder);
 336         Column<GenericTableSchema, Boolean> colConnected = mock(Column.class);
 337         when(controller.getIsConnectedColumn()).thenReturn(colConnected );
 338         when(colConnected.getData()).thenReturn(true);
 339         when(controllerEntryBuilder.setIsConnected(any(Boolean.class))).thenReturn(controllerEntryBuilder);
 340         when(controllerEntryBuilder.setControllerUuid(any(Uuid.class))).thenReturn(controllerEntryBuilder);
 341         when(controllerEntryBuilder.build()).thenReturn(controllerEntry);
 342
 343         assertEquals(controllerEntries, SouthboundMapper.createControllerEntries(bridge, updatedControllerRows));
 344     }
 345
 346     @Test
 347     public void testCreateControllerEntries1() throws Exception {
 348
 349     }
 350
 351     @Test
 352     public void testCreateOvsdbController() throws Exception {
 353         OvsdbBridgeAugmentation omn = mock(OvsdbBridgeAugmentation.class);
 354         DatabaseSchema dbSchema = mock(DatabaseSchema.class);
 355         List<ControllerEntry> controllerEntries = new ArrayList<>();
 356         ControllerEntry controllerEntry = mock(ControllerEntry.class);
 357         controllerEntries.add(controllerEntry);
 358         when(omn.getControllerEntry()).thenReturn(controllerEntries);
 359         Map<UUID,Controller> controllerMap = new HashMap<>();
 360         PowerMockito.mockStatic(TyperUtils.class);
 361         Controller controller = mock(Controller.class);
 362         PowerMockito.when(TyperUtils.getTypedRowWrapper(any(DatabaseSchema.class), eq(Controller.class))).thenReturn(controller);
 363         Uri uri = mock(Uri.class);
 364         when(controllerEntry.getTarget()).thenReturn(uri);
 365         when(uri.getValue()).thenReturn("uri");
 366         UUID uuid = mock(UUID.class);
 367         PowerMockito.whenNew(UUID.class).withAnyArguments().thenReturn(uuid);
 368
 369         controllerMap.put(uuid, controller);
 370         assertEquals(controllerMap, SouthboundMapper.createOvsdbController(omn, dbSchema));
 371     }
 372
 373     @Test
 374     public void testCreateConnectionInfo() throws Exception {
 375         OvsdbClient client = mock(OvsdbClient.class, Mockito.RETURNS_DEEP_STUBS);
 376         ConnectionInfoBuilder connectionInfoBuilder = mock(ConnectionInfoBuilder.class);
 377         PowerMockito.whenNew(ConnectionInfoBuilder.class).withNoArguments().thenReturn(connectionInfoBuilder);
 378
 379         when(client.getConnectionInfo().getRemoteAddress()).thenReturn(mock(InetAddress.class));
 380         when(client.getConnectionInfo().getRemotePort()).thenReturn(8080);
 381         when(client.getConnectionInfo().getLocalAddress()).thenReturn(mock(InetAddress.class));
 382         when(client.getConnectionInfo().getLocalPort()).thenReturn(8080);
 383         PortNumber portNum = mock(PortNumber.class);
 384         PowerMockito.whenNew(PortNumber.class).withAnyArguments().thenReturn(portNum);
 385         when(connectionInfoBuilder.setRemoteIp(any(IpAddress .class))).thenReturn(connectionInfoBuilder);
 386         when(connectionInfoBuilder.setRemotePort(any(PortNumber.class))).thenReturn(connectionInfoBuilder);
 387         when(connectionInfoBuilder.setLocalIp(any(IpAddress .class))).thenReturn(connectionInfoBuilder);
 388         when(connectionInfoBuilder.setLocalPort(any(PortNumber.class))).thenReturn(connectionInfoBuilder);
 389         ConnectionInfo connectionInfo = mock(ConnectionInfo.class);
 390         when(connectionInfoBuilder.build()).thenReturn(connectionInfo);
 391         assertEquals(connectionInfo, SouthboundMapper.createConnectionInfo(client));
 392     }
 393
 394     @Test
 395     public void testSuppressLocalIpPort() throws Exception {
 396         ConnectionInfo connectionInfo = mock(ConnectionInfo.class);
 397         ConnectionInfoBuilder connectionInfoBuilder = mock(ConnectionInfoBuilder.class);
 398         PowerMockito.whenNew(ConnectionInfoBuilder.class).withNoArguments().thenReturn(connectionInfoBuilder);
 399         when(connectionInfo.getRemoteIp()).thenReturn(mock(IpAddress.class));
 400         when(connectionInfo.getRemotePort()).thenReturn(mock(PortNumber.class));
 401         when(connectionInfoBuilder.setRemoteIp(any(IpAddress .class))).thenReturn(connectionInfoBuilder);
 402         when(connectionInfoBuilder.setRemotePort(any(PortNumber.class))).thenReturn(connectionInfoBuilder);
 403         when(connectionInfoBuilder.build()).thenReturn(connectionInfo);
 404         assertEquals(connectionInfo, SouthboundMapper.suppressLocalIpPort(connectionInfo));
 405     }
 406
 407     @SuppressWarnings("unchecked")
 408     @Test
 409     public void testCreateManagerEntries() throws Exception {
 410         OpenVSwitch ovsdbNode = mock(OpenVSwitch.class);
 411         Map<UUID, Manager> updatedManagerRows = new HashMap<>();
 412         Set<UUID> managerUUIDs = new HashSet<>();
 413         UUID managerUUID = mock(UUID.class);
 414         Manager manager = mock(Manager.class);
 415         managerUUIDs.add(managerUUID);
 416         updatedManagerRows.put(managerUUID, manager);
 417         Column<GenericTableSchema, Set<UUID>> column = mock(Column.class);
 418         when(ovsdbNode.getManagerOptionsColumn()).thenReturn(column);
 419         when(column.getData()).thenReturn(managerUUIDs);
 420         List<ManagerEntry> managerEntries = new ArrayList<>();
 421         ManagerEntry managerEntry = mock(ManagerEntry.class);
 422         managerEntries.add(managerEntry);
 423
 424         //Test addManagerEntries(managerEntriesCreated, manager)
 425         Column<GenericTableSchema, String> value = mock(Column.class);
 426         when(manager.getTargetColumn()).thenReturn(value);
 427         when(value.getData()).thenReturn("dummy");
 428
 429         Column<GenericTableSchema, Map<String, String>> statusColumn = mock(Column.class);
 430         when(manager.getStatusColumn()).thenReturn(statusColumn);
 431         Map<String, String> statusAttributeMap = new HashMap<>();
 432         when(statusColumn.getData()).thenReturn(statusAttributeMap);
 433         String numberOfConnectionValueStr = "999";
 434
 435         //statusAttributeMap contains N_CONNECTIONS_STR key
 436         statusAttributeMap.put("n_connections", numberOfConnectionValueStr);
 437
 438         Column<GenericTableSchema, Boolean> isConnectedColumn = mock(Column.class);
 439         when(manager.getIsConnectedColumn()).thenReturn(isConnectedColumn);
 440         when(isConnectedColumn.getData()).thenReturn(true);
 441         ManagerEntryBuilder managerEntryBuilder = mock(ManagerEntryBuilder.class);
 442         PowerMockito.whenNew(ManagerEntryBuilder.class).withNoArguments().thenReturn(managerEntryBuilder);
 443         PowerMockito.whenNew(Uri.class).withAnyArguments().thenReturn(mock(Uri.class));
 444         when(managerEntryBuilder.setTarget(any(Uri.class))).thenReturn(managerEntryBuilder);
 445         when(managerEntryBuilder.setNumberOfConnections(any(Long.class))).thenReturn(managerEntryBuilder);
 446         when(managerEntryBuilder.setConnected(true)).thenReturn(managerEntryBuilder);
 447
 448         when(managerEntryBuilder.build()).thenReturn(managerEntry);
 449
 450         assertEquals(managerEntries, SouthboundMapper.createManagerEntries(ovsdbNode, updatedManagerRows));
 451
 452         //statusAttributeMap contains N_CONNECTIONS_STR key
 453         statusAttributeMap.remove("n_connections");
 454         assertEquals(managerEntries, SouthboundMapper.createManagerEntries(ovsdbNode, updatedManagerRows));
 455     }
 456
 457     @SuppressWarnings("unchecked")
 458     @Test
 459     public void testCreateManagerEntries1() throws Exception {
 460         Node ovsdbNode = mock(Node.class);
 461         Map<Uri, Manager> updatedManagerRows = new HashMap<>();
 462         Uri uri = mock(Uri.class);
 463         Manager manager = mock(Manager.class);
 464         updatedManagerRows.put(uri, manager);
 465
 466         List<ManagerEntry> managerEntriesCreated = new ArrayList<>();
 467
 468         //ovsdbNodeAugmentation is null
 469         when(ovsdbNode.getAugmentation(OvsdbNodeAugmentation.class)).thenReturn(null);
 470         assertEquals(managerEntriesCreated, SouthboundMapper.createManagerEntries(ovsdbNode, updatedManagerRows));
 471
 472         //ovsdbNodeAugmentation not null
 473         OvsdbNodeAugmentation ovsdbNodeAugmentation = mock(OvsdbNodeAugmentation.class);
 474         when(ovsdbNode.getAugmentation(OvsdbNodeAugmentation.class)).thenReturn(ovsdbNodeAugmentation);
 475
 476         List<ManagerEntry> managerEntries = new ArrayList<>();
 477         ManagerEntry managerEntry = mock(ManagerEntry.class);
 478         managerEntries.add(managerEntry);
 479         when(ovsdbNodeAugmentation.getManagerEntry()).thenReturn(managerEntries);
 480         when(managerEntry.getTarget()).thenReturn(uri);
 481
 482         //Test addManagerEntries(managerEntriesCreated, manager)
 483         Column<GenericTableSchema, String> value = mock(Column.class);
 484         when(manager.getTargetColumn()).thenReturn(value);
 485         when(value.getData()).thenReturn("dummy");
 486
 487         Column<GenericTableSchema, Map<String, String>> statusColumn = mock(Column.class);
 488         when(manager.getStatusColumn()).thenReturn(statusColumn);
 489         Map<String, String> statusAttributeMap = new HashMap<>();
 490         when(statusColumn.getData()).thenReturn(statusAttributeMap);
 491         String numberOfConnectionValueStr = "999";
 492
 493         //statusAttributeMap contains N_CONNECTIONS_STR key
 494         statusAttributeMap.put("n_connections", numberOfConnectionValueStr);
 495
 496         Column<GenericTableSchema, Boolean> isConnectedColumn = mock(Column.class);
 497         when(manager.getIsConnectedColumn()).thenReturn(isConnectedColumn);
 498         when(isConnectedColumn.getData()).thenReturn(true);
 499         ManagerEntryBuilder managerEntryBuilder = mock(ManagerEntryBuilder.class);
 500         PowerMockito.whenNew(ManagerEntryBuilder.class).withNoArguments().thenReturn(managerEntryBuilder);
 501         PowerMockito.whenNew(Uri.class).withAnyArguments().thenReturn(mock(Uri.class));
 502         when(managerEntryBuilder.setTarget(any(Uri.class))).thenReturn(managerEntryBuilder);
 503         when(managerEntryBuilder.setNumberOfConnections(any(Long.class))).thenReturn(managerEntryBuilder);
 504         when(managerEntryBuilder.setConnected(true)).thenReturn(managerEntryBuilder);
 505
 506         when(managerEntryBuilder.build()).thenReturn(managerEntry);
 507
 508         assertEquals(managerEntries, SouthboundMapper.createManagerEntries(ovsdbNode, updatedManagerRows));
 509
 510         //statusAttributeMap contains N_CONNECTIONS_STR key
 511         statusAttributeMap.remove("n_connections");
 512         assertEquals(managerEntries, SouthboundMapper.createManagerEntries(ovsdbNode, updatedManagerRows));
 513     }
 514
 515     @SuppressWarnings("unchecked")
 516     @Test
 517     public void testGetInstanceIdentifier() throws Exception {
 518         OpenVSwitch ovs = mock(OpenVSwitch.class);
 519         InstanceIdentifier<Node> iid = mock(InstanceIdentifier.class);
 520         Column<GenericTableSchema, Map<String, String>> externalIdColumn = mock(Column.class);
 521         when(ovs.getExternalIdsColumn()).thenReturn(externalIdColumn);
 522         Map<String, String> externalIdMap = new HashMap<>();
 523         when(externalIdColumn.getData()).thenReturn(externalIdMap);
 524         // if true
 525         externalIdMap.put(SouthboundConstants.IID_EXTERNAL_ID_KEY, "test");
 526         PowerMockito.mockStatic(SouthboundUtil.class);
 527         when((InstanceIdentifier<Node>) SouthboundUtil.deserializeInstanceIdentifier(anyString())).thenReturn(iid);
 528         assertEquals("Incorrect Instance Identifier received", iid, SouthboundMapper.getInstanceIdentifier(ovs));
 529         // if false
 530         externalIdMap.clear();
 531         UUID uuID = new UUID("test");
 532         when(ovs.getUuid()).thenReturn(uuID);
 533         assertNotNull(SouthboundMapper.getInstanceIdentifier(ovs));
 534     }
 535 }