X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-distributed-datastore%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fcluster%2Fdatabroker%2Factors%2Fdds%2FClientTransactionCommitCohortTest.java;h=b30986ee3d330009a46ee809449ceabdf57fde01;hb=refs%2Fchanges%2F22%2F65622%2F11;hp=9497157ff8f5071fd753cea1c834972ccedb9d58;hpb=43f9eeb31e4d04620e41e5acf9c33b5639da3fd7;p=controller.git

diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/databroker/actors/dds/ClientTransactionCommitCohortTest.java b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/databroker/actors/dds/ClientTransactionCommitCohortTest.java
index 9497157ff8..b30986ee3d 100644
--- a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/databroker/actors/dds/ClientTransactionCommitCohortTest.java
+++ b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/databroker/actors/dds/ClientTransactionCommitCohortTest.java
@@ -14,8 +14,8 @@ import static org.opendaylight.controller.cluster.databroker.actors.dds.TestUtil
 import static org.opendaylight.controller.cluster.databroker.actors.dds.TestUtils.getWithTimeout;
 
 import akka.actor.ActorSystem;
-import akka.testkit.JavaTestKit;
 import akka.testkit.TestProbe;
+import akka.testkit.javadsl.TestKit;
 import com.google.common.primitives.UnsignedLong;
 import com.google.common.util.concurrent.ListenableFuture;
 import java.util.ArrayList;
@@ -56,7 +56,7 @@ public class ClientTransactionCommitCohortTest {
     @Mock
     private AbstractClientHistory history;
     private ActorSystem system;
-    private List<TranasactionTester> transactions;
+    private List<TransactionTester<RemoteProxyTransaction>> transactions;
     private ClientTransactionCommitCohort cohort;
 
     @Before
@@ -71,7 +71,7 @@ public class ClientTransactionCommitCohortTest {
             transactions.add(createTransactionTester(new TestProbe(system, "backend" + i), context, history));
         }
         final Collection<AbstractProxyTransaction> proxies = transactions.stream()
-                .map(TranasactionTester::getTransaction)
+                .map(TransactionTester::getTransaction)
                 .collect(Collectors.toList());
         proxies.forEach(AbstractProxyTransaction::seal);
         cohort = new ClientTransactionCommitCohort(history, TRANSACTION_ID, proxies);
@@ -79,13 +79,13 @@ public class ClientTransactionCommitCohortTest {
 
     @After
     public void tearDown() throws Exception {
-        JavaTestKit.shutdownActorSystem(system);
+        TestKit.shutdownActorSystem(system);
     }
 
     @Test
     public void testCanCommit() throws Exception {
         testOpSuccess(ClientTransactionCommitCohort::canCommit, this::expectCanCommit,
-                this::replyCanCommitSuccess, true);
+                this::replyCanCommitSuccess, Boolean.TRUE);
     }
 
     @Test
@@ -124,65 +124,64 @@ public class ClientTransactionCommitCohortTest {
         testOpFail(ClientTransactionCommitCohort::abort, this::expectAbort, this::replyAbortSuccess);
     }
 
-    private void expectCanCommit(final TranasactionTester tester) {
+    private void expectCanCommit(final TransactionTester<RemoteProxyTransaction> tester) {
         final ModifyTransactionRequest request = tester.expectTransactionRequest(ModifyTransactionRequest.class);
         Assert.assertTrue(request.getPersistenceProtocol().isPresent());
         Assert.assertEquals(PersistenceProtocol.THREE_PHASE, request.getPersistenceProtocol().get());
     }
 
-    void expectPreCommit(final TranasactionTester tester) {
+    void expectPreCommit(final TransactionTester<?> tester) {
         tester.expectTransactionRequest(TransactionPreCommitRequest.class);
     }
 
-    void expectCommit(final TranasactionTester tester) {
+    void expectCommit(final TransactionTester<?> tester) {
         tester.expectTransactionRequest(TransactionDoCommitRequest.class);
     }
 
-    void expectAbort(final TranasactionTester tester) {
+    void expectAbort(final TransactionTester<?> tester) {
         tester.expectTransactionRequest(TransactionAbortRequest.class);
     }
 
-    void replyCanCommitSuccess(final TranasactionTester tester) {
+    void replyCanCommitSuccess(final TransactionTester<?> tester) {
         final RequestSuccess<?, ?> success = new TransactionCanCommitSuccess(tester.getTransaction().getIdentifier(),
                 tester.getLastReceivedMessage().getSequence());
         tester.replySuccess(success);
     }
 
-    void replyPreCommitSuccess(final TranasactionTester tester) {
+    void replyPreCommitSuccess(final TransactionTester<?> tester) {
         final RequestSuccess<?, ?> success = new TransactionPreCommitSuccess(tester.getTransaction().getIdentifier(),
                 tester.getLastReceivedMessage().getSequence());
         tester.replySuccess(success);
     }
 
-    void replyCommitSuccess(final TranasactionTester tester) {
+    void replyCommitSuccess(final TransactionTester<?> tester) {
         final RequestSuccess<?, ?> success = new TransactionCommitSuccess(tester.getTransaction().getIdentifier(),
                 tester.getLastReceivedMessage().getSequence());
         tester.replySuccess(success);
     }
 
-    void replyAbortSuccess(final TranasactionTester tester) {
+    void replyAbortSuccess(final TransactionTester<?> tester) {
         final RequestSuccess<?, ?> success = new TransactionAbortSuccess(tester.getTransaction().getIdentifier(),
                 tester.getLastReceivedMessage().getSequence());
         tester.replySuccess(success);
     }
 
-    private static TranasactionTester createTransactionTester(final TestProbe backendProbe,
-                                                              final ClientActorContext context,
-                                                              final AbstractClientHistory history) {
+    private static TransactionTester<RemoteProxyTransaction> createTransactionTester(final TestProbe backendProbe,
+                                                             final ClientActorContext context,
+                                                             final AbstractClientHistory history) {
         final ShardBackendInfo backend = new ShardBackendInfo(backendProbe.ref(), 0L, ABIVersion.BORON,
                 "default", UnsignedLong.ZERO, Optional.empty(), 3);
         final AbstractClientConnection<ShardBackendInfo> connection =
                 AccessClientUtil.createConnectedConnection(context, 0L, backend);
         final ProxyHistory proxyHistory = ProxyHistory.createClient(history, connection, HISTORY_ID);
         final RemoteProxyTransaction transaction =
-                new RemoteProxyTransaction(proxyHistory, TRANSACTION_ID, false, false);
-        return new TranasactionTester(transaction, connection, backendProbe);
+                new RemoteProxyTransaction(proxyHistory, TRANSACTION_ID, false, false, false);
+        return new TransactionTester<>(transaction, connection, backendProbe);
     }
 
-    private void replySuccess(final Collection<TranasactionTester> transactions,
-                              final Consumer<TranasactionTester> expect,
-                              final Consumer<TranasactionTester> reply) {
-        for (final TranasactionTester transaction : transactions) {
+    private static <T extends TransactionTester<?>> void replySuccess(final Collection<T> transactions,
+                              final Consumer<T> expect, final Consumer<T> reply) {
+        for (final T transaction : transactions) {
             expect.accept(transaction);
             reply.accept(transaction);
         }
@@ -201,8 +200,8 @@ public class ClientTransactionCommitCohortTest {
      * @throws Exception unexpected exception
      */
     private <T> void testOpSuccess(final Function<ClientTransactionCommitCohort, ListenableFuture<T>> operation,
-                                   final Consumer<TranasactionTester> expectFunction,
-                                   final Consumer<TranasactionTester> replyFunction,
+                                   final Consumer<TransactionTester<RemoteProxyTransaction>> expectFunction,
+                                   final Consumer<TransactionTester<RemoteProxyTransaction>> replyFunction,
                                    final T expectedResult) throws Exception {
         final ListenableFuture<T> result = operation.apply(cohort);
         replySuccess(transactions, expectFunction, replyFunction);
@@ -221,20 +220,21 @@ public class ClientTransactionCommitCohortTest {
      * @throws Exception unexpected exception
      */
     private <T> void testOpFail(final Function<ClientTransactionCommitCohort, ListenableFuture<T>> operation,
-                                final Consumer<TranasactionTester> expectFunction,
-                                final Consumer<TranasactionTester> replyFunction) throws Exception {
+            final Consumer<TransactionTester<RemoteProxyTransaction>> expectFunction,
+            final Consumer<TransactionTester<RemoteProxyTransaction>> replyFunction) throws Exception {
         final ListenableFuture<T> canCommit = operation.apply(cohort);
         //reply success to all except last transaction
         replySuccess(transactions.subList(0, transactions.size() - 1), expectFunction, replyFunction);
         //reply fail to last transaction
-        final TranasactionTester last = transactions.get(transactions.size() - 1);
+        final TransactionTester<RemoteProxyTransaction> last = transactions.get(transactions.size() - 1);
         expectFunction.accept(last);
-        final RuntimeRequestException cause = new RuntimeRequestException("fail", new RuntimeException());
+        final RuntimeException e = new RuntimeException();
+        final RuntimeRequestException cause = new RuntimeRequestException("fail", e);
         last.replyFailure(cause);
         //check future fail
         final ExecutionException exception =
                 assertOperationThrowsException(() -> getWithTimeout(canCommit), ExecutionException.class);
-        Assert.assertEquals(cause, exception.getCause());
+        Assert.assertEquals(e, exception.getCause());
     }
 
-}
\ No newline at end of file
+}