*/
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;
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;
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;
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";
@Mock
private AbstractClientHistory history;
private ActorSystem system;
- private List<TransactionTester> transactions;
+ private List<TransactionTester<RemoteProxyTransaction>> 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 =
}
@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
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());
+ assertEquals(Optional.of(PersistenceProtocol.THREE_PHASE), request.getPersistenceProtocol());
}
- void expectPreCommit(final TransactionTester tester) {
+ void expectPreCommit(final TransactionTester<?> tester) {
tester.expectTransactionRequest(TransactionPreCommitRequest.class);
}
- void expectCommit(final TransactionTester tester) {
+ void expectCommit(final TransactionTester<?> tester) {
tester.expectTransactionRequest(TransactionDoCommitRequest.class);
}
- void expectAbort(final TransactionTester tester) {
+ void expectAbort(final TransactionTester<?> tester) {
tester.expectTransactionRequest(TransactionAbortRequest.class);
}
- void replyCanCommitSuccess(final TransactionTester tester) {
+ void replyCanCommitSuccess(final TransactionTester<?> tester) {
final RequestSuccess<?, ?> success = new TransactionCanCommitSuccess(tester.getTransaction().getIdentifier(),
tester.getLastReceivedMessage().getSequence());
tester.replySuccess(success);
}
- void replyPreCommitSuccess(final TransactionTester tester) {
+ void replyPreCommitSuccess(final TransactionTester<?> tester) {
final RequestSuccess<?, ?> success = new TransactionPreCommitSuccess(tester.getTransaction().getIdentifier(),
tester.getLastReceivedMessage().getSequence());
tester.replySuccess(success);
}
- void replyCommitSuccess(final TransactionTester tester) {
+ void replyCommitSuccess(final TransactionTester<?> tester) {
final RequestSuccess<?, ?> success = new TransactionCommitSuccess(tester.getTransaction().getIdentifier(),
tester.getLastReceivedMessage().getSequence());
tester.replySuccess(success);
}
- void replyAbortSuccess(final TransactionTester tester) {
+ void replyAbortSuccess(final TransactionTester<?> tester) {
final RequestSuccess<?, ?> success = new TransactionAbortSuccess(tester.getTransaction().getIdentifier(),
tester.getLastReceivedMessage().getSequence());
tester.replySuccess(success);
}
- private static TransactionTester createTransactionTester(final TestProbe backendProbe,
+ private static TransactionTester<RemoteProxyTransaction> createTransactionTester(final TestProbe backendProbe,
final ClientActorContext context,
final AbstractClientHistory history) {
final ShardBackendInfo backend = new ShardBackendInfo(backendProbe.ref(), 0L, ABIVersion.BORON,
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 TransactionTester(transaction, connection, backendProbe);
+ new RemoteProxyTransaction(proxyHistory, TRANSACTION_ID, false, false, false);
+ return new TransactionTester<>(transaction, connection, backendProbe);
}
- private void replySuccess(final Collection<TransactionTester> transactions,
- final Consumer<TransactionTester> expect,
- final Consumer<TransactionTester> reply) {
- for (final TransactionTester 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);
}
* @throws Exception unexpected exception
*/
private <T> void testOpSuccess(final Function<ClientTransactionCommitCohort, ListenableFuture<T>> operation,
- final Consumer<TransactionTester> expectFunction,
- final Consumer<TransactionTester> 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);
- Assert.assertEquals(expectedResult, getWithTimeout(result));
+ assertEquals(expectedResult, getWithTimeout(result));
}
/**
* @throws Exception unexpected exception
*/
private <T> void testOpFail(final Function<ClientTransactionCommitCohort, ListenableFuture<T>> operation,
- final Consumer<TransactionTester> expectFunction,
- final Consumer<TransactionTester> 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 TransactionTester 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());
+ assertEquals(e, exception.getCause());
}
-}
\ No newline at end of file
+}
Code Review / controller.git / blobdiff