*/
package org.opendaylight.controller.cluster.databroker.actors.dds;
-import static org.mockito.Matchers.any;
+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 static org.opendaylight.controller.cluster.databroker.actors.dds.TestUtils.assertFutureEquals;
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.mockito.stubbing.Answer;
+import org.opendaylight.controller.cluster.access.client.ClientActorBehavior;
+import org.opendaylight.controller.cluster.access.client.InternalCommand;
import org.opendaylight.controller.cluster.access.commands.AbortLocalTransactionRequest;
import org.opendaylight.controller.cluster.access.commands.CommitLocalTransactionRequest;
import org.opendaylight.controller.cluster.access.commands.ExistsTransactionRequest;
@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.<InternalCommand<?>>getArgument(0).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);
final Consumer<Response<?, ?>> callback = createCallbackMock();
- transaction.handleForwardedRemoteRequest(request, callback);
- final ArgumentCaptor<Response> captor = ArgumentCaptor.forClass(Response.class);
+ setupExecuteInActor();
+
+ transaction.handleReplayedRemoteRequest(request, callback, Ticker.systemTicker().read());
+ final ArgumentCaptor<Response<?, ?>> captor = ArgumentCaptor.forClass(Response.class);
verify(callback).accept(captor.capture());
- final Response value = captor.getValue();
+ final Response<?, ?> value = captor.getValue();
Assert.assertTrue(value instanceof ReadTransactionSuccess);
final ReadTransactionSuccess success = (ReadTransactionSuccess) value;
Assert.assertTrue(success.getData().isPresent());
}
@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);
final Consumer<Response<?, ?>> callback = createCallbackMock();
- transaction.handleForwardedRemoteRequest(request, callback);
- final ArgumentCaptor<Response> captor = ArgumentCaptor.forClass(Response.class);
+ setupExecuteInActor();
+
+ transaction.handleReplayedRemoteRequest(request, callback, Ticker.systemTicker().read());
+ final ArgumentCaptor<Response<?, ?>> captor = ArgumentCaptor.forClass(Response.class);
verify(callback).accept(captor.capture());
- final Response value = captor.getValue();
+ final Response<?, ?> value = captor.getValue();
Assert.assertTrue(value instanceof ExistsTransactionSuccess);
final ExistsTransactionSuccess success = (ExistsTransactionSuccess) value;
Assert.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());
@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);
@Override
@Test
- public void testForwardToRemoteCommit() throws Exception {
+ public void testForwardToRemoteCommit() {
final TestProbe probe = createProbe();
final CursorAwareDataTreeModification modification = mock(CursorAwareDataTreeModification.class);
final CommitLocalTransactionRequest request =
- new CommitLocalTransactionRequest(TRANSACTION_ID, 0L, probe.ref(), modification, true);
- doAnswer(this::applyToCursorAnswer).when(modification).applyToCursor(any());
+ new CommitLocalTransactionRequest(TRANSACTION_ID, 0L, probe.ref(), modification, null, true);
+ doAnswer(LocalProxyTransactionTest::applyToCursorAnswer).when(modification).applyToCursor(any());
final ModifyTransactionRequest modifyRequest = testForwardToRemote(request, ModifyTransactionRequest.class);
verify(modification).applyToCursor(any());
Assert.assertTrue(modifyRequest.getPersistenceProtocol().isPresent());
}
@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 <T extends TransactionRequest> T testForwardToLocal(final TransactionRequest toForward,
- final Class<T> expectedMessageClass) {
+ protected <R extends TransactionRequest<R>> R testForwardToLocal(final TransactionRequest<?> toForward,
+ final Class<R> expectedMessageClass) {
final Consumer<Response<?, ?>> callback = createCallbackMock();
final TransactionTester<LocalReadWriteProxyTransaction> transactionTester = createLocalProxy();
final LocalReadWriteProxyTransaction successor = transactionTester.getTransaction();
* @param invocation invocation
* @return void - always null
*/
- protected Answer applyToCursorAnswer(final InvocationOnMock invocation) {
- final DataTreeModificationCursor cursor =
- invocation.getArgumentAt(0, DataTreeModificationCursor.class);
+ protected static final <T> Answer<T> applyToCursorAnswer(final InvocationOnMock invocation) {
+ 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;
}
-
-}
\ No newline at end of file
+}
Code Review / controller.git / blobdiff