*/
package org.opendaylight.mdsal.binding.util;
-import static com.google.common.truth.Truth.assertThat;
-import static com.google.common.truth.Truth8.assertThat;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.junit.Assert.assertThrows;
import static org.opendaylight.mdsal.binding.test.model.util.ListsBindingUtils.TOP_FOO_KEY;
import static org.opendaylight.mdsal.binding.test.model.util.ListsBindingUtils.path;
import static org.opendaylight.mdsal.binding.test.model.util.ListsBindingUtils.topLevelList;
import java.io.IOException;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.mdsal.binding.api.DataBroker;
super(true);
}
- protected ManagedNewTransactionRunner createManagedNewTransactionRunnerToTest(DataBroker dataBroker) {
+ protected ManagedNewTransactionRunner createManagedNewTransactionRunnerToTest(final DataBroker dataBroker) {
return new ManagedNewTransactionRunnerImpl(dataBroker);
}
@Test
public void testCallWithNewTypedWriteOnlyTransactionAndSubmitPutButLaterException() throws Exception {
- try {
- managedNewTransactionRunner.callWithNewWriteOnlyTransactionAndSubmit(OPERATIONAL, writeTx -> {
+ Future<?> future = managedNewTransactionRunner.callWithNewWriteOnlyTransactionAndSubmit(OPERATIONAL,
+ writeTx -> {
writeTx.put(TEST_PATH, newTestDataObject());
// We now throw an arbitrary kind of checked (not unchecked!) exception here
throw new IOException("something didn't quite go as expected...");
- }).get();
- fail("This should have led to an ExecutionException!");
- } catch (ExecutionException e) {
- assertTrue(e.getCause() instanceof IOException);
- }
- assertThat(syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH)).isEmpty();
+ });
+ ExecutionException ex = assertThrows(ExecutionException.class, () -> future.get());
+ assertThat(ex.getCause(), instanceOf(IOException.class));
+ assertEquals(Optional.empty(), syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH));
}
@Test
public void testCallWithNewTypedReadWriteTransactionAndSubmitPutButLaterException() throws Exception {
- try {
- managedNewTransactionRunner.callWithNewReadWriteTransactionAndSubmit(OPERATIONAL, writeTx -> {
+ Future<?> future = managedNewTransactionRunner.callWithNewReadWriteTransactionAndSubmit(OPERATIONAL,
+ writeTx -> {
writeTx.put(TEST_PATH, newTestDataObject());
// We now throw an arbitrary kind of checked (not unchecked!) exception here
throw new IOException("something didn't quite go as expected...");
- }).get();
- fail("This should have led to an ExecutionException!");
- } catch (ExecutionException e) {
- assertTrue(e.getCause() instanceof IOException);
- }
- assertThat(syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH)).isEmpty();
+ });
+ ExecutionException ex = assertThrows(ExecutionException.class, () -> future.get());
+ assertThat(ex.getCause(), instanceOf(IOException.class));
+ assertEquals(Optional.empty(), syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH));
}
@Test
public void testApplyWithNewReadWriteTransactionAndSubmitPutButLaterException() throws Exception {
- try {
- managedNewTransactionRunner.applyWithNewReadWriteTransactionAndSubmit(OPERATIONAL,
- writeTx -> {
- writeTx.put(TEST_PATH, newTestDataObject());
- // We now throw an arbitrary kind of checked (not unchecked!) exception here
- throw new IOException("something didn't quite go as expected...");
- }).get();
- fail("This should have led to an ExecutionException!");
- } catch (ExecutionException e) {
- assertTrue(e.getCause() instanceof IOException);
- }
- assertThat(syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH)).isEmpty();
+ Future<?> future = managedNewTransactionRunner.applyWithNewReadWriteTransactionAndSubmit(OPERATIONAL,
+ writeTx -> {
+ writeTx.put(TEST_PATH, newTestDataObject());
+ // We now throw an arbitrary kind of checked (not unchecked!) exception here
+ throw new IOException("something didn't quite go as expected...");
+ });
+ ExecutionException ex = assertThrows(ExecutionException.class, () -> future.get());
+ assertThat(ex.getCause(), instanceOf(IOException.class));
+ assertEquals(Optional.empty(), syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH));
}
@Test
public void testCallWithNewTypedWriteOnlyTransactionCommitFailedException() throws Exception {
- try {
- testableDataBroker.failCommits(new TransactionCommitFailedException("bada boum bam!"));
- managedNewTransactionRunner.callWithNewWriteOnlyTransactionAndSubmit(OPERATIONAL,
- writeTx -> writeTx.put(TEST_PATH, newTestDataObject())).get();
- fail("This should have led to an ExecutionException!");
- } catch (ExecutionException e) {
- assertTrue(e.getCause() instanceof TransactionCommitFailedException);
- }
- assertThat(syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH)).isEmpty();
+ testableDataBroker.failCommits(new TransactionCommitFailedException("bada boum bam!"));
+ Future<?> future = managedNewTransactionRunner.callWithNewWriteOnlyTransactionAndSubmit(OPERATIONAL,
+ writeTx -> writeTx.put(TEST_PATH, newTestDataObject()));
+ ExecutionException ex = assertThrows(ExecutionException.class, () -> future.get());
+ assertThat(ex.getCause(), instanceOf(TransactionCommitFailedException.class));
+ assertEquals(Optional.empty(), syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH));
}
@Test
public void testCallWithNewTypedReadWriteTransactionCommitFailedException() throws Exception {
- try {
- testableDataBroker.failCommits(new TransactionCommitFailedException("bada boum bam!"));
- managedNewTransactionRunner.callWithNewReadWriteTransactionAndSubmit(OPERATIONAL,
- writeTx -> writeTx.put(TEST_PATH, newTestDataObject())).get();
- fail("This should have led to an ExecutionException!");
- } catch (ExecutionException e) {
- assertTrue(e.getCause() instanceof TransactionCommitFailedException);
- }
- assertThat(syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH)).isEmpty();
+ testableDataBroker.failCommits(new TransactionCommitFailedException("bada boum bam!"));
+ Future<?> future = managedNewTransactionRunner.callWithNewReadWriteTransactionAndSubmit(OPERATIONAL,
+ writeTx -> writeTx.put(TEST_PATH, newTestDataObject()));
+ ExecutionException ex = assertThrows(ExecutionException.class, () -> future.get());
+ assertThat(ex.getCause(), instanceOf(TransactionCommitFailedException.class));
+ assertEquals(Optional.empty(), syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH));
}
@Test
public void testApplyWithNewReadWriteTransactionCommitFailedException() throws Exception {
- try {
- testableDataBroker.failCommits(new TransactionCommitFailedException("bada boum bam!"));
- managedNewTransactionRunner.applyWithNewReadWriteTransactionAndSubmit(OPERATIONAL,
- writeTx -> {
- writeTx.put(TEST_PATH, newTestDataObject());
- return 1;
- }).get();
- fail("This should have led to an ExecutionException!");
- } catch (ExecutionException e) {
- assertTrue(e.getCause() instanceof TransactionCommitFailedException);
- }
- assertThat(syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH)).isEmpty();
+ testableDataBroker.failCommits(new TransactionCommitFailedException("bada boum bam!"));
+ Future<?> future = managedNewTransactionRunner.applyWithNewReadWriteTransactionAndSubmit(OPERATIONAL,
+ writeTx -> {
+ writeTx.put(TEST_PATH, newTestDataObject());
+ return 1;
+ });
+ ExecutionException ex = assertThrows(ExecutionException.class, () -> future.get());
+ assertThat(ex.getCause(), instanceOf(TransactionCommitFailedException.class));
+ assertEquals(Optional.empty(), syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH));
}
@Test
public void testCallWithNewTypedWriteOnlyTransactionOptimisticLockFailedException() throws Exception {
- try {
- testableDataBroker.failCommits(2, new OptimisticLockFailedException("bada boum bam!"));
- managedNewTransactionRunner.callWithNewWriteOnlyTransactionAndSubmit(OPERATIONAL,
- writeTx -> writeTx.put(TEST_PATH, newTestDataObject())).get();
- fail("This should have led to an ExecutionException!");
- } catch (ExecutionException e) {
- assertTrue(e.getCause() instanceof OptimisticLockFailedException);
- }
- assertThat(syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH)).isEmpty();
+ testableDataBroker.failCommits(2, new OptimisticLockFailedException("bada boum bam!"));
+ Future<?> future = managedNewTransactionRunner.callWithNewWriteOnlyTransactionAndSubmit(OPERATIONAL,
+ writeTx -> writeTx.put(TEST_PATH, newTestDataObject()));
+ ExecutionException ex = assertThrows(ExecutionException.class, () -> future.get());
+ assertThat(ex.getCause(), instanceOf(OptimisticLockFailedException.class));
+ assertEquals(Optional.empty(), syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH));
}
@Test
public void testCallWithNewTypedReadWriteTransactionOptimisticLockFailedException() throws Exception {
- try {
- testableDataBroker.failCommits(2, new OptimisticLockFailedException("bada boum bam!"));
- managedNewTransactionRunner.callWithNewReadWriteTransactionAndSubmit(OPERATIONAL,
- writeTx -> writeTx.put(TEST_PATH, newTestDataObject())).get();
- fail("This should have led to an ExecutionException!");
- } catch (ExecutionException e) {
- assertTrue(e.getCause() instanceof OptimisticLockFailedException);
- }
- assertThat(syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH)).isEmpty();
+ testableDataBroker.failCommits(2, new OptimisticLockFailedException("bada boum bam!"));
+ Future<?> future = managedNewTransactionRunner.callWithNewReadWriteTransactionAndSubmit(OPERATIONAL,
+ writeTx -> writeTx.put(TEST_PATH, newTestDataObject()));
+ ExecutionException ex = assertThrows(ExecutionException.class, () -> future.get());
+ assertThat(ex.getCause(), instanceOf(OptimisticLockFailedException.class));
+ assertEquals(Optional.empty(), syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH));
}
@Test
public void testApplyWithNewReadWriteTransactionOptimisticLockFailedException() throws Exception {
- try {
- testableDataBroker.failCommits(2, new OptimisticLockFailedException("bada boum bam!"));
- managedNewTransactionRunner.applyWithNewReadWriteTransactionAndSubmit(OPERATIONAL,
- writeTx -> {
- writeTx.put(TEST_PATH, newTestDataObject());
- return 1;
- }).get();
- fail("This should have led to an ExecutionException!");
- } catch (ExecutionException e) {
- assertThat(e.getCause() instanceof OptimisticLockFailedException).isTrue();
- }
- assertThat(syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH)).isEmpty();
+ testableDataBroker.failCommits(2, new OptimisticLockFailedException("bada boum bam!"));
+ Future<?> future = managedNewTransactionRunner.applyWithNewReadWriteTransactionAndSubmit(OPERATIONAL,
+ writeTx -> {
+ writeTx.put(TEST_PATH, newTestDataObject());
+ return 1;
+ });
+ ExecutionException ex = assertThrows(ExecutionException.class, () -> future.get());
+ assertThat(ex.getCause(), instanceOf(OptimisticLockFailedException.class));
+ assertEquals(Optional.empty(), syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH));
}
- private <T extends DataObject> Optional<T> syncReadOptional(LogicalDatastoreType datastoreType,
- InstanceIdentifier<T> path) throws ExecutionException, InterruptedException {
+ private <T extends DataObject> Optional<T> syncReadOptional(final LogicalDatastoreType datastoreType,
+ final InstanceIdentifier<T> path) throws ExecutionException, InterruptedException {
try (ReadTransaction tx = getDataBroker().newReadOnlyTransaction()) {
return tx.read(datastoreType, path).get();
}
}
- <T extends DataObject> T syncRead(LogicalDatastoreType datastoreType, InstanceIdentifier<T> path)
+ <T extends DataObject> T syncRead(final LogicalDatastoreType datastoreType, final InstanceIdentifier<T> path)
throws ExecutionException, InterruptedException {
return syncReadOptional(datastoreType, path).get();
}
import static org.junit.Assert.assertEquals;
import static org.opendaylight.mdsal.binding.util.Datastore.OPERATIONAL;
-import org.junit.Assert;
import org.junit.Test;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
public class RetryingManagedNewTransactionRunnerTest extends ManagedNewTransactionRunnerImplTest {
@Override
- protected ManagedNewTransactionRunner createManagedNewTransactionRunnerToTest(DataBroker dataBroker) {
+ protected ManagedNewTransactionRunner createManagedNewTransactionRunnerToTest(final DataBroker dataBroker) {
return new RetryingManagedNewTransactionRunner(dataBroker);
}
TopLevelList data = newTestDataObject();
managedNewTransactionRunner.callWithNewWriteOnlyTransactionAndSubmit(OPERATIONAL,
writeTx -> writeTx.put(TEST_PATH, data)).get();
- Assert.assertEquals(data, syncRead(LogicalDatastoreType.OPERATIONAL, TEST_PATH));
+ assertEquals(data, syncRead(LogicalDatastoreType.OPERATIONAL, TEST_PATH));
}
@Override
TopLevelList data = newTestDataObject();
managedNewTransactionRunner.callWithNewReadWriteTransactionAndSubmit(OPERATIONAL,
writeTx -> writeTx.put(TEST_PATH, data)).get();
- Assert.assertEquals(data, syncRead(LogicalDatastoreType.OPERATIONAL, TEST_PATH));
+ assertEquals(data, syncRead(LogicalDatastoreType.OPERATIONAL, TEST_PATH));
}
@Override
writeTx.put(TEST_PATH, data);
return 1;
}).get());
- Assert.assertEquals(data, syncRead(LogicalDatastoreType.OPERATIONAL, TEST_PATH));
+ assertEquals(data, syncRead(LogicalDatastoreType.OPERATIONAL, TEST_PATH));
}
@Test
managedNewTransactionRunner.callWithNewReadWriteTransactionAndSubmit(OPERATIONAL,
tx -> {
tx.put(TEST_PATH, data);
- Assert.assertEquals(data, tx.read(TEST_PATH).get().get());
+ assertEquals(data, tx.read(TEST_PATH).get().get());
}).get();
- Assert.assertEquals(data, syncRead(LogicalDatastoreType.OPERATIONAL, TEST_PATH));
+ assertEquals(data, syncRead(LogicalDatastoreType.OPERATIONAL, TEST_PATH));
}
@Test
public void testApplyWithNewReadWriteTransactionReadFailedException() throws Exception {
testableDataBroker.failReads(2, new ReadFailedException("bada boum bam!"));
TopLevelList data = newTestDataObject();
- Assert.assertEquals(data, managedNewTransactionRunner.applyWithNewReadWriteTransactionAndSubmit(
+ assertEquals(data, managedNewTransactionRunner.applyWithNewReadWriteTransactionAndSubmit(
OPERATIONAL,
tx -> {
tx.put(TEST_PATH, data);
return tx.read(TEST_PATH).get().get();
}).get());
- Assert.assertEquals(data, syncRead(LogicalDatastoreType.OPERATIONAL, TEST_PATH));
+ assertEquals(data, syncRead(LogicalDatastoreType.OPERATIONAL, TEST_PATH));
}
}
*/
package org.opendaylight.mdsal.binding.util;
-import static com.google.common.truth.Truth8.assertThat;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.junit.Assert.assertThrows;
import static org.opendaylight.mdsal.binding.test.model.util.ListsBindingUtils.TOP_FOO_KEY;
import static org.opendaylight.mdsal.binding.test.model.util.ListsBindingUtils.path;
import static org.opendaylight.mdsal.binding.test.model.util.ListsBindingUtils.topLevelList;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.mdsal.binding.api.DataBroker;
/**
* Test for {@link TransactionAdapter}.
*/
-// This is a test for a deprecated class
-@SuppressWarnings("deprecation")
+@Deprecated
public class TransactionAdapterTest extends AbstractConcurrentDataBrokerTest {
private static final InstanceIdentifier<TopLevelList> TEST_PATH = path(TOP_FOO_KEY);
private ManagedNewTransactionRunner managedNewTransactionRunner;
private DataBrokerFailuresImpl testableDataBroker;
- private ManagedNewTransactionRunner createManagedNewTransactionRunnerToTest(DataBroker dataBroker) {
+ private ManagedNewTransactionRunner createManagedNewTransactionRunnerToTest(final DataBroker dataBroker) {
return new ManagedNewTransactionRunnerImpl(dataBroker);
}
@Test
public void testAdaptedWriteTransactionFailsOnInvalidDatastore() throws Exception {
- try {
- managedNewTransactionRunner.callWithNewWriteOnlyTransactionAndSubmit(OPERATIONAL,
- writeTx -> TransactionAdapter.toWriteTransaction(writeTx).put(LogicalDatastoreType.CONFIGURATION,
- TEST_PATH, newTestDataObject())).get();
- fail("This should have led to an ExecutionException!");
- } catch (ExecutionException e) {
- assertTrue(e.getCause() instanceof IllegalArgumentException);
- }
- assertThat(syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH)).isEmpty();
+ Future<?> future = managedNewTransactionRunner.callWithNewWriteOnlyTransactionAndSubmit(OPERATIONAL,
+ writeTx -> TransactionAdapter.toWriteTransaction(writeTx).put(LogicalDatastoreType.CONFIGURATION,
+ TEST_PATH, newTestDataObject()));
+ ExecutionException ex = assertThrows(ExecutionException.class, () -> future.get());
+ assertThat(ex.getCause(), instanceOf(IllegalArgumentException.class));
+ assertEquals(Optional.empty(), syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH));
}
@Test
public void testAdaptedReadWriteTransactionFailsOnInvalidDatastore() throws Exception {
- try {
- managedNewTransactionRunner.callWithNewReadWriteTransactionAndSubmit(OPERATIONAL,
- writeTx -> TransactionAdapter.toReadWriteTransaction(writeTx).put(LogicalDatastoreType.CONFIGURATION,
- TEST_PATH, newTestDataObject())).get();
- fail("This should have led to an ExecutionException!");
- } catch (ExecutionException e) {
- assertTrue(e.getCause() instanceof IllegalArgumentException);
- }
- assertThat(syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH)).isEmpty();
+ Future<?> future = managedNewTransactionRunner.callWithNewReadWriteTransactionAndSubmit(OPERATIONAL,
+ writeTx -> TransactionAdapter.toReadWriteTransaction(writeTx).put(LogicalDatastoreType.CONFIGURATION,
+ TEST_PATH, newTestDataObject()));
+ ExecutionException ex = assertThrows(ExecutionException.class, () -> future.get());
+ assertThat(ex.getCause(), instanceOf(IllegalArgumentException.class));
+ assertEquals(Optional.empty(), syncReadOptional(LogicalDatastoreType.OPERATIONAL, TEST_PATH));
}
@Test(expected = ExecutionException.class)
return topLevelList(TOP_FOO_KEY, fooAugment);
}
- private <T extends DataObject> Optional<T> syncReadOptional(LogicalDatastoreType datastoreType,
- InstanceIdentifier<T> path) throws ExecutionException, InterruptedException {
+ private <T extends DataObject> Optional<T> syncReadOptional(final LogicalDatastoreType datastoreType,
+ final InstanceIdentifier<T> path) throws ExecutionException, InterruptedException {
try (ReadTransaction tx = getDataBroker().newReadOnlyTransaction()) {
return tx.read(datastoreType, path).get();
}
}
- private <T extends DataObject> T syncRead(LogicalDatastoreType datastoreType, InstanceIdentifier<T> path)
- throws ExecutionException, InterruptedException {
+ private <T extends DataObject> T syncRead(final LogicalDatastoreType datastoreType,
+ final InstanceIdentifier<T> path) throws ExecutionException, InterruptedException {
return syncReadOptional(datastoreType, path).get();
}
}