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

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