*/
package org.opendaylight.controller.cluster.databroker.actors.dds;
-import static org.mockito.Matchers.any;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import akka.testkit.TestProbe;
import com.google.common.base.Ticker;
+import java.util.Optional;
import java.util.function.Consumer;
-import org.junit.Assert;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.invocation.InvocationOnMock;
import org.opendaylight.controller.cluster.access.commands.TransactionPurgeRequest;
import org.opendaylight.controller.cluster.access.commands.TransactionRequest;
import org.opendaylight.controller.cluster.access.concepts.Response;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.CursorAwareDataTreeModification;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModificationCursor;
+import org.opendaylight.yangtools.yang.data.tree.api.CursorAwareDataTreeModification;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeModificationCursor;
public abstract class LocalProxyTransactionTest<T extends LocalProxyTransaction>
extends AbstractProxyTransactionTest<T> {
@Override
@Test
public void testExists() throws Exception {
- assertFutureEquals(true, transaction.exists(PATH_1));
- assertFutureEquals(false, transaction.exists(PATH_3));
+ assertFutureEquals(Boolean.TRUE, transaction.exists(PATH_1));
+ assertFutureEquals(Boolean.FALSE, transaction.exists(PATH_3));
}
@Override
@Test
public void testRead() throws Exception {
- assertFutureEquals(com.google.common.base.Optional.of(DATA_1), transaction.read(PATH_1));
- assertFutureEquals(com.google.common.base.Optional.absent(), transaction.read(PATH_3));
+ assertFutureEquals(Optional.of(DATA_1), transaction.read(PATH_1));
+ assertFutureEquals(Optional.empty(), transaction.read(PATH_3));
}
@Test
- public void testDoAbort() throws Exception {
- transaction.doAbort();
+ public void testAbort() {
+ transaction.abort();
getTester().expectTransactionRequest(AbortLocalTransactionRequest.class);
}
@SuppressWarnings("unchecked")
private void setupExecuteInActor() {
doAnswer(inv -> {
- inv.getArgumentAt(0, InternalCommand.class).execute(mock(ClientActorBehavior.class));
+ inv.getArgument(0, InternalCommand.class).execute(mock(ClientActorBehavior.class));
return null;
}).when(context).executeInActor(any(InternalCommand.class));
}
@Test
- public void testHandleForwardedRemoteReadRequest() throws Exception {
+ public void testHandleForwardedRemoteReadRequest() {
final TestProbe probe = createProbe();
final ReadTransactionRequest request =
new ReadTransactionRequest(TRANSACTION_ID, 0L, probe.ref(), PATH_1, true);
setupExecuteInActor();
transaction.handleReplayedRemoteRequest(request, callback, Ticker.systemTicker().read());
- final ArgumentCaptor<Response> captor = ArgumentCaptor.forClass(Response.class);
+ final ArgumentCaptor<Response<?, ?>> captor = ArgumentCaptor.forClass(Response.class);
verify(callback).accept(captor.capture());
final Response<?, ?> value = captor.getValue();
- Assert.assertTrue(value instanceof ReadTransactionSuccess);
+ assertTrue(value instanceof ReadTransactionSuccess);
final ReadTransactionSuccess success = (ReadTransactionSuccess) value;
- Assert.assertTrue(success.getData().isPresent());
- Assert.assertEquals(DATA_1, success.getData().get());
+ assertTrue(success.getData().isPresent());
+ assertEquals(DATA_1, success.getData().get());
}
@Test
- public void testHandleForwardedRemoteExistsRequest() throws Exception {
+ public void testHandleForwardedRemoteExistsRequest() {
final TestProbe probe = createProbe();
final ExistsTransactionRequest request =
new ExistsTransactionRequest(TRANSACTION_ID, 0L, probe.ref(), PATH_1, true);
setupExecuteInActor();
transaction.handleReplayedRemoteRequest(request, callback, Ticker.systemTicker().read());
- final ArgumentCaptor<Response> captor = ArgumentCaptor.forClass(Response.class);
+ final ArgumentCaptor<Response<?, ?>> captor = ArgumentCaptor.forClass(Response.class);
verify(callback).accept(captor.capture());
final Response<?, ?> value = captor.getValue();
- Assert.assertTrue(value instanceof ExistsTransactionSuccess);
+ assertTrue(value instanceof ExistsTransactionSuccess);
final ExistsTransactionSuccess success = (ExistsTransactionSuccess) value;
- Assert.assertTrue(success.getExists());
+ assertTrue(success.getExists());
}
@Test
- public void testHandleForwardedRemotePurgeRequest() throws Exception {
+ public void testHandleForwardedRemotePurgeRequest() {
final TestProbe probe = createProbe();
- final TransactionPurgeRequest request =
- new TransactionPurgeRequest(TRANSACTION_ID, 0L, probe.ref());
+ final TransactionPurgeRequest request = new TransactionPurgeRequest(TRANSACTION_ID, 0L, probe.ref());
testHandleForwardedRemoteRequest(request);
}
@Override
@Test
- public void testForwardToRemoteAbort() throws Exception {
+ public void testForwardToRemoteAbort() {
final TestProbe probe = createProbe();
final AbortLocalTransactionRequest request = new AbortLocalTransactionRequest(TRANSACTION_ID, probe.ref());
final ModifyTransactionRequest modifyRequest = testForwardToRemote(request, ModifyTransactionRequest.class);
- Assert.assertTrue(modifyRequest.getPersistenceProtocol().isPresent());
- Assert.assertEquals(PersistenceProtocol.ABORT, modifyRequest.getPersistenceProtocol().get());
+ assertTrue(modifyRequest.getPersistenceProtocol().isPresent());
+ assertEquals(PersistenceProtocol.ABORT, modifyRequest.getPersistenceProtocol().get());
}
@Override
@Test
- public void testForwardToRemoteCommit() throws Exception {
+ public void testForwardToRemoteCommit() {
final TestProbe probe = createProbe();
final CursorAwareDataTreeModification modification = mock(CursorAwareDataTreeModification.class);
final CommitLocalTransactionRequest request =
doAnswer(LocalProxyTransactionTest::applyToCursorAnswer).when(modification).applyToCursor(any());
final ModifyTransactionRequest modifyRequest = testForwardToRemote(request, ModifyTransactionRequest.class);
verify(modification).applyToCursor(any());
- Assert.assertTrue(modifyRequest.getPersistenceProtocol().isPresent());
- Assert.assertEquals(PersistenceProtocol.THREE_PHASE, modifyRequest.getPersistenceProtocol().get());
+ assertTrue(modifyRequest.getPersistenceProtocol().isPresent());
+ assertEquals(PersistenceProtocol.THREE_PHASE, modifyRequest.getPersistenceProtocol().get());
checkModifications(modifyRequest);
}
@Test
- public void testForwardToLocalAbort() throws Exception {
+ public void testForwardToLocalAbort() {
final TestProbe probe = createProbe();
final AbortLocalTransactionRequest request = new AbortLocalTransactionRequest(TRANSACTION_ID, probe.ref());
testForwardToLocal(request, AbortLocalTransactionRequest.class);
}
@Test
- public void testForwardToLocalPurge() throws Exception {
+ public void testForwardToLocalPurge() {
final TestProbe probe = createProbe();
final TransactionPurgeRequest request = new TransactionPurgeRequest(TRANSACTION_ID, 0L, probe.ref());
testForwardToLocal(request, TransactionPurgeRequest.class);
}
protected <R extends TransactionRequest<R>> R testForwardToLocal(final TransactionRequest<?> toForward,
- final Class<R> expectedMessageClass) {
+ final Class<R> expectedMessageClass) {
final Consumer<Response<?, ?>> callback = createCallbackMock();
final TransactionTester<LocalReadWriteProxyTransaction> transactionTester = createLocalProxy();
final LocalReadWriteProxyTransaction successor = transactionTester.getTransaction();
* @return void - always null
*/
protected static final <T> Answer<T> applyToCursorAnswer(final InvocationOnMock invocation) {
- final DataTreeModificationCursor cursor =
- invocation.getArgumentAt(0, DataTreeModificationCursor.class);
+ final DataTreeModificationCursor cursor = invocation.getArgument(0);
cursor.write(PATH_1.getLastPathArgument(), DATA_1);
cursor.merge(PATH_2.getLastPathArgument(), DATA_2);
cursor.delete(PATH_3.getLastPathArgument());
return null;
}
-
}
Code Review / controller.git / blobdiff