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;
@Mock
private AbstractClientHistory history;
private ActorSystem system;
- private List<TranasactionTester> transactions;
+ private List<TransactionTester<RemoteProxyTransaction>> transactions;
private ClientTransactionCommitCohort cohort;
@Before
- public void setUp() throws Exception {
+ public void setUp() {
MockitoAnnotations.initMocks(this);
system = ActorSystem.apply();
final TestProbe clientContextProbe = new TestProbe(system, "clientContext");
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);
}
@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
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);
}
* @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);
* @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
+}