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