X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=openflowplugin-impl%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fopenflowplugin%2Fimpl%2Fdevice%2FTransactionChainManagerTest.java;h=5610f5e2a02468c6df8e4065af6dac5c35743e43;hb=05f8db12159673d0e0a95642fe86e62c14b7dc7b;hp=ef3d969b12b0200029368eb68be6d1bed167ca23;hpb=42bcd5113ccbc49385bc8f440ba659d853a3275c;p=openflowplugin.git diff --git a/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/device/TransactionChainManagerTest.java b/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/device/TransactionChainManagerTest.java index ef3d969b12..5610f5e2a0 100644 --- a/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/device/TransactionChainManagerTest.java +++ b/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/device/TransactionChainManagerTest.java @@ -5,71 +5,51 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ - package org.opendaylight.openflowplugin.impl.device; -import com.google.common.base.Optional; -import com.google.common.util.concurrent.CheckedFuture; -import com.google.common.util.concurrent.Futures; -import io.netty.util.HashedWheelTimer; +import static org.mockito.ArgumentMatchers.any; + +import java.util.concurrent.ExecutionException; import org.junit.After; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; -import org.mockito.Matchers; import org.mockito.Mock; import org.mockito.Mockito; -import org.mockito.runners.MockitoJUnitRunner; -import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain; -import org.opendaylight.controller.md.sal.binding.api.DataBroker; -import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction; -import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; -import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction; -import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; -import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException; -import org.opendaylight.controller.md.sal.common.api.data.TransactionChain; -import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener; -import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException; -import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext; +import org.mockito.junit.MockitoJUnitRunner; +import org.opendaylight.mdsal.binding.api.DataBroker; +import org.opendaylight.mdsal.binding.api.ReadTransaction; +import org.opendaylight.mdsal.binding.api.ReadWriteTransaction; +import org.opendaylight.mdsal.binding.api.Transaction; +import org.opendaylight.mdsal.binding.api.TransactionChain; +import org.opendaylight.mdsal.binding.api.TransactionChainListener; +import org.opendaylight.mdsal.common.api.CommitInfo; +import org.opendaylight.mdsal.common.api.LogicalDatastoreType; import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo; -import org.opendaylight.openflowplugin.api.openflow.device.DeviceState; -import org.opendaylight.openflowplugin.api.openflow.lifecycle.LifecycleService; +import org.opendaylight.openflowplugin.common.txchain.TransactionChainManager; import org.opendaylight.openflowplugin.impl.util.DeviceStateUtil; import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId; import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes; import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node; import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey; -import org.opendaylight.yangtools.concepts.Registration; +import org.opendaylight.yangtools.util.concurrent.FluentFutures; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier; -/** - * Created by mirehak on 4/5/15. - */ @RunWith(MockitoJUnitRunner.class) public class TransactionChainManagerTest { @Mock private DataBroker dataBroker; @Mock - private ConnectionContext connectionContext; - @Mock - private BindingTransactionChain txChain; + private TransactionChain txChain; @Mock - private WriteTransaction writeTx; + private ReadWriteTransaction writeTx; @Mock - private TransactionChain transactionChain; - @Mock - HashedWheelTimer timer; - @Mock - Registration registration; - @Mock - DeviceState deviceState; + private TransactionChain transactionChain; @Mock DeviceInfo deviceInfo; - @Mock - LifecycleService lifecycleService; @Mock private KeyedInstanceIdentifier nodeKeyIdent; @@ -79,161 +59,145 @@ public class TransactionChainManagerTest { private NodeId nodeId; @Before - public void setUp() throws Exception { - final ReadOnlyTransaction readOnlyTx = Mockito.mock(ReadOnlyTransaction.class); - final CheckedFuture, ReadFailedException> noExistNodeFuture = Futures.immediateCheckedFuture(Optional.absent()); - Mockito.when(readOnlyTx.read(LogicalDatastoreType.OPERATIONAL, nodeKeyIdent)).thenReturn(noExistNodeFuture); - Mockito.when(dataBroker.newReadOnlyTransaction()).thenReturn(readOnlyTx); - Mockito.when(dataBroker.createTransactionChain(Matchers.any(TransactionChainListener.class))) + public void setUp() { + final ReadTransaction readOnlyTx = Mockito.mock(ReadTransaction.class); + Mockito.when(dataBroker.createTransactionChain(any(TransactionChainListener.class))) .thenReturn(txChain); nodeId = new NodeId("h2g2:42"); nodeKeyIdent = DeviceStateUtil.createNodeInstanceIdentifier(nodeId); - Mockito.when(deviceInfo.getNodeInstanceIdentifier()).thenReturn(nodeKeyIdent); - Mockito.when(deviceInfo.getNodeId()).thenReturn(nodeId); - txChainManager = new TransactionChainManager(dataBroker, deviceInfo); - Mockito.when(txChain.newWriteOnlyTransaction()).thenReturn(writeTx); + txChainManager = new TransactionChainManager(dataBroker, nodeId.getValue()); + Mockito.when(txChain.newReadWriteTransaction()).thenReturn(writeTx); path = InstanceIdentifier.create(Nodes.class).child(Node.class, new NodeKey(nodeId)); - Mockito.when(writeTx.submit()).thenReturn(Futures.immediateCheckedFuture(null)); + Mockito.doReturn(CommitInfo.emptyFluentFuture()).when(writeTx).commit(); txChainManager.activateTransactionManager(); } @After - public void tearDown() throws Exception { + public void tearDown() { Mockito.verifyNoMoreInteractions(txChain, writeTx); } @Test - public void testWriteToTransaction() throws Exception { + public void testWriteToTransaction() { final Node data = new NodeBuilder().setId(nodeId).build(); txChainManager.writeToTransaction(LogicalDatastoreType.CONFIGURATION, path, data, false); - Mockito.verify(txChain).newWriteOnlyTransaction(); - Mockito.verify(writeTx).put(LogicalDatastoreType.CONFIGURATION, path, data, false); + Mockito.verify(txChain).newReadWriteTransaction(); + Mockito.verify(writeTx).put(LogicalDatastoreType.CONFIGURATION, path, data); } /** - * test of {@link TransactionChainManager#submitWriteTransaction()} - * @throws Exception + * Tests transaction submit {@link TransactionChainManager#submitTransaction()}. */ @Test - public void testSubmitTransaction() throws Exception { + public void testSubmitTransaction() { final Node data = new NodeBuilder().setId(nodeId).build(); txChainManager.initialSubmitWriteTransaction(); txChainManager.writeToTransaction(LogicalDatastoreType.CONFIGURATION, path, data, false); - txChainManager.submitWriteTransaction(); + txChainManager.submitTransaction(); - Mockito.verify(txChain).newWriteOnlyTransaction(); - Mockito.verify(writeTx).put(LogicalDatastoreType.CONFIGURATION, path, data, false); - Mockito.verify(writeTx).submit(); + Mockito.verify(txChain).newReadWriteTransaction(); + Mockito.verify(writeTx).put(LogicalDatastoreType.CONFIGURATION, path, data); + Mockito.verify(writeTx).commit(); } /** - * test of {@link TransactionChainManager#submitWriteTransaction()}: no submit, never enabled - * @throws Exception + * test of {@link TransactionChainManager#submitTransaction()}: no submit, never enabled. */ @Test - public void testSubmitTransaction1() throws Exception { + public void testSubmitTransaction1() { final Node data = new NodeBuilder().setId(nodeId).build(); txChainManager.writeToTransaction(LogicalDatastoreType.CONFIGURATION, path, data, false); - txChainManager.submitWriteTransaction(); + txChainManager.submitTransaction(); - Mockito.verify(txChain).newWriteOnlyTransaction(); - Mockito.verify(writeTx).put(LogicalDatastoreType.CONFIGURATION, path, data, false); - Mockito.verify(writeTx, Mockito.never()).submit(); + Mockito.verify(txChain).newReadWriteTransaction(); + Mockito.verify(writeTx).put(LogicalDatastoreType.CONFIGURATION, path, data); + Mockito.verify(writeTx, Mockito.never()).commit(); } - /** - * @throws Exception - */ @Test - public void testSubmitTransactionFailed() throws Exception { - Mockito.when(writeTx.submit()).thenReturn(Futures.immediateFailedCheckedFuture(new TransactionCommitFailedException("mock"))); + public void testSubmitTransactionFailed() { + Mockito.doReturn(FluentFutures.immediateFailedFluentFuture(new ExecutionException(new Throwable("mock")))) + .when(writeTx).commit(); final Node data = new NodeBuilder().setId(nodeId).build(); txChainManager.initialSubmitWriteTransaction(); txChainManager.writeToTransaction(LogicalDatastoreType.CONFIGURATION, path, data, false); - txChainManager.submitWriteTransaction(); + txChainManager.submitTransaction(); - Mockito.verify(txChain).newWriteOnlyTransaction(); - Mockito.verify(writeTx).put(LogicalDatastoreType.CONFIGURATION, path, data, false); - Mockito.verify(writeTx).submit(); + Mockito.verify(txChain).newReadWriteTransaction(); + Mockito.verify(writeTx).put(LogicalDatastoreType.CONFIGURATION, path, data); + Mockito.verify(writeTx).commit(); } /** - * test of {@link TransactionChainManager#enableSubmit()}: no submit - counter is not active - * - * @throws Exception + * Test of {@link TransactionChainManager#enableSubmit()}: no submit - counter is not active. */ @Test - public void testEnableCounter1() throws Exception { + public void testEnableCounter1() { final Node data = new NodeBuilder().setId(nodeId).build(); txChainManager.writeToTransaction(LogicalDatastoreType.CONFIGURATION, path, data, false); txChainManager.writeToTransaction(LogicalDatastoreType.CONFIGURATION, path, data, false); - Mockito.verify(txChain).newWriteOnlyTransaction(); - Mockito.verify(writeTx, Mockito.times(2)).put(LogicalDatastoreType.CONFIGURATION, path, data, false); - Mockito.verify(writeTx, Mockito.never()).submit(); + Mockito.verify(txChain).newReadWriteTransaction(); + Mockito.verify(writeTx, Mockito.times(2)).put(LogicalDatastoreType.CONFIGURATION, path, data); + Mockito.verify(writeTx, Mockito.never()).commit(); } - /** - * @throws Exception - */ @Test - public void testOnTransactionChainFailed() throws Exception { - txChainManager.onTransactionChainFailed(transactionChain, Mockito.mock(AsyncTransaction.class), Mockito.mock(Throwable.class)); + public void testOnTransactionChainFailed() { + txChainManager.onTransactionChainFailed(txChain, Mockito.mock(Transaction.class), + Mockito.mock(Throwable.class)); Mockito.verify(txChain).close(); Mockito.verify(dataBroker, Mockito.times(2)).createTransactionChain(txChainManager); } @Test - public void testOnTransactionChainSuccessful() throws Exception { + public void testOnTransactionChainSuccessful() { txChainManager.onTransactionChainSuccessful(transactionChain); // NOOP Mockito.verifyZeroInteractions(transactionChain); } @Test - public void testAddDeleteOperationTotTxChain() throws Exception { - txChainManager.addDeleteOperationTotTxChain(LogicalDatastoreType.CONFIGURATION, path); + public void testAddDeleteOperationTotTxChain() { + txChainManager.addDeleteOperationToTxChain(LogicalDatastoreType.CONFIGURATION, path); - Mockito.verify(txChain).newWriteOnlyTransaction(); + Mockito.verify(txChain).newReadWriteTransaction(); Mockito.verify(writeTx).delete(LogicalDatastoreType.CONFIGURATION, path); } @Test - public void testDeactivateTransactionChainManager() throws Exception { + public void testDeactivateTransactionChainManager() { txChainManager.deactivateTransactionManager(); Mockito.verify(txChain).close(); } - /** - * @throws Exception - */ @Test - public void testDeactivateTransactionChainManagerFailed() throws Exception { - Mockito.when(writeTx.submit()).thenReturn(Futures.immediateFailedCheckedFuture(new TransactionCommitFailedException("mock"))); + public void testDeactivateTransactionChainManagerFailed() { final Node data = new NodeBuilder().setId(nodeId).build(); txChainManager.writeToTransaction(LogicalDatastoreType.CONFIGURATION, path, data, false); txChainManager.deactivateTransactionManager(); - Mockito.verify(txChain).newWriteOnlyTransaction(); - Mockito.verify(writeTx).put(LogicalDatastoreType.CONFIGURATION, path, data, false); - Mockito.verify(writeTx).submit(); + Mockito.verify(txChain).newReadWriteTransaction(); + Mockito.verify(writeTx).put(LogicalDatastoreType.CONFIGURATION, path, data); + Mockito.verify(writeTx, Mockito.never()).commit(); + Mockito.verify(writeTx).cancel(); Mockito.verify(txChain).close(); } @Test - public void testShuttingDown() throws Exception{ + public void testShuttingDown() { final Node data = new NodeBuilder().setId(nodeId).build(); + txChainManager.initialSubmitWriteTransaction(); txChainManager.writeToTransaction(LogicalDatastoreType.CONFIGURATION, path, data, false); - txChainManager.shuttingDown(); - Mockito.verify(txChain).newWriteOnlyTransaction(); - Mockito.verify(writeTx).put(LogicalDatastoreType.CONFIGURATION, path, data, false); - Mockito.verify(writeTx).submit(); + Mockito.verify(txChain).newReadWriteTransaction(); + Mockito.verify(writeTx).put(LogicalDatastoreType.CONFIGURATION, path, data); + Mockito.verify(writeTx).commit(); } @Test @@ -242,4 +206,4 @@ public class TransactionChainManagerTest { txChainManager.close(); Mockito.verify(txChain).close(); } -} \ No newline at end of file +}