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