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