import static org.mockito.Matchers.eq;
import static org.mockito.Matchers.isA;
import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.opendaylight.controller.cluster.datastore.TransactionType.READ_ONLY;
import static org.opendaylight.controller.cluster.datastore.TransactionType.READ_WRITE;
import org.opendaylight.controller.cluster.datastore.messages.CloseTransaction;
import org.opendaylight.controller.cluster.datastore.messages.CommitTransactionReply;
import org.opendaylight.controller.cluster.datastore.messages.PrimaryShardInfo;
-import org.opendaylight.controller.cluster.datastore.messages.ReadyTransaction;
import org.opendaylight.controller.cluster.datastore.modification.DeleteModification;
import org.opendaylight.controller.cluster.datastore.modification.MergeModification;
import org.opendaylight.controller.cluster.datastore.modification.WriteModification;
import org.opendaylight.controller.cluster.datastore.shardstrategy.DefaultShardStrategy;
-import org.opendaylight.controller.cluster.datastore.utils.DoNothingActor;
import org.opendaylight.controller.cluster.datastore.utils.NormalizedNodeAggregatorTest;
+import org.opendaylight.controller.cluster.raft.utils.DoNothingActor;
import org.opendaylight.controller.md.cluster.datastore.model.CarsModel;
import org.opendaylight.controller.md.cluster.datastore.model.SchemaContextHelper;
import org.opendaylight.controller.md.cluster.datastore.model.TestModel;
TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
- doReturn(readSerializedDataReply(null)).when(mockActorContext).executeOperationAsync(
+ doReturn(readDataReply(null)).when(mockActorContext).executeOperationAsync(
eq(actorSelection(actorRef)), eqSerializedReadData());
Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(
NormalizedNode<?, ?> expectedNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
- doReturn(readSerializedDataReply(expectedNode)).when(mockActorContext).executeOperationAsync(
+ doReturn(readDataReply(expectedNode)).when(mockActorContext).executeOperationAsync(
eq(actorSelection(actorRef)), eqSerializedReadData());
readOptional = transactionProxy.read(TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
expectBatchedModifications(actorRef, 1);
- doReturn(readSerializedDataReply(expectedNode)).when(mockActorContext).executeOperationAsync(
+ doReturn(readDataReply(expectedNode)).when(mockActorContext).executeOperationAsync(
eq(actorSelection(actorRef)), eqSerializedReadData());
TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
- doReturn(dataExistsSerializedReply(false)).when(mockActorContext).executeOperationAsync(
+ doReturn(dataExistsReply(false)).when(mockActorContext).executeOperationAsync(
eq(actorSelection(actorRef)), eqSerializedDataExists());
Boolean exists = transactionProxy.exists(TestModel.TEST_PATH).checkedGet();
assertEquals("Exists response", false, exists);
- doReturn(dataExistsSerializedReply(true)).when(mockActorContext).executeOperationAsync(
+ doReturn(dataExistsReply(true)).when(mockActorContext).executeOperationAsync(
eq(actorSelection(actorRef)), eqSerializedDataExists());
exists = transactionProxy.exists(TestModel.TEST_PATH).checkedGet();
expectBatchedModifications(actorRef, 1);
- doReturn(dataExistsSerializedReply(true)).when(mockActorContext).executeOperationAsync(
+ doReturn(dataExistsReply(true)).when(mockActorContext).executeOperationAsync(
eq(actorSelection(actorRef)), eqSerializedDataExists());
TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
eq(getSystem().actorSelection(actorRef.path())),
eqCreateTransaction(memberName, READ_WRITE), any(Timeout.class));
- doReturn(readSerializedDataReply(null)).when(mockActorContext).executeOperationAsync(
+ doReturn(readDataReply(null)).when(mockActorContext).executeOperationAsync(
eq(actorSelection(actorRef)), eqSerializedReadData());
expectBatchedModificationsReady(actorRef);
NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
- doReturn(readSerializedDataReply(null)).when(mockActorContext).executeOperationAsync(
+ doReturn(readDataReply(null)).when(mockActorContext).executeOperationAsync(
eq(actorSelection(actorRef)), eqSerializedReadData());
expectBatchedModifications(actorRef, 1);
NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
- doReturn(readSerializedDataReply(null)).when(mockActorContext).executeOperationAsync(
+ doReturn(readDataReply(null)).when(mockActorContext).executeOperationAsync(
eq(actorSelection(actorRef)), eqSerializedReadData());
expectBatchedModificationsReady(actorRef, true);
public void testReadyWithNoModifications() throws Exception {
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
- doReturn(readSerializedDataReply(null)).when(mockActorContext).executeOperationAsync(
+ doReturn(readDataReply(null)).when(mockActorContext).executeOperationAsync(
eq(actorSelection(actorRef)), eqSerializedReadData());
expectBatchedModificationsReady(actorRef, true);
verifyBatchedModifications(batchedModifications.get(0), true, true,
new WriteModification(TestModel.TEST_PATH, nodeToWrite));
-
- verify(mockActorContext, never()).executeOperationAsync(eq(actorSelection(actorRef)),
- isA(ReadyTransaction.SERIALIZABLE_CLASS));
}
@Test
new WriteModification(TestModel.TEST_PATH, nodeToWrite));
verifyBatchedModifications(batchedModifications.get(1), true, true);
-
- verify(mockActorContext, never()).executeOperationAsync(eq(actorSelection(actorRef)),
- isA(ReadyTransaction.SERIALIZABLE_CLASS));
}
@Test
verifyCohortFutures((DebugThreePhaseCommitCohort)ready, new CommitTransactionReply().toSerializable());
}
+ @Test
+ public void testReadyWithLocalTransaction() throws Exception {
+ ActorRef shardActorRef = getSystem().actorOf(Props.create(DoNothingActor.class));
+
+ doReturn(getSystem().actorSelection(shardActorRef.path())).
+ when(mockActorContext).actorSelection(shardActorRef.path().toString());
+
+ doReturn(Futures.successful(newPrimaryShardInfo(shardActorRef, createDataTree()))).
+ when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
+
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY);
+
+ expectReadyLocalTransaction(shardActorRef, true);
+
+ NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
+
+ DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
+ assertTrue(ready instanceof SingleCommitCohortProxy);
+ verifyCohortFutures((SingleCommitCohortProxy)ready, new CommitTransactionReply().toSerializable());
+ }
+
+ @Test
+ public void testReadyWithLocalTransactionWithFailure() throws Exception {
+ ActorRef shardActorRef = getSystem().actorOf(Props.create(DoNothingActor.class));
+
+ doReturn(getSystem().actorSelection(shardActorRef.path())).
+ when(mockActorContext).actorSelection(shardActorRef.path().toString());
+
+ Optional<DataTree> mockDataTree = createDataTree();
+ DataTreeModification mockModification = mockDataTree.get().takeSnapshot().newModification();
+ doThrow(new RuntimeException("mock")).when(mockModification).ready();
+
+ doReturn(Futures.successful(newPrimaryShardInfo(shardActorRef, mockDataTree))).
+ when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
+
+ TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY);
+
+ expectReadyLocalTransaction(shardActorRef, true);
+
+ NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
+
+ DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
+ assertTrue(ready instanceof SingleCommitCohortProxy);
+ verifyCohortFutures((SingleCommitCohortProxy)ready, RuntimeException.class);
+ }
+
private void testWriteOnlyTxWithFindPrimaryShardFailure(Exception toThrow) throws Exception {
doReturn(Futures.failed(toThrow)).when(mockActorContext).findPrimaryShardAsync(anyString());
public void testClose() throws Exception{
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
- doReturn(readSerializedDataReply(null)).when(mockActorContext).executeOperationAsync(
+ doReturn(readDataReply(null)).when(mockActorContext).executeOperationAsync(
eq(actorSelection(actorRef)), eqSerializedReadData());
TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
transactionProxy.close();
verify(mockActorContext).sendOperationAsync(
- eq(actorSelection(actorRef)), isA(CloseTransaction.SERIALIZABLE_CLASS));
+ eq(actorSelection(actorRef)), isA(CloseTransaction.class));
}
expectBatchedModifications(2);
- doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
- any(ActorSelection.class), any(ReadyTransaction.class));
-
transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
// Trying to write to Cars will cause another transaction context to get created
YangInstanceIdentifier deletePath = TestModel.OUTER_LIST_PATH;
- doReturn(readSerializedDataReply(writeNode2)).when(mockActorContext).executeOperationAsync(
+ doReturn(readDataReply(writeNode2)).when(mockActorContext).executeOperationAsync(
eq(actorSelection(actorRef)), eqSerializedReadData(writePath2));
- doReturn(readSerializedDataReply(mergeNode2)).when(mockActorContext).executeOperationAsync(
+ doReturn(readDataReply(mergeNode2)).when(mockActorContext).executeOperationAsync(
eq(actorSelection(actorRef)), eqSerializedReadData(mergePath2));
- doReturn(dataExistsSerializedReply(true)).when(mockActorContext).executeOperationAsync(
+ doReturn(dataExistsReply(true)).when(mockActorContext).executeOperationAsync(
eq(actorSelection(actorRef)), eqSerializedDataExists());
TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
executeOperationAsync(eq(actorSystem.actorSelection(shardActorRef.path())),
eqCreateTransaction(memberName, TransactionType.READ_ONLY), any(Timeout.class));
- doReturn(readSerializedDataReply(expectedNode)).when(mockActorContext).executeOperationAsync(
+ doReturn(readDataReply(expectedNode)).when(mockActorContext).executeOperationAsync(
eq(actorSelection(txActorRef)), eqSerializedReadData(YangInstanceIdentifier.builder().build()));
}
}