*/
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.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+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 akka.actor.ActorRef;
import akka.actor.ActorSelection;
import akka.actor.ActorSystem;
-import akka.testkit.JavaTestKit;
import akka.testkit.TestProbe;
+import akka.testkit.javadsl.TestKit;
import java.util.Collection;
import java.util.Collections;
import java.util.function.Function;
import org.opendaylight.controller.cluster.access.commands.AbortLocalTransactionRequest;
import org.opendaylight.controller.cluster.access.commands.ConnectClientRequest;
import org.opendaylight.controller.cluster.access.commands.ConnectClientSuccess;
-import org.opendaylight.controller.cluster.access.concepts.ClientIdentifier;
import org.opendaylight.controller.cluster.access.concepts.Envelope;
import org.opendaylight.controller.cluster.access.concepts.FailureEnvelope;
-import org.opendaylight.controller.cluster.access.concepts.FrontendIdentifier;
-import org.opendaylight.controller.cluster.access.concepts.FrontendType;
-import org.opendaylight.controller.cluster.access.concepts.LocalHistoryIdentifier;
-import org.opendaylight.controller.cluster.access.concepts.MemberName;
import org.opendaylight.controller.cluster.access.concepts.Request;
import org.opendaylight.controller.cluster.access.concepts.RequestEnvelope;
import org.opendaylight.controller.cluster.access.concepts.RequestFailure;
import org.opendaylight.controller.cluster.access.concepts.RequestSuccess;
import org.opendaylight.controller.cluster.access.concepts.Response;
import org.opendaylight.controller.cluster.access.concepts.SuccessEnvelope;
-import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
import org.opendaylight.controller.cluster.datastore.messages.PrimaryShardInfo;
import org.opendaylight.controller.cluster.datastore.utils.ActorContext;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
public abstract class AbstractClientHandleTest<T extends AbstractClientHandle<AbstractProxyTransaction>> {
- private static final MemberName MEMBER_NAME = MemberName.forName("member-1");
- private static final FrontendType FRONTEND_TYPE = FrontendType.forName("type-1");
- private static final FrontendIdentifier FRONTEND_ID = FrontendIdentifier.create(MEMBER_NAME, FRONTEND_TYPE);
- private static final ClientIdentifier CLIENT_ID = ClientIdentifier.create(FRONTEND_ID, 0);
- private static final LocalHistoryIdentifier HISTORY_ID = new LocalHistoryIdentifier(CLIENT_ID, 0L);
private static final String PERSISTENCE_ID = "per-1";
private static final YangInstanceIdentifier PATH = YangInstanceIdentifier.EMPTY;
- protected static final TransactionIdentifier TRANSACTION_ID = new TransactionIdentifier(HISTORY_ID, 0L);
@Mock
private DataTree dataTree;
final long sequence = 0L;
contextProbe.reply(new ConnectClientSuccess(CLIENT_ID, sequence, backendProbe.ref(),
Collections.emptyList(), dataTree, 3));
- final InternalCommand command = clientContextProbe.expectMsgClass(InternalCommand.class);
+ final InternalCommand<ShardBackendInfo> command = clientContextProbe.expectMsgClass(InternalCommand.class);
command.execute(client);
//data tree mock
when(dataTree.takeSnapshot()).thenReturn(dataTreeSnapshot);
handle = createHandle(parent);
}
+ @SuppressWarnings("checkstyle:hiddenField")
protected abstract T createHandle(AbstractClientHistory parent);
/**
*
* @param handle handle
*/
+ @SuppressWarnings("checkstyle:hiddenField")
protected abstract void doHandleOperation(T handle);
@After
- public void tearDown() throws Exception {
- JavaTestKit.shutdownActorSystem(system);
+ public void tearDown() {
+ TestKit.shutdownActorSystem(system);
}
@Test
- public void testGetIdentifier() throws Exception {
+ public void testGetIdentifier() {
Assert.assertEquals(TRANSACTION_ID, handle.getIdentifier());
}
public void testAbort() throws Exception {
doHandleOperation(handle);
handle.abort();
- final Envelope envelope = backendProbe.expectMsgClass(Envelope.class);
+ final Envelope<?> envelope = backendProbe.expectMsgClass(Envelope.class);
final AbortLocalTransactionRequest request = (AbortLocalTransactionRequest) envelope.getMessage();
Assert.assertEquals(TRANSACTION_ID, request.getTarget());
checkClosed();
public void testLocalAbort() throws Exception {
doHandleOperation(handle);
handle.localAbort(new RuntimeException("fail"));
- final Envelope envelope = backendProbe.expectMsgClass(Envelope.class);
+ final Envelope<?> envelope = backendProbe.expectMsgClass(Envelope.class);
final AbortLocalTransactionRequest request = (AbortLocalTransactionRequest) envelope.getMessage();
Assert.assertEquals(TRANSACTION_ID, request.getTarget());
checkClosed();
}
@Test
- public void testEnsureClosed() throws Exception {
+ public void testEnsureClosed() {
doHandleOperation(handle);
final Collection<AbstractProxyTransaction> transactions = handle.ensureClosed();
Assert.assertNotNull(transactions);
}
@Test
- public void testEnsureProxy() throws Exception {
+ public void testEnsureProxy() {
final Function<Long, AbstractProxyTransaction> function = mock(Function.class);
final AbstractProxyTransaction expected = mock(AbstractProxyTransaction.class);
when(function.apply(0L)).thenReturn(expected);
}
@Test
- public void testParent() throws Exception {
+ public void testParent() {
Assert.assertEquals(parent, handle.parent());
}
* @param <R> expected request type
* @return request message
*/
- protected <R extends Request> R backendRespondToRequest(final Class<R> expectedRequestClass,
- final Response response) {
+ protected <R extends Request<?, R>> R backendRespondToRequest(final Class<R> expectedRequestClass,
+ final Response<?, ?> response) {
final RequestEnvelope envelope = backendProbe.expectMsgClass(RequestEnvelope.class);
Assert.assertEquals(expectedRequestClass, envelope.getMessage().getClass());
final AbstractClientConnection<ShardBackendInfo> connection = client.getConnection(0L);
final FailureEnvelope responseEnvelope = new FailureEnvelope(fail, sessionId, txSequence, executionTime);
AccessClientUtil.completeRequest(connection, responseEnvelope);
}
- return (R) envelope.getMessage();
+ return expectedRequestClass.cast(envelope.getMessage());
}
protected T getHandle() {
return mock;
}
-}
\ No newline at end of file
+}