UT for southbound/transactions/md - set 4

8. OvsdbManagersUpdateCommand.java
9. OvsdbNodeRemoveCommand.java
10. OvsdbOperationalCommandAggregator.java

Change-Id: I4597340cb871fb6b8558f2632ad71423a3cb8176
Signed-off-by: Rashmi Pujar <rpujar@inocybe.com>

diff --git a/southbound/southbound-impl/src/test/java/org/opendaylight/ovsdb/southbound/transactions/md/OvsdbManagersUpdateCommandTest.java b/southbound/southbound-impl/src/test/java/org/opendaylight/ovsdb/southbound/transactions/md/OvsdbManagersUpdateCommandTest.java
new file mode 100644 (file)
index 0000000..4a8aa7e
--- /dev/null
+++ b/southbound/southbound-impl/src/test/java/org/opendaylight/ovsdb/southbound/transactions/md/OvsdbManagersUpdateCommandTest.java
@@ -0,0 +1,169 @@
+package org.opendaylight.ovsdb.southbound.transactions.md;
+
+import static org.junit.Assert.*;
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mockito;
+import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.ovsdb.lib.message.TableUpdates;
+import org.opendaylight.ovsdb.lib.notation.Column;
+import org.opendaylight.ovsdb.lib.notation.UUID;
+import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
+import org.opendaylight.ovsdb.lib.schema.GenericTableSchema;
+import org.opendaylight.ovsdb.schema.openvswitch.Bridge;
+import org.opendaylight.ovsdb.schema.openvswitch.Controller;
+import org.opendaylight.ovsdb.schema.openvswitch.Manager;
+import org.opendaylight.ovsdb.schema.openvswitch.OpenVSwitch;
+import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance;
+import org.opendaylight.ovsdb.southbound.SouthboundMapper;
+import org.opendaylight.ovsdb.southbound.SouthboundUtil;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Uri;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagerEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagerEntryKey;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.api.support.membermodification.MemberMatcher;
+import org.powermock.api.support.membermodification.MemberModifier;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+import org.powermock.reflect.Whitebox;
+
+import com.google.common.base.Optional;
+
+@PrepareForTest({OvsdbManagersUpdateCommand.class, SouthboundMapper.class, SouthboundUtil.class, InstanceIdentifier.class})
+@RunWith(PowerMockRunner.class)
+public class OvsdbManagersUpdateCommandTest {
+
+    private static final String TARGET_COLUMN_DATA = "Manager Column";
+    private static final String NODE_ID = "Node ID String";
+    private Map<UUID, Manager> updatedManagerRows;
+    private Map<UUID, OpenVSwitch> updatedOpenVSwitchRows;
+    private OvsdbManagersUpdateCommand ovsdbManagersUpdateCommand;
+
+    @Before
+    public void setUp() {
+        ovsdbManagersUpdateCommand = PowerMockito.mock(OvsdbManagersUpdateCommand.class, Mockito.CALLS_REAL_METHODS);
+    }
+
+    @Test
+    public void testOvsdbManagersUpdateCommand() {
+        OvsdbConnectionInstance key = mock(OvsdbConnectionInstance.class);
+        TableUpdates updates = mock(TableUpdates.class);
+        DatabaseSchema dbSchema = mock(DatabaseSchema.class);
+        OvsdbManagersUpdateCommand ovsdbManagersUpdateCommand1 = new OvsdbManagersUpdateCommand(key, updates, dbSchema);
+        assertEquals(key, Whitebox.getInternalState(ovsdbManagersUpdateCommand1, "key"));
+        assertEquals(updates, Whitebox.getInternalState(ovsdbManagersUpdateCommand1, "updates"));
+        assertEquals(dbSchema, Whitebox.getInternalState(ovsdbManagersUpdateCommand1, "dbSchema"));
+    }
+
+    @Test
+    public void testExecute() throws Exception {
+        ReadWriteTransaction transaction= mock(ReadWriteTransaction.class);
+        updatedManagerRows = new HashMap<UUID, Manager>();
+        updatedManagerRows.put(mock(UUID.class), mock(Manager.class));
+        MemberModifier.field(OvsdbManagersUpdateCommand.class, "updatedManagerRows").set(ovsdbManagersUpdateCommand, updatedManagerRows);
+        Map<Uri, Manager> updatedManagerRowsWithUri = new HashMap<>();
+        PowerMockito.doReturn(updatedManagerRowsWithUri).when(ovsdbManagersUpdateCommand, "getUriManagerMap", any(Map.class));
+
+        updatedOpenVSwitchRows = new HashMap<UUID, OpenVSwitch>();
+        updatedOpenVSwitchRows.put(mock(UUID.class), mock(OpenVSwitch.class));
+        MemberModifier.field(OvsdbManagersUpdateCommand.class, "updatedOpenVSwitchRows").set(ovsdbManagersUpdateCommand, updatedOpenVSwitchRows);
+
+        //mock updateManagers()
+        PowerMockito.doNothing().when(ovsdbManagersUpdateCommand, "updateManagers", any(ReadWriteTransaction.class), any(Map.class), any(Map.class));
+
+        ovsdbManagersUpdateCommand.execute(transaction);
+        PowerMockito.verifyPrivate(ovsdbManagersUpdateCommand).invoke("getUriManagerMap", any(Map.class));
+        PowerMockito.verifyPrivate(ovsdbManagersUpdateCommand).invoke("updateManagers", any(ReadWriteTransaction.class), any(Map.class), any(Map.class));
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void testUpdateManagers() throws Exception {
+        ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
+        Map<UUID, Manager> updatedManagerRows = new HashMap<>();
+        Map<UUID, OpenVSwitch> updatedOpenVSwitchRows = new HashMap<>();
+        OpenVSwitch openVSwitch = mock(OpenVSwitch.class);
+        updatedOpenVSwitchRows.put(mock(UUID.class), openVSwitch);
+
+        PowerMockito.mockStatic(SouthboundMapper.class);
+        List<ManagerEntry> managerEntries = new ArrayList<ManagerEntry>();
+        managerEntries.add(mock(ManagerEntry.class));
+        when(SouthboundMapper.createManagerEntries(any(OpenVSwitch.class), any(Map.class))).thenReturn(managerEntries);
+
+        //mock getManagerEntryIid()
+        PowerMockito.doReturn(mock(InstanceIdentifier.class)).when(ovsdbManagersUpdateCommand, "getManagerEntryIid", any(ManagerEntry.class));
+        doNothing().when(transaction).merge(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(ManagerEntry.class));
+        Whitebox.invokeMethod(ovsdbManagersUpdateCommand, "updateManagers", transaction, updatedManagerRows, updatedOpenVSwitchRows);
+        verify(transaction).merge(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(ManagerEntry.class));
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void testUpdateManagers1() throws Exception {
+        ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
+        Map<Uri, Manager> updatedManagerRows = new HashMap<Uri, Manager>();
+        OvsdbConnectionInstance ovsdbConnectionInstance = mock(OvsdbConnectionInstance.class);
+        when(ovsdbManagersUpdateCommand.getOvsdbConnectionInstance()).thenReturn(ovsdbConnectionInstance);
+        InstanceIdentifier<Node> connectionIId = mock(InstanceIdentifier.class);
+        when(ovsdbConnectionInstance.getInstanceIdentifier()).thenReturn(connectionIId);
+
+        Optional<Node> ovsdbNode = mock(Optional.class);
+        PowerMockito.mockStatic(SouthboundUtil.class);
+        when(SouthboundUtil.readNode(any(ReadWriteTransaction.class), any(InstanceIdentifier.class))).thenReturn(ovsdbNode);
+        when(ovsdbNode.isPresent()).thenReturn(true);
+        when(ovsdbNode.get()).thenReturn(mock(Node.class));
+        Whitebox.invokeMethod(ovsdbManagersUpdateCommand, "updateManagers", transaction, updatedManagerRows);
+        verify(ovsdbNode, times(2)).get();
+    }
+
+    @Test
+    public void testGetManagerEntryIid() throws Exception {
+        ManagerEntry managerEntry = mock(ManagerEntry.class);
+        OvsdbConnectionInstance client = mock(OvsdbConnectionInstance.class, Mockito.RETURNS_DEEP_STUBS);
+        when(ovsdbManagersUpdateCommand.getOvsdbConnectionInstance()).thenReturn(client);
+        when(client.getNodeKey().getNodeId().getValue()).thenReturn(NODE_ID);
+        PowerMockito.whenNew(Uri.class).withAnyArguments().thenReturn(mock(Uri.class));
+
+        NodeId nodeId = mock(NodeId.class);
+        PowerMockito.whenNew(NodeId.class).withAnyArguments().thenReturn(nodeId);
+        NodeKey nodeKey = mock(NodeKey.class);
+        PowerMockito.whenNew(NodeKey.class).withAnyArguments().thenReturn(nodeKey);
+        when(managerEntry.getKey()).thenReturn(mock(ManagerEntryKey.class));
+        assertEquals(KeyedInstanceIdentifier.class, Whitebox.invokeMethod(ovsdbManagersUpdateCommand, "getManagerEntryIid", managerEntry).getClass());
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void testGetUriManagerMap() throws Exception {
+        Map<UUID,Manager> uuidManagerMap = new HashMap<>();
+        Manager manager = mock(Manager.class);
+        uuidManagerMap.put(mock(UUID.class), manager);
+        Map<Uri, Manager> testUriManagerMap = new HashMap<>();
+
+        Column<GenericTableSchema, String> column = mock(Column.class);
+        when(manager.getTargetColumn()).thenReturn(column);
+        when(column.getData()).thenReturn(TARGET_COLUMN_DATA);
+
+        Uri uri = mock(Uri.class);
+        PowerMockito.whenNew(Uri.class).withAnyArguments().thenReturn(uri);
+        testUriManagerMap.put(uri, manager);
+        assertEquals(testUriManagerMap, Whitebox.invokeMethod(ovsdbManagersUpdateCommand, "getUriManagerMap", uuidManagerMap));
+    }
+}

diff --git a/southbound/southbound-impl/src/test/java/org/opendaylight/ovsdb/southbound/transactions/md/OvsdbNodeRemoveCommandTest.java b/southbound/southbound-impl/src/test/java/org/opendaylight/ovsdb/southbound/transactions/md/OvsdbNodeRemoveCommandTest.java
new file mode 100644 (file)
index 0000000..834e23d
--- /dev/null
+++ b/southbound/southbound-impl/src/test/java/org/opendaylight/ovsdb/southbound/transactions/md/OvsdbNodeRemoveCommandTest.java
@@ -0,0 +1,123 @@
+package org.opendaylight.ovsdb.southbound.transactions.md;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mockito;
+import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.ovsdb.lib.message.TableUpdates;
+import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
+import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeRef;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagerEntry;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+import org.powermock.reflect.Whitebox;
+
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.CheckedFuture;
+
+@PrepareForTest({OvsdbNodeRemoveCommand.class})
+@RunWith(PowerMockRunner.class)
+public class OvsdbNodeRemoveCommandTest {
+    private static final long ONE_CONNECTED_MANAGER = 1;
+    private static final long ONE_ACTIVE_CONNECTION_IN_PASSIVE_MODE = 1;
+    private OvsdbNodeRemoveCommand ovsdbNodeRemoveCommand;
+
+    @Before
+    public void setUp() throws Exception {
+        ovsdbNodeRemoveCommand = PowerMockito.mock(OvsdbNodeRemoveCommand.class, Mockito.CALLS_REAL_METHODS);
+    }
+
+    @Test
+    public void testOvsdbControllerRemovedCommand() {
+        OvsdbConnectionInstance key = mock(OvsdbConnectionInstance.class);
+        TableUpdates updates = mock(TableUpdates.class);
+        DatabaseSchema dbSchema = mock(DatabaseSchema.class);
+        OvsdbNodeRemoveCommand ovsdbNodeRemoveCommand1 = new OvsdbNodeRemoveCommand(key, updates, dbSchema);
+        assertEquals(key, Whitebox.getInternalState(ovsdbNodeRemoveCommand1, "key"));
+        assertEquals(updates, Whitebox.getInternalState(ovsdbNodeRemoveCommand1, "updates"));
+        assertEquals(dbSchema, Whitebox.getInternalState(ovsdbNodeRemoveCommand1, "dbSchema"));
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void testExecute() throws Exception {
+        ReadWriteTransaction transaction= mock(ReadWriteTransaction.class);
+        CheckedFuture<Optional<Node>, ReadFailedException> ovsdbNodeFuture = mock(CheckedFuture.class);
+        OvsdbConnectionInstance ovsdbConnectionInstance = mock(OvsdbConnectionInstance.class);
+        when(ovsdbNodeRemoveCommand.getOvsdbConnectionInstance()).thenReturn(ovsdbConnectionInstance);
+        when(ovsdbConnectionInstance.getInstanceIdentifier()).thenReturn(mock(InstanceIdentifier.class));
+        when(transaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(ovsdbNodeFuture);
+
+        Optional<Node> ovsdbNodeOptional = mock(Optional.class);
+        when(ovsdbNodeFuture.get()).thenReturn(ovsdbNodeOptional);
+        when(ovsdbNodeOptional.isPresent()).thenReturn(true);
+        Node ovsdbNode = mock(Node.class);
+        when(ovsdbNodeOptional.get()).thenReturn(ovsdbNode);
+        OvsdbNodeAugmentation ovsdbNodeAugmentation = mock(OvsdbNodeAugmentation.class);
+        when(ovsdbNode.getAugmentation(OvsdbNodeAugmentation.class)).thenReturn(ovsdbNodeAugmentation);
+
+        PowerMockito.doReturn(true).when(ovsdbNodeRemoveCommand, "checkIfOnlyConnectedManager", any(OvsdbNodeAugmentation.class));
+
+        List<ManagedNodeEntry> listManagedNodeEntry = new ArrayList<ManagedNodeEntry>();
+        ManagedNodeEntry managedNode = mock(ManagedNodeEntry.class);
+        listManagedNodeEntry.add(managedNode);
+        when(ovsdbNodeAugmentation.getManagedNodeEntry()).thenReturn(listManagedNodeEntry);
+        OvsdbBridgeRef ovsdbBridgeRef = mock(OvsdbBridgeRef.class);
+        when(managedNode.getBridgeRef()).thenReturn(ovsdbBridgeRef);
+        when(ovsdbBridgeRef.getValue()).thenReturn(mock(InstanceIdentifier.class));
+
+        doNothing().when(transaction).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
+
+        ovsdbNodeRemoveCommand.execute(transaction);
+        verify(ovsdbNodeAugmentation, times(2)).getManagedNodeEntry();
+        verify(transaction, times(2)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
+    }
+
+    @Test
+    public void testCheckIfOnlyConnectedManager() throws Exception {
+        OvsdbNodeAugmentation ovsdbNodeAugmentation = mock(OvsdbNodeAugmentation.class);
+        ManagerEntry onlyConnectedManager= mock(ManagerEntry.class);
+        ManagerEntry manager = mock(ManagerEntry.class);
+        List<ManagerEntry> listManagerEntry = new ArrayList<ManagerEntry>();
+        listManagerEntry.add(manager);
+
+        //case 1: connectedManager > ONE_CONNECTED_MANAGER
+        ManagerEntry manager1 = mock(ManagerEntry.class);
+        listManagerEntry.add(manager1);
+        when(ovsdbNodeAugmentation.getManagerEntry()).thenReturn(listManagerEntry);
+        when(manager.isConnected()).thenReturn(true, false, true);
+        when(manager1.isConnected()).thenReturn(true, false, true);
+        assertEquals(false, Whitebox.invokeMethod(ovsdbNodeRemoveCommand, "checkIfOnlyConnectedManager", ovsdbNodeAugmentation));
+
+        //case 2: connectedManager == 0
+        assertEquals(true, Whitebox.invokeMethod(ovsdbNodeRemoveCommand, "checkIfOnlyConnectedManager", ovsdbNodeAugmentation));
+
+        //case 3: onlyConnectedManager.getNumberOfConnections().longValue() > ONE_ACTIVE_CONNECTION_IN_PASSIVE_MODE
+        when(onlyConnectedManager.getNumberOfConnections()).thenReturn(new Long(ONE_CONNECTED_MANAGER + 1), new Long(ONE_ACTIVE_CONNECTION_IN_PASSIVE_MODE));
+        assertEquals(false, Whitebox.invokeMethod(ovsdbNodeRemoveCommand, "checkIfOnlyConnectedManager", ovsdbNodeAugmentation));
+
+        //case 4: when all the above don't apply
+        listManagerEntry.remove(manager1);
+        assertEquals(true, Whitebox.invokeMethod(ovsdbNodeRemoveCommand, "checkIfOnlyConnectedManager", ovsdbNodeAugmentation));
+    }
+}

diff --git a/southbound/southbound-impl/src/test/java/org/opendaylight/ovsdb/southbound/transactions/md/OvsdbOperationalCommandAggregatorTest.java b/southbound/southbound-impl/src/test/java/org/opendaylight/ovsdb/southbound/transactions/md/OvsdbOperationalCommandAggregatorTest.java
new file mode 100644 (file)
index 0000000..29aaa16
--- /dev/null
+++ b/southbound/southbound-impl/src/test/java/org/opendaylight/ovsdb/southbound/transactions/md/OvsdbOperationalCommandAggregatorTest.java
@@ -0,0 +1,69 @@
+package org.opendaylight.ovsdb.southbound.transactions.md;
+
+import static org.junit.Assert.*;
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mockito;
+import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
+import org.opendaylight.ovsdb.lib.message.TableUpdates;
+import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
+import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.api.support.membermodification.MemberModifier;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+import org.powermock.reflect.Whitebox;
+
+@PrepareForTest({})
+@RunWith(PowerMockRunner.class)
+public class OvsdbOperationalCommandAggregatorTest {
+    private static final int NUMBER_OF_COMMANDS = 9;
+    private List<TransactionCommand> commands = new ArrayList<TransactionCommand>();
+    private OvsdbOperationalCommandAggregator ovsdbOperationalCommandAggregator;
+
+    @Before
+    public void setUp() throws Exception {
+        ovsdbOperationalCommandAggregator = PowerMockito.mock(OvsdbOperationalCommandAggregator.class, Mockito.CALLS_REAL_METHODS);
+
+        //mock commands field
+        commands.add(mock(OpenVSwitchUpdateCommand.class));
+        commands.add(mock(OvsdbManagersUpdateCommand.class));
+        commands.add(mock(OvsdbManagersRemovedCommand.class));
+        commands.add(mock(OvsdbBridgeUpdateCommand.class));
+        commands.add(mock(OvsdbBridgeRemovedCommand.class));
+        commands.add(mock(OvsdbControllerUpdateCommand.class));
+        commands.add(mock(OvsdbControllerRemovedCommand.class));
+        commands.add(mock(OvsdbPortUpdateCommand.class));
+        commands.add(mock(OvsdbPortRemoveCommand.class));
+        MemberModifier.field(OvsdbOperationalCommandAggregator.class, "commands").set(ovsdbOperationalCommandAggregator, commands);
+    }
+
+    @Test
+    public void testOvsdbOperationalCommandAggregator() throws Exception {
+        OvsdbConnectionInstance key = mock(OvsdbConnectionInstance.class);
+        TableUpdates updates = mock(TableUpdates.class);
+        DatabaseSchema dbSchema = mock(DatabaseSchema.class);
+        OvsdbOperationalCommandAggregator ovsdbOperationalCommandAggregator1 = new OvsdbOperationalCommandAggregator(key, updates, dbSchema);
+        List<TransactionCommand> testCommands = Whitebox.getInternalState(ovsdbOperationalCommandAggregator1, "commands");
+        assertEquals(NUMBER_OF_COMMANDS, testCommands.size());
+    }
+
+    @Test
+    public void testExecute() {
+        ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
+        for (TransactionCommand command: commands) {
+            doNothing().when(command).execute(any(ReadWriteTransaction.class));
+        }
+        ovsdbOperationalCommandAggregator.execute(transaction);
+        for (TransactionCommand command: commands) {
+            verify(command).execute(any(ReadWriteTransaction.class));
+        }
+    }
+}