1 package org.opendaylight.controller.cluster.datastore;
3 import static org.junit.Assert.assertEquals;
4 import static org.junit.Assert.assertNotNull;
5 import static org.junit.Assert.assertTrue;
6 import static org.junit.Assert.fail;
7 import static org.mockito.Matchers.any;
8 import static org.mockito.Matchers.anyString;
9 import static org.mockito.Matchers.argThat;
10 import static org.mockito.Matchers.eq;
11 import static org.mockito.Matchers.isA;
12 import static org.mockito.Mockito.doReturn;
13 import static org.mockito.Mockito.mock;
14 import static org.mockito.Mockito.times;
15 import static org.mockito.Mockito.verify;
16 import static org.opendaylight.controller.cluster.datastore.TransactionProxy.TransactionType.READ_ONLY;
17 import static org.opendaylight.controller.cluster.datastore.TransactionProxy.TransactionType.READ_WRITE;
18 import static org.opendaylight.controller.cluster.datastore.TransactionProxy.TransactionType.WRITE_ONLY;
19 import akka.actor.ActorRef;
20 import akka.actor.ActorSelection;
21 import akka.actor.ActorSystem;
22 import akka.actor.Props;
23 import akka.dispatch.Futures;
24 import akka.testkit.JavaTestKit;
25 import com.google.common.base.Optional;
26 import com.google.common.collect.ImmutableMap;
27 import com.google.common.util.concurrent.CheckedFuture;
28 import com.typesafe.config.Config;
29 import com.typesafe.config.ConfigFactory;
30 import java.io.IOException;
31 import java.util.List;
32 import java.util.concurrent.TimeUnit;
33 import org.junit.AfterClass;
34 import org.junit.Assert;
35 import org.junit.Before;
36 import org.junit.BeforeClass;
37 import org.junit.Test;
38 import org.mockito.ArgumentMatcher;
39 import org.mockito.Mock;
40 import org.mockito.Mockito;
41 import org.mockito.MockitoAnnotations;
42 import org.opendaylight.controller.cluster.datastore.TransactionProxy.TransactionType;
43 import org.opendaylight.controller.cluster.datastore.exceptions.PrimaryNotFoundException;
44 import org.opendaylight.controller.cluster.datastore.exceptions.TimeoutException;
45 import org.opendaylight.controller.cluster.datastore.messages.CloseTransaction;
46 import org.opendaylight.controller.cluster.datastore.messages.CreateTransaction;
47 import org.opendaylight.controller.cluster.datastore.messages.DataExists;
48 import org.opendaylight.controller.cluster.datastore.messages.DataExistsReply;
49 import org.opendaylight.controller.cluster.datastore.messages.DeleteData;
50 import org.opendaylight.controller.cluster.datastore.messages.DeleteDataReply;
51 import org.opendaylight.controller.cluster.datastore.messages.MergeData;
52 import org.opendaylight.controller.cluster.datastore.messages.MergeDataReply;
53 import org.opendaylight.controller.cluster.datastore.messages.ReadData;
54 import org.opendaylight.controller.cluster.datastore.messages.ReadDataReply;
55 import org.opendaylight.controller.cluster.datastore.messages.ReadyTransaction;
56 import org.opendaylight.controller.cluster.datastore.messages.ReadyTransactionReply;
57 import org.opendaylight.controller.cluster.datastore.messages.WriteData;
58 import org.opendaylight.controller.cluster.datastore.messages.WriteDataReply;
59 import org.opendaylight.controller.cluster.datastore.shardstrategy.DefaultShardStrategy;
60 import org.opendaylight.controller.cluster.datastore.shardstrategy.ShardStrategyFactory;
61 import org.opendaylight.controller.cluster.datastore.utils.ActorContext;
62 import org.opendaylight.controller.cluster.datastore.utils.DoNothingActor;
63 import org.opendaylight.controller.cluster.datastore.utils.MockConfiguration;
64 import org.opendaylight.controller.md.cluster.datastore.model.CarsModel;
65 import org.opendaylight.controller.md.cluster.datastore.model.TestModel;
66 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
67 import org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages;
68 import org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransactionReply;
69 import org.opendaylight.controller.sal.core.spi.data.DOMStoreThreePhaseCommitCohort;
70 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
71 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
72 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
73 import scala.concurrent.Await;
74 import scala.concurrent.Future;
75 import scala.concurrent.duration.Duration;
77 @SuppressWarnings("resource")
78 public class TransactionProxyTest {
80 @SuppressWarnings("serial")
81 static class TestException extends RuntimeException {
84 static interface Invoker {
85 CheckedFuture<?, ReadFailedException> invoke(TransactionProxy proxy) throws Exception;
88 private static ActorSystem system;
90 private final Configuration configuration = new MockConfiguration();
93 private ActorContext mockActorContext;
95 private SchemaContext schemaContext;
98 private ClusterWrapper mockClusterWrapper;
100 String memberName = "mock-member";
103 public static void setUpClass() throws IOException {
105 Config config = ConfigFactory.parseMap(ImmutableMap.<String, Object>builder().
106 put("akka.actor.default-dispatcher.type",
107 "akka.testkit.CallingThreadDispatcherConfigurator").build()).
108 withFallback(ConfigFactory.load());
109 system = ActorSystem.create("test", config);
113 public static void tearDownClass() throws IOException {
114 JavaTestKit.shutdownActorSystem(system);
120 MockitoAnnotations.initMocks(this);
122 schemaContext = TestModel.createTestContext();
124 DatastoreContext dataStoreContext = DatastoreContext.newBuilder().operationTimeoutInSeconds(2).build();
126 doReturn(getSystem()).when(mockActorContext).getActorSystem();
127 doReturn(memberName).when(mockActorContext).getCurrentMemberName();
128 doReturn(schemaContext).when(mockActorContext).getSchemaContext();
129 doReturn(mockClusterWrapper).when(mockActorContext).getClusterWrapper();
130 doReturn(mockClusterWrapper).when(mockActorContext).getClusterWrapper();
131 doReturn(dataStoreContext).when(mockActorContext).getDatastoreContext();
132 doReturn(10).when(mockActorContext).getTransactionOutstandingOperationLimit();
134 ShardStrategyFactory.setConfiguration(configuration);
137 private ActorSystem getSystem() {
141 private CreateTransaction eqCreateTransaction(final String memberName,
142 final TransactionType type) {
143 ArgumentMatcher<CreateTransaction> matcher = new ArgumentMatcher<CreateTransaction>() {
145 public boolean matches(Object argument) {
146 if(CreateTransaction.SERIALIZABLE_CLASS.equals(argument.getClass())) {
147 CreateTransaction obj = CreateTransaction.fromSerializable(argument);
148 return obj.getTransactionId().startsWith(memberName) &&
149 obj.getTransactionType() == type.ordinal();
156 return argThat(matcher);
159 private DataExists eqSerializedDataExists() {
160 ArgumentMatcher<DataExists> matcher = new ArgumentMatcher<DataExists>() {
162 public boolean matches(Object argument) {
163 return DataExists.SERIALIZABLE_CLASS.equals(argument.getClass()) &&
164 DataExists.fromSerializable(argument).getPath().equals(TestModel.TEST_PATH);
168 return argThat(matcher);
171 private DataExists eqDataExists() {
172 ArgumentMatcher<DataExists> matcher = new ArgumentMatcher<DataExists>() {
174 public boolean matches(Object argument) {
175 return (argument instanceof DataExists) &&
176 ((DataExists)argument).getPath().equals(TestModel.TEST_PATH);
180 return argThat(matcher);
183 private ReadData eqSerializedReadData() {
184 ArgumentMatcher<ReadData> matcher = new ArgumentMatcher<ReadData>() {
186 public boolean matches(Object argument) {
187 return ReadData.SERIALIZABLE_CLASS.equals(argument.getClass()) &&
188 ReadData.fromSerializable(argument).getPath().equals(TestModel.TEST_PATH);
192 return argThat(matcher);
195 private ReadData eqReadData() {
196 ArgumentMatcher<ReadData> matcher = new ArgumentMatcher<ReadData>() {
198 public boolean matches(Object argument) {
199 return (argument instanceof ReadData) &&
200 ((ReadData)argument).getPath().equals(TestModel.TEST_PATH);
204 return argThat(matcher);
207 private WriteData eqSerializedWriteData(final NormalizedNode<?, ?> nodeToWrite) {
208 return eqSerializedWriteData(nodeToWrite, DataStoreVersions.CURRENT_VERSION);
211 private WriteData eqSerializedWriteData(final NormalizedNode<?, ?> nodeToWrite,
212 final int transactionVersion) {
213 ArgumentMatcher<WriteData> matcher = new ArgumentMatcher<WriteData>() {
215 public boolean matches(Object argument) {
216 if((transactionVersion >= DataStoreVersions.LITHIUM_VERSION &&
217 WriteData.SERIALIZABLE_CLASS.equals(argument.getClass())) ||
218 (transactionVersion < DataStoreVersions.LITHIUM_VERSION &&
219 ShardTransactionMessages.WriteData.class.equals(argument.getClass()))) {
221 WriteData obj = WriteData.fromSerializable(argument);
222 return obj.getPath().equals(TestModel.TEST_PATH) &&
223 obj.getData().equals(nodeToWrite);
230 return argThat(matcher);
233 private WriteData eqWriteData(final NormalizedNode<?, ?> nodeToWrite) {
234 ArgumentMatcher<WriteData> matcher = new ArgumentMatcher<WriteData>() {
236 public boolean matches(Object argument) {
237 if(argument instanceof WriteData) {
238 WriteData obj = (WriteData) argument;
239 return obj.getPath().equals(TestModel.TEST_PATH) &&
240 obj.getData().equals(nodeToWrite);
246 return argThat(matcher);
249 private MergeData eqSerializedMergeData(final NormalizedNode<?, ?> nodeToWrite) {
250 return eqSerializedMergeData(nodeToWrite, DataStoreVersions.CURRENT_VERSION);
253 private MergeData eqSerializedMergeData(final NormalizedNode<?, ?> nodeToWrite,
254 final int transactionVersion) {
255 ArgumentMatcher<MergeData> matcher = new ArgumentMatcher<MergeData>() {
257 public boolean matches(Object argument) {
258 if((transactionVersion >= DataStoreVersions.LITHIUM_VERSION &&
259 MergeData.SERIALIZABLE_CLASS.equals(argument.getClass())) ||
260 (transactionVersion < DataStoreVersions.LITHIUM_VERSION &&
261 ShardTransactionMessages.MergeData.class.equals(argument.getClass()))) {
263 MergeData obj = MergeData.fromSerializable(argument);
264 return obj.getPath().equals(TestModel.TEST_PATH) &&
265 obj.getData().equals(nodeToWrite);
272 return argThat(matcher);
275 private MergeData eqMergeData(final NormalizedNode<?, ?> nodeToWrite) {
276 ArgumentMatcher<MergeData> matcher = new ArgumentMatcher<MergeData>() {
278 public boolean matches(Object argument) {
279 if(argument instanceof MergeData) {
280 MergeData obj = ((MergeData) argument);
281 return obj.getPath().equals(TestModel.TEST_PATH) &&
282 obj.getData().equals(nodeToWrite);
289 return argThat(matcher);
292 private DeleteData eqSerializedDeleteData() {
293 ArgumentMatcher<DeleteData> matcher = new ArgumentMatcher<DeleteData>() {
295 public boolean matches(Object argument) {
296 return DeleteData.SERIALIZABLE_CLASS.equals(argument.getClass()) &&
297 DeleteData.fromSerializable(argument).getPath().equals(TestModel.TEST_PATH);
301 return argThat(matcher);
304 private DeleteData eqDeleteData() {
305 ArgumentMatcher<DeleteData> matcher = new ArgumentMatcher<DeleteData>() {
307 public boolean matches(Object argument) {
308 return argument instanceof DeleteData &&
309 ((DeleteData)argument).getPath().equals(TestModel.TEST_PATH);
313 return argThat(matcher);
316 private Future<Object> readySerializedTxReply(String path) {
317 return Futures.successful((Object)new ReadyTransactionReply(path).toSerializable());
320 private Future<Object> readyTxReply(String path) {
321 return Futures.successful((Object)new ReadyTransactionReply(path));
324 private Future<Object> readSerializedDataReply(NormalizedNode<?, ?> data,
325 short transactionVersion) {
326 return Futures.successful(new ReadDataReply(data).toSerializable(transactionVersion));
329 private Future<Object> readSerializedDataReply(NormalizedNode<?, ?> data) {
330 return readSerializedDataReply(data, DataStoreVersions.CURRENT_VERSION);
333 private Future<ReadDataReply> readDataReply(NormalizedNode<?, ?> data) {
334 return Futures.successful(new ReadDataReply(data));
337 private Future<Object> dataExistsSerializedReply(boolean exists) {
338 return Futures.successful(new DataExistsReply(exists).toSerializable());
341 private Future<DataExistsReply> dataExistsReply(boolean exists) {
342 return Futures.successful(new DataExistsReply(exists));
345 private Future<Object> writeSerializedDataReply(short version) {
346 return Futures.successful(new WriteDataReply().toSerializable(version));
349 private Future<Object> writeSerializedDataReply() {
350 return writeSerializedDataReply(DataStoreVersions.CURRENT_VERSION);
353 private Future<WriteDataReply> writeDataReply() {
354 return Futures.successful(new WriteDataReply());
357 private Future<Object> mergeSerializedDataReply(short version) {
358 return Futures.successful(new MergeDataReply().toSerializable(version));
361 private Future<Object> mergeSerializedDataReply() {
362 return mergeSerializedDataReply(DataStoreVersions.CURRENT_VERSION);
365 private Future<Object> incompleteFuture(){
366 return mock(Future.class);
369 private Future<MergeDataReply> mergeDataReply() {
370 return Futures.successful(new MergeDataReply());
373 private Future<Object> deleteSerializedDataReply(short version) {
374 return Futures.successful(new DeleteDataReply().toSerializable(version));
377 private Future<Object> deleteSerializedDataReply() {
378 return deleteSerializedDataReply(DataStoreVersions.CURRENT_VERSION);
381 private Future<DeleteDataReply> deleteDataReply() {
382 return Futures.successful(new DeleteDataReply());
385 private ActorSelection actorSelection(ActorRef actorRef) {
386 return getSystem().actorSelection(actorRef.path());
389 private CreateTransactionReply createTransactionReply(ActorRef actorRef, int transactionVersion){
390 return CreateTransactionReply.newBuilder()
391 .setTransactionActorPath(actorRef.path().toString())
392 .setTransactionId("txn-1")
393 .setMessageVersion(transactionVersion)
397 private ActorRef setupActorContextWithInitialCreateTransaction(ActorSystem actorSystem,
398 TransactionType type, int transactionVersion) {
399 ActorRef actorRef = actorSystem.actorOf(Props.create(DoNothingActor.class));
400 doReturn(actorSystem.actorSelection(actorRef.path())).
401 when(mockActorContext).actorSelection(actorRef.path().toString());
403 doReturn(Futures.successful(actorSystem.actorSelection(actorRef.path()))).
404 when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
406 doReturn(Futures.successful(createTransactionReply(actorRef, transactionVersion))).when(mockActorContext).
407 executeOperationAsync(eq(actorSystem.actorSelection(actorRef.path())),
408 eqCreateTransaction(memberName, type));
410 doReturn(false).when(mockActorContext).isPathLocal(actorRef.path().toString());
412 doReturn(10).when(mockActorContext).getTransactionOutstandingOperationLimit();
417 private ActorRef setupActorContextWithInitialCreateTransaction(ActorSystem actorSystem, TransactionType type) {
418 return setupActorContextWithInitialCreateTransaction(actorSystem, type, DataStoreVersions.CURRENT_VERSION);
422 private void propagateReadFailedExceptionCause(CheckedFuture<?, ReadFailedException> future)
426 future.checkedGet(5, TimeUnit.SECONDS);
427 fail("Expected ReadFailedException");
428 } catch(ReadFailedException e) {
434 public void testRead() throws Exception {
435 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_ONLY);
437 TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
440 doReturn(readSerializedDataReply(null)).when(mockActorContext).executeOperationAsync(
441 eq(actorSelection(actorRef)), eqSerializedReadData());
443 Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(
444 TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
446 assertEquals("NormalizedNode isPresent", false, readOptional.isPresent());
448 NormalizedNode<?, ?> expectedNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
450 doReturn(readSerializedDataReply(expectedNode)).when(mockActorContext).executeOperationAsync(
451 eq(actorSelection(actorRef)), eqSerializedReadData());
453 readOptional = transactionProxy.read(TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
455 assertEquals("NormalizedNode isPresent", true, readOptional.isPresent());
457 assertEquals("Response NormalizedNode", expectedNode, readOptional.get());
460 @Test(expected = ReadFailedException.class)
461 public void testReadWithInvalidReplyMessageType() throws Exception {
462 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_ONLY);
464 doReturn(Futures.successful(new Object())).when(mockActorContext).
465 executeOperationAsync(eq(actorSelection(actorRef)), eqSerializedReadData());
467 TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
470 transactionProxy.read(TestModel.TEST_PATH).checkedGet(5, TimeUnit.SECONDS);
473 @Test(expected = TestException.class)
474 public void testReadWithAsyncRemoteOperatonFailure() throws Throwable {
475 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_ONLY);
477 doReturn(Futures.failed(new TestException())).when(mockActorContext).
478 executeOperationAsync(eq(actorSelection(actorRef)), eqSerializedReadData());
480 TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
483 propagateReadFailedExceptionCause(transactionProxy.read(TestModel.TEST_PATH));
486 private void testExceptionOnInitialCreateTransaction(Exception exToThrow, Invoker invoker)
488 ActorRef actorRef = getSystem().actorOf(Props.create(DoNothingActor.class));
490 if (exToThrow instanceof PrimaryNotFoundException) {
491 doReturn(Futures.failed(exToThrow)).when(mockActorContext).findPrimaryShardAsync(anyString());
493 doReturn(Futures.successful(getSystem().actorSelection(actorRef.path()))).
494 when(mockActorContext).findPrimaryShardAsync(anyString());
497 doReturn(Futures.failed(exToThrow)).when(mockActorContext).executeOperationAsync(
498 any(ActorSelection.class), any());
500 TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, READ_ONLY);
502 propagateReadFailedExceptionCause(invoker.invoke(transactionProxy));
505 private void testReadWithExceptionOnInitialCreateTransaction(Exception exToThrow) throws Throwable {
506 testExceptionOnInitialCreateTransaction(exToThrow, new Invoker() {
508 public CheckedFuture<?, ReadFailedException> invoke(TransactionProxy proxy) throws Exception {
509 return proxy.read(TestModel.TEST_PATH);
514 @Test(expected = PrimaryNotFoundException.class)
515 public void testReadWhenAPrimaryNotFoundExceptionIsThrown() throws Throwable {
516 testReadWithExceptionOnInitialCreateTransaction(new PrimaryNotFoundException("test"));
519 @Test(expected = TimeoutException.class)
520 public void testReadWhenATimeoutExceptionIsThrown() throws Throwable {
521 testReadWithExceptionOnInitialCreateTransaction(new TimeoutException("test",
522 new Exception("reason")));
525 @Test(expected = TestException.class)
526 public void testReadWhenAnyOtherExceptionIsThrown() throws Throwable {
527 testReadWithExceptionOnInitialCreateTransaction(new TestException());
530 @Test(expected = TestException.class)
531 public void testReadWithPriorRecordingOperationFailure() throws Throwable {
532 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
534 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
536 doReturn(writeSerializedDataReply()).when(mockActorContext).executeOperationAsync(
537 eq(actorSelection(actorRef)), eqSerializedWriteData(nodeToWrite));
539 doReturn(Futures.failed(new TestException())).when(mockActorContext).
540 executeOperationAsync(eq(actorSelection(actorRef)), eqSerializedDeleteData());
542 doReturn(readSerializedDataReply(null)).when(mockActorContext).executeOperationAsync(
543 eq(actorSelection(actorRef)), eqSerializedReadData());
545 TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
548 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
550 transactionProxy.delete(TestModel.TEST_PATH);
553 propagateReadFailedExceptionCause(transactionProxy.read(TestModel.TEST_PATH));
555 verify(mockActorContext, times(0)).executeOperationAsync(
556 eq(actorSelection(actorRef)), eqSerializedReadData());
561 public void testReadWithPriorRecordingOperationSuccessful() throws Throwable {
562 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
564 NormalizedNode<?, ?> expectedNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
566 doReturn(writeSerializedDataReply()).when(mockActorContext).executeOperationAsync(
567 eq(actorSelection(actorRef)), eqSerializedWriteData(expectedNode));
569 doReturn(readSerializedDataReply(expectedNode)).when(mockActorContext).executeOperationAsync(
570 eq(actorSelection(actorRef)), eqSerializedReadData());
572 TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
575 transactionProxy.write(TestModel.TEST_PATH, expectedNode);
577 Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(
578 TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
580 assertEquals("NormalizedNode isPresent", true, readOptional.isPresent());
582 assertEquals("Response NormalizedNode", expectedNode, readOptional.get());
585 @Test(expected=IllegalStateException.class)
586 public void testReadPreConditionCheck() {
588 TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
591 transactionProxy.read(TestModel.TEST_PATH);
594 @Test(expected=IllegalArgumentException.class)
595 public void testInvalidCreateTransactionReply() throws Throwable {
596 ActorRef actorRef = getSystem().actorOf(Props.create(DoNothingActor.class));
598 doReturn(getSystem().actorSelection(actorRef.path())).when(mockActorContext).
599 actorSelection(actorRef.path().toString());
601 doReturn(Futures.successful(getSystem().actorSelection(actorRef.path()))).
602 when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
604 doReturn(Futures.successful(new Object())).when(mockActorContext).executeOperationAsync(
605 eq(getSystem().actorSelection(actorRef.path())), eqCreateTransaction(memberName, READ_ONLY));
607 TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, READ_ONLY);
609 propagateReadFailedExceptionCause(transactionProxy.read(TestModel.TEST_PATH));
613 public void testExists() throws Exception {
614 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_ONLY);
616 TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
619 doReturn(dataExistsSerializedReply(false)).when(mockActorContext).executeOperationAsync(
620 eq(actorSelection(actorRef)), eqSerializedDataExists());
622 Boolean exists = transactionProxy.exists(TestModel.TEST_PATH).checkedGet();
624 assertEquals("Exists response", false, exists);
626 doReturn(dataExistsSerializedReply(true)).when(mockActorContext).executeOperationAsync(
627 eq(actorSelection(actorRef)), eqSerializedDataExists());
629 exists = transactionProxy.exists(TestModel.TEST_PATH).checkedGet();
631 assertEquals("Exists response", true, exists);
634 @Test(expected = PrimaryNotFoundException.class)
635 public void testExistsWhenAPrimaryNotFoundExceptionIsThrown() throws Throwable {
636 testExceptionOnInitialCreateTransaction(new PrimaryNotFoundException("test"), new Invoker() {
638 public CheckedFuture<?, ReadFailedException> invoke(TransactionProxy proxy) throws Exception {
639 return proxy.exists(TestModel.TEST_PATH);
644 @Test(expected = ReadFailedException.class)
645 public void testExistsWithInvalidReplyMessageType() throws Exception {
646 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_ONLY);
648 doReturn(Futures.successful(new Object())).when(mockActorContext).
649 executeOperationAsync(eq(actorSelection(actorRef)), eqSerializedDataExists());
651 TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
654 transactionProxy.exists(TestModel.TEST_PATH).checkedGet(5, TimeUnit.SECONDS);
657 @Test(expected = TestException.class)
658 public void testExistsWithAsyncRemoteOperatonFailure() throws Throwable {
659 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_ONLY);
661 doReturn(Futures.failed(new TestException())).when(mockActorContext).
662 executeOperationAsync(eq(actorSelection(actorRef)), eqSerializedDataExists());
664 TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
667 propagateReadFailedExceptionCause(transactionProxy.exists(TestModel.TEST_PATH));
670 @Test(expected = TestException.class)
671 public void testExistsWithPriorRecordingOperationFailure() throws Throwable {
672 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
674 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
676 doReturn(writeSerializedDataReply()).when(mockActorContext).executeOperationAsync(
677 eq(actorSelection(actorRef)), eqSerializedWriteData(nodeToWrite));
679 doReturn(Futures.failed(new TestException())).when(mockActorContext).
680 executeOperationAsync(eq(actorSelection(actorRef)), eqSerializedDeleteData());
682 doReturn(dataExistsSerializedReply(false)).when(mockActorContext).executeOperationAsync(
683 eq(actorSelection(actorRef)), eqSerializedDataExists());
685 TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
688 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
690 transactionProxy.delete(TestModel.TEST_PATH);
693 propagateReadFailedExceptionCause(transactionProxy.exists(TestModel.TEST_PATH));
695 verify(mockActorContext, times(0)).executeOperationAsync(
696 eq(actorSelection(actorRef)), eqSerializedDataExists());
701 public void testExistsWithPriorRecordingOperationSuccessful() throws Throwable {
702 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
704 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
706 doReturn(writeSerializedDataReply()).when(mockActorContext).executeOperationAsync(
707 eq(actorSelection(actorRef)), eqSerializedWriteData(nodeToWrite));
709 doReturn(dataExistsSerializedReply(true)).when(mockActorContext).executeOperationAsync(
710 eq(actorSelection(actorRef)), eqSerializedDataExists());
712 TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
715 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
717 Boolean exists = transactionProxy.exists(TestModel.TEST_PATH).checkedGet();
719 assertEquals("Exists response", true, exists);
722 @Test(expected=IllegalStateException.class)
723 public void testExistsPreConditionCheck() {
725 TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
728 transactionProxy.exists(TestModel.TEST_PATH);
731 private void verifyRecordingOperationFutures(List<Future<Object>> futures,
732 Class<?>... expResultTypes) throws Exception {
733 assertEquals("getRecordingOperationFutures size", expResultTypes.length, futures.size());
736 for( Future<Object> future: futures) {
737 assertNotNull("Recording operation Future is null", future);
739 Class<?> expResultType = expResultTypes[i++];
740 if(Throwable.class.isAssignableFrom(expResultType)) {
742 Await.result(future, Duration.create(5, TimeUnit.SECONDS));
743 fail("Expected exception from recording operation Future");
744 } catch(Exception e) {
748 assertEquals("Recording operation Future result type", expResultType,
749 Await.result(future, Duration.create(5, TimeUnit.SECONDS)).getClass());
755 public void testWrite() throws Exception {
756 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
758 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
760 doReturn(writeSerializedDataReply()).when(mockActorContext).executeOperationAsync(
761 eq(actorSelection(actorRef)), eqSerializedWriteData(nodeToWrite));
763 TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
766 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
768 verify(mockActorContext).executeOperationAsync(
769 eq(actorSelection(actorRef)), eqSerializedWriteData(nodeToWrite));
771 verifyRecordingOperationFutures(transactionProxy.getRecordedOperationFutures(),
772 WriteDataReply.class);
775 @Test(expected=IllegalStateException.class)
776 public void testWritePreConditionCheck() {
778 TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
781 transactionProxy.write(TestModel.TEST_PATH,
782 ImmutableNodes.containerNode(TestModel.TEST_QNAME));
785 @Test(expected=IllegalStateException.class)
786 public void testWriteAfterReadyPreConditionCheck() {
788 TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
791 transactionProxy.ready();
793 transactionProxy.write(TestModel.TEST_PATH,
794 ImmutableNodes.containerNode(TestModel.TEST_QNAME));
798 public void testMerge() throws Exception {
799 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
801 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
803 doReturn(mergeSerializedDataReply()).when(mockActorContext).executeOperationAsync(
804 eq(actorSelection(actorRef)), eqSerializedMergeData(nodeToWrite));
806 TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, WRITE_ONLY);
808 transactionProxy.merge(TestModel.TEST_PATH, nodeToWrite);
810 verify(mockActorContext).executeOperationAsync(
811 eq(actorSelection(actorRef)), eqSerializedMergeData(nodeToWrite));
813 verifyRecordingOperationFutures(transactionProxy.getRecordedOperationFutures(),
814 MergeDataReply.class);
818 public void testDelete() throws Exception {
819 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
821 doReturn(deleteSerializedDataReply()).when(mockActorContext).executeOperationAsync(
822 eq(actorSelection(actorRef)), eqSerializedDeleteData());
824 TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
827 transactionProxy.delete(TestModel.TEST_PATH);
829 verify(mockActorContext).executeOperationAsync(
830 eq(actorSelection(actorRef)), eqSerializedDeleteData());
832 verifyRecordingOperationFutures(transactionProxy.getRecordedOperationFutures(),
833 DeleteDataReply.class);
836 private void verifyCohortFutures(ThreePhaseCommitCohortProxy proxy,
837 Object... expReplies) throws Exception {
838 assertEquals("getReadyOperationFutures size", expReplies.length,
839 proxy.getCohortFutures().size());
842 for( Future<ActorSelection> future: proxy.getCohortFutures()) {
843 assertNotNull("Ready operation Future is null", future);
845 Object expReply = expReplies[i++];
846 if(expReply instanceof ActorSelection) {
847 ActorSelection actual = Await.result(future, Duration.create(5, TimeUnit.SECONDS));
848 assertEquals("Cohort actor path", expReply, actual);
850 // Expecting exception.
852 Await.result(future, Duration.create(5, TimeUnit.SECONDS));
853 fail("Expected exception from ready operation Future");
854 } catch(Exception e) {
862 public void testReady() throws Exception {
863 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
865 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
867 doReturn(readSerializedDataReply(null)).when(mockActorContext).executeOperationAsync(
868 eq(actorSelection(actorRef)), eqSerializedReadData());
870 doReturn(writeSerializedDataReply()).when(mockActorContext).executeOperationAsync(
871 eq(actorSelection(actorRef)), eqSerializedWriteData(nodeToWrite));
873 doReturn(readySerializedTxReply(actorRef.path().toString())).when(mockActorContext).executeOperationAsync(
874 eq(actorSelection(actorRef)), isA(ReadyTransaction.SERIALIZABLE_CLASS));
876 TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
879 transactionProxy.read(TestModel.TEST_PATH);
881 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
883 DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
885 assertTrue(ready instanceof ThreePhaseCommitCohortProxy);
887 ThreePhaseCommitCohortProxy proxy = (ThreePhaseCommitCohortProxy) ready;
889 verifyRecordingOperationFutures(transactionProxy.getRecordedOperationFutures(),
890 WriteDataReply.class);
892 verifyCohortFutures(proxy, getSystem().actorSelection(actorRef.path()));
895 private ActorRef testCompatibilityWithHeliumVersion(short version) throws Exception {
896 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(),
897 READ_WRITE, version);
899 NormalizedNode<?, ?> testNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
901 doReturn(readSerializedDataReply(testNode, version)).when(mockActorContext).executeOperationAsync(
902 eq(actorSelection(actorRef)), eqSerializedReadData());
904 doReturn(writeSerializedDataReply(version)).when(mockActorContext).executeOperationAsync(
905 eq(actorSelection(actorRef)), eqSerializedWriteData(testNode, version));
907 doReturn(mergeSerializedDataReply(version)).when(mockActorContext).executeOperationAsync(
908 eq(actorSelection(actorRef)), eqSerializedMergeData(testNode, version));
910 doReturn(readySerializedTxReply(actorRef.path().toString())).when(mockActorContext).executeOperationAsync(
911 eq(actorSelection(actorRef)), isA(ReadyTransaction.SERIALIZABLE_CLASS));
913 doReturn(actorRef.path().toString()).when(mockActorContext).resolvePath(eq(actorRef.path().toString()),
914 eq(actorRef.path().toString()));
916 TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, READ_WRITE);
918 Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(TestModel.TEST_PATH).
919 get(5, TimeUnit.SECONDS);
921 assertEquals("NormalizedNode isPresent", true, readOptional.isPresent());
922 assertEquals("Response NormalizedNode", testNode, readOptional.get());
924 transactionProxy.write(TestModel.TEST_PATH, testNode);
926 transactionProxy.merge(TestModel.TEST_PATH, testNode);
928 DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
930 assertTrue(ready instanceof ThreePhaseCommitCohortProxy);
932 ThreePhaseCommitCohortProxy proxy = (ThreePhaseCommitCohortProxy) ready;
934 verifyRecordingOperationFutures(transactionProxy.getRecordedOperationFutures(),
935 ShardTransactionMessages.WriteDataReply.class, ShardTransactionMessages.MergeDataReply.class);
937 verifyCohortFutures(proxy, getSystem().actorSelection(actorRef.path()));
943 public void testCompatibilityWithBaseHeliumVersion() throws Exception {
944 ActorRef actorRef = testCompatibilityWithHeliumVersion(DataStoreVersions.BASE_HELIUM_VERSION);
946 verify(mockActorContext).resolvePath(eq(actorRef.path().toString()),
947 eq(actorRef.path().toString()));
951 public void testCompatibilityWithHeliumR1Version() throws Exception {
952 ActorRef actorRef = testCompatibilityWithHeliumVersion(DataStoreVersions.HELIUM_1_VERSION);
954 verify(mockActorContext, Mockito.never()).resolvePath(eq(actorRef.path().toString()),
955 eq(actorRef.path().toString()));
959 public void testReadyWithRecordingOperationFailure() throws Exception {
960 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
962 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
964 doReturn(mergeSerializedDataReply()).when(mockActorContext).executeOperationAsync(
965 eq(actorSelection(actorRef)), eqSerializedMergeData(nodeToWrite));
967 doReturn(Futures.failed(new TestException())).when(mockActorContext).
968 executeOperationAsync(eq(actorSelection(actorRef)), eqSerializedWriteData(nodeToWrite));
970 doReturn(readySerializedTxReply(actorRef.path().toString())).when(mockActorContext).executeOperationAsync(
971 eq(actorSelection(actorRef)), isA(ReadyTransaction.SERIALIZABLE_CLASS));
973 doReturn(false).when(mockActorContext).isPathLocal(actorRef.path().toString());
975 TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
978 transactionProxy.merge(TestModel.TEST_PATH, nodeToWrite);
980 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
982 DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
984 assertTrue(ready instanceof ThreePhaseCommitCohortProxy);
986 ThreePhaseCommitCohortProxy proxy = (ThreePhaseCommitCohortProxy) ready;
988 verifyCohortFutures(proxy, TestException.class);
990 verifyRecordingOperationFutures(transactionProxy.getRecordedOperationFutures(),
991 MergeDataReply.class, TestException.class);
995 public void testReadyWithReplyFailure() throws Exception {
996 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
998 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1000 doReturn(mergeSerializedDataReply()).when(mockActorContext).executeOperationAsync(
1001 eq(actorSelection(actorRef)), eqSerializedMergeData(nodeToWrite));
1003 doReturn(Futures.failed(new TestException())).when(mockActorContext).
1004 executeOperationAsync(eq(actorSelection(actorRef)),
1005 isA(ReadyTransaction.SERIALIZABLE_CLASS));
1007 TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
1010 transactionProxy.merge(TestModel.TEST_PATH, nodeToWrite);
1012 DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
1014 assertTrue(ready instanceof ThreePhaseCommitCohortProxy);
1016 ThreePhaseCommitCohortProxy proxy = (ThreePhaseCommitCohortProxy) ready;
1018 verifyRecordingOperationFutures(transactionProxy.getRecordedOperationFutures(),
1019 MergeDataReply.class);
1021 verifyCohortFutures(proxy, TestException.class);
1025 public void testReadyWithInitialCreateTransactionFailure() throws Exception {
1027 doReturn(Futures.failed(new PrimaryNotFoundException("mock"))).when(
1028 mockActorContext).findPrimaryShardAsync(anyString());
1030 TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
1033 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1035 transactionProxy.merge(TestModel.TEST_PATH, nodeToWrite);
1037 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
1039 transactionProxy.delete(TestModel.TEST_PATH);
1041 DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
1043 assertTrue(ready instanceof ThreePhaseCommitCohortProxy);
1045 ThreePhaseCommitCohortProxy proxy = (ThreePhaseCommitCohortProxy) ready;
1047 verifyCohortFutures(proxy, PrimaryNotFoundException.class);
1051 public void testReadyWithInvalidReplyMessageType() throws Exception {
1052 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
1054 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1056 doReturn(writeSerializedDataReply()).when(mockActorContext).executeOperationAsync(
1057 eq(actorSelection(actorRef)), eqSerializedWriteData(nodeToWrite));
1059 doReturn(Futures.successful(new Object())).when(mockActorContext).
1060 executeOperationAsync(eq(actorSelection(actorRef)),
1061 isA(ReadyTransaction.SERIALIZABLE_CLASS));
1063 TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
1066 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
1068 DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
1070 assertTrue(ready instanceof ThreePhaseCommitCohortProxy);
1072 ThreePhaseCommitCohortProxy proxy = (ThreePhaseCommitCohortProxy) ready;
1074 verifyCohortFutures(proxy, IllegalArgumentException.class);
1078 public void testGetIdentifier() {
1079 setupActorContextWithInitialCreateTransaction(getSystem(), READ_ONLY);
1080 TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
1081 TransactionProxy.TransactionType.READ_ONLY);
1083 Object id = transactionProxy.getIdentifier();
1084 assertNotNull("getIdentifier returned null", id);
1085 assertTrue("Invalid identifier: " + id, id.toString().startsWith(memberName));
1089 public void testClose() throws Exception{
1090 ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
1092 doReturn(readSerializedDataReply(null)).when(mockActorContext).executeOperationAsync(
1093 eq(actorSelection(actorRef)), eqSerializedReadData());
1095 TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
1098 transactionProxy.read(TestModel.TEST_PATH);
1100 transactionProxy.close();
1102 verify(mockActorContext).sendOperationAsync(
1103 eq(actorSelection(actorRef)), isA(CloseTransaction.SERIALIZABLE_CLASS));
1108 * Method to test a local Tx actor. The Tx paths are matched to decide if the
1109 * Tx actor is local or not. This is done by mocking the Tx actor path
1110 * and the caller paths and ensuring that the paths have the remote-address format
1112 * Note: Since the default akka provider for test is not a RemoteActorRefProvider,
1113 * the paths returned for the actors for all the tests are not qualified remote paths.
1114 * Hence are treated as non-local/remote actors. In short, all tests except
1115 * few below run for remote actors
1120 public void testLocalTxActorRead() throws Exception {
1121 ActorSystem actorSystem = getSystem();
1122 ActorRef shardActorRef = actorSystem.actorOf(Props.create(DoNothingActor.class));
1124 doReturn(actorSystem.actorSelection(shardActorRef.path())).
1125 when(mockActorContext).actorSelection(shardActorRef.path().toString());
1127 doReturn(Futures.successful(actorSystem.actorSelection(shardActorRef.path()))).
1128 when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
1130 String actorPath = "akka.tcp://system@127.0.0.1:2550/user/tx-actor";
1131 CreateTransactionReply createTransactionReply = CreateTransactionReply.newBuilder()
1132 .setTransactionId("txn-1")
1133 .setTransactionActorPath(actorPath)
1136 doReturn(Futures.successful(createTransactionReply)).when(mockActorContext).
1137 executeOperationAsync(eq(actorSystem.actorSelection(shardActorRef.path())),
1138 eqCreateTransaction(memberName, READ_ONLY));
1140 doReturn(true).when(mockActorContext).isPathLocal(actorPath);
1142 TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,READ_ONLY);
1144 // negative test case with null as the reply
1145 doReturn(readDataReply(null)).when(mockActorContext).executeOperationAsync(
1146 any(ActorSelection.class), eqReadData());
1148 Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(
1149 TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
1151 assertEquals("NormalizedNode isPresent", false, readOptional.isPresent());
1153 // test case with node as read data reply
1154 NormalizedNode<?, ?> expectedNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1156 doReturn(readDataReply(expectedNode)).when(mockActorContext).executeOperationAsync(
1157 any(ActorSelection.class), eqReadData());
1159 readOptional = transactionProxy.read(TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
1161 assertEquals("NormalizedNode isPresent", true, readOptional.isPresent());
1163 assertEquals("Response NormalizedNode", expectedNode, readOptional.get());
1165 // test for local data exists
1166 doReturn(dataExistsReply(true)).when(mockActorContext).executeOperationAsync(
1167 any(ActorSelection.class), eqDataExists());
1169 boolean exists = transactionProxy.exists(TestModel.TEST_PATH).checkedGet();
1171 assertEquals("Exists response", true, exists);
1175 public void testLocalTxActorWrite() throws Exception {
1176 ActorSystem actorSystem = getSystem();
1177 ActorRef shardActorRef = actorSystem.actorOf(Props.create(DoNothingActor.class));
1179 doReturn(actorSystem.actorSelection(shardActorRef.path())).
1180 when(mockActorContext).actorSelection(shardActorRef.path().toString());
1182 doReturn(Futures.successful(actorSystem.actorSelection(shardActorRef.path()))).
1183 when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
1185 String actorPath = "akka.tcp://system@127.0.0.1:2550/user/tx-actor";
1186 CreateTransactionReply createTransactionReply = CreateTransactionReply.newBuilder()
1187 .setTransactionId("txn-1")
1188 .setTransactionActorPath(actorPath)
1191 doReturn(Futures.successful(createTransactionReply)).when(mockActorContext).
1192 executeOperationAsync(eq(actorSystem.actorSelection(shardActorRef.path())),
1193 eqCreateTransaction(memberName, WRITE_ONLY));
1195 doReturn(true).when(mockActorContext).isPathLocal(actorPath);
1197 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1199 doReturn(writeDataReply()).when(mockActorContext).executeOperationAsync(
1200 any(ActorSelection.class), eqWriteData(nodeToWrite));
1202 TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, WRITE_ONLY);
1203 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
1205 verify(mockActorContext).executeOperationAsync(
1206 any(ActorSelection.class), eqWriteData(nodeToWrite));
1208 //testing local merge
1209 doReturn(mergeDataReply()).when(mockActorContext).executeOperationAsync(
1210 any(ActorSelection.class), eqMergeData(nodeToWrite));
1212 transactionProxy.merge(TestModel.TEST_PATH, nodeToWrite);
1214 verify(mockActorContext).executeOperationAsync(
1215 any(ActorSelection.class), eqMergeData(nodeToWrite));
1218 //testing local delete
1219 doReturn(deleteDataReply()).when(mockActorContext).executeOperationAsync(
1220 any(ActorSelection.class), eqDeleteData());
1222 transactionProxy.delete(TestModel.TEST_PATH);
1224 verify(mockActorContext).executeOperationAsync(any(ActorSelection.class), eqDeleteData());
1226 verifyRecordingOperationFutures(transactionProxy.getRecordedOperationFutures(),
1227 WriteDataReply.class, MergeDataReply.class, DeleteDataReply.class);
1230 doReturn(readyTxReply(shardActorRef.path().toString())).when(mockActorContext).executeOperationAsync(
1231 any(ActorSelection.class), isA(ReadyTransaction.class));
1233 DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
1235 assertTrue(ready instanceof ThreePhaseCommitCohortProxy);
1237 ThreePhaseCommitCohortProxy proxy = (ThreePhaseCommitCohortProxy) ready;
1239 verifyCohortFutures(proxy, getSystem().actorSelection(shardActorRef.path()));
1242 private static interface TransactionProxyOperation {
1243 void run(TransactionProxy transactionProxy);
1246 private void throttleOperation(TransactionProxyOperation operation) {
1247 throttleOperation(operation, 1, true);
1250 private void throttleOperation(TransactionProxyOperation operation, int outstandingOpsLimit, boolean shardFound){
1251 ActorSystem actorSystem = getSystem();
1252 ActorRef shardActorRef = actorSystem.actorOf(Props.create(DoNothingActor.class));
1254 doReturn(outstandingOpsLimit).when(mockActorContext).getTransactionOutstandingOperationLimit();
1256 doReturn(actorSystem.actorSelection(shardActorRef.path())).
1257 when(mockActorContext).actorSelection(shardActorRef.path().toString());
1260 doReturn(Futures.successful(actorSystem.actorSelection(shardActorRef.path()))).
1261 when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
1263 doReturn(Futures.failed(new Exception("not found")))
1264 .when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
1267 String actorPath = "akka.tcp://system@127.0.0.1:2550/user/tx-actor";
1268 CreateTransactionReply createTransactionReply = CreateTransactionReply.newBuilder()
1269 .setTransactionId("txn-1")
1270 .setTransactionActorPath(actorPath)
1273 doReturn(Futures.successful(createTransactionReply)).when(mockActorContext).
1274 executeOperationAsync(eq(actorSystem.actorSelection(shardActorRef.path())),
1275 eqCreateTransaction(memberName, READ_WRITE));
1277 doReturn(true).when(mockActorContext).isPathLocal(actorPath);
1279 TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, READ_WRITE);
1281 long start = System.currentTimeMillis();
1283 operation.run(transactionProxy);
1285 long end = System.currentTimeMillis();
1287 Assert.assertTrue(String.format("took less time than expected %s was %s",
1288 mockActorContext.getDatastoreContext().getOperationTimeoutInSeconds()*1000,
1289 (end-start)), (end - start) > mockActorContext.getDatastoreContext().getOperationTimeoutInSeconds()*1000);
1293 private void completeOperation(TransactionProxyOperation operation){
1294 completeOperation(operation, true);
1297 private void completeOperation(TransactionProxyOperation operation, boolean shardFound){
1298 ActorSystem actorSystem = getSystem();
1299 ActorRef shardActorRef = actorSystem.actorOf(Props.create(DoNothingActor.class));
1301 doReturn(1).when(mockActorContext).getTransactionOutstandingOperationLimit();
1303 doReturn(actorSystem.actorSelection(shardActorRef.path())).
1304 when(mockActorContext).actorSelection(shardActorRef.path().toString());
1307 doReturn(Futures.successful(actorSystem.actorSelection(shardActorRef.path()))).
1308 when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
1310 doReturn(Futures.failed(new Exception("not found")))
1311 .when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
1314 String actorPath = "akka.tcp://system@127.0.0.1:2550/user/tx-actor";
1315 CreateTransactionReply createTransactionReply = CreateTransactionReply.newBuilder()
1316 .setTransactionId("txn-1")
1317 .setTransactionActorPath(actorPath)
1320 doReturn(Futures.successful(createTransactionReply)).when(mockActorContext).
1321 executeOperationAsync(eq(actorSystem.actorSelection(shardActorRef.path())),
1322 eqCreateTransaction(memberName, READ_WRITE));
1324 doReturn(true).when(mockActorContext).isPathLocal(actorPath);
1326 TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, READ_WRITE);
1328 long start = System.currentTimeMillis();
1330 operation.run(transactionProxy);
1332 long end = System.currentTimeMillis();
1334 Assert.assertTrue(String.format("took more time than expected %s was %s",
1335 mockActorContext.getDatastoreContext().getOperationTimeoutInSeconds()*1000,
1336 (end-start)), (end - start) <= mockActorContext.getDatastoreContext().getOperationTimeoutInSeconds()*1000);
1339 public void testWriteThrottling(boolean shardFound){
1341 throttleOperation(new TransactionProxyOperation() {
1343 public void run(TransactionProxy transactionProxy) {
1344 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1346 doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
1347 any(ActorSelection.class), eqWriteData(nodeToWrite));
1349 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
1351 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
1357 public void testWriteThrottlingWhenShardFound(){
1358 throttleOperation(new TransactionProxyOperation() {
1360 public void run(TransactionProxy transactionProxy) {
1361 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1363 doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
1364 any(ActorSelection.class), eqWriteData(nodeToWrite));
1366 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
1368 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
1375 public void testWriteThrottlingWhenShardNotFound(){
1376 // Confirm that there is no throttling when the Shard is not found
1377 completeOperation(new TransactionProxyOperation() {
1379 public void run(TransactionProxy transactionProxy) {
1380 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1382 doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
1383 any(ActorSelection.class), eqWriteData(nodeToWrite));
1385 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
1387 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
1395 public void testWriteCompletion(){
1396 completeOperation(new TransactionProxyOperation() {
1398 public void run(TransactionProxy transactionProxy) {
1399 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1401 doReturn(writeSerializedDataReply()).when(mockActorContext).executeOperationAsync(
1402 any(ActorSelection.class), eqSerializedWriteData(nodeToWrite));
1404 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
1406 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
1413 public void testMergeThrottlingWhenShardFound(){
1415 throttleOperation(new TransactionProxyOperation() {
1417 public void run(TransactionProxy transactionProxy) {
1418 NormalizedNode<?, ?> nodeToMerge = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1420 doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
1421 any(ActorSelection.class), eqMergeData(nodeToMerge));
1423 transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
1425 transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
1431 public void testMergeThrottlingWhenShardNotFound(){
1433 completeOperation(new TransactionProxyOperation() {
1435 public void run(TransactionProxy transactionProxy) {
1436 NormalizedNode<?, ?> nodeToMerge = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1438 doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
1439 any(ActorSelection.class), eqMergeData(nodeToMerge));
1441 transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
1443 transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
1449 public void testMergeCompletion(){
1450 completeOperation(new TransactionProxyOperation() {
1452 public void run(TransactionProxy transactionProxy) {
1453 NormalizedNode<?, ?> nodeToMerge = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1455 doReturn(mergeDataReply()).when(mockActorContext).executeOperationAsync(
1456 any(ActorSelection.class), eqMergeData(nodeToMerge));
1458 transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
1460 transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
1467 public void testDeleteThrottlingWhenShardFound(){
1469 throttleOperation(new TransactionProxyOperation() {
1471 public void run(TransactionProxy transactionProxy) {
1472 doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
1473 any(ActorSelection.class), eqDeleteData());
1475 transactionProxy.delete(TestModel.TEST_PATH);
1477 transactionProxy.delete(TestModel.TEST_PATH);
1484 public void testDeleteThrottlingWhenShardNotFound(){
1486 completeOperation(new TransactionProxyOperation() {
1488 public void run(TransactionProxy transactionProxy) {
1489 doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
1490 any(ActorSelection.class), eqDeleteData());
1492 transactionProxy.delete(TestModel.TEST_PATH);
1494 transactionProxy.delete(TestModel.TEST_PATH);
1500 public void testDeleteCompletion(){
1501 completeOperation(new TransactionProxyOperation() {
1503 public void run(TransactionProxy transactionProxy) {
1504 doReturn(deleteDataReply()).when(mockActorContext).executeOperationAsync(
1505 any(ActorSelection.class), eqDeleteData());
1507 transactionProxy.delete(TestModel.TEST_PATH);
1509 transactionProxy.delete(TestModel.TEST_PATH);
1516 public void testReadThrottlingWhenShardFound(){
1518 throttleOperation(new TransactionProxyOperation() {
1520 public void run(TransactionProxy transactionProxy) {
1521 doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
1522 any(ActorSelection.class), eqReadData());
1524 transactionProxy.read(TestModel.TEST_PATH);
1526 transactionProxy.read(TestModel.TEST_PATH);
1532 public void testReadThrottlingWhenShardNotFound(){
1534 completeOperation(new TransactionProxyOperation() {
1536 public void run(TransactionProxy transactionProxy) {
1537 doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
1538 any(ActorSelection.class), eqReadData());
1540 transactionProxy.read(TestModel.TEST_PATH);
1542 transactionProxy.read(TestModel.TEST_PATH);
1549 public void testReadCompletion(){
1550 completeOperation(new TransactionProxyOperation() {
1552 public void run(TransactionProxy transactionProxy) {
1553 NormalizedNode<?, ?> nodeToRead = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1555 doReturn(readDataReply(nodeToRead)).when(mockActorContext).executeOperationAsync(
1556 any(ActorSelection.class), eqReadData());
1558 transactionProxy.read(TestModel.TEST_PATH);
1560 transactionProxy.read(TestModel.TEST_PATH);
1567 public void testExistsThrottlingWhenShardFound(){
1569 throttleOperation(new TransactionProxyOperation() {
1571 public void run(TransactionProxy transactionProxy) {
1572 doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
1573 any(ActorSelection.class), eqDataExists());
1575 transactionProxy.exists(TestModel.TEST_PATH);
1577 transactionProxy.exists(TestModel.TEST_PATH);
1583 public void testExistsThrottlingWhenShardNotFound(){
1585 completeOperation(new TransactionProxyOperation() {
1587 public void run(TransactionProxy transactionProxy) {
1588 doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
1589 any(ActorSelection.class), eqDataExists());
1591 transactionProxy.exists(TestModel.TEST_PATH);
1593 transactionProxy.exists(TestModel.TEST_PATH);
1600 public void testExistsCompletion(){
1601 completeOperation(new TransactionProxyOperation() {
1603 public void run(TransactionProxy transactionProxy) {
1604 doReturn(dataExistsReply(true)).when(mockActorContext).executeOperationAsync(
1605 any(ActorSelection.class), eqDataExists());
1607 transactionProxy.exists(TestModel.TEST_PATH);
1609 transactionProxy.exists(TestModel.TEST_PATH);
1616 public void testReadyThrottling(){
1618 throttleOperation(new TransactionProxyOperation() {
1620 public void run(TransactionProxy transactionProxy) {
1621 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1623 doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
1624 any(ActorSelection.class), eqWriteData(nodeToWrite));
1626 doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
1627 any(ActorSelection.class), any(ReadyTransaction.class));
1629 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
1631 transactionProxy.ready();
1637 public void testReadyThrottlingWithTwoTransactionContexts(){
1639 throttleOperation(new TransactionProxyOperation() {
1641 public void run(TransactionProxy transactionProxy) {
1642 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1643 NormalizedNode<?, ?> carsNode = ImmutableNodes.containerNode(CarsModel.BASE_QNAME);
1645 doReturn(writeDataReply()).when(mockActorContext).executeOperationAsync(
1646 any(ActorSelection.class), eqWriteData(nodeToWrite));
1648 doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
1649 any(ActorSelection.class), eqWriteData(carsNode));
1651 doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
1652 any(ActorSelection.class), any(ReadyTransaction.class));
1654 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
1656 transactionProxy.write(TestModel.TEST_PATH, carsNode);
1658 transactionProxy.ready();