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

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