*/
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.assertNotNull;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.lenient;
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 java.util.Collection;
-import java.util.Collections;
-import java.util.function.Function;
+import akka.testkit.javadsl.TestKit;
+import java.util.List;
+import java.util.Map;
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.client.AbstractClientConnection;
import org.opendaylight.controller.cluster.access.client.AccessClientUtil;
import org.opendaylight.controller.cluster.access.client.ClientActorContext;
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.datastore.DatastoreContext;
import org.opendaylight.controller.cluster.datastore.messages.PrimaryShardInfo;
-import org.opendaylight.controller.cluster.datastore.utils.ActorContext;
+import org.opendaylight.controller.cluster.datastore.utils.ActorUtils;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshot;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTree;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeSnapshot;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import scala.concurrent.Promise;
+@RunWith(MockitoJUnitRunner.StrictStubs.class)
public abstract class AbstractClientHandleTest<T extends AbstractClientHandle<AbstractProxyTransaction>> {
-
private static final String PERSISTENCE_ID = "per-1";
- private static final YangInstanceIdentifier PATH = YangInstanceIdentifier.EMPTY;
+ private static final YangInstanceIdentifier PATH = YangInstanceIdentifier.empty();
@Mock
private DataTree dataTree;
@Before
public void setUp() throws Exception {
- MockitoAnnotations.initMocks(this);
system = ActorSystem.apply();
final TestProbe contextProbe = new TestProbe(system, "context");
final TestProbe clientContextProbe = new TestProbe(system, "client-context");
backendProbe = new TestProbe(system, "backend");
//create handle dependencies
- final ActorContext actorContext = createActorContextMock(system, contextProbe.ref());
+ final ActorUtils actorUtils = createActorContextMock(system, contextProbe.ref());
final ClientActorContext clientContext =
AccessClientUtil.createClientActorContext(system, clientContextProbe.ref(), CLIENT_ID, PERSISTENCE_ID);
- client = new SimpleDataStoreClientBehavior(clientContext, actorContext, "shard");
+ client = new SimpleDataStoreClientBehavior(clientContext, actorUtils, "shard");
client.createLocalHistory();
parent = new SingleClientHistory(client, HISTORY_ID);
//connect client
client.getConnection(0L);
contextProbe.expectMsgClass(ConnectClientRequest.class);
final long sequence = 0L;
- contextProbe.reply(new ConnectClientSuccess(CLIENT_ID, sequence, backendProbe.ref(),
- Collections.emptyList(), dataTree, 3));
- final InternalCommand command = clientContextProbe.expectMsgClass(InternalCommand.class);
+ contextProbe.reply(new ConnectClientSuccess(CLIENT_ID, sequence, backendProbe.ref(), List.of(), dataTree, 3));
+ final InternalCommand<ShardBackendInfo> command = clientContextProbe.expectMsgClass(InternalCommand.class);
command.execute(client);
//data tree mock
- when(dataTree.takeSnapshot()).thenReturn(dataTreeSnapshot);
+ doReturn(dataTreeSnapshot).when(dataTree).takeSnapshot();
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 {
- Assert.assertEquals(TRANSACTION_ID, handle.getIdentifier());
+ public void testGetIdentifier() {
+ assertEquals(TRANSACTION_ID, handle.getIdentifier());
}
@Test
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());
+ 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());
+ 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);
- Assert.assertEquals(1, transactions.size());
+ final Map<Long, AbstractProxyTransaction> transactions = handle.ensureClosed();
+ assertNotNull(transactions);
+ assertEquals(1, transactions.size());
}
@Test
- public void testEnsureProxy() throws Exception {
- final Function<Long, AbstractProxyTransaction> function = mock(Function.class);
+ public void testEnsureProxy() {
final AbstractProxyTransaction expected = mock(AbstractProxyTransaction.class);
- when(function.apply(0L)).thenReturn(expected);
- final AbstractProxyTransaction proxy = handle.ensureProxy(PATH, function);
- verify(function).apply(0L);
- Assert.assertEquals(expected, proxy);
+ final AbstractProxyTransaction proxy = handle.ensureProxy(PATH);
+ assertEquals(0, proxy.getIdentifier().getTransactionId());
}
@Test
- public void testParent() throws Exception {
- Assert.assertEquals(parent, handle.parent());
+ public void testParent() {
+ assertEquals(parent, handle.parent());
}
protected void checkClosed() throws Exception {
* @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());
+ assertEquals(expectedRequestClass, envelope.getMessage().getClass());
final AbstractClientConnection<ShardBackendInfo> connection = client.getConnection(0L);
final long sessionId = envelope.getSessionId();
final long txSequence = envelope.getTxSequence();
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 dataTreeSnapshot;
}
- private static ActorContext createActorContextMock(final ActorSystem system, final ActorRef actor) {
- final ActorContext mock = mock(ActorContext.class);
+ private static ActorUtils createActorContextMock(final ActorSystem system, final ActorRef actor) {
+ final ActorUtils mock = mock(ActorUtils.class);
final Promise<PrimaryShardInfo> promise = new scala.concurrent.impl.Promise.DefaultPromise<>();
final ActorSelection selection = system.actorSelection(actor.path());
final PrimaryShardInfo shardInfo = new PrimaryShardInfo(selection, (short) 0);
promise.success(shardInfo);
- when(mock.findPrimaryShardAsync(any())).thenReturn(promise.future());
+ doReturn(promise.future()).when(mock).findPrimaryShardAsync(any());
+
+ final EffectiveModelContext context = mock(EffectiveModelContext.class);
+ lenient().doCallRealMethod().when(context).getQName();
+ lenient().doReturn(context).when(mock).getSchemaContext();
+ lenient().doReturn(DatastoreContext.newBuilder().build()).when(mock).getDatastoreContext();
+
return mock;
}
-
-}
\ No newline at end of file
+}