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