X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-distributed-datastore%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fcluster%2Fdatabroker%2Factors%2Fdds%2FClientTransactionCommitCohortTest.java;h=8b58e1587790384f10ae0635d740c1f48a5f2470;hp=9497157ff8f5071fd753cea1c834972ccedb9d58;hb=514df5b3d350482fee8ee8f1f5b257c229f7e61a;hpb=43f9eeb31e4d04620e41e5acf9c33b5639da3fd7 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..8b58e15877 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 @@ -7,6 +7,7 @@ */ package org.opendaylight.controller.cluster.databroker.actors.dds; +import static org.junit.Assert.assertEquals; import static org.opendaylight.controller.cluster.databroker.actors.dds.TestUtils.CLIENT_ID; import static org.opendaylight.controller.cluster.databroker.actors.dds.TestUtils.HISTORY_ID; import static org.opendaylight.controller.cluster.databroker.actors.dds.TestUtils.TRANSACTION_ID; @@ -14,8 +15,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; @@ -27,11 +28,11 @@ import java.util.function.Consumer; import java.util.function.Function; import java.util.stream.Collectors; import org.junit.After; -import org.junit.Assert; import org.junit.Before; import org.junit.Test; +import org.junit.runner.RunWith; import org.mockito.Mock; -import org.mockito.MockitoAnnotations; +import org.mockito.junit.MockitoJUnitRunner; import org.opendaylight.controller.cluster.access.ABIVersion; import org.opendaylight.controller.cluster.access.client.AbstractClientConnection; import org.opendaylight.controller.cluster.access.client.AccessClientUtil; @@ -48,6 +49,7 @@ import org.opendaylight.controller.cluster.access.commands.TransactionPreCommitS import org.opendaylight.controller.cluster.access.concepts.RequestSuccess; import org.opendaylight.controller.cluster.access.concepts.RuntimeRequestException; +@RunWith(MockitoJUnitRunner.StrictStubs.class) public class ClientTransactionCommitCohortTest { private static final String PERSISTENCE_ID = "per-1"; @@ -56,12 +58,11 @@ public class ClientTransactionCommitCohortTest { @Mock private AbstractClientHistory history; private ActorSystem system; - private List transactions; + private List> transactions; private ClientTransactionCommitCohort cohort; @Before - public void setUp() throws Exception { - MockitoAnnotations.initMocks(this); + public void setUp() { system = ActorSystem.apply(); final TestProbe clientContextProbe = new TestProbe(system, "clientContext"); final ClientActorContext context = @@ -71,21 +72,21 @@ public class ClientTransactionCommitCohortTest { transactions.add(createTransactionTester(new TestProbe(system, "backend" + i), context, history)); } final Collection proxies = transactions.stream() - .map(TranasactionTester::getTransaction) + .map(TransactionTester::getTransaction) .collect(Collectors.toList()); proxies.forEach(AbstractProxyTransaction::seal); cohort = new ClientTransactionCommitCohort(history, TRANSACTION_ID, proxies); } @After - public void tearDown() throws Exception { - JavaTestKit.shutdownActorSystem(system); + public void tearDown() { + TestKit.shutdownActorSystem(system); } @Test public void testCanCommit() throws Exception { testOpSuccess(ClientTransactionCommitCohort::canCommit, this::expectCanCommit, - this::replyCanCommitSuccess, true); + this::replyCanCommitSuccess, Boolean.TRUE); } @Test @@ -124,65 +125,63 @@ public class ClientTransactionCommitCohortTest { testOpFail(ClientTransactionCommitCohort::abort, this::expectAbort, this::replyAbortSuccess); } - private void expectCanCommit(final TranasactionTester tester) { + private void expectCanCommit(final TransactionTester tester) { final ModifyTransactionRequest request = tester.expectTransactionRequest(ModifyTransactionRequest.class); - Assert.assertTrue(request.getPersistenceProtocol().isPresent()); - Assert.assertEquals(PersistenceProtocol.THREE_PHASE, request.getPersistenceProtocol().get()); + assertEquals(Optional.of(PersistenceProtocol.THREE_PHASE), request.getPersistenceProtocol()); } - 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 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 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 transactions, - final Consumer expect, - final Consumer reply) { - for (final TranasactionTester transaction : transactions) { + private static > void replySuccess(final Collection transactions, + final Consumer expect, final Consumer reply) { + for (final T transaction : transactions) { expect.accept(transaction); reply.accept(transaction); } @@ -201,12 +200,12 @@ public class ClientTransactionCommitCohortTest { * @throws Exception unexpected exception */ private void testOpSuccess(final Function> operation, - final Consumer expectFunction, - final Consumer replyFunction, + final Consumer> expectFunction, + final Consumer> replyFunction, final T expectedResult) throws Exception { final ListenableFuture result = operation.apply(cohort); replySuccess(transactions, expectFunction, replyFunction); - Assert.assertEquals(expectedResult, getWithTimeout(result)); + assertEquals(expectedResult, getWithTimeout(result)); } /** @@ -221,20 +220,21 @@ public class ClientTransactionCommitCohortTest { * @throws Exception unexpected exception */ private void testOpFail(final Function> operation, - final Consumer expectFunction, - final Consumer replyFunction) throws Exception { + final Consumer> expectFunction, + final Consumer> replyFunction) throws Exception { final ListenableFuture 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 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()); + assertEquals(e, exception.getCause()); } -} \ No newline at end of file +}