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.mockito.Matchers.any;
  15 import static org.mockito.Matchers.anyString;
  16 import static org.mockito.Mockito.mock;
  17 import static org.mockito.Mockito.when;
  18
  19 import java.io.InputStream;
  20 import java.net.InetAddress;
  21 import java.util.ArrayList;
  22 import java.util.Collections;
  23 import java.util.HashMap;
  24 import java.util.HashSet;
  25 import java.util.List;
  26 import java.util.Map;
  27 import java.util.Set;
  28
  29 import com.fasterxml.jackson.databind.JsonNode;
  30 import com.fasterxml.jackson.databind.ObjectMapper;
  31 import org.junit.Test;
  32 import org.mockito.Mockito;
  33 import org.mockito.invocation.InvocationOnMock;
  34 import org.mockito.stubbing.Answer;
  35 import org.opendaylight.controller.md.sal.binding.test.AbstractDataBrokerTest;
  36 import org.opendaylight.ovsdb.lib.OvsdbClient;
  37 import org.opendaylight.ovsdb.lib.notation.Column;
  38 import org.opendaylight.ovsdb.lib.notation.UUID;
  39 import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
  40 import org.opendaylight.ovsdb.lib.schema.GenericTableSchema;
  41 import org.opendaylight.ovsdb.schema.openvswitch.Bridge;
  42 import org.opendaylight.ovsdb.schema.openvswitch.Controller;
  43 import org.opendaylight.ovsdb.schema.openvswitch.Manager;
  44 import org.opendaylight.ovsdb.schema.openvswitch.OpenVSwitch;
  45 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
  46 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddressBuilder;
  47 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.PortNumber;
  48 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Uri;
  49 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.DatapathId;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.DatapathTypeBase;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.DatapathTypeNetdev;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.DatapathTypeSystem;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeInternal;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeVxlan;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentationBuilder;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeProtocolBase;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeProtocolOpenflow10;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntry;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntryBuilder;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntry;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfo;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfoBuilder;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagerEntry;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagerEntryBuilder;
  68 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  69 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  70 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  71 import org.powermock.api.mockito.PowerMockito;
  72
  73 public class SouthboundMapperTest extends AbstractDataBrokerTest {
  74
  75     @Test
  76     public void testCreateIpAddress() throws Exception {
  77         IpAddress ipAddress = IpAddressBuilder.getDefaultInstance("127.0.0.1");
  78         InetAddress inetAddress = InetAddress.getByAddress(new byte[] {127, 0, 0, 1});
  79         assertEquals("Incorrect IP address created", ipAddress, SouthboundMapper.createIpAddress(inetAddress));
  80     }
  81
  82     @Test
  83     public void testCreateInstanceIdentifier() throws Exception {
  84         NodeId nodeId = NodeId.getDefaultInstance("test");
  85         InstanceIdentifier<Node> iid = SouthboundMapper.createInstanceIdentifier(nodeId);
  86         assertEquals(nodeId, iid.firstKeyOf(Node.class).getNodeId());
  87     }
  88
  89     @SuppressWarnings("unchecked")
  90     @Test
  91     public void testCreateInstanceIdentifier1() throws Exception {
  92         OvsdbConnectionInstance client = mock(OvsdbConnectionInstance.class, Mockito.RETURNS_DEEP_STUBS);
  93         Bridge bridge = mock(Bridge.class);
  94
  95         // When bridge is not empty, we expect a deserialized identifier
  96         InstanceIdentifier deserializedIid = InstanceIdentifier.create(Node.class);
  97         Column<GenericTableSchema, Map<String, String>> column = mock(Column.class);
  98         when(bridge.getExternalIdsColumn()).thenReturn(column);
  99         Map<String, String> map = new HashMap<>();
 100         map.put(SouthboundConstants.IID_EXTERNAL_ID_KEY, "IID_EXTERNAL_ID_KEY");
 101         when(column.getData()).thenReturn(map);
 102         InstanceIdentifierCodec iidc = mock(InstanceIdentifierCodec.class);
 103         when(iidc.bindingDeserializer("IID_EXTERNAL_ID_KEY")).thenReturn(deserializedIid);
 104         SouthboundUtil.setInstanceIdentifierCodec(iidc);
 105         assertEquals("Incorrect Instance Identifier received", deserializedIid,
 106                 SouthboundMapper.createInstanceIdentifier(client, bridge));
 107
 108         // When bridge is empty, we expect a new identifier pointing to the bridge
 109         when(bridge.getExternalIdsColumn()).thenReturn(null);
 110         when(client.getNodeKey().getNodeId().getValue()).thenReturn("uri");
 111         when(bridge.getName()).thenReturn("bridgeName");
 112         InstanceIdentifier<Node> returnedIid = SouthboundMapper.createInstanceIdentifier(client, bridge);
 113         assertEquals("Incorrect identifier type", Node.class, returnedIid.getTargetType());
 114         assertEquals("Incorrect node key", new NodeId(new Uri("uri/bridge/bridgeName")),
 115                 returnedIid.firstKeyOf(Node.class).getNodeId());
 116     }
 117
 118     @SuppressWarnings("unchecked")
 119     @Test
 120     public void testCreateInstanceIdentifier2() throws Exception {
 121         OvsdbConnectionInstance client = mock(OvsdbConnectionInstance.class, Mockito.RETURNS_DEEP_STUBS);
 122         Controller controller = mock(Controller.class);
 123
 124         // When controller is not empty, we expect a deserialized identifier
 125         InstanceIdentifier deserializedIid = InstanceIdentifier.create(Node.class);
 126         Column<GenericTableSchema, Map<String, String>> column = mock(Column.class);
 127         when(controller.getExternalIdsColumn()).thenReturn(column);
 128         Map<String, String> map = new HashMap<>();
 129         map.put(SouthboundConstants.IID_EXTERNAL_ID_KEY, "IID_EXTERNAL_ID_KEY");
 130         when(column.getData()).thenReturn(map);
 131         InstanceIdentifierCodec iidc = mock(InstanceIdentifierCodec.class);
 132         when(iidc.bindingDeserializer("IID_EXTERNAL_ID_KEY")).thenReturn(deserializedIid);
 133         SouthboundUtil.setInstanceIdentifierCodec(iidc);
 134         assertEquals("Incorrect Instance Identifier received", deserializedIid,
 135                 SouthboundMapper.createInstanceIdentifier(client, controller, "bridgeName"));
 136
 137         // When controller is empty, we expect a new identifier pointing to the bridge
 138         when(controller.getExternalIdsColumn()).thenReturn(null);
 139         when(client.getNodeKey().getNodeId().getValue()).thenReturn("uri");
 140         InstanceIdentifier<Node> returnedIid =
 141                 SouthboundMapper.createInstanceIdentifier(client, controller, "bridgeName");
 142         assertEquals("Incorrect identifier type", Node.class, returnedIid.getTargetType());
 143         assertEquals("Incorrect node key", new NodeId(new Uri("uri/bridge/bridgeName")),
 144                 returnedIid.firstKeyOf(Node.class).getNodeId());
 145     }
 146
 147     @Test
 148     public void testCreateInetAddress() throws Exception {
 149         // IPv4 address
 150         IpAddress ipV4Address = IpAddressBuilder.getDefaultInstance("99.99.99.99");
 151         assertEquals("Incorrect InetAddress received", InetAddress.getByAddress(new byte[] {99, 99, 99, 99}),
 152                 SouthboundMapper.createInetAddress(ipV4Address));
 153
 154         // IPv6 address
 155         IpAddress ipV6Address = IpAddressBuilder.getDefaultInstance("0000:0000:0000:0000:0000:9999:FE1E:8329");
 156         assertEquals("Incorrect InetAddress received", InetAddress.getByAddress(
 157                 new byte[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, (byte) 0x99, (byte) 0x99, (byte) 0xFE, 0x1E, (byte) 0x83,
 158                         0x29}),
 159                 SouthboundMapper.createInetAddress(ipV6Address));
 160     }
 161
 162     @SuppressWarnings("unchecked")
 163     @Test
 164     public void testCreateDatapathId() throws Exception {
 165         Bridge bridge = mock(Bridge.class);
 166         when(bridge.getDatapathIdColumn()).thenReturn(null);
 167         assertNull(SouthboundMapper.createDatapathId(bridge));
 168
 169         Column<GenericTableSchema, Set<String>> column = mock(Column.class);
 170         when(bridge.getDatapathIdColumn()).thenReturn(column);
 171         Set<String> set = new HashSet<>();
 172         set.add("00:11:22:33:44:55:66:77");
 173         when(column.getData()).thenReturn(set);
 174         assertNotNull(column.getData());
 175
 176         DatapathId dataPathId = new DatapathId("00:11:22:33:44:55:66:77");
 177
 178         assertEquals(dataPathId, SouthboundMapper.createDatapathId(bridge));
 179     }
 180
 181     @Test
 182     public void testCreateDatapathType() throws Exception {
 183         OvsdbBridgeAugmentation mdsalbridge = mock(OvsdbBridgeAugmentation.class);
 184         when(mdsalbridge.getDatapathType()).thenAnswer(new Answer<Class<? extends DatapathTypeBase>>() {
 185             public Class<? extends DatapathTypeBase> answer(
 186                     InvocationOnMock invocation) throws Throwable {
 187                 return DatapathTypeNetdev.class;
 188             }
 189         });
 190         assertEquals("netdev", SouthboundMapper.createDatapathType(mdsalbridge));
 191
 192         when(mdsalbridge.getDatapathType()).thenAnswer(new Answer<Class<? extends DatapathTypeBase>>() {
 193             public Class<? extends DatapathTypeBase> answer(
 194                     InvocationOnMock invocation) throws Throwable {
 195                 return DatapathTypeSystem.class;
 196             }
 197         });
 198         assertEquals("system", SouthboundMapper.createDatapathType(mdsalbridge));
 199     }
 200
 201     @Test
 202     public void testCreateDatapathType1() {
 203         assertEquals(DatapathTypeSystem.class, SouthboundMapper.createDatapathType(""));
 204         assertEquals(DatapathTypeSystem.class, SouthboundMapper.createDatapathType("system"));
 205         assertEquals(DatapathTypeNetdev.class, SouthboundMapper.createDatapathType("netdev"));
 206     }
 207
 208     @Test
 209     public void testCreateOvsdbBridgeProtocols() {
 210         OvsdbBridgeAugmentation ovsdbBridgeNode = mock(OvsdbBridgeAugmentation.class);
 211         List<ProtocolEntry> protocolList = new ArrayList<>();
 212         ProtocolEntry protocolEntry = mock(ProtocolEntry.class);
 213         protocolList.add(protocolEntry);
 214         when(ovsdbBridgeNode.getProtocolEntry()).thenReturn(protocolList);
 215         when(protocolEntry.getProtocol()).thenAnswer(new Answer<Class<? extends OvsdbBridgeProtocolBase>>() {
 216             public Class<? extends OvsdbBridgeProtocolBase> answer(
 217                     InvocationOnMock invocation) throws Throwable {
 218                 return OvsdbBridgeProtocolOpenflow10.class;
 219             }
 220         });
 221         Set<String> protocols = new HashSet<>();
 222         protocols.add("OpenFlow10");
 223         assertEquals(protocols, SouthboundMapper.createOvsdbBridgeProtocols(ovsdbBridgeNode));
 224     }
 225
 226     @Test
 227     public void testCreateInterfaceType() {
 228         assertEquals(InterfaceTypeInternal.class, SouthboundMapper.createInterfaceType("internal"));
 229         assertEquals(InterfaceTypeVxlan.class, SouthboundMapper.createInterfaceType("vxlan"));
 230     }
 231
 232     @Test
 233     public void testCreateOvsdbInterfaceType() {
 234         assertEquals("internal", SouthboundMapper.createOvsdbInterfaceType(InterfaceTypeInternal.class));
 235         assertEquals("vxlan", SouthboundMapper.createOvsdbInterfaceType(InterfaceTypeVxlan.class));
 236     }
 237
 238     @SuppressWarnings("unchecked")
 239     @Test
 240     public void testCreateMdsalProtocols() throws Exception {
 241         Bridge bridge = mock(Bridge.class);
 242         Set<String> value = new HashSet<>();
 243         value.add("OpenFlow10");
 244         Column<GenericTableSchema, Set<String>> column = mock(Column.class);
 245         when(bridge.getProtocolsColumn()).thenReturn(column);
 246         when(column.getData()).thenReturn(value);
 247
 248         List<ProtocolEntry> returnedProtocols = SouthboundMapper.createMdsalProtocols(bridge);
 249         assertEquals(value.size(), returnedProtocols.size());
 250         assertEquals(OvsdbBridgeProtocolOpenflow10.class, returnedProtocols.get(0).getProtocol());
 251     }
 252
 253     @SuppressWarnings("unchecked")
 254     @Test
 255     public void testCreateControllerEntries() throws Exception {
 256         Bridge bridge = mock(Bridge.class);
 257         Map<UUID, Controller> updatedControllerRows = new HashMap<>();
 258         Column<GenericTableSchema, Set<UUID>> controllerColumn = mock(Column.class);
 259         when(bridge.getControllerColumn()).thenReturn(controllerColumn);
 260         Set<UUID> controllerUUIDs = new HashSet<>();
 261         String uuidString = "7da709ff-397f-4778-a0e8-994811272fdb";
 262         UUID uuid = new UUID(uuidString);
 263         controllerUUIDs.add(uuid);
 264         Controller controller = mock(Controller.class);
 265         Column<GenericTableSchema, String> targetColumn = mock(Column.class);
 266         when(targetColumn.getData()).thenReturn("targetData");
 267         when(controller.getTargetColumn()).thenReturn(targetColumn);
 268         when(controller.getUuid()).thenReturn(uuid);
 269         Column<GenericTableSchema, Boolean> isConnectedColumn = mock(Column.class);
 270         when(isConnectedColumn.getData()).thenReturn(true);
 271         when(controller.getIsConnectedColumn()).thenReturn(isConnectedColumn);
 272         updatedControllerRows.put(uuid, controller);
 273         when(controllerColumn.getData()).thenReturn(controllerUUIDs);
 274
 275         List<ControllerEntry> controllerEntries = new ArrayList<>();
 276         ControllerEntry controllerEntry = new ControllerEntryBuilder()
 277                 .setControllerUuid(Uuid.getDefaultInstance(uuidString))
 278                 .setIsConnected(true)
 279                 .setTarget(Uri.getDefaultInstance("targetData"))
 280                 .build();
 281         controllerEntries.add(controllerEntry);
 282
 283         assertEquals(controllerEntries, SouthboundMapper.createControllerEntries(bridge, updatedControllerRows));
 284     }
 285
 286     @Test
 287     public void testCreateControllerEntries1() throws Exception {
 288
 289     }
 290
 291     @Test
 292     public void testCreateOvsdbController() throws Exception {
 293         try (InputStream resourceAsStream = SouthboundMapperTest.class.getResourceAsStream("openvswitch_schema.json")) {
 294             ObjectMapper mapper = new ObjectMapper();
 295             JsonNode jsonNode = mapper.readTree(resourceAsStream);
 296             System.out.println("jsonNode = " + jsonNode.get("id"));
 297
 298             DatabaseSchema dbSchema = DatabaseSchema.fromJson(OvsdbSchemaContants.databaseName, jsonNode.get("result"));
 299
 300             String uuidString = "7da709ff-397f-4778-a0e8-994811272fdb";
 301             OvsdbBridgeAugmentation omn = new OvsdbBridgeAugmentationBuilder()
 302                     .setControllerEntry(Collections.singletonList(new ControllerEntryBuilder()
 303                             .setControllerUuid(Uuid.getDefaultInstance(uuidString))
 304                             .setTarget(Uri.getDefaultInstance("uri"))
 305                             .build()))
 306                     .build();
 307
 308             Map<UUID, Controller> returnedControllers = SouthboundMapper.createOvsdbController(omn, dbSchema);
 309             assertEquals(1, returnedControllers.size());
 310             Controller returnedController = returnedControllers.values().iterator().next();
 311             assertEquals("uri", returnedController.getTargetColumn().getData());
 312         }
 313     }
 314
 315     @Test
 316     public void testCreateConnectionInfo() throws Exception {
 317         OvsdbClient client = mock(OvsdbClient.class, Mockito.RETURNS_DEEP_STUBS);
 318         ConnectionInfoBuilder connectionInfoBuilder = mock(ConnectionInfoBuilder.class);
 319         PowerMockito.whenNew(ConnectionInfoBuilder.class).withNoArguments().thenReturn(connectionInfoBuilder);
 320
 321         InetAddress remoteAddress = InetAddress.getByAddress(new byte[] {1, 2, 3, 4});
 322         when(client.getConnectionInfo().getRemoteAddress()).thenReturn(remoteAddress);
 323         when(client.getConnectionInfo().getRemotePort()).thenReturn(8080);
 324         InetAddress localAddress = InetAddress.getByAddress(new byte[] {1, 2, 3, 5});
 325         when(client.getConnectionInfo().getLocalAddress()).thenReturn(localAddress);
 326         when(client.getConnectionInfo().getLocalPort()).thenReturn(8081);
 327
 328         ConnectionInfo returnedConnectionInfo = SouthboundMapper.createConnectionInfo(client);
 329         assertEquals(IpAddressBuilder.getDefaultInstance("1.2.3.4"), returnedConnectionInfo.getRemoteIp());
 330         assertEquals(8080, (int) returnedConnectionInfo.getRemotePort().getValue());
 331         assertEquals(IpAddressBuilder.getDefaultInstance("1.2.3.5"), returnedConnectionInfo.getLocalIp());
 332         assertEquals(8081, (int) returnedConnectionInfo.getLocalPort().getValue());
 333     }
 334
 335     @Test
 336     public void testSuppressLocalIpPort() throws Exception {
 337         ConnectionInfo connectionInfo = mock(ConnectionInfo.class);
 338         IpAddress ipAddress = IpAddressBuilder.getDefaultInstance("1.2.3.4");
 339         when(connectionInfo.getRemoteIp()).thenReturn(ipAddress);
 340         PortNumber portNumber = PortNumber.getDefaultInstance("8080");
 341         when(connectionInfo.getRemotePort()).thenReturn(portNumber);
 342         ConnectionInfo returnedConnectionInfo = SouthboundMapper.suppressLocalIpPort(connectionInfo);
 343         assertEquals(ipAddress, returnedConnectionInfo.getRemoteIp());
 344         assertEquals(portNumber, returnedConnectionInfo.getRemotePort());
 345         assertNull(returnedConnectionInfo.getLocalIp());
 346         assertNull(returnedConnectionInfo.getLocalPort());
 347     }
 348
 349     @SuppressWarnings("unchecked")
 350     @Test
 351     public void testCreateManagerEntries() throws Exception {
 352         OpenVSwitch ovsdbNode = mock(OpenVSwitch.class);
 353         Map<UUID, Manager> updatedManagerRows = new HashMap<>();
 354         Set<UUID> managerUUIDs = new HashSet<>();
 355         UUID managerUUID = new UUID("7da709ff-397f-4778-a0e8-994811272fdb");
 356         Manager manager = mock(Manager.class);
 357         managerUUIDs.add(managerUUID);
 358         updatedManagerRows.put(managerUUID, manager);
 359         Column<GenericTableSchema, Set<UUID>> column = mock(Column.class);
 360         when(ovsdbNode.getManagerOptionsColumn()).thenReturn(column);
 361         when(column.getData()).thenReturn(managerUUIDs);
 362
 363         //Test addManagerEntries(managerEntriesCreated, manager)
 364         Column<GenericTableSchema, String> value = mock(Column.class);
 365         when(manager.getTargetColumn()).thenReturn(value);
 366         when(value.getData()).thenReturn("dummy");
 367
 368         Column<GenericTableSchema, Map<String, String>> statusColumn = mock(Column.class);
 369         when(manager.getStatusColumn()).thenReturn(statusColumn);
 370         Map<String, String> statusAttributeMap = new HashMap<>();
 371         when(statusColumn.getData()).thenReturn(statusAttributeMap);
 372         String numberOfConnectionValueStr = "999";
 373
 374         //statusAttributeMap contains N_CONNECTIONS_STR key
 375         statusAttributeMap.put("n_connections", numberOfConnectionValueStr);
 376
 377         Column<GenericTableSchema, Boolean> isConnectedColumn = mock(Column.class);
 378         when(manager.getIsConnectedColumn()).thenReturn(isConnectedColumn);
 379         when(isConnectedColumn.getData()).thenReturn(true);
 380
 381         assertEquals(Collections.singletonList(new ManagerEntryBuilder()
 382                 .setConnected(true)
 383                 .setNumberOfConnections(999L)
 384                 .setTarget(Uri.getDefaultInstance("dummy"))
 385                 .build()), SouthboundMapper.createManagerEntries(ovsdbNode, updatedManagerRows));
 386
 387         //statusAttributeMap contains N_CONNECTIONS_STR key
 388         statusAttributeMap.remove("n_connections");
 389         assertEquals(Collections.singletonList(new ManagerEntryBuilder()
 390                 .setConnected(true)
 391                 .setNumberOfConnections(1L)
 392                 .setTarget(Uri.getDefaultInstance("dummy"))
 393                 .build()), SouthboundMapper.createManagerEntries(ovsdbNode, updatedManagerRows));
 394     }
 395
 396     @SuppressWarnings("unchecked")
 397     @Test
 398     public void testCreateManagerEntries1() throws Exception {
 399         Node ovsdbNode = mock(Node.class);
 400         Map<Uri, Manager> updatedManagerRows = new HashMap<>();
 401         Uri uri = mock(Uri.class);
 402         Manager manager = mock(Manager.class);
 403         updatedManagerRows.put(uri, manager);
 404
 405         List<ManagerEntry> managerEntriesCreated = new ArrayList<>();
 406
 407         //ovsdbNodeAugmentation is null
 408         when(ovsdbNode.getAugmentation(OvsdbNodeAugmentation.class)).thenReturn(null);
 409         assertEquals(managerEntriesCreated, SouthboundMapper.createManagerEntries(ovsdbNode, updatedManagerRows));
 410
 411         //ovsdbNodeAugmentation not null
 412         OvsdbNodeAugmentation ovsdbNodeAugmentation = mock(OvsdbNodeAugmentation.class);
 413         when(ovsdbNode.getAugmentation(OvsdbNodeAugmentation.class)).thenReturn(ovsdbNodeAugmentation);
 414
 415         List<ManagerEntry> managerEntries = new ArrayList<>();
 416         ManagerEntry managerEntry = mock(ManagerEntry.class);
 417         managerEntries.add(managerEntry);
 418         when(ovsdbNodeAugmentation.getManagerEntry()).thenReturn(managerEntries);
 419         when(managerEntry.getTarget()).thenReturn(uri);
 420
 421         //Test addManagerEntries(managerEntriesCreated, manager)
 422         Column<GenericTableSchema, String> value = mock(Column.class);
 423         when(manager.getTargetColumn()).thenReturn(value);
 424         when(value.getData()).thenReturn("dummy");
 425
 426         Column<GenericTableSchema, Map<String, String>> statusColumn = mock(Column.class);
 427         when(manager.getStatusColumn()).thenReturn(statusColumn);
 428         Map<String, String> statusAttributeMap = new HashMap<>();
 429         when(statusColumn.getData()).thenReturn(statusAttributeMap);
 430         String numberOfConnectionValueStr = "999";
 431
 432         //statusAttributeMap contains N_CONNECTIONS_STR key
 433         statusAttributeMap.put("n_connections", numberOfConnectionValueStr);
 434
 435         Column<GenericTableSchema, Boolean> isConnectedColumn = mock(Column.class);
 436         when(manager.getIsConnectedColumn()).thenReturn(isConnectedColumn);
 437         when(isConnectedColumn.getData()).thenReturn(true);
 438         ManagerEntryBuilder managerEntryBuilder = mock(ManagerEntryBuilder.class);
 439         PowerMockito.whenNew(ManagerEntryBuilder.class).withNoArguments().thenReturn(managerEntryBuilder);
 440         PowerMockito.whenNew(Uri.class).withAnyArguments().thenReturn(mock(Uri.class));
 441         when(managerEntryBuilder.setTarget(any(Uri.class))).thenReturn(managerEntryBuilder);
 442         when(managerEntryBuilder.setNumberOfConnections(any(Long.class))).thenReturn(managerEntryBuilder);
 443         when(managerEntryBuilder.setConnected(true)).thenReturn(managerEntryBuilder);
 444
 445         when(managerEntryBuilder.build()).thenReturn(managerEntry);
 446
 447         assertEquals(Collections.singletonList(new ManagerEntryBuilder()
 448                 .setConnected(true)
 449                 .setNumberOfConnections(999L)
 450                 .setTarget(Uri.getDefaultInstance("dummy"))
 451                 .build()), SouthboundMapper.createManagerEntries(ovsdbNode, updatedManagerRows));
 452
 453         //statusAttributeMap contains N_CONNECTIONS_STR key
 454         statusAttributeMap.remove("n_connections");
 455         assertEquals(Collections.singletonList(new ManagerEntryBuilder()
 456                 .setConnected(true)
 457                 .setNumberOfConnections(1L)
 458                 .setTarget(Uri.getDefaultInstance("dummy"))
 459                 .build()), SouthboundMapper.createManagerEntries(ovsdbNode, updatedManagerRows));
 460     }
 461
 462     @SuppressWarnings("unchecked")
 463     @Test
 464     public void testGetInstanceIdentifier() throws Exception {
 465         OpenVSwitch ovs = mock(OpenVSwitch.class);
 466         InstanceIdentifier<Node> iid = mock(InstanceIdentifier.class);
 467         Column<GenericTableSchema, Map<String, String>> externalIdColumn = mock(Column.class);
 468         when(ovs.getExternalIdsColumn()).thenReturn(externalIdColumn);
 469         Map<String, String> externalIdMap = new HashMap<>();
 470         when(externalIdColumn.getData()).thenReturn(externalIdMap);
 471         // if true
 472         externalIdMap.put(SouthboundConstants.IID_EXTERNAL_ID_KEY, "test");
 473         PowerMockito.mockStatic(SouthboundUtil.class);
 474         when((InstanceIdentifier<Node>) SouthboundUtil.deserializeInstanceIdentifier(anyString())).thenReturn(iid);
 475         assertEquals("Incorrect Instance Identifier received", iid, SouthboundMapper.getInstanceIdentifier(ovs));
 476         // if false
 477         externalIdMap.clear();
 478         UUID uuID = new UUID("test");
 479         when(ovs.getUuid()).thenReturn(uuID);
 480         assertNotNull(SouthboundMapper.getInstanceIdentifier(ovs));
 481     }
 482 }