southbound/southbound-impl/src/test/java/org/opendaylight/ovsdb/southbound/transactions/md/OpenVSwitchUpdateCommandTest.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.transactions.md;
  10
  11 import static org.mockito.Matchers.any;
  12 import static org.mockito.Matchers.anyString;
  13 import static org.mockito.Matchers.eq;
  14 import static org.mockito.Mockito.doNothing;
  15 import static org.mockito.Mockito.mock;
  16 import static org.mockito.Mockito.times;
  17 import static org.mockito.Mockito.verify;
  18 import static org.mockito.Mockito.when;
  19
  20 import java.util.HashMap;
  21 import java.util.HashSet;
  22 import java.util.List;
  23 import java.util.Map;
  24 import java.util.Set;
  25 import org.junit.Before;
  26 import org.junit.Test;
  27 import org.junit.runner.RunWith;
  28 import org.mockito.Mock;
  29 import org.mockito.Mockito;
  30 import org.mockito.invocation.InvocationOnMock;
  31 import org.mockito.stubbing.Answer;
  32 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
  33 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  34 import org.opendaylight.ovsdb.lib.message.TableUpdates;
  35 import org.opendaylight.ovsdb.lib.notation.Column;
  36 import org.opendaylight.ovsdb.lib.notation.UUID;
  37 import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
  38 import org.opendaylight.ovsdb.lib.schema.GenericTableSchema;
  39 import org.opendaylight.ovsdb.lib.schema.typed.TyperUtils;
  40 import org.opendaylight.ovsdb.schema.openvswitch.OpenVSwitch;
  41 import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance;
  42 import org.opendaylight.ovsdb.southbound.SouthboundConstants;
  43 import org.opendaylight.ovsdb.southbound.SouthboundMapper;
  44 import org.opendaylight.ovsdb.southbound.SouthboundUtil;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.DatapathTypeBase;
  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.InterfaceTypeBase;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeInternal;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentationBuilder;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfo;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.DatapathTypeEntry;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.DatapathTypeEntryBuilder;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.InterfaceTypeEntry;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.InterfaceTypeEntryBuilder;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchExternalIds;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchExternalIdsBuilder;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchOtherConfigs;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchOtherConfigsBuilder;
  60 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  61 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  62 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
  63 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
  64 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  65 import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
  66 import org.powermock.api.mockito.PowerMockito;
  67 import org.powermock.api.support.membermodification.MemberMatcher;
  68 import org.powermock.api.support.membermodification.MemberModifier;
  69 import org.powermock.core.classloader.annotations.PrepareForTest;
  70 import org.powermock.modules.junit4.PowerMockRunner;
  71 import org.powermock.reflect.Whitebox;
  72
  73 @PrepareForTest({ TyperUtils.class, OpenVSwitchUpdateCommand.class, SouthboundUtil.class, SouthboundMapper.class,
  74         InstanceIdentifier.class })
  75 @RunWith(PowerMockRunner.class)
  76 public class OpenVSwitchUpdateCommandTest {
  77
  78     @Mock private OpenVSwitchUpdateCommand openVSwitchUpdateCommand;
  79     @Mock private TableUpdates updates;
  80     @Mock private DatabaseSchema dbSchema;
  81
  82     @Before
  83     public void setUp() {
  84         openVSwitchUpdateCommand = mock(OpenVSwitchUpdateCommand.class, Mockito.CALLS_REAL_METHODS);
  85     }
  86
  87     @SuppressWarnings("unchecked")
  88     @Test
  89     public void testExecute() throws Exception {
  90         PowerMockito.mockStatic(TyperUtils.class);
  91         Map<UUID, OpenVSwitch> updatedOpenVSwitchRows = new HashMap<>();
  92         UUID uuid = mock(UUID.class);
  93         OpenVSwitch ovs = mock(OpenVSwitch.class);
  94         updatedOpenVSwitchRows.put(uuid, ovs);
  95         when(TyperUtils.extractRowsUpdated(eq(OpenVSwitch.class), any(TableUpdates.class), any(DatabaseSchema.class)))
  96                 .thenReturn(updatedOpenVSwitchRows);
  97         Map<UUID, OpenVSwitch> deletedOpenVSwitchRows = new HashMap<>();
  98         OpenVSwitch ovs1 = mock(OpenVSwitch.class);
  99
 100         deletedOpenVSwitchRows.put(uuid, ovs1);
 101         when(TyperUtils.extractRowsOld(eq(OpenVSwitch.class), any(TableUpdates.class), any(DatabaseSchema.class)))
 102                 .thenReturn(deletedOpenVSwitchRows);
 103
 104         //mock getUpdates() and getDbSchema()
 105         when(openVSwitchUpdateCommand.getUpdates()).thenReturn(updates);
 106         when(openVSwitchUpdateCommand.getDbSchema()).thenReturn(dbSchema);
 107
 108         //Test getInstanceIdentifier(): case 1:
 109         // ovs.getExternalIdsColumn().getData().containsKey(SouthboundConstants.IID_EXTERNAL_ID_KEY)) == true
 110         Column<GenericTableSchema, Map<String, String>> column = mock(Column.class);
 111         Map<String, String> map = new HashMap<>();
 112         map.put(SouthboundConstants.IID_EXTERNAL_ID_KEY, "iidString");
 113         when(ovs.getExternalIdsColumn()).thenReturn(column);
 114         when(column.getData()).thenReturn(map);
 115         InstanceIdentifier<Node> iid = mock(InstanceIdentifier.class);
 116         PowerMockito.mockStatic(SouthboundUtil.class);
 117         when((InstanceIdentifier<Node>) SouthboundUtil.deserializeInstanceIdentifier(anyString())).thenReturn(iid);
 118         MemberModifier.suppress(MemberMatcher.method(OpenVSwitchUpdateCommand.class, "getOvsdbConnectionInstance"));
 119         OvsdbConnectionInstance ovsdbConnectionInstance = mock(OvsdbConnectionInstance.class);
 120         when(openVSwitchUpdateCommand.getOvsdbConnectionInstance()).thenReturn(ovsdbConnectionInstance);
 121         doNothing().when(ovsdbConnectionInstance).setInstanceIdentifier(any(InstanceIdentifier.class));
 122         when(ovsdbConnectionInstance.getInstanceIdentifier()).thenReturn(iid);
 123
 124         OvsdbNodeAugmentationBuilder ovsdbNodeBuilder = mock(OvsdbNodeAugmentationBuilder.class);
 125         PowerMockito.whenNew(OvsdbNodeAugmentationBuilder.class).withNoArguments().thenReturn(ovsdbNodeBuilder);
 126
 127         //suppress the setter methods of the class
 128         MemberModifier.suppress(MemberMatcher.method(OpenVSwitchUpdateCommand.class, "setVersion",
 129                 OvsdbNodeAugmentationBuilder.class, OpenVSwitch.class));
 130         MemberModifier.suppress(MemberMatcher.method(OpenVSwitchUpdateCommand.class, "setDataPathTypes",
 131                 OvsdbNodeAugmentationBuilder.class, OpenVSwitch.class));
 132         MemberModifier.suppress(MemberMatcher.method(OpenVSwitchUpdateCommand.class, "setInterfaceTypes",
 133                 OvsdbNodeAugmentationBuilder.class, OpenVSwitch.class));
 134         MemberModifier.suppress(MemberMatcher.method(OpenVSwitchUpdateCommand.class, "setExternalIds",
 135                 ReadWriteTransaction.class, OvsdbNodeAugmentationBuilder.class, OpenVSwitch.class, OpenVSwitch.class));
 136         MemberModifier.suppress(MemberMatcher.method(OpenVSwitchUpdateCommand.class, "setOtherConfig",
 137                 ReadWriteTransaction.class, OvsdbNodeAugmentationBuilder.class, OpenVSwitch.class, OpenVSwitch.class));
 138         MemberModifier.suppress(MemberMatcher.method(OpenVSwitchUpdateCommand.class, "getConnectionInfo"));
 139         when(openVSwitchUpdateCommand.getConnectionInfo()).thenReturn(mock(ConnectionInfo.class));
 140         when(ovsdbNodeBuilder.setConnectionInfo(any(ConnectionInfo.class))).thenReturn(ovsdbNodeBuilder);
 141
 142         NodeBuilder nodeBuilder = mock(NodeBuilder.class);
 143         PowerMockito.whenNew(NodeBuilder.class).withNoArguments().thenReturn(nodeBuilder);
 144
 145         //suppress getNodeId()
 146         MemberModifier.suppress(MemberMatcher.method(OpenVSwitchUpdateCommand.class, "getNodeId", OpenVSwitch.class));
 147         when(nodeBuilder.setNodeId(any(NodeId.class))).thenReturn(nodeBuilder);
 148         when(ovsdbNodeBuilder.build()).thenReturn(mock(OvsdbNodeAugmentation.class));
 149         when(nodeBuilder.addAugmentation(eq(OvsdbNodeAugmentation.class), any(OvsdbNodeAugmentation.class)))
 150                 .thenReturn(nodeBuilder);
 151         when(nodeBuilder.build()).thenReturn(mock(Node.class));
 152         ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
 153         doNothing().when(transaction).merge(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
 154                 any(Node.class));
 155
 156         openVSwitchUpdateCommand.execute(transaction);
 157         verify(openVSwitchUpdateCommand, times(2)).getUpdates();
 158         verify(openVSwitchUpdateCommand, times(2)).getDbSchema();
 159
 160         //Test getInstanceIdentifier(): case 2: ovs.getExternalIdsColumn() is null
 161         when(ovs.getExternalIdsColumn()).thenReturn(null);
 162         when(ovs.getUuid()).thenReturn(uuid);
 163         openVSwitchUpdateCommand.execute(transaction);
 164         verify(openVSwitchUpdateCommand, times(4)).getUpdates();
 165         verify(openVSwitchUpdateCommand, times(4)).getDbSchema();
 166     }
 167
 168     @Test
 169     @SuppressWarnings("unchecked")
 170     public void testSetOtherConfig() throws Exception {
 171         OpenVSwitch oldEntry = mock(OpenVSwitch.class);
 172         OpenVSwitch openVSwitch = mock(OpenVSwitch.class);
 173
 174         Column<GenericTableSchema, Map<String, String>> column = mock(Column.class);
 175         when(openVSwitch.getOtherConfigColumn()).thenReturn(column);
 176         Map<String, String> map = new HashMap<>();
 177         when(column.getData()).thenReturn(map);
 178         when(oldEntry.getOtherConfigColumn()).thenReturn(column);
 179         MemberModifier.suppress(MemberMatcher.method(OpenVSwitchUpdateCommand.class, "removeOldConfigs",
 180                 ReadWriteTransaction.class, Map.class, OpenVSwitch.class));
 181         MemberModifier.suppress(MemberMatcher.method(OpenVSwitchUpdateCommand.class, "setNewOtherConfigs",
 182                 OvsdbNodeAugmentationBuilder.class, Map.class));
 183
 184         ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
 185         OvsdbNodeAugmentationBuilder ovsdbNodeBuilder = mock(OvsdbNodeAugmentationBuilder.class);
 186         Whitebox.invokeMethod(openVSwitchUpdateCommand, "setOtherConfig", transaction, ovsdbNodeBuilder, oldEntry,
 187                 openVSwitch);
 188         verify(openVSwitch, times(2)).getOtherConfigColumn();
 189         verify(oldEntry, times(2)).getOtherConfigColumn();
 190         PowerMockito.verifyPrivate(openVSwitchUpdateCommand).invoke("removeOldConfigs", any(ReadWriteTransaction.class),
 191                 any(Map.class), any(OpenVSwitch.class));
 192     }
 193
 194     @Test
 195     public void testRemoveOldConfigs() throws Exception {
 196         ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
 197         Map<String, String> oldOtherConfigs = new HashMap<>();
 198         oldOtherConfigs.put("OpenvswitchOtherConfigsKey", "OpenvswitchOtherConfigsValue");
 199         doNothing().when(transaction).delete(any(LogicalDatastoreType.class), any(KeyedInstanceIdentifier.class));
 200
 201         //suppress getNodeId()
 202         MemberModifier.suppress(MemberMatcher.method(OpenVSwitchUpdateCommand.class, "getNodeId", OpenVSwitch.class));
 203         PowerMockito.whenNew(NodeKey.class).withAnyArguments().thenReturn(mock(NodeKey.class));
 204         OpenVSwitch ovs = mock(OpenVSwitch.class);
 205         Whitebox.invokeMethod(openVSwitchUpdateCommand, "removeOldConfigs", transaction, oldOtherConfigs, ovs);
 206         verify(transaction).delete(any(LogicalDatastoreType.class), any(KeyedInstanceIdentifier.class));
 207     }
 208
 209     @Test
 210     @SuppressWarnings("unchecked")
 211     public void testSetNewOtherConfigs() throws Exception {
 212         Map<String, String> otherConfigs = new HashMap<>();
 213         otherConfigs.put("otherConfigKey", "otherConfigValue");
 214
 215         OpenvswitchOtherConfigsBuilder openvswitchOtherConfigsBuilder = mock(OpenvswitchOtherConfigsBuilder.class);
 216         PowerMockito.whenNew(OpenvswitchOtherConfigsBuilder.class).withNoArguments()
 217                 .thenReturn(openvswitchOtherConfigsBuilder);
 218         when(openvswitchOtherConfigsBuilder.setOtherConfigKey(anyString())).thenReturn(openvswitchOtherConfigsBuilder);
 219         when(openvswitchOtherConfigsBuilder.setOtherConfigValue(anyString()))
 220                 .thenReturn(openvswitchOtherConfigsBuilder);
 221         when(openvswitchOtherConfigsBuilder.build()).thenReturn(mock(OpenvswitchOtherConfigs.class));
 222         OvsdbNodeAugmentationBuilder ovsdbNodeBuilder = mock(OvsdbNodeAugmentationBuilder.class);
 223         when(ovsdbNodeBuilder.setOpenvswitchOtherConfigs(any(List.class))).thenReturn(ovsdbNodeBuilder);
 224
 225         Whitebox.invokeMethod(openVSwitchUpdateCommand, "setNewOtherConfigs", ovsdbNodeBuilder, otherConfigs);
 226         verify(openvswitchOtherConfigsBuilder).setOtherConfigKey(anyString());
 227         verify(openvswitchOtherConfigsBuilder).setOtherConfigValue(anyString());
 228         verify(ovsdbNodeBuilder).setOpenvswitchOtherConfigs(any(List.class));
 229     }
 230
 231     @Test
 232     @SuppressWarnings("unchecked")
 233     public void testSetExternalIds() throws Exception {
 234         OpenVSwitch oldEntry = mock(OpenVSwitch.class);
 235         OpenVSwitch openVSwitch = mock(OpenVSwitch.class);
 236
 237         Column<GenericTableSchema, Map<String, String>> column = mock(Column.class);
 238         when(openVSwitch.getExternalIdsColumn()).thenReturn(column);
 239         Map<String, String> map = new HashMap<>();
 240         when(column.getData()).thenReturn(map);
 241         when(oldEntry.getExternalIdsColumn()).thenReturn(column);
 242         MemberModifier.suppress(MemberMatcher.method(OpenVSwitchUpdateCommand.class, "removeExternalIds",
 243                 ReadWriteTransaction.class, Map.class, OpenVSwitch.class));
 244         MemberModifier.suppress(MemberMatcher.method(OpenVSwitchUpdateCommand.class, "setNewExternalIds",
 245                 OvsdbNodeAugmentationBuilder.class, Map.class));
 246
 247         ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
 248         OvsdbNodeAugmentationBuilder ovsdbNodeBuilder = mock(OvsdbNodeAugmentationBuilder.class);
 249         Whitebox.invokeMethod(openVSwitchUpdateCommand, "setExternalIds", transaction, ovsdbNodeBuilder, oldEntry,
 250                 openVSwitch);
 251         verify(openVSwitch, times(2)).getExternalIdsColumn();
 252         verify(oldEntry, times(2)).getExternalIdsColumn();
 253         PowerMockito.verifyPrivate(openVSwitchUpdateCommand).invoke("removeExternalIds",
 254                 any(ReadWriteTransaction.class), any(Map.class), any(OpenVSwitch.class));
 255     }
 256
 257     @Test
 258     public void testRemoveExternalIds() throws Exception {
 259         ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
 260         Map<String, String> oldExternalIds = new HashMap<>();
 261         oldExternalIds.put("OpenvswitchExternalIdKey", "OpenvswitchExternalIdValue");
 262         doNothing().when(transaction).delete(any(LogicalDatastoreType.class), any(KeyedInstanceIdentifier.class));
 263
 264         //suppress getNodeId()
 265         MemberModifier.suppress(MemberMatcher.method(OpenVSwitchUpdateCommand.class, "getNodeId", OpenVSwitch.class));
 266         PowerMockito.whenNew(NodeKey.class).withAnyArguments().thenReturn(mock(NodeKey.class));
 267         OpenVSwitch ovs = mock(OpenVSwitch.class);
 268         Whitebox.invokeMethod(openVSwitchUpdateCommand, "removeExternalIds", transaction, oldExternalIds, ovs);
 269         verify(transaction).delete(any(LogicalDatastoreType.class), any(KeyedInstanceIdentifier.class));
 270     }
 271
 272     @SuppressWarnings("unchecked")
 273     @Test
 274     public void testSetNewExternalIds() throws Exception {
 275         Map<String, String> externalIds = new HashMap<>();
 276         externalIds.put("externalIdsKey", "externalIdsValue");
 277
 278         OvsdbNodeAugmentationBuilder ovsdbNodeBuilder = mock(OvsdbNodeAugmentationBuilder.class);
 279         OpenvswitchExternalIdsBuilder ovsExternalIdsBuilder = mock(OpenvswitchExternalIdsBuilder.class);
 280         PowerMockito.whenNew(OpenvswitchExternalIdsBuilder.class).withNoArguments().thenReturn(ovsExternalIdsBuilder);
 281         when(ovsExternalIdsBuilder.setExternalIdKey(anyString())).thenReturn(ovsExternalIdsBuilder);
 282         when(ovsExternalIdsBuilder.setExternalIdValue(anyString())).thenReturn(ovsExternalIdsBuilder);
 283         when(ovsExternalIdsBuilder.build()).thenReturn(mock(OpenvswitchExternalIds.class));
 284         when(ovsdbNodeBuilder.setOpenvswitchExternalIds(any(List.class))).thenReturn(ovsdbNodeBuilder);
 285
 286         Whitebox.invokeMethod(openVSwitchUpdateCommand, "setNewExternalIds", ovsdbNodeBuilder, externalIds);
 287         verify(ovsExternalIdsBuilder).setExternalIdKey(anyString());
 288         verify(ovsExternalIdsBuilder).setExternalIdValue(anyString());
 289         verify(ovsdbNodeBuilder).setOpenvswitchExternalIds(any(List.class));
 290     }
 291
 292     @Test
 293     @SuppressWarnings("unchecked")
 294     public void testSetInterfaceTypes() throws Exception {
 295         OpenVSwitch openVSwitch = mock(OpenVSwitch.class);
 296
 297         Column<GenericTableSchema, Set<String>> column = mock(Column.class);
 298         when(openVSwitch.getIfaceTypesColumn()).thenReturn(column );
 299         Set<String> set = new HashSet<>();
 300         set.add("dpdk");
 301         set.add("dpdkr");
 302         set.add("dpdkvhostuser");
 303         set.add("geneve");
 304         set.add("gre");
 305         set.add("internal");
 306         set.add("ipsec_gre");
 307         set.add("lisp");
 308         set.add("patch");
 309         set.add("stt");
 310         set.add("system");
 311         set.add("tap");
 312         set.add("vxlan");
 313         when(column.getData()).thenReturn(set);
 314         PowerMockito.mockStatic(SouthboundMapper.class);
 315         when(SouthboundMapper.createInterfaceType(anyString()))
 316                 .thenAnswer(new Answer<Class<? extends InterfaceTypeBase>>() {
 317                     public Class<? extends InterfaceTypeBase> answer(InvocationOnMock invocation) throws Exception {
 318                         return InterfaceTypeInternal.class;
 319                     }
 320                 });
 321
 322         InterfaceTypeEntry ifEntry = mock(InterfaceTypeEntry.class);
 323         InterfaceTypeEntryBuilder interfaceTypeEntryBldr = mock(InterfaceTypeEntryBuilder.class);
 324         PowerMockito.whenNew(InterfaceTypeEntryBuilder.class).withNoArguments().thenReturn(interfaceTypeEntryBldr);
 325         when(interfaceTypeEntryBldr.setInterfaceType(InterfaceTypeInternal.class)).thenReturn(interfaceTypeEntryBldr);
 326         when(interfaceTypeEntryBldr.build()).thenReturn(ifEntry);
 327
 328         OvsdbNodeAugmentationBuilder ovsdbNodeBuilder = mock(OvsdbNodeAugmentationBuilder.class);
 329         when(ovsdbNodeBuilder.setInterfaceTypeEntry(any(List.class))).thenReturn(ovsdbNodeBuilder);
 330         Whitebox.invokeMethod(openVSwitchUpdateCommand, "setInterfaceTypes", ovsdbNodeBuilder, openVSwitch);
 331         verify(openVSwitch).getIfaceTypesColumn();
 332         verify(interfaceTypeEntryBldr,times(13)).setInterfaceType(InterfaceTypeInternal.class);
 333     }
 334
 335     @Test
 336     @SuppressWarnings("unchecked")
 337     public void testSetDataPathTypes() throws Exception {
 338         OpenVSwitch openVSwitch = mock(OpenVSwitch.class);
 339         Column<GenericTableSchema, Set<String>> column = mock(Column.class);
 340         when(openVSwitch.getDatapathTypesColumn()).thenReturn(column );
 341         Set<String> set = new HashSet<>();
 342         set.add("netdev");
 343         set.add("system");
 344         when(column.getData()).thenReturn(set);
 345         PowerMockito.mockStatic(SouthboundMapper.class);
 346         when(SouthboundMapper.createDatapathType(anyString()))
 347                 .thenAnswer(new Answer<Class<? extends DatapathTypeBase>>() {
 348                     public Class<? extends DatapathTypeBase> answer(InvocationOnMock invocation) throws Exception {
 349                         return DatapathTypeSystem.class;
 350                     }
 351                 });
 352         DatapathTypeEntry dpEntry = mock(DatapathTypeEntry.class);
 353         DatapathTypeEntryBuilder datapathTypeEntryBuilder = mock(DatapathTypeEntryBuilder.class);
 354         PowerMockito.whenNew(DatapathTypeEntryBuilder.class).withNoArguments().thenReturn(datapathTypeEntryBuilder);
 355         when(datapathTypeEntryBuilder.setDatapathType(DatapathTypeSystem.class)).thenReturn(datapathTypeEntryBuilder);
 356         when(datapathTypeEntryBuilder.build()).thenReturn(dpEntry);
 357
 358         OvsdbNodeAugmentationBuilder ovsdbNodeBuilder = mock(OvsdbNodeAugmentationBuilder.class);
 359         when(ovsdbNodeBuilder.setDatapathTypeEntry(any(List.class))).thenReturn(ovsdbNodeBuilder);
 360         Whitebox.invokeMethod(openVSwitchUpdateCommand, "setDataPathTypes", ovsdbNodeBuilder, openVSwitch);
 361         verify(openVSwitch).getDatapathTypesColumn();
 362         verify(datapathTypeEntryBuilder,times(2)).setDatapathType(DatapathTypeSystem.class);
 363     }
 364
 365     @Test
 366     @SuppressWarnings("unchecked")
 367     public void testSetVersion() throws Exception {
 368         OpenVSwitch openVSwitch = mock(OpenVSwitch.class);
 369         Column<GenericTableSchema, Set<String>> column = mock(Column.class);
 370         when(openVSwitch.getOvsVersionColumn()).thenReturn(column);
 371         Set<String> set = new HashSet<>();
 372         set.add("v2.3.0");
 373         when(column.getData()).thenReturn(set);
 374         OvsdbNodeAugmentationBuilder ovsdbNodeBuilder = mock(OvsdbNodeAugmentationBuilder.class);
 375         when(ovsdbNodeBuilder.setOvsVersion(anyString())).thenReturn(ovsdbNodeBuilder);
 376
 377         Whitebox.invokeMethod(openVSwitchUpdateCommand, "setVersion", ovsdbNodeBuilder, openVSwitch);
 378         verify(ovsdbNodeBuilder).setOvsVersion(anyString());
 379         verify(openVSwitch).getOvsVersionColumn();
 380
 381
 382     }
 383 }