package org.opendaylight.controller.cluster.datastore.compat;
import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.argThat;
import static org.mockito.Matchers.eq;
import static org.mockito.Matchers.isA;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.verify;
-import static org.opendaylight.controller.cluster.datastore.TransactionProxy.TransactionType.READ_WRITE;
-import static org.opendaylight.controller.cluster.datastore.TransactionProxy.TransactionType.WRITE_ONLY;
+import static org.opendaylight.controller.cluster.datastore.TransactionType.READ_WRITE;
+import static org.opendaylight.controller.cluster.datastore.TransactionType.WRITE_ONLY;
import akka.actor.ActorRef;
import akka.dispatch.Futures;
import akka.util.Timeout;
import com.google.common.base.Optional;
+import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
-import org.junit.Ignore;
+import java.util.concurrent.TimeoutException;
import org.junit.Test;
import org.mockito.ArgumentMatcher;
import org.mockito.Mockito;
import org.opendaylight.controller.cluster.datastore.AbstractThreePhaseCommitCohort;
import org.opendaylight.controller.cluster.datastore.AbstractTransactionProxyTest;
import org.opendaylight.controller.cluster.datastore.DataStoreVersions;
-import org.opendaylight.controller.cluster.datastore.ThreePhaseCommitCohortProxy;
import org.opendaylight.controller.cluster.datastore.TransactionProxy;
import org.opendaylight.controller.cluster.datastore.messages.CanCommitTransaction;
import org.opendaylight.controller.cluster.datastore.messages.CanCommitTransactionReply;
*/
public class PreLithiumTransactionProxyTest extends AbstractTransactionProxyTest {
- private WriteData eqLegacyWriteData(final NormalizedNode<?, ?> nodeToWrite) {
+ private static WriteData eqLegacyWriteData(final NormalizedNode<?, ?> nodeToWrite) {
ArgumentMatcher<WriteData> matcher = new ArgumentMatcher<WriteData>() {
@Override
public boolean matches(Object argument) {
return argThat(matcher);
}
- private MergeData eqLegacyMergeData(final NormalizedNode<?, ?> nodeToWrite) {
+ private static MergeData eqLegacyMergeData(final NormalizedNode<?, ?> nodeToWrite) {
ArgumentMatcher<MergeData> matcher = new ArgumentMatcher<MergeData>() {
@Override
public boolean matches(Object argument) {
return argThat(matcher);
}
- private DeleteData eqLegacyDeleteData(final YangInstanceIdentifier expPath) {
+ private static DeleteData eqLegacyDeleteData(final YangInstanceIdentifier expPath) {
ArgumentMatcher<DeleteData> matcher = new ArgumentMatcher<DeleteData>() {
@Override
public boolean matches(Object argument) {
return argThat(matcher);
}
- private CanCommitTransaction eqCanCommitTransaction(final String transactionID) {
+ private static CanCommitTransaction eqCanCommitTransaction(final String transactionID) {
ArgumentMatcher<CanCommitTransaction> matcher = new ArgumentMatcher<CanCommitTransaction>() {
@Override
public boolean matches(Object argument) {
return argThat(matcher);
}
- private CommitTransaction eqCommitTransaction(final String transactionID) {
+ private static CommitTransaction eqCommitTransaction(final String transactionID) {
ArgumentMatcher<CommitTransaction> matcher = new ArgumentMatcher<CommitTransaction>() {
@Override
public boolean matches(Object argument) {
return argThat(matcher);
}
- private Future<Object> readySerializedTxReply(String path, short version) {
+ private static Future<Object> readySerializedTxReply(String path, short version) {
return Futures.successful(new ReadyTransactionReply(path, version).toSerializable());
}
doReturn(actorRef.path().toString()).when(mockActorContext).resolvePath(eq(actorRef.path().toString()),
eq(actorRef.path().toString()));
- TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, READ_WRITE);
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(TestModel.TEST_PATH).
get(5, TimeUnit.SECONDS);
verifyCohortFutures(proxy, getSystem().actorSelection(actorRef.path()));
+ doThreePhaseCommit(actorRef, transactionProxy, proxy);
+
+ return actorRef;
+ }
+
+ private void doThreePhaseCommit(ActorRef actorRef, TransactionProxy transactionProxy,
+ AbstractThreePhaseCommitCohort<?> proxy) throws InterruptedException, ExecutionException, TimeoutException {
doReturn(Futures.successful(CanCommitTransactionReply.YES.toSerializable())).when(mockActorContext).
- executeOperationAsync(eq(actorSelection(actorRef)),
- eqCanCommitTransaction(transactionProxy.getIdentifier().toString()), any(Timeout.class));
+ executeOperationAsync(eq(actorSelection(actorRef)), eqCanCommitTransaction(
+ transactionProxy.getIdentifier().toString()), any(Timeout.class));
doReturn(Futures.successful(new CommitTransactionReply().toSerializable())).when(mockActorContext).
- executeOperationAsync(eq(actorSelection(actorRef)),
- eqCommitTransaction(transactionProxy.getIdentifier().toString()), any(Timeout.class));
+ executeOperationAsync(eq(actorSelection(actorRef)), eqCommitTransaction(
+ transactionProxy.getIdentifier().toString()), any(Timeout.class));
Boolean canCommit = proxy.canCommit().get(3, TimeUnit.SECONDS);
assertEquals("canCommit", true, canCommit.booleanValue());
proxy.commit().get(3, TimeUnit.SECONDS);
- return actorRef;
+ verify(mockActorContext).executeOperationAsync(eq(actorSelection(actorRef)), eqCanCommitTransaction(
+ transactionProxy.getIdentifier().toString()), any(Timeout.class));
+
+ verify(mockActorContext).executeOperationAsync(eq(actorSelection(actorRef)), eqCommitTransaction(
+ transactionProxy.getIdentifier().toString()), any(Timeout.class));
}
@Test
}
@Test
- @Ignore
- // FIXME: disabled until we can get the primary shard version from the ShardManager as we now skip
- // creating transaction actors for write-only Tx's.
public void testWriteOnlyCompatibilityWithHeliumR2Version() throws Exception {
short version = DataStoreVersions.HELIUM_2_VERSION;
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY, version,
doReturn(readySerializedTxReply(actorRef.path().toString(), version)).when(mockActorContext).executeOperationAsync(
eq(actorSelection(actorRef)), isA(ReadyTransaction.SERIALIZABLE_CLASS));
- doReturn(actorRef.path().toString()).when(mockActorContext).resolvePath(eq(actorRef.path().toString()),
- eq(actorRef.path().toString()));
-
- TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, WRITE_ONLY);
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY);
transactionProxy.write(TestModel.TEST_PATH, testNode);
DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
- assertTrue(ready instanceof ThreePhaseCommitCohortProxy);
-
- ThreePhaseCommitCohortProxy proxy = (ThreePhaseCommitCohortProxy) ready;
+ AbstractThreePhaseCommitCohort<?> proxy = (AbstractThreePhaseCommitCohort<?>) ready;
verifyCohortFutures(proxy, getSystem().actorSelection(actorRef.path()));
+
+ doThreePhaseCommit(actorRef, transactionProxy, proxy);
}
}