X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=common%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Ftransportpce%2Fcommon%2Fdevice%2FDeviceTransactionManagerTest.java;h=885de6d240a6f282b088ccc8653c1cdedc80a078;hb=1b2f9f488bdd54e577c88c230c4875daccc0b93c;hp=1815c184f6245c1f5dc70419bae318d24a6fbb20;hpb=f8f1b05b6eefd0f5c18e22c22b4d4e023f61faf6;p=transportpce.git diff --git a/common/src/test/java/org/opendaylight/transportpce/common/device/DeviceTransactionManagerTest.java b/common/src/test/java/org/opendaylight/transportpce/common/device/DeviceTransactionManagerTest.java index 1815c184f..885de6d24 100644 --- a/common/src/test/java/org/opendaylight/transportpce/common/device/DeviceTransactionManagerTest.java +++ b/common/src/test/java/org/opendaylight/transportpce/common/device/DeviceTransactionManagerTest.java @@ -8,87 +8,93 @@ package org.opendaylight.transportpce.common.device; -import static org.mockito.Matchers.any; - -import com.google.common.base.Optional; -import com.google.common.util.concurrent.Futures; -import com.google.common.util.concurrent.ListenableFuture; -import com.google.common.util.concurrent.ListeningExecutorService; -import com.google.common.util.concurrent.MoreExecutors; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.lenient; +import static org.mockito.Mockito.when; import java.util.LinkedList; import java.util.List; +import java.util.Optional; import java.util.concurrent.ExecutionException; -import java.util.concurrent.Executors; import java.util.concurrent.Future; import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; - -import org.junit.After; -import org.junit.Assert; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.Mock; import org.mockito.Mockito; -import org.mockito.runners.MockitoJUnitRunner; -import org.opendaylight.controller.md.sal.binding.api.DataBroker; -import org.opendaylight.controller.md.sal.binding.api.MountPoint; -import org.opendaylight.controller.md.sal.binding.api.MountPointService; -import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction; -import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev150608.Network; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev150608.NetworkBuilder; +import org.mockito.junit.jupiter.MockitoExtension; +import org.opendaylight.mdsal.binding.api.DataBroker; +import org.opendaylight.mdsal.binding.api.MountPoint; +import org.opendaylight.mdsal.binding.api.MountPointService; +import org.opendaylight.mdsal.binding.api.ReadWriteTransaction; +import org.opendaylight.mdsal.common.api.LogicalDatastoreType; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NetworkId; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.Networks; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.Network; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.NetworkBuilder; +import org.opendaylight.yangtools.util.concurrent.FluentFutures; import org.opendaylight.yangtools.yang.binding.DataObject; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; - -@RunWith(MockitoJUnitRunner.class) +@ExtendWith(MockitoExtension.class) public class DeviceTransactionManagerTest { - @Mock private MountPointService mountPointServiceMock; - @Mock private MountPoint mountPointMock; - @Mock private DataBroker dataBrokerMock; - @Mock private ReadWriteTransaction rwTransactionMock; + @Mock + private MountPointService mountPointServiceMock; + @Mock + private MountPoint mountPointMock; + @Mock + private DataBroker dataBrokerMock; + @Mock + private ReadWriteTransaction rwTransactionMock; + private DeviceTransactionManagerImpl transactionManager; private String defaultDeviceId = "device-id"; private LogicalDatastoreType defaultDatastore = LogicalDatastoreType.OPERATIONAL; - private InstanceIdentifier defaultIid = InstanceIdentifier.create(Network.class); - private Network defaultData = new NetworkBuilder().build(); + private InstanceIdentifier defaultIid = InstanceIdentifier + .builder(Networks.class).child(Network.class).build(); + private Network defaultData; private long defaultTimeout = 1000; private TimeUnit defaultTimeUnit = TimeUnit.MILLISECONDS; - @Before - public void before() { - Mockito.when(mountPointServiceMock.getMountPoint(any())).thenReturn(Optional.of(mountPointMock)); - Mockito.when(mountPointMock.getService(any())).thenReturn(Optional.of(dataBrokerMock)); - Mockito.when(dataBrokerMock.newReadWriteTransaction()).thenReturn(rwTransactionMock); - Mockito.when(rwTransactionMock.submit()).thenReturn(Futures.immediateCheckedFuture(null)); - + @BeforeEach + void before() { + when(mountPointServiceMock.getMountPoint(any())).thenReturn(Optional.of(mountPointMock)); + when(mountPointMock.getService(any())).thenReturn(Optional.of(dataBrokerMock)); + when(dataBrokerMock.newReadWriteTransaction()).thenReturn(rwTransactionMock); + lenient().when(rwTransactionMock.commit()).thenReturn(FluentFutures.immediateNullFluentFuture()); + NetworkId networkId = new NetworkId("NETWORK1"); + defaultData = new NetworkBuilder().setNetworkId(networkId).build(); this.transactionManager = new DeviceTransactionManagerImpl(mountPointServiceMock, 3000); } - @After - public void after() { + @AfterEach + void after() { transactionManager.preDestroy(); } @Test - public void basicPositiveTransactionTest() { + void basicPositiveTransactionTest() { try { putAndSubmit(transactionManager, defaultDeviceId, defaultDatastore, defaultIid, defaultData); } catch (InterruptedException | ExecutionException e) { - Assert.fail("Exception catched! " + e); + fail("Exception catched! " + e); return; } Mockito.verify(rwTransactionMock, Mockito.times(1)).put(defaultDatastore, defaultIid, defaultData); - Mockito.verify(rwTransactionMock, Mockito.times(1)).submit(); + Mockito.verify(rwTransactionMock, Mockito.times(1)).commit(); } @Test - public void advancedPositiveTransactionTest() { + void advancedPositiveTransactionTest() { try { Future> firstDeviceTxFuture = transactionManager.getDeviceTransaction(defaultDeviceId); @@ -96,51 +102,51 @@ public class DeviceTransactionManagerTest { Future> secondDeviceTxFuture = transactionManager.getDeviceTransaction(defaultDeviceId); - Assert.assertFalse(secondDeviceTxFuture.isDone()); + assertFalse(secondDeviceTxFuture.isDone()); Future> thirdDeviceTxFuture = transactionManager.getDeviceTransaction(defaultDeviceId); - Assert.assertFalse(thirdDeviceTxFuture.isDone()); - - Future> anotherDeviceTxFuture = - transactionManager.getDeviceTransaction("another-id"); + assertFalse(thirdDeviceTxFuture.isDone()); firstDeviceTx.put(defaultDatastore, defaultIid, defaultData); - Assert.assertFalse(secondDeviceTxFuture.isDone()); - Assert.assertFalse(thirdDeviceTxFuture.isDone()); + assertFalse(secondDeviceTxFuture.isDone()); + assertFalse(thirdDeviceTxFuture.isDone()); Thread.sleep(200); - Assert.assertFalse(secondDeviceTxFuture.isDone()); - Assert.assertFalse(thirdDeviceTxFuture.isDone()); + assertFalse(secondDeviceTxFuture.isDone()); + assertFalse(thirdDeviceTxFuture.isDone()); - Assert.assertTrue(anotherDeviceTxFuture.isDone()); - anotherDeviceTxFuture.get().get().submit(defaultTimeout, defaultTimeUnit); + Future> anotherDeviceTxFuture = + transactionManager.getDeviceTransaction("another-id"); + Thread.sleep(50); + assertTrue(anotherDeviceTxFuture.isDone()); + anotherDeviceTxFuture.get().get().commit(defaultTimeout, defaultTimeUnit); - firstDeviceTx.submit(defaultTimeout, defaultTimeUnit); + firstDeviceTx.commit(defaultTimeout, defaultTimeUnit); Thread.sleep(200); - Assert.assertTrue(secondDeviceTxFuture.isDone()); - Assert.assertFalse(thirdDeviceTxFuture.isDone()); + assertTrue(secondDeviceTxFuture.isDone()); + assertFalse(thirdDeviceTxFuture.isDone()); DeviceTransaction secondDeviceTx = secondDeviceTxFuture.get().get(); secondDeviceTx.put(defaultDatastore, defaultIid, defaultData); - Assert.assertFalse(thirdDeviceTxFuture.isDone()); + assertFalse(thirdDeviceTxFuture.isDone()); - secondDeviceTx.submit(defaultTimeout, defaultTimeUnit); + secondDeviceTx.commit(defaultTimeout, defaultTimeUnit); Thread.sleep(200); - Assert.assertTrue(thirdDeviceTxFuture.isDone()); + assertTrue(thirdDeviceTxFuture.isDone()); DeviceTransaction thirdDeviceTx = thirdDeviceTxFuture.get().get(); thirdDeviceTx.put(defaultDatastore, defaultIid, defaultData); - thirdDeviceTx.submit(defaultTimeout, defaultTimeUnit); + thirdDeviceTx.commit(defaultTimeout, defaultTimeUnit); Mockito.verify(rwTransactionMock, Mockito.times(3)).put(defaultDatastore, defaultIid, defaultData); - Mockito.verify(rwTransactionMock, Mockito.times(4)).submit(); + Mockito.verify(rwTransactionMock, Mockito.times(4)).commit(); } catch (InterruptedException | ExecutionException e) { - Assert.fail("Exception catched! " + e); + fail("Exception catched! " + e); } } @Test - public void bigAmountOfTransactionsOnSameDeviceTest() { + void bigAmountOfTransactionsOnSameDeviceTest() { int numberOfTxs = 100; List>> deviceTransactionFutures = new LinkedList<>(); List deviceTransactions = new LinkedList<>(); @@ -152,20 +158,20 @@ public class DeviceTransactionManagerTest { try { for (Future> futureTx : deviceTransactionFutures) { DeviceTransaction deviceTx = futureTx.get().get(); - deviceTx.submit(defaultTimeout, defaultTimeUnit); + deviceTx.commit(defaultTimeout, defaultTimeUnit); deviceTransactions.add(deviceTx); } } catch (InterruptedException | ExecutionException e) { - Assert.fail("Exception catched! " + e); + fail("Exception catched! " + e); } for (DeviceTransaction deviceTx : deviceTransactions) { - Assert.assertTrue(deviceTx.wasSubmittedOrCancelled().get()); + assertTrue(deviceTx.wasSubmittedOrCancelled().get()); } } @Test - public void bigAmountOfTransactionsOnDifferentDevicesTest() { + void bigAmountOfTransactionsOnDifferentDevicesTest() { int numberOfTxs = 1000; List deviceTransactions = new LinkedList<>(); @@ -174,18 +180,18 @@ public class DeviceTransactionManagerTest { deviceTransactions.add(transactionManager.getDeviceTransaction(defaultDeviceId + " " + i).get().get()); } } catch (InterruptedException | ExecutionException e) { - Assert.fail("Exception catched! " + e); + fail("Exception catched! " + e); } deviceTransactions.parallelStream() - .forEach(deviceTransaction -> deviceTransaction.submit(defaultTimeout, defaultTimeUnit)); + .forEach(deviceTransaction -> deviceTransaction.commit(defaultTimeout, defaultTimeUnit)); deviceTransactions.parallelStream() - .forEach(deviceTransaction -> Assert.assertTrue(deviceTransaction.wasSubmittedOrCancelled().get())); + .forEach(deviceTransaction -> assertTrue(deviceTransaction.wasSubmittedOrCancelled().get())); } @Test - public void bigAmountOfTransactionsOnDifferentDevicesWithoutSubmitTest() { + void bigAmountOfTransactionsOnDifferentDevicesWithoutSubmitTest() { int numberOfTxs = 1000; List deviceTransactions = new LinkedList<>(); @@ -194,44 +200,44 @@ public class DeviceTransactionManagerTest { deviceTransactions.add(transactionManager.getDeviceTransaction(defaultDeviceId + " " + i).get().get()); } } catch (InterruptedException | ExecutionException e) { - Assert.fail("Exception catched! " + e); + fail("Exception catched! " + e); } try { Thread.sleep(transactionManager.getMaxDurationToSubmitTransaction() + 1000); } catch (InterruptedException e) { - Assert.fail("Exception catched! " + e); + fail("Exception catched! " + e); } deviceTransactions.parallelStream() - .forEach(deviceTransaction -> Assert.assertTrue(deviceTransaction.wasSubmittedOrCancelled().get())); + .forEach(deviceTransaction -> assertTrue(deviceTransaction.wasSubmittedOrCancelled().get())); } @Test - public void notSubmittedTransactionTest() { + void notSubmittedTransactionTest() { Future> deviceTxFuture = transactionManager.getDeviceTransaction(defaultDeviceId); try { deviceTxFuture.get(); Thread.sleep(transactionManager.getMaxDurationToSubmitTransaction() + 1000); } catch (InterruptedException | ExecutionException e) { - Assert.fail("Exception catched! " + e); + fail("Exception catched! " + e); } Mockito.verify(rwTransactionMock, Mockito.times(1)).cancel(); try { putAndSubmit(transactionManager, defaultDeviceId, defaultDatastore, defaultIid, defaultData); } catch (InterruptedException | ExecutionException e) { - Assert.fail("Exception catched! " + e); + fail("Exception catched! " + e); return; } Mockito.verify(rwTransactionMock, Mockito.times(1)).cancel(); Mockito.verify(rwTransactionMock, Mockito.times(1)).put(defaultDatastore, defaultIid, defaultData); - Mockito.verify(rwTransactionMock, Mockito.times(1)).submit(); + Mockito.verify(rwTransactionMock, Mockito.times(1)).commit(); } @Test - public void dataBrokerTimeoutTransactionTest() { + void dataBrokerTimeoutTransactionTest() { Mockito.when(dataBrokerMock.newReadWriteTransaction()).then(invocation -> { Thread.sleep(transactionManager.getMaxDurationToSubmitTransaction() + 1000); return rwTransactionMock; @@ -240,26 +246,26 @@ public class DeviceTransactionManagerTest { try { putAndSubmit(transactionManager, defaultDeviceId, defaultDatastore, defaultIid, defaultData); } catch (InterruptedException | ExecutionException e) { - Assert.fail("Exception catched! " + e); + fail("Exception catched! " + e); } - Mockito.verify(rwTransactionMock, Mockito.times(1)).submit(); + Mockito.verify(rwTransactionMock, Mockito.times(1)).commit(); Mockito.when(dataBrokerMock.newReadWriteTransaction()).thenReturn(rwTransactionMock); // remove sleep try { putAndSubmit(transactionManager, defaultDeviceId, defaultDatastore, defaultIid, defaultData); } catch (InterruptedException | ExecutionException e) { - Assert.fail("Exception catched! " + e); + fail("Exception catched! " + e); return; } Mockito.verify(rwTransactionMock, Mockito.times(2)).put(defaultDatastore, defaultIid, defaultData); - Mockito.verify(rwTransactionMock, Mockito.times(2)).submit(); + Mockito.verify(rwTransactionMock, Mockito.times(2)).commit(); } @Test - public void getFutureTimeoutTransactionTest() { + void getFutureTimeoutTransactionTest() { Mockito.when(dataBrokerMock.newReadWriteTransaction()).then(invocation -> { Thread.sleep(3000); return rwTransactionMock; @@ -272,13 +278,13 @@ public class DeviceTransactionManagerTest { try { deviceTxFuture.get(1000, TimeUnit.MILLISECONDS); } catch (InterruptedException | ExecutionException e) { - Assert.fail("Exception catched! " + e); + fail("Exception catched! " + e); } catch (TimeoutException e) { throwedException = e; } if (throwedException == null) { - Assert.fail("TimeoutException should be thrown!"); + fail("TimeoutException should be thrown!"); return; } @@ -287,69 +293,12 @@ public class DeviceTransactionManagerTest { try { putAndSubmit(transactionManager, defaultDeviceId, defaultDatastore, defaultIid, defaultData); } catch (InterruptedException | ExecutionException e) { - Assert.fail("Exception catched! " + e); + fail("Exception catched! " + e); return; } Mockito.verify(rwTransactionMock, Mockito.times(1)).put(defaultDatastore, defaultIid, defaultData); - Mockito.verify(rwTransactionMock, Mockito.times(1)).submit(); - } - - @Test - public void submitTxTimeoutTransactionTest() { - ListeningExecutorService executor = MoreExecutors.listeningDecorator(Executors.newSingleThreadExecutor()); - Mockito.when(rwTransactionMock.submit()).then(invocation -> Futures.makeChecked(executor.submit(() -> { - try { - Thread.sleep(3000); - } catch (InterruptedException e) { - Assert.fail("Exception catched in future! " + e); - } - return null; - }), input -> input)); - - Future> deviceTxFuture = - transactionManager.getDeviceTransaction(defaultDeviceId); - DeviceTransaction deviceTx; - try { - deviceTx = deviceTxFuture.get().get(); - } catch (InterruptedException | ExecutionException e) { - Assert.fail("Exception catched! " + e); - return; - } - - deviceTx.put(defaultDatastore, defaultIid, defaultData); - - Exception throwedException = null; - - ListenableFuture submitFuture = deviceTx.submit(200, defaultTimeUnit); - try { - submitFuture.get(); - } catch (InterruptedException e) { - Assert.fail("Exception catched! " + e); - } catch (ExecutionException e) { - throwedException = e; - } - - if (throwedException == null - || !throwedException.getMessage().contains(TimeoutException.class.getName())) { - Assert.fail("TimeoutException inside of should be thrown!"); - return; - } - - - Mockito.when(rwTransactionMock.submit()).thenReturn(Futures.immediateCheckedFuture(null)); - - try { - putAndSubmit(transactionManager, defaultDeviceId, defaultDatastore, defaultIid, defaultData); - } catch (InterruptedException | ExecutionException e) { - Assert.fail("Exception catched! " + e); - return; - } - - Mockito.verify(rwTransactionMock, Mockito.times(2)).put(defaultDatastore, defaultIid, defaultData); - Mockito.verify(rwTransactionMock, Mockito.times(2)).submit(); - - executor.shutdown(); + Mockito.verify(rwTransactionMock, Mockito.times(1)).commit(); } private void putAndSubmit(DeviceTransactionManagerImpl deviceTxManager, String deviceId, @@ -358,6 +307,6 @@ public class DeviceTransactionManagerTest { Future> deviceTxFuture = deviceTxManager.getDeviceTransaction(deviceId); DeviceTransaction deviceTx = deviceTxFuture.get().get(); deviceTx.put(store, path, data); - deviceTx.submit(defaultTimeout, defaultTimeUnit); + deviceTx.commit(defaultTimeout, defaultTimeUnit); } }