*/
package org.opendaylight.controller.cluster.databroker.actors.dds;
-import static org.opendaylight.controller.cluster.databroker.actors.dds.TestUtils.CLIENT_ID;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.endsWith;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
import akka.actor.ActorSystem;
-import akka.testkit.JavaTestKit;
import akka.testkit.TestProbe;
+import akka.testkit.javadsl.TestKit;
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.TransactionIdentifier;
-import org.opendaylight.controller.cluster.datastore.utils.ActorContext;
+import org.opendaylight.controller.cluster.datastore.utils.ActorUtils;
+@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class ClientLocalHistoryTest extends AbstractClientHistoryTest<ClientLocalHistory> {
private ActorSystem system;
private AbstractDataStoreClientBehavior behavior;
private ClientTransaction transaction;
@Before
- public void setUp() throws Exception {
- MockitoAnnotations.initMocks(this);
-
+ public void setUp() {
system = ActorSystem.apply();
final TestProbe clientContextProbe = new TestProbe(system, "client");
final TestProbe actorContextProbe = new TestProbe(system, "actor-context");
clientActorContext = AccessClientUtil.createClientActorContext(
- system, clientContextProbe.ref(), CLIENT_ID, PERSISTENCE_ID);
- final ActorContext actorContextMock = createActorContextMock(system, actorContextProbe.ref());
- behavior = new SimpleDataStoreClientBehavior(clientActorContext, actorContextMock, SHARD_NAME);
+ system, clientContextProbe.ref(), TestUtils.CLIENT_ID, PERSISTENCE_ID);
+ final ActorUtils actorUtilsMock = createActorUtilsMock(system, actorContextProbe.ref());
+ behavior = new SimpleDataStoreClientBehavior(clientActorContext, actorUtilsMock, SHARD_NAME);
object = new ClientLocalHistory(behavior, HISTORY_ID);
}
@After
- public void tearDown() throws Exception {
- JavaTestKit.shutdownActorSystem(system);
+ public void tearDown() {
+ TestKit.shutdownActorSystem(system);
}
@Override
}
@Test
- public void testClose() throws Exception {
+ public void testClose() {
object().close();
- Assert.assertEquals(AbstractClientHistory.State.CLOSED, object().state());
+ assertEquals(AbstractClientHistory.State.CLOSED, object().state());
}
@Override
@Test
- public void testDoCreateTransaction() throws Exception {
+ public void testDoCreateTransaction() {
final ClientTransaction clientTransaction = object().doCreateTransaction();
- Assert.assertEquals(object().getIdentifier(), clientTransaction.getIdentifier().getHistoryId());
+ assertEquals(object().getIdentifier(), clientTransaction.getIdentifier().getHistoryId());
}
@Override
@Test
- public void testOnTransactionAbort() throws Exception {
+ public void testOnTransactionAbort() {
final ClientSnapshot clientSnapshot = object().doCreateSnapshot();
- Assert.assertTrue(clientSnapshot.abort());
+ assertTrue(clientSnapshot.abort());
}
@Override
@Test
- public void testCreateHistoryProxy() throws Exception {
+ public void testCreateHistoryProxy() {
final AbstractClientConnection<ShardBackendInfo> clientConnection = behavior.getConnection(0L);
final ProxyHistory historyProxy = object().createHistoryProxy(HISTORY_ID, clientConnection);
- Assert.assertEquals(object().getIdentifier(), historyProxy.getIdentifier());
+ assertEquals(object().getIdentifier(), historyProxy.getIdentifier());
}
@Override
@Test
- public void testDoCreateSnapshot() throws Exception {
+ public void testDoCreateSnapshot() {
final ClientSnapshot clientSnapshot = object().doCreateSnapshot();
- Assert.assertEquals(new TransactionIdentifier(object().getIdentifier(), object().nextTx()).getHistoryId(),
+ assertEquals(new TransactionIdentifier(object().getIdentifier(), object().nextTx()).getHistoryId(),
clientSnapshot.getIdentifier().getHistoryId());
}
@Override
@Test
- public void testOnTransactionComplete() throws Exception {
- final ClientTransaction transaction = object().createTransaction();
+ public void testOnTransactionComplete() {
+ final ClientTransaction tx = object().createTransaction();
// make transaction ready
- object().onTransactionReady(transaction, cohort);
+ object().onTransactionReady(tx, cohort);
// state should be set to IDLE
- Assert.assertEquals(AbstractClientHistory.State.IDLE, object.state());
+ assertEquals(AbstractClientHistory.State.IDLE, object.state());
// complete transaction
- object().onTransactionComplete(transaction.getIdentifier());
+ object().onTransactionComplete(tx.getIdentifier());
// state is still IDLE
- Assert.assertEquals(AbstractClientHistory.State.IDLE, object.state());
+ assertEquals(AbstractClientHistory.State.IDLE, object.state());
}
@Override
@Test
- public void testOnTransactionReady() throws Exception {
- final AbstractTransactionCommitCohort result = object().onTransactionReady(
- object().createTransaction(), cohort);
- Assert.assertEquals(result, cohort);
+ public void testOnTransactionReady() {
+ final AbstractTransactionCommitCohort result = object().onTransactionReady(object().createTransaction(),
+ cohort);
+ assertEquals(result, cohort);
}
@Override
- @Test(expected = IllegalStateException.class)
- public void testOnTransactionReadyDuplicate() throws Exception {
- final ClientTransaction transaction = object().createTransaction();
- object().onTransactionReady(transaction, cohort);
- object().onTransactionReady(transaction, cohort);
+ @Test
+ public void testOnTransactionReadyDuplicate() {
+ final ClientTransaction tx = object().createTransaction();
+ object().onTransactionReady(tx, cohort);
+ final IllegalStateException ise = assertThrows(IllegalStateException.class,
+ () -> object().onTransactionReady(tx, cohort));
+ assertThat(ise.getMessage(), containsString(" is idle when readying transaction "));
}
@Test
- public void testOnTransactionReadyAndComplete() throws Exception {
+ public void testOnTransactionReadyAndComplete() {
object().updateState(AbstractClientHistory.State.IDLE, AbstractClientHistory.State.TX_OPEN);
final AbstractTransactionCommitCohort transactionCommitCohort =
object().onTransactionReady(transaction, cohort);
- Assert.assertEquals(cohort, transactionCommitCohort);
+ assertEquals(cohort, transactionCommitCohort);
}
@Test
- public void testOnTransactionReadyAndCompleteStateClosed() throws Exception {
+ public void testOnTransactionReadyAndCompleteStateClosed() {
object().updateState(AbstractClientHistory.State.IDLE, AbstractClientHistory.State.CLOSED);
final AbstractTransactionCommitCohort transactionCommitCohort =
object().onTransactionReady(transaction, cohort);
- Assert.assertEquals(cohort, transactionCommitCohort);
+ assertEquals(cohort, transactionCommitCohort);
}
- @Test(expected = IllegalStateException.class)
- public void testOnTransactionReadyAndCompleteIdleFail() throws Exception {
- object().onTransactionReady(transaction, cohort);
+ @Test
+ public void testOnTransactionReadyAndCompleteIdleFail() {
+ final IllegalStateException ise = assertThrows(IllegalStateException.class,
+ () -> object().onTransactionReady(transaction, cohort));
+ assertThat(ise.getMessage(), endsWith(" is idle when readying transaction null"));
}
-}
\ No newline at end of file
+}