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.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.invocation.InvocationOnMock;
  31 import org.mockito.stubbing.Answer;
  32 import org.opendaylight.ovsdb.lib.OvsdbClient;
  33 import org.opendaylight.ovsdb.lib.notation.Column;
  34 import org.opendaylight.ovsdb.lib.notation.UUID;
  35 import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
  36 import org.opendaylight.ovsdb.lib.schema.GenericTableSchema;
  37 import org.opendaylight.ovsdb.schema.openvswitch.Bridge;
  38 import org.opendaylight.ovsdb.schema.openvswitch.Controller;
  39 import org.opendaylight.ovsdb.schema.openvswitch.Manager;
  40 import org.opendaylight.ovsdb.schema.openvswitch.OpenVSwitch;
  41 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
  42 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddressBuilder;
  43 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
  44 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
  45 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.DatapathId;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.DatapathTypeBase;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.DatapathTypeNetdev;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.DatapathTypeSystem;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeInternal;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeVxlan;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentationBuilder;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeProtocolBase;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeProtocolOpenflow10;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntry;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntryBuilder;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntry;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfo;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagerEntry;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagerEntryBuilder;
  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
  67 public class SouthboundMapperTest {
  68
  69     @Test
  70     public void testCreateIpAddress() throws Exception {
  71         IpAddress ipAddress = IpAddressBuilder.getDefaultInstance("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(Node.class);
  96         when(iidc.bindingDeserializer("IID_EXTERNAL_ID_KEY")).thenReturn(deserializedIid);
  97         SouthboundUtil.setInstanceIdentifierCodec(iidc);
  98         OvsdbConnectionInstance client = mock(OvsdbConnectionInstance.class, Mockito.RETURNS_DEEP_STUBS);
  99         assertEquals("Incorrect Instance Identifier received", deserializedIid,
 100                 SouthboundMapper.createInstanceIdentifier(client, bridge));
 101
 102         // When bridge is empty, we expect a new identifier pointing to the bridge
 103         when(bridge.getExternalIdsColumn()).thenReturn(null);
 104         when(client.getNodeKey().getNodeId().getValue()).thenReturn("uri");
 105         when(bridge.getName()).thenReturn("bridgeName");
 106         InstanceIdentifier<Node> returnedIid = SouthboundMapper.createInstanceIdentifier(client, bridge);
 107         assertEquals("Incorrect identifier type", Node.class, returnedIid.getTargetType());
 108         assertEquals("Incorrect node key", new NodeId(new Uri("uri/bridge/bridgeName")),
 109                 returnedIid.firstKeyOf(Node.class).getNodeId());
 110     }
 111
 112     @SuppressWarnings("unchecked")
 113     @Test
 114     public void testCreateInstanceIdentifier2() throws Exception {
 115         Controller controller = mock(Controller.class);
 116
 117         // When controller is not empty, we expect a deserialized identifier
 118         Column<GenericTableSchema, Map<String, String>> column = mock(Column.class);
 119         when(controller.getExternalIdsColumn()).thenReturn(column);
 120         Map<String, String> map = new HashMap<>();
 121         map.put(SouthboundConstants.IID_EXTERNAL_ID_KEY, "IID_EXTERNAL_ID_KEY");
 122         when(column.getData()).thenReturn(map);
 123         InstanceIdentifierCodec iidc = mock(InstanceIdentifierCodec.class);
 124         InstanceIdentifier deserializedIid = InstanceIdentifier.create(Node.class);
 125         when(iidc.bindingDeserializer("IID_EXTERNAL_ID_KEY")).thenReturn(deserializedIid);
 126         SouthboundUtil.setInstanceIdentifierCodec(iidc);
 127         OvsdbConnectionInstance client = mock(OvsdbConnectionInstance.class, Mockito.RETURNS_DEEP_STUBS);
 128         assertEquals("Incorrect Instance Identifier received", deserializedIid,
 129                 SouthboundMapper.createInstanceIdentifier(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(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(new Answer<Class<? extends DatapathTypeBase>>() {
 179             public Class<? extends DatapathTypeBase> answer(
 180                     InvocationOnMock invocation) throws Throwable {
 181                 return DatapathTypeNetdev.class;
 182             }
 183         });
 184         assertEquals("netdev", SouthboundMapper.createDatapathType(mdsalbridge));
 185
 186         when(mdsalbridge.getDatapathType()).thenAnswer(new Answer<Class<? extends DatapathTypeBase>>() {
 187             public Class<? extends DatapathTypeBase> answer(
 188                     InvocationOnMock invocation) throws Throwable {
 189                 return DatapathTypeSystem.class;
 190             }
 191         });
 192         assertEquals("system", SouthboundMapper.createDatapathType(mdsalbridge));
 193     }
 194
 195     @Test
 196     public void testCreateDatapathType1() {
 197         assertEquals(DatapathTypeSystem.class, SouthboundMapper.createDatapathType(""));
 198         assertEquals(DatapathTypeSystem.class, SouthboundMapper.createDatapathType("system"));
 199         assertEquals(DatapathTypeNetdev.class, SouthboundMapper.createDatapathType("netdev"));
 200     }
 201
 202     @Test
 203     public void testCreateOvsdbBridgeProtocols() {
 204         OvsdbBridgeAugmentation ovsdbBridgeNode = mock(OvsdbBridgeAugmentation.class);
 205         List<ProtocolEntry> protocolList = new ArrayList<>();
 206         ProtocolEntry protocolEntry = mock(ProtocolEntry.class);
 207         protocolList.add(protocolEntry);
 208         when(ovsdbBridgeNode.getProtocolEntry()).thenReturn(protocolList);
 209         when(protocolEntry.getProtocol()).thenAnswer(new Answer<Class<? extends OvsdbBridgeProtocolBase>>() {
 210             public Class<? extends OvsdbBridgeProtocolBase> answer(
 211                     InvocationOnMock invocation) throws Throwable {
 212                 return OvsdbBridgeProtocolOpenflow10.class;
 213             }
 214         });
 215         Set<String> protocols = new HashSet<>();
 216         protocols.add("OpenFlow10");
 217         assertEquals(protocols, SouthboundMapper.createOvsdbBridgeProtocols(ovsdbBridgeNode));
 218     }
 219
 220     @Test
 221     public void testCreateInterfaceType() {
 222         assertEquals(InterfaceTypeInternal.class, SouthboundMapper.createInterfaceType("internal"));
 223         assertEquals(InterfaceTypeVxlan.class, SouthboundMapper.createInterfaceType("vxlan"));
 224     }
 225
 226     @Test
 227     public void testCreateOvsdbInterfaceType() {
 228         assertEquals("internal", SouthboundMapper.createOvsdbInterfaceType(InterfaceTypeInternal.class));
 229         assertEquals("vxlan", SouthboundMapper.createOvsdbInterfaceType(InterfaceTypeVxlan.class));
 230     }
 231
 232     @SuppressWarnings("unchecked")
 233     @Test
 234     public void testCreateMdsalProtocols() throws Exception {
 235         Bridge bridge = mock(Bridge.class);
 236         Set<String> value = new HashSet<>();
 237         value.add("OpenFlow10");
 238         Column<GenericTableSchema, Set<String>> column = mock(Column.class);
 239         when(bridge.getProtocolsColumn()).thenReturn(column);
 240         when(column.getData()).thenReturn(value);
 241
 242         List<ProtocolEntry> returnedProtocols = SouthboundMapper.createMdsalProtocols(bridge);
 243         assertEquals(value.size(), returnedProtocols.size());
 244         assertEquals(OvsdbBridgeProtocolOpenflow10.class, returnedProtocols.get(0).getProtocol());
 245     }
 246
 247     @SuppressWarnings("unchecked")
 248     @Test
 249     public void testCreateControllerEntries() throws Exception {
 250         Bridge bridge = mock(Bridge.class);
 251         Column<GenericTableSchema, Set<UUID>> controllerColumn = mock(Column.class);
 252         when(bridge.getControllerColumn()).thenReturn(controllerColumn);
 253         Set<UUID> controllerUUIDs = new HashSet<>();
 254         String uuidString = "7da709ff-397f-4778-a0e8-994811272fdb";
 255         UUID uuid = new UUID(uuidString);
 256         controllerUUIDs.add(uuid);
 257         Controller controller = mock(Controller.class);
 258         Column<GenericTableSchema, String> targetColumn = mock(Column.class);
 259         when(targetColumn.getData()).thenReturn("targetData");
 260         when(controller.getTargetColumn()).thenReturn(targetColumn);
 261         when(controller.getUuid()).thenReturn(uuid);
 262         Column<GenericTableSchema, Boolean> isConnectedColumn = mock(Column.class);
 263         when(isConnectedColumn.getData()).thenReturn(true);
 264         when(controller.getIsConnectedColumn()).thenReturn(isConnectedColumn);
 265         Map<UUID, Controller> updatedControllerRows = new HashMap<>();
 266         updatedControllerRows.put(uuid, controller);
 267         when(controllerColumn.getData()).thenReturn(controllerUUIDs);
 268
 269         List<ControllerEntry> controllerEntries = new ArrayList<>();
 270         ControllerEntry controllerEntry = new ControllerEntryBuilder()
 271                 .setControllerUuid(Uuid.getDefaultInstance(uuidString))
 272                 .setIsConnected(true)
 273                 .setTarget(Uri.getDefaultInstance("targetData"))
 274                 .build();
 275         controllerEntries.add(controllerEntry);
 276
 277         assertEquals(controllerEntries, SouthboundMapper.createControllerEntries(bridge, updatedControllerRows));
 278     }
 279
 280     @Test
 281     public void testCreateControllerEntries1() throws Exception {
 282
 283     }
 284
 285     @Test
 286     public void testCreateOvsdbController() throws Exception {
 287         try (InputStream resourceAsStream = SouthboundMapperTest.class.getResourceAsStream("openvswitch_schema.json")) {
 288             ObjectMapper mapper = new ObjectMapper();
 289             JsonNode jsonNode = mapper.readTree(resourceAsStream);
 290
 291             DatabaseSchema dbSchema = DatabaseSchema.fromJson(OvsdbSchemaContants.DATABASE_NAME, jsonNode.get("result"));
 292
 293             String uuidString = "7da709ff-397f-4778-a0e8-994811272fdb";
 294             OvsdbBridgeAugmentation omn = new OvsdbBridgeAugmentationBuilder()
 295                     .setControllerEntry(Collections.singletonList(new ControllerEntryBuilder()
 296                             .setControllerUuid(Uuid.getDefaultInstance(uuidString))
 297                             .setTarget(Uri.getDefaultInstance("uri"))
 298                             .build()))
 299                     .build();
 300
 301             Map<UUID, Controller> returnedControllers = SouthboundMapper.createOvsdbController(omn, dbSchema);
 302             assertEquals(1, returnedControllers.size());
 303             Controller returnedController = returnedControllers.values().iterator().next();
 304             assertEquals("uri", returnedController.getTargetColumn().getData());
 305         }
 306     }
 307
 308     @Test
 309     public void testCreateConnectionInfo() throws Exception {
 310         OvsdbClient client = mock(OvsdbClient.class, Mockito.RETURNS_DEEP_STUBS);
 311
 312         InetAddress remoteAddress = InetAddress.getByAddress(new byte[] {1, 2, 3, 4});
 313         when(client.getConnectionInfo().getRemoteAddress()).thenReturn(remoteAddress);
 314         when(client.getConnectionInfo().getRemotePort()).thenReturn(8080);
 315         InetAddress localAddress = InetAddress.getByAddress(new byte[] {1, 2, 3, 5});
 316         when(client.getConnectionInfo().getLocalAddress()).thenReturn(localAddress);
 317         when(client.getConnectionInfo().getLocalPort()).thenReturn(8081);
 318
 319         ConnectionInfo returnedConnectionInfo = SouthboundMapper.createConnectionInfo(client);
 320         assertEquals(IpAddressBuilder.getDefaultInstance("1.2.3.4"), returnedConnectionInfo.getRemoteIp());
 321         assertEquals(8080, (int) returnedConnectionInfo.getRemotePort().getValue());
 322         assertEquals(IpAddressBuilder.getDefaultInstance("1.2.3.5"), returnedConnectionInfo.getLocalIp());
 323         assertEquals(8081, (int) returnedConnectionInfo.getLocalPort().getValue());
 324     }
 325
 326     @Test
 327     public void testSuppressLocalIpPort() throws Exception {
 328         ConnectionInfo connectionInfo = mock(ConnectionInfo.class);
 329         IpAddress ipAddress = IpAddressBuilder.getDefaultInstance("1.2.3.4");
 330         when(connectionInfo.getRemoteIp()).thenReturn(ipAddress);
 331         PortNumber portNumber = PortNumber.getDefaultInstance("8080");
 332         when(connectionInfo.getRemotePort()).thenReturn(portNumber);
 333         ConnectionInfo returnedConnectionInfo = SouthboundMapper.suppressLocalIpPort(connectionInfo);
 334         assertEquals(ipAddress, returnedConnectionInfo.getRemoteIp());
 335         assertEquals(portNumber, returnedConnectionInfo.getRemotePort());
 336         assertNull(returnedConnectionInfo.getLocalIp());
 337         assertNull(returnedConnectionInfo.getLocalPort());
 338     }
 339
 340     @SuppressWarnings("unchecked")
 341     @Test
 342     public void testCreateManagerEntries() throws Exception {
 343         OpenVSwitch ovsdbNode = mock(OpenVSwitch.class);
 344         Map<UUID, Manager> updatedManagerRows = new HashMap<>();
 345         Set<UUID> managerUUIDs = new HashSet<>();
 346         UUID uuid = new UUID("7da709ff-397f-4778-a0e8-994811272fdb");
 347         Manager manager = mock(Manager.class);
 348         managerUUIDs.add(uuid);
 349         updatedManagerRows.put(uuid, manager);
 350         Column<GenericTableSchema, Set<UUID>> column = mock(Column.class);
 351         when(ovsdbNode.getManagerOptionsColumn()).thenReturn(column);
 352         when(column.getData()).thenReturn(managerUUIDs);
 353
 354         //Test addManagerEntries(managerEntriesCreated, manager)
 355         Column<GenericTableSchema, String> value = mock(Column.class);
 356         when(manager.getTargetColumn()).thenReturn(value);
 357         when(value.getData()).thenReturn("dummy");
 358
 359         Column<GenericTableSchema, Map<String, String>> statusColumn = mock(Column.class);
 360         when(manager.getStatusColumn()).thenReturn(statusColumn);
 361         Map<String, String> statusAttributeMap = new HashMap<>();
 362         when(statusColumn.getData()).thenReturn(statusAttributeMap);
 363         String numberOfConnectionValueStr = "999";
 364
 365         //statusAttributeMap contains N_CONNECTIONS_STR key
 366         statusAttributeMap.put("n_connections", numberOfConnectionValueStr);
 367
 368         Column<GenericTableSchema, Boolean> isConnectedColumn = mock(Column.class);
 369         when(manager.getIsConnectedColumn()).thenReturn(isConnectedColumn);
 370         when(isConnectedColumn.getData()).thenReturn(true);
 371
 372         assertEquals(Collections.singletonList(new ManagerEntryBuilder()
 373                 .setConnected(true)
 374                 .setNumberOfConnections(999L)
 375                 .setTarget(Uri.getDefaultInstance("dummy"))
 376                 .build()), SouthboundMapper.createManagerEntries(ovsdbNode, updatedManagerRows));
 377
 378         //statusAttributeMap contains N_CONNECTIONS_STR key
 379         statusAttributeMap.remove("n_connections");
 380         assertEquals(Collections.singletonList(new ManagerEntryBuilder()
 381                 .setConnected(true)
 382                 .setNumberOfConnections(1L)
 383                 .setTarget(Uri.getDefaultInstance("dummy"))
 384                 .build()), SouthboundMapper.createManagerEntries(ovsdbNode, updatedManagerRows));
 385     }
 386
 387     @SuppressWarnings("unchecked")
 388     @Test
 389     public void testCreateManagerEntries1() throws Exception {
 390         Node ovsdbNode = mock(Node.class);
 391         Map<Uri, Manager> updatedManagerRows = new HashMap<>();
 392         Uri uri = mock(Uri.class);
 393         Manager manager = mock(Manager.class);
 394         updatedManagerRows.put(uri, manager);
 395
 396         List<ManagerEntry> managerEntriesCreated = new ArrayList<>();
 397
 398         //ovsdbNodeAugmentation is null
 399         when(ovsdbNode.getAugmentation(OvsdbNodeAugmentation.class)).thenReturn(null);
 400         assertEquals(managerEntriesCreated, SouthboundMapper.createManagerEntries(ovsdbNode, updatedManagerRows));
 401
 402         //ovsdbNodeAugmentation not null
 403         OvsdbNodeAugmentation ovsdbNodeAugmentation = mock(OvsdbNodeAugmentation.class);
 404         when(ovsdbNode.getAugmentation(OvsdbNodeAugmentation.class)).thenReturn(ovsdbNodeAugmentation);
 405
 406         List<ManagerEntry> managerEntries = new ArrayList<>();
 407         ManagerEntry managerEntry = mock(ManagerEntry.class);
 408         managerEntries.add(managerEntry);
 409         when(ovsdbNodeAugmentation.getManagerEntry()).thenReturn(managerEntries);
 410         when(managerEntry.getTarget()).thenReturn(uri);
 411
 412         //Test addManagerEntries(managerEntriesCreated, manager)
 413         Column<GenericTableSchema, String> value = mock(Column.class);
 414         when(manager.getTargetColumn()).thenReturn(value);
 415         when(value.getData()).thenReturn("dummy");
 416
 417         Column<GenericTableSchema, Map<String, String>> statusColumn = mock(Column.class);
 418         when(manager.getStatusColumn()).thenReturn(statusColumn);
 419         Map<String, String> statusAttributeMap = new HashMap<>();
 420         when(statusColumn.getData()).thenReturn(statusAttributeMap);
 421         String numberOfConnectionValueStr = "999";
 422
 423         //statusAttributeMap contains N_CONNECTIONS_STR key
 424         statusAttributeMap.put("n_connections", numberOfConnectionValueStr);
 425
 426         Column<GenericTableSchema, Boolean> isConnectedColumn = mock(Column.class);
 427         when(manager.getIsConnectedColumn()).thenReturn(isConnectedColumn);
 428         when(isConnectedColumn.getData()).thenReturn(true);
 429
 430         assertEquals(Collections.singletonList(new ManagerEntryBuilder()
 431                 .setConnected(true)
 432                 .setNumberOfConnections(999L)
 433                 .setTarget(Uri.getDefaultInstance("dummy"))
 434                 .build()), SouthboundMapper.createManagerEntries(ovsdbNode, updatedManagerRows));
 435
 436         //statusAttributeMap contains N_CONNECTIONS_STR key
 437         statusAttributeMap.remove("n_connections");
 438         assertEquals(Collections.singletonList(new ManagerEntryBuilder()
 439                 .setConnected(true)
 440                 .setNumberOfConnections(1L)
 441                 .setTarget(Uri.getDefaultInstance("dummy"))
 442                 .build()), SouthboundMapper.createManagerEntries(ovsdbNode, updatedManagerRows));
 443     }
 444
 445     @SuppressWarnings("unchecked")
 446     @Test
 447     public void testGetInstanceIdentifier() throws Exception {
 448         OpenVSwitch ovs = mock(OpenVSwitch.class);
 449         Column<GenericTableSchema, Map<String, String>> externalIdColumn = mock(Column.class);
 450         when(ovs.getExternalIdsColumn()).thenReturn(externalIdColumn);
 451         Map<String, String> externalIdMap = new HashMap<>();
 452         when(externalIdColumn.getData()).thenReturn(externalIdMap);
 453         // if true
 454         externalIdMap.put(SouthboundConstants.IID_EXTERNAL_ID_KEY, "test");
 455         InstanceIdentifierCodec iidc = mock(InstanceIdentifierCodec.class);
 456         InstanceIdentifier iid = InstanceIdentifier.create(Node.class);
 457         when(iidc.bindingDeserializer("test")).thenReturn(iid);
 458         SouthboundUtil.setInstanceIdentifierCodec(iidc);
 459         assertEquals("Incorrect Instance Identifier received", iid, SouthboundMapper.getInstanceIdentifier(ovs));
 460         // if false
 461         externalIdMap.clear();
 462         UUID uuID = new UUID("test");
 463         when(ovs.getUuid()).thenReturn(uuID);
 464         assertNotNull(SouthboundMapper.getInstanceIdentifier(ovs));
 465     }
 466 }