opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/TransactionProxyTest.java

   1 package org.opendaylight.controller.cluster.datastore;
   2
   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.google.common.util.concurrent.FutureCallback;
  29 import com.google.common.util.concurrent.Uninterruptibles;
  30 import com.typesafe.config.Config;
  31 import com.typesafe.config.ConfigFactory;
  32 import java.io.IOException;
  33 import java.util.List;
  34 import java.util.concurrent.CountDownLatch;
  35 import java.util.concurrent.TimeUnit;
  36 import java.util.concurrent.atomic.AtomicReference;
  37 import org.junit.AfterClass;
  38 import org.junit.Assert;
  39 import org.junit.Before;
  40 import org.junit.BeforeClass;
  41 import org.junit.Test;
  42 import org.mockito.ArgumentMatcher;
  43 import org.mockito.Mock;
  44 import org.mockito.Mockito;
  45 import org.mockito.MockitoAnnotations;
  46 import org.opendaylight.controller.cluster.datastore.TransactionProxy.TransactionType;
  47 import org.opendaylight.controller.cluster.datastore.exceptions.PrimaryNotFoundException;
  48 import org.opendaylight.controller.cluster.datastore.exceptions.TimeoutException;
  49 import org.opendaylight.controller.cluster.datastore.messages.CloseTransaction;
  50 import org.opendaylight.controller.cluster.datastore.messages.CreateTransaction;
  51 import org.opendaylight.controller.cluster.datastore.messages.DataExists;
  52 import org.opendaylight.controller.cluster.datastore.messages.DataExistsReply;
  53 import org.opendaylight.controller.cluster.datastore.messages.DeleteData;
  54 import org.opendaylight.controller.cluster.datastore.messages.DeleteDataReply;
  55 import org.opendaylight.controller.cluster.datastore.messages.MergeData;
  56 import org.opendaylight.controller.cluster.datastore.messages.MergeDataReply;
  57 import org.opendaylight.controller.cluster.datastore.messages.ReadData;
  58 import org.opendaylight.controller.cluster.datastore.messages.ReadDataReply;
  59 import org.opendaylight.controller.cluster.datastore.messages.ReadyTransaction;
  60 import org.opendaylight.controller.cluster.datastore.messages.ReadyTransactionReply;
  61 import org.opendaylight.controller.cluster.datastore.messages.WriteData;
  62 import org.opendaylight.controller.cluster.datastore.messages.WriteDataReply;
  63 import org.opendaylight.controller.cluster.datastore.shardstrategy.DefaultShardStrategy;
  64 import org.opendaylight.controller.cluster.datastore.shardstrategy.ShardStrategyFactory;
  65 import org.opendaylight.controller.cluster.datastore.utils.ActorContext;
  66 import org.opendaylight.controller.cluster.datastore.utils.DoNothingActor;
  67 import org.opendaylight.controller.cluster.datastore.utils.MockConfiguration;
  68 import org.opendaylight.controller.md.cluster.datastore.model.CarsModel;
  69 import org.opendaylight.controller.md.cluster.datastore.model.TestModel;
  70 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  71 import org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages;
  72 import org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransactionReply;
  73 import org.opendaylight.controller.sal.core.spi.data.DOMStoreThreePhaseCommitCohort;
  74 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  75 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
  76 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  77 import scala.concurrent.Await;
  78 import scala.concurrent.Future;
  79 import scala.concurrent.Promise;
  80 import scala.concurrent.duration.Duration;
  81
  82 @SuppressWarnings("resource")
  83 public class TransactionProxyTest {
  84
  85     @SuppressWarnings("serial")
  86     static class TestException extends RuntimeException {
  87     }
  88
  89     static interface Invoker {
  90         CheckedFuture<?, ReadFailedException> invoke(TransactionProxy proxy) throws Exception;
  91     }
  92
  93     private static ActorSystem system;
  94
  95     private final Configuration configuration = new MockConfiguration();
  96
  97     @Mock
  98     private ActorContext mockActorContext;
  99
 100     private SchemaContext schemaContext;
 101
 102     @Mock
 103     private ClusterWrapper mockClusterWrapper;
 104
 105     String memberName = "mock-member";
 106
 107     @BeforeClass
 108     public static void setUpClass() throws IOException {
 109
 110         Config config = ConfigFactory.parseMap(ImmutableMap.<String, Object>builder().
 111                 put("akka.actor.default-dispatcher.type",
 112                         "akka.testkit.CallingThreadDispatcherConfigurator").build()).
 113                 withFallback(ConfigFactory.load());
 114         system = ActorSystem.create("test", config);
 115     }
 116
 117     @AfterClass
 118     public static void tearDownClass() throws IOException {
 119         JavaTestKit.shutdownActorSystem(system);
 120         system = null;
 121     }
 122
 123     @Before
 124     public void setUp(){
 125         MockitoAnnotations.initMocks(this);
 126
 127         schemaContext = TestModel.createTestContext();
 128
 129         DatastoreContext dataStoreContext = DatastoreContext.newBuilder().operationTimeoutInSeconds(2).build();
 130
 131         doReturn(getSystem()).when(mockActorContext).getActorSystem();
 132         doReturn(getSystem().dispatchers().defaultGlobalDispatcher()).when(mockActorContext).getClientDispatcher();
 133         doReturn(memberName).when(mockActorContext).getCurrentMemberName();
 134         doReturn(schemaContext).when(mockActorContext).getSchemaContext();
 135         doReturn(mockClusterWrapper).when(mockActorContext).getClusterWrapper();
 136         doReturn(mockClusterWrapper).when(mockActorContext).getClusterWrapper();
 137         doReturn(dataStoreContext).when(mockActorContext).getDatastoreContext();
 138         doReturn(10).when(mockActorContext).getTransactionOutstandingOperationLimit();
 139
 140         ShardStrategyFactory.setConfiguration(configuration);
 141     }
 142
 143     private ActorSystem getSystem() {
 144         return system;
 145     }
 146
 147     private CreateTransaction eqCreateTransaction(final String memberName,
 148             final TransactionType type) {
 149         ArgumentMatcher<CreateTransaction> matcher = new ArgumentMatcher<CreateTransaction>() {
 150             @Override
 151             public boolean matches(Object argument) {
 152                 if(CreateTransaction.SERIALIZABLE_CLASS.equals(argument.getClass())) {
 153                     CreateTransaction obj = CreateTransaction.fromSerializable(argument);
 154                     return obj.getTransactionId().startsWith(memberName) &&
 155                             obj.getTransactionType() == type.ordinal();
 156                 }
 157
 158                 return false;
 159             }
 160         };
 161
 162         return argThat(matcher);
 163     }
 164
 165     private DataExists eqSerializedDataExists() {
 166         ArgumentMatcher<DataExists> matcher = new ArgumentMatcher<DataExists>() {
 167             @Override
 168             public boolean matches(Object argument) {
 169                 return DataExists.SERIALIZABLE_CLASS.equals(argument.getClass()) &&
 170                        DataExists.fromSerializable(argument).getPath().equals(TestModel.TEST_PATH);
 171             }
 172         };
 173
 174         return argThat(matcher);
 175     }
 176
 177     private DataExists eqDataExists() {
 178         ArgumentMatcher<DataExists> matcher = new ArgumentMatcher<DataExists>() {
 179             @Override
 180             public boolean matches(Object argument) {
 181                 return (argument instanceof DataExists) &&
 182                     ((DataExists)argument).getPath().equals(TestModel.TEST_PATH);
 183             }
 184         };
 185
 186         return argThat(matcher);
 187     }
 188
 189     private ReadData eqSerializedReadData() {
 190         ArgumentMatcher<ReadData> matcher = new ArgumentMatcher<ReadData>() {
 191             @Override
 192             public boolean matches(Object argument) {
 193                 return ReadData.SERIALIZABLE_CLASS.equals(argument.getClass()) &&
 194                        ReadData.fromSerializable(argument).getPath().equals(TestModel.TEST_PATH);
 195             }
 196         };
 197
 198         return argThat(matcher);
 199     }
 200
 201     private ReadData eqReadData() {
 202         ArgumentMatcher<ReadData> matcher = new ArgumentMatcher<ReadData>() {
 203             @Override
 204             public boolean matches(Object argument) {
 205                 return (argument instanceof ReadData) &&
 206                     ((ReadData)argument).getPath().equals(TestModel.TEST_PATH);
 207             }
 208         };
 209
 210         return argThat(matcher);
 211     }
 212
 213     private WriteData eqSerializedWriteData(final NormalizedNode<?, ?> nodeToWrite) {
 214         return eqSerializedWriteData(nodeToWrite, DataStoreVersions.CURRENT_VERSION);
 215     }
 216
 217     private WriteData eqSerializedWriteData(final NormalizedNode<?, ?> nodeToWrite,
 218             final int transactionVersion) {
 219         ArgumentMatcher<WriteData> matcher = new ArgumentMatcher<WriteData>() {
 220             @Override
 221             public boolean matches(Object argument) {
 222                 if((transactionVersion >= DataStoreVersions.LITHIUM_VERSION &&
 223                         WriteData.SERIALIZABLE_CLASS.equals(argument.getClass())) ||
 224                    (transactionVersion < DataStoreVersions.LITHIUM_VERSION &&
 225                            ShardTransactionMessages.WriteData.class.equals(argument.getClass()))) {
 226
 227                     WriteData obj = WriteData.fromSerializable(argument);
 228                     return obj.getPath().equals(TestModel.TEST_PATH) &&
 229                            obj.getData().equals(nodeToWrite);
 230                 }
 231
 232                 return false;
 233             }
 234         };
 235
 236         return argThat(matcher);
 237     }
 238
 239     private WriteData eqWriteData(final NormalizedNode<?, ?> nodeToWrite) {
 240         ArgumentMatcher<WriteData> matcher = new ArgumentMatcher<WriteData>() {
 241             @Override
 242             public boolean matches(Object argument) {
 243                 if(argument instanceof WriteData) {
 244                     WriteData obj = (WriteData) argument;
 245                     return obj.getPath().equals(TestModel.TEST_PATH) &&
 246                         obj.getData().equals(nodeToWrite);
 247                 }
 248                 return false;
 249             }
 250         };
 251
 252         return argThat(matcher);
 253     }
 254
 255     private MergeData eqSerializedMergeData(final NormalizedNode<?, ?> nodeToWrite) {
 256         return eqSerializedMergeData(nodeToWrite, DataStoreVersions.CURRENT_VERSION);
 257     }
 258
 259     private MergeData eqSerializedMergeData(final NormalizedNode<?, ?> nodeToWrite,
 260             final int transactionVersion) {
 261         ArgumentMatcher<MergeData> matcher = new ArgumentMatcher<MergeData>() {
 262             @Override
 263             public boolean matches(Object argument) {
 264                 if((transactionVersion >= DataStoreVersions.LITHIUM_VERSION &&
 265                         MergeData.SERIALIZABLE_CLASS.equals(argument.getClass())) ||
 266                    (transactionVersion < DataStoreVersions.LITHIUM_VERSION &&
 267                            ShardTransactionMessages.MergeData.class.equals(argument.getClass()))) {
 268
 269                     MergeData obj = MergeData.fromSerializable(argument);
 270                     return obj.getPath().equals(TestModel.TEST_PATH) &&
 271                            obj.getData().equals(nodeToWrite);
 272                 }
 273
 274                 return false;
 275             }
 276         };
 277
 278         return argThat(matcher);
 279     }
 280
 281     private MergeData eqMergeData(final NormalizedNode<?, ?> nodeToWrite) {
 282         ArgumentMatcher<MergeData> matcher = new ArgumentMatcher<MergeData>() {
 283             @Override
 284             public boolean matches(Object argument) {
 285                 if(argument instanceof MergeData) {
 286                     MergeData obj = ((MergeData) argument);
 287                     return obj.getPath().equals(TestModel.TEST_PATH) &&
 288                         obj.getData().equals(nodeToWrite);
 289                 }
 290
 291                return false;
 292             }
 293         };
 294
 295         return argThat(matcher);
 296     }
 297
 298     private DeleteData eqSerializedDeleteData() {
 299         ArgumentMatcher<DeleteData> matcher = new ArgumentMatcher<DeleteData>() {
 300             @Override
 301             public boolean matches(Object argument) {
 302                 return DeleteData.SERIALIZABLE_CLASS.equals(argument.getClass()) &&
 303                        DeleteData.fromSerializable(argument).getPath().equals(TestModel.TEST_PATH);
 304             }
 305         };
 306
 307         return argThat(matcher);
 308     }
 309
 310         private DeleteData eqDeleteData() {
 311         ArgumentMatcher<DeleteData> matcher = new ArgumentMatcher<DeleteData>() {
 312             @Override
 313             public boolean matches(Object argument) {
 314                 return argument instanceof DeleteData &&
 315                     ((DeleteData)argument).getPath().equals(TestModel.TEST_PATH);
 316             }
 317         };
 318
 319         return argThat(matcher);
 320     }
 321
 322     private Future<Object> readySerializedTxReply(String path) {
 323         return Futures.successful((Object)new ReadyTransactionReply(path).toSerializable());
 324     }
 325
 326     private Future<Object> readyTxReply(String path) {
 327         return Futures.successful((Object)new ReadyTransactionReply(path));
 328     }
 329
 330     private Future<Object> readSerializedDataReply(NormalizedNode<?, ?> data,
 331             short transactionVersion) {
 332         return Futures.successful(new ReadDataReply(data).toSerializable(transactionVersion));
 333     }
 334
 335     private Future<Object> readSerializedDataReply(NormalizedNode<?, ?> data) {
 336         return readSerializedDataReply(data, DataStoreVersions.CURRENT_VERSION);
 337     }
 338
 339     private Future<ReadDataReply> readDataReply(NormalizedNode<?, ?> data) {
 340         return Futures.successful(new ReadDataReply(data));
 341     }
 342
 343     private Future<Object> dataExistsSerializedReply(boolean exists) {
 344         return Futures.successful(new DataExistsReply(exists).toSerializable());
 345     }
 346
 347     private Future<DataExistsReply> dataExistsReply(boolean exists) {
 348         return Futures.successful(new DataExistsReply(exists));
 349     }
 350
 351     private Future<Object> writeSerializedDataReply(short version) {
 352         return Futures.successful(new WriteDataReply().toSerializable(version));
 353     }
 354
 355     private Future<Object> writeSerializedDataReply() {
 356         return writeSerializedDataReply(DataStoreVersions.CURRENT_VERSION);
 357     }
 358
 359     private Future<WriteDataReply> writeDataReply() {
 360         return Futures.successful(new WriteDataReply());
 361     }
 362
 363     private Future<Object> mergeSerializedDataReply(short version) {
 364         return Futures.successful(new MergeDataReply().toSerializable(version));
 365     }
 366
 367     private Future<Object> mergeSerializedDataReply() {
 368         return mergeSerializedDataReply(DataStoreVersions.CURRENT_VERSION);
 369     }
 370
 371     private Future<Object> incompleteFuture(){
 372         return mock(Future.class);
 373     }
 374
 375     private Future<MergeDataReply> mergeDataReply() {
 376         return Futures.successful(new MergeDataReply());
 377     }
 378
 379     private Future<Object> deleteSerializedDataReply(short version) {
 380         return Futures.successful(new DeleteDataReply().toSerializable(version));
 381     }
 382
 383     private Future<Object> deleteSerializedDataReply() {
 384         return deleteSerializedDataReply(DataStoreVersions.CURRENT_VERSION);
 385     }
 386
 387     private Future<DeleteDataReply> deleteDataReply() {
 388         return Futures.successful(new DeleteDataReply());
 389     }
 390
 391     private ActorSelection actorSelection(ActorRef actorRef) {
 392         return getSystem().actorSelection(actorRef.path());
 393     }
 394
 395     private CreateTransactionReply createTransactionReply(ActorRef actorRef, int transactionVersion){
 396         return CreateTransactionReply.newBuilder()
 397             .setTransactionActorPath(actorRef.path().toString())
 398             .setTransactionId("txn-1")
 399             .setMessageVersion(transactionVersion)
 400             .build();
 401     }
 402
 403     private ActorRef setupActorContextWithoutInitialCreateTransaction(ActorSystem actorSystem) {
 404         ActorRef actorRef = actorSystem.actorOf(Props.create(DoNothingActor.class));
 405         doReturn(actorSystem.actorSelection(actorRef.path())).
 406                 when(mockActorContext).actorSelection(actorRef.path().toString());
 407
 408         doReturn(Futures.successful(actorSystem.actorSelection(actorRef.path()))).
 409                 when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
 410
 411         doReturn(false).when(mockActorContext).isPathLocal(actorRef.path().toString());
 412
 413         doReturn(10).when(mockActorContext).getTransactionOutstandingOperationLimit();
 414
 415         return actorRef;
 416     }
 417
 418     private ActorRef setupActorContextWithInitialCreateTransaction(ActorSystem actorSystem,
 419             TransactionType type, int transactionVersion) {
 420         ActorRef actorRef = setupActorContextWithoutInitialCreateTransaction(actorSystem);
 421
 422         doReturn(Futures.successful(createTransactionReply(actorRef, transactionVersion))).when(mockActorContext).
 423                 executeOperationAsync(eq(actorSystem.actorSelection(actorRef.path())),
 424                         eqCreateTransaction(memberName, type));
 425
 426         return actorRef;
 427     }
 428
 429     private ActorRef setupActorContextWithInitialCreateTransaction(ActorSystem actorSystem, TransactionType type) {
 430         return setupActorContextWithInitialCreateTransaction(actorSystem, type, DataStoreVersions.CURRENT_VERSION);
 431     }
 432
 433
 434     private void propagateReadFailedExceptionCause(CheckedFuture<?, ReadFailedException> future)
 435             throws Throwable {
 436
 437         try {
 438             future.checkedGet(5, TimeUnit.SECONDS);
 439             fail("Expected ReadFailedException");
 440         } catch(ReadFailedException e) {
 441             throw e.getCause();
 442         }
 443     }
 444
 445     @Test
 446     public void testRead() throws Exception {
 447         ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_ONLY);
 448
 449         TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
 450                 READ_ONLY);
 451
 452         doReturn(readSerializedDataReply(null)).when(mockActorContext).executeOperationAsync(
 453                 eq(actorSelection(actorRef)), eqSerializedReadData());
 454
 455         Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(
 456                 TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
 457
 458         assertEquals("NormalizedNode isPresent", false, readOptional.isPresent());
 459
 460         NormalizedNode<?, ?> expectedNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
 461
 462         doReturn(readSerializedDataReply(expectedNode)).when(mockActorContext).executeOperationAsync(
 463                 eq(actorSelection(actorRef)), eqSerializedReadData());
 464
 465         readOptional = transactionProxy.read(TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
 466
 467         assertEquals("NormalizedNode isPresent", true, readOptional.isPresent());
 468
 469         assertEquals("Response NormalizedNode", expectedNode, readOptional.get());
 470     }
 471
 472     @Test(expected = ReadFailedException.class)
 473     public void testReadWithInvalidReplyMessageType() throws Exception {
 474         ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_ONLY);
 475
 476         doReturn(Futures.successful(new Object())).when(mockActorContext).
 477                 executeOperationAsync(eq(actorSelection(actorRef)), eqSerializedReadData());
 478
 479         TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
 480                 READ_ONLY);
 481
 482         transactionProxy.read(TestModel.TEST_PATH).checkedGet(5, TimeUnit.SECONDS);
 483     }
 484
 485     @Test(expected = TestException.class)
 486     public void testReadWithAsyncRemoteOperatonFailure() throws Throwable {
 487         ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_ONLY);
 488
 489         doReturn(Futures.failed(new TestException())).when(mockActorContext).
 490                 executeOperationAsync(eq(actorSelection(actorRef)), eqSerializedReadData());
 491
 492         TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
 493                 READ_ONLY);
 494
 495         propagateReadFailedExceptionCause(transactionProxy.read(TestModel.TEST_PATH));
 496     }
 497
 498     private void testExceptionOnInitialCreateTransaction(Exception exToThrow, Invoker invoker)
 499             throws Throwable {
 500         ActorRef actorRef = getSystem().actorOf(Props.create(DoNothingActor.class));
 501
 502         if (exToThrow instanceof PrimaryNotFoundException) {
 503             doReturn(Futures.failed(exToThrow)).when(mockActorContext).findPrimaryShardAsync(anyString());
 504         } else {
 505             doReturn(Futures.successful(getSystem().actorSelection(actorRef.path()))).
 506                     when(mockActorContext).findPrimaryShardAsync(anyString());
 507         }
 508
 509         doReturn(Futures.failed(exToThrow)).when(mockActorContext).executeOperationAsync(
 510                 any(ActorSelection.class), any());
 511
 512         TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, READ_ONLY);
 513
 514         propagateReadFailedExceptionCause(invoker.invoke(transactionProxy));
 515     }
 516
 517     private void testReadWithExceptionOnInitialCreateTransaction(Exception exToThrow) throws Throwable {
 518         testExceptionOnInitialCreateTransaction(exToThrow, new Invoker() {
 519             @Override
 520             public CheckedFuture<?, ReadFailedException> invoke(TransactionProxy proxy) throws Exception {
 521                 return proxy.read(TestModel.TEST_PATH);
 522             }
 523         });
 524     }
 525
 526     @Test(expected = PrimaryNotFoundException.class)
 527     public void testReadWhenAPrimaryNotFoundExceptionIsThrown() throws Throwable {
 528         testReadWithExceptionOnInitialCreateTransaction(new PrimaryNotFoundException("test"));
 529     }
 530
 531     @Test(expected = TimeoutException.class)
 532     public void testReadWhenATimeoutExceptionIsThrown() throws Throwable {
 533         testReadWithExceptionOnInitialCreateTransaction(new TimeoutException("test",
 534                 new Exception("reason")));
 535     }
 536
 537     @Test(expected = TestException.class)
 538     public void testReadWhenAnyOtherExceptionIsThrown() throws Throwable {
 539         testReadWithExceptionOnInitialCreateTransaction(new TestException());
 540     }
 541
 542     @Test(expected = TestException.class)
 543     public void testReadWithPriorRecordingOperationFailure() throws Throwable {
 544         ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
 545
 546         NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
 547
 548         doReturn(writeSerializedDataReply()).when(mockActorContext).executeOperationAsync(
 549                 eq(actorSelection(actorRef)), eqSerializedWriteData(nodeToWrite));
 550
 551         doReturn(Futures.failed(new TestException())).when(mockActorContext).
 552                 executeOperationAsync(eq(actorSelection(actorRef)), eqSerializedDeleteData());
 553
 554         doReturn(readSerializedDataReply(null)).when(mockActorContext).executeOperationAsync(
 555                 eq(actorSelection(actorRef)), eqSerializedReadData());
 556
 557         TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
 558                 READ_WRITE);
 559
 560         transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
 561
 562         transactionProxy.delete(TestModel.TEST_PATH);
 563
 564         try {
 565             propagateReadFailedExceptionCause(transactionProxy.read(TestModel.TEST_PATH));
 566         } finally {
 567             verify(mockActorContext, times(0)).executeOperationAsync(
 568                     eq(actorSelection(actorRef)), eqSerializedReadData());
 569         }
 570     }
 571
 572     @Test
 573     public void testReadWithPriorRecordingOperationSuccessful() throws Throwable {
 574         ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
 575
 576         NormalizedNode<?, ?> expectedNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
 577
 578         doReturn(writeSerializedDataReply()).when(mockActorContext).executeOperationAsync(
 579                 eq(actorSelection(actorRef)), eqSerializedWriteData(expectedNode));
 580
 581         doReturn(readSerializedDataReply(expectedNode)).when(mockActorContext).executeOperationAsync(
 582                 eq(actorSelection(actorRef)), eqSerializedReadData());
 583
 584         TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
 585                 READ_WRITE);
 586
 587         transactionProxy.write(TestModel.TEST_PATH, expectedNode);
 588
 589         Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(
 590                 TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
 591
 592         assertEquals("NormalizedNode isPresent", true, readOptional.isPresent());
 593
 594         assertEquals("Response NormalizedNode", expectedNode, readOptional.get());
 595     }
 596
 597     @Test(expected=IllegalStateException.class)
 598     public void testReadPreConditionCheck() {
 599
 600         TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
 601                 WRITE_ONLY);
 602
 603         transactionProxy.read(TestModel.TEST_PATH);
 604     }
 605
 606     @Test(expected=IllegalArgumentException.class)
 607     public void testInvalidCreateTransactionReply() throws Throwable {
 608         ActorRef actorRef = getSystem().actorOf(Props.create(DoNothingActor.class));
 609
 610         doReturn(getSystem().actorSelection(actorRef.path())).when(mockActorContext).
 611             actorSelection(actorRef.path().toString());
 612
 613         doReturn(Futures.successful(getSystem().actorSelection(actorRef.path()))).
 614             when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
 615
 616         doReturn(Futures.successful(new Object())).when(mockActorContext).executeOperationAsync(
 617             eq(getSystem().actorSelection(actorRef.path())), eqCreateTransaction(memberName, READ_ONLY));
 618
 619         TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, READ_ONLY);
 620
 621         propagateReadFailedExceptionCause(transactionProxy.read(TestModel.TEST_PATH));
 622     }
 623
 624     @Test
 625     public void testExists() throws Exception {
 626         ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_ONLY);
 627
 628         TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
 629                 READ_ONLY);
 630
 631         doReturn(dataExistsSerializedReply(false)).when(mockActorContext).executeOperationAsync(
 632                 eq(actorSelection(actorRef)), eqSerializedDataExists());
 633
 634         Boolean exists = transactionProxy.exists(TestModel.TEST_PATH).checkedGet();
 635
 636         assertEquals("Exists response", false, exists);
 637
 638         doReturn(dataExistsSerializedReply(true)).when(mockActorContext).executeOperationAsync(
 639                 eq(actorSelection(actorRef)), eqSerializedDataExists());
 640
 641         exists = transactionProxy.exists(TestModel.TEST_PATH).checkedGet();
 642
 643         assertEquals("Exists response", true, exists);
 644     }
 645
 646     @Test(expected = PrimaryNotFoundException.class)
 647     public void testExistsWhenAPrimaryNotFoundExceptionIsThrown() throws Throwable {
 648         testExceptionOnInitialCreateTransaction(new PrimaryNotFoundException("test"), new Invoker() {
 649             @Override
 650             public CheckedFuture<?, ReadFailedException> invoke(TransactionProxy proxy) throws Exception {
 651                 return proxy.exists(TestModel.TEST_PATH);
 652             }
 653         });
 654     }
 655
 656     @Test(expected = ReadFailedException.class)
 657     public void testExistsWithInvalidReplyMessageType() throws Exception {
 658         ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_ONLY);
 659
 660         doReturn(Futures.successful(new Object())).when(mockActorContext).
 661                 executeOperationAsync(eq(actorSelection(actorRef)), eqSerializedDataExists());
 662
 663         TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
 664                 READ_ONLY);
 665
 666         transactionProxy.exists(TestModel.TEST_PATH).checkedGet(5, TimeUnit.SECONDS);
 667     }
 668
 669     @Test(expected = TestException.class)
 670     public void testExistsWithAsyncRemoteOperatonFailure() throws Throwable {
 671         ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_ONLY);
 672
 673         doReturn(Futures.failed(new TestException())).when(mockActorContext).
 674                 executeOperationAsync(eq(actorSelection(actorRef)), eqSerializedDataExists());
 675
 676         TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
 677                 READ_ONLY);
 678
 679         propagateReadFailedExceptionCause(transactionProxy.exists(TestModel.TEST_PATH));
 680     }
 681
 682     @Test(expected = TestException.class)
 683     public void testExistsWithPriorRecordingOperationFailure() throws Throwable {
 684         ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
 685
 686         NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
 687
 688         doReturn(writeSerializedDataReply()).when(mockActorContext).executeOperationAsync(
 689                 eq(actorSelection(actorRef)), eqSerializedWriteData(nodeToWrite));
 690
 691         doReturn(Futures.failed(new TestException())).when(mockActorContext).
 692                 executeOperationAsync(eq(actorSelection(actorRef)), eqSerializedDeleteData());
 693
 694         doReturn(dataExistsSerializedReply(false)).when(mockActorContext).executeOperationAsync(
 695                 eq(actorSelection(actorRef)), eqSerializedDataExists());
 696
 697         TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
 698                 READ_WRITE);
 699
 700         transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
 701
 702         transactionProxy.delete(TestModel.TEST_PATH);
 703
 704         try {
 705             propagateReadFailedExceptionCause(transactionProxy.exists(TestModel.TEST_PATH));
 706         } finally {
 707             verify(mockActorContext, times(0)).executeOperationAsync(
 708                     eq(actorSelection(actorRef)), eqSerializedDataExists());
 709         }
 710     }
 711
 712     @Test
 713     public void testExistsWithPriorRecordingOperationSuccessful() throws Throwable {
 714         ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
 715
 716         NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
 717
 718         doReturn(writeSerializedDataReply()).when(mockActorContext).executeOperationAsync(
 719                 eq(actorSelection(actorRef)), eqSerializedWriteData(nodeToWrite));
 720
 721         doReturn(dataExistsSerializedReply(true)).when(mockActorContext).executeOperationAsync(
 722                 eq(actorSelection(actorRef)), eqSerializedDataExists());
 723
 724         TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
 725                 READ_WRITE);
 726
 727         transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
 728
 729         Boolean exists = transactionProxy.exists(TestModel.TEST_PATH).checkedGet();
 730
 731         assertEquals("Exists response", true, exists);
 732     }
 733
 734     @Test(expected=IllegalStateException.class)
 735     public void testExistsPreConditionCheck() {
 736
 737         TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
 738                 WRITE_ONLY);
 739
 740         transactionProxy.exists(TestModel.TEST_PATH);
 741     }
 742
 743     private void verifyRecordingOperationFutures(List<Future<Object>> futures,
 744             Class<?>... expResultTypes) throws Exception {
 745         assertEquals("getRecordingOperationFutures size", expResultTypes.length, futures.size());
 746
 747         int i = 0;
 748         for( Future<Object> future: futures) {
 749             assertNotNull("Recording operation Future is null", future);
 750
 751             Class<?> expResultType = expResultTypes[i++];
 752             if(Throwable.class.isAssignableFrom(expResultType)) {
 753                 try {
 754                     Await.result(future, Duration.create(5, TimeUnit.SECONDS));
 755                     fail("Expected exception from recording operation Future");
 756                 } catch(Exception e) {
 757                     // Expected
 758                 }
 759             } else {
 760                 assertEquals("Recording operation Future result type", expResultType,
 761                              Await.result(future, Duration.create(5, TimeUnit.SECONDS)).getClass());
 762             }
 763         }
 764     }
 765
 766     @Test
 767     public void testWrite() throws Exception {
 768         ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
 769
 770         NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
 771
 772         doReturn(writeSerializedDataReply()).when(mockActorContext).executeOperationAsync(
 773                 eq(actorSelection(actorRef)), eqSerializedWriteData(nodeToWrite));
 774
 775         TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
 776                 WRITE_ONLY);
 777
 778         transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
 779
 780         verify(mockActorContext).executeOperationAsync(
 781                 eq(actorSelection(actorRef)), eqSerializedWriteData(nodeToWrite));
 782
 783         verifyRecordingOperationFutures(transactionProxy.getRecordedOperationFutures(),
 784                 WriteDataReply.class);
 785     }
 786
 787     @Test
 788     public void testWriteAfterAsyncRead() throws Throwable {
 789         ActorRef actorRef = setupActorContextWithoutInitialCreateTransaction(getSystem());
 790
 791         Promise<Object> createTxPromise = akka.dispatch.Futures.promise();
 792         doReturn(createTxPromise).when(mockActorContext).executeOperationAsync(
 793                 eq(getSystem().actorSelection(actorRef.path())),
 794                 eqCreateTransaction(memberName, READ_WRITE));
 795
 796         doReturn(readSerializedDataReply(null)).when(mockActorContext).executeOperationAsync(
 797                 eq(actorSelection(actorRef)), eqSerializedReadData());
 798
 799         final NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
 800
 801         doReturn(writeSerializedDataReply()).when(mockActorContext).executeOperationAsync(
 802                 eq(actorSelection(actorRef)), eqSerializedWriteData(nodeToWrite));
 803
 804         final TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, READ_WRITE);
 805
 806         final CountDownLatch readComplete = new CountDownLatch(1);
 807         final AtomicReference<Throwable> caughtEx = new AtomicReference<>();
 808         com.google.common.util.concurrent.Futures.addCallback(transactionProxy.read(TestModel.TEST_PATH),
 809                 new  FutureCallback<Optional<NormalizedNode<?, ?>>>() {
 810                     @Override
 811                     public void onSuccess(Optional<NormalizedNode<?, ?>> result) {
 812                         try {
 813                             transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
 814                         } catch (Exception e) {
 815                             caughtEx.set(e);
 816                         } finally {
 817                             readComplete.countDown();
 818                         }
 819                     }
 820
 821                     @Override
 822                     public void onFailure(Throwable t) {
 823                         caughtEx.set(t);
 824                         readComplete.countDown();
 825                     }
 826                 });
 827
 828         createTxPromise.success(createTransactionReply(actorRef, DataStoreVersions.CURRENT_VERSION));
 829
 830         Uninterruptibles.awaitUninterruptibly(readComplete, 5, TimeUnit.SECONDS);
 831
 832         if(caughtEx.get() != null) {
 833             throw caughtEx.get();
 834         }
 835
 836         verify(mockActorContext).executeOperationAsync(
 837                 eq(actorSelection(actorRef)), eqSerializedWriteData(nodeToWrite));
 838
 839         verifyRecordingOperationFutures(transactionProxy.getRecordedOperationFutures(),
 840                 WriteDataReply.class);
 841     }
 842
 843     @Test(expected=IllegalStateException.class)
 844     public void testWritePreConditionCheck() {
 845
 846         TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
 847                 READ_ONLY);
 848
 849         transactionProxy.write(TestModel.TEST_PATH,
 850                 ImmutableNodes.containerNode(TestModel.TEST_QNAME));
 851     }
 852
 853     @Test(expected=IllegalStateException.class)
 854     public void testWriteAfterReadyPreConditionCheck() {
 855
 856         TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
 857                 WRITE_ONLY);
 858
 859         transactionProxy.ready();
 860
 861         transactionProxy.write(TestModel.TEST_PATH,
 862                 ImmutableNodes.containerNode(TestModel.TEST_QNAME));
 863     }
 864
 865     @Test
 866     public void testMerge() throws Exception {
 867         ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
 868
 869         NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
 870
 871         doReturn(mergeSerializedDataReply()).when(mockActorContext).executeOperationAsync(
 872                 eq(actorSelection(actorRef)), eqSerializedMergeData(nodeToWrite));
 873
 874         TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, WRITE_ONLY);
 875
 876         transactionProxy.merge(TestModel.TEST_PATH, nodeToWrite);
 877
 878         verify(mockActorContext).executeOperationAsync(
 879                 eq(actorSelection(actorRef)), eqSerializedMergeData(nodeToWrite));
 880
 881         verifyRecordingOperationFutures(transactionProxy.getRecordedOperationFutures(),
 882                 MergeDataReply.class);
 883     }
 884
 885     @Test
 886     public void testDelete() throws Exception {
 887         ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
 888
 889         doReturn(deleteSerializedDataReply()).when(mockActorContext).executeOperationAsync(
 890                 eq(actorSelection(actorRef)), eqSerializedDeleteData());
 891
 892         TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
 893                 WRITE_ONLY);
 894
 895         transactionProxy.delete(TestModel.TEST_PATH);
 896
 897         verify(mockActorContext).executeOperationAsync(
 898                 eq(actorSelection(actorRef)), eqSerializedDeleteData());
 899
 900         verifyRecordingOperationFutures(transactionProxy.getRecordedOperationFutures(),
 901                 DeleteDataReply.class);
 902     }
 903
 904     private void verifyCohortFutures(ThreePhaseCommitCohortProxy proxy,
 905         Object... expReplies) throws Exception {
 906         assertEquals("getReadyOperationFutures size", expReplies.length,
 907                 proxy.getCohortFutures().size());
 908
 909         int i = 0;
 910         for( Future<ActorSelection> future: proxy.getCohortFutures()) {
 911             assertNotNull("Ready operation Future is null", future);
 912
 913             Object expReply = expReplies[i++];
 914             if(expReply instanceof ActorSelection) {
 915                 ActorSelection actual = Await.result(future, Duration.create(5, TimeUnit.SECONDS));
 916                 assertEquals("Cohort actor path", expReply, actual);
 917             } else {
 918                 // Expecting exception.
 919                 try {
 920                     Await.result(future, Duration.create(5, TimeUnit.SECONDS));
 921                     fail("Expected exception from ready operation Future");
 922                 } catch(Exception e) {
 923                     // Expected
 924                 }
 925             }
 926         }
 927     }
 928
 929     @Test
 930     public void testReady() throws Exception {
 931         ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
 932
 933         NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
 934
 935         doReturn(readSerializedDataReply(null)).when(mockActorContext).executeOperationAsync(
 936                 eq(actorSelection(actorRef)), eqSerializedReadData());
 937
 938         doReturn(writeSerializedDataReply()).when(mockActorContext).executeOperationAsync(
 939                 eq(actorSelection(actorRef)), eqSerializedWriteData(nodeToWrite));
 940
 941         doReturn(readySerializedTxReply(actorRef.path().toString())).when(mockActorContext).executeOperationAsync(
 942                 eq(actorSelection(actorRef)), isA(ReadyTransaction.SERIALIZABLE_CLASS));
 943
 944         TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
 945                 READ_WRITE);
 946
 947         transactionProxy.read(TestModel.TEST_PATH);
 948
 949         transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
 950
 951         DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
 952
 953         assertTrue(ready instanceof ThreePhaseCommitCohortProxy);
 954
 955         ThreePhaseCommitCohortProxy proxy = (ThreePhaseCommitCohortProxy) ready;
 956
 957         verifyRecordingOperationFutures(transactionProxy.getRecordedOperationFutures(),
 958                 WriteDataReply.class);
 959
 960         verifyCohortFutures(proxy, getSystem().actorSelection(actorRef.path()));
 961     }
 962
 963     private ActorRef testCompatibilityWithHeliumVersion(short version) throws Exception {
 964         ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(),
 965                 READ_WRITE, version);
 966
 967         NormalizedNode<?, ?> testNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
 968
 969         doReturn(readSerializedDataReply(testNode, version)).when(mockActorContext).executeOperationAsync(
 970                 eq(actorSelection(actorRef)), eqSerializedReadData());
 971
 972         doReturn(writeSerializedDataReply(version)).when(mockActorContext).executeOperationAsync(
 973                 eq(actorSelection(actorRef)), eqSerializedWriteData(testNode, version));
 974
 975         doReturn(mergeSerializedDataReply(version)).when(mockActorContext).executeOperationAsync(
 976                 eq(actorSelection(actorRef)), eqSerializedMergeData(testNode, version));
 977
 978         doReturn(readySerializedTxReply(actorRef.path().toString())).when(mockActorContext).executeOperationAsync(
 979                 eq(actorSelection(actorRef)), isA(ReadyTransaction.SERIALIZABLE_CLASS));
 980
 981         doReturn(actorRef.path().toString()).when(mockActorContext).resolvePath(eq(actorRef.path().toString()),
 982                 eq(actorRef.path().toString()));
 983
 984         TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, READ_WRITE);
 985
 986         Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(TestModel.TEST_PATH).
 987                 get(5, TimeUnit.SECONDS);
 988
 989         assertEquals("NormalizedNode isPresent", true, readOptional.isPresent());
 990         assertEquals("Response NormalizedNode", testNode, readOptional.get());
 991
 992         transactionProxy.write(TestModel.TEST_PATH, testNode);
 993
 994         transactionProxy.merge(TestModel.TEST_PATH, testNode);
 995
 996         DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
 997
 998         assertTrue(ready instanceof ThreePhaseCommitCohortProxy);
 999
1000         ThreePhaseCommitCohortProxy proxy = (ThreePhaseCommitCohortProxy) ready;
1001
1002         verifyRecordingOperationFutures(transactionProxy.getRecordedOperationFutures(),
1003                 ShardTransactionMessages.WriteDataReply.class, ShardTransactionMessages.MergeDataReply.class);
1004
1005         verifyCohortFutures(proxy, getSystem().actorSelection(actorRef.path()));
1006
1007         return actorRef;
1008     }
1009
1010     @Test
1011     public void testCompatibilityWithBaseHeliumVersion() throws Exception {
1012         ActorRef actorRef = testCompatibilityWithHeliumVersion(DataStoreVersions.BASE_HELIUM_VERSION);
1013
1014         verify(mockActorContext).resolvePath(eq(actorRef.path().toString()),
1015                 eq(actorRef.path().toString()));
1016     }
1017
1018     @Test
1019     public void testCompatibilityWithHeliumR1Version() throws Exception {
1020         ActorRef actorRef = testCompatibilityWithHeliumVersion(DataStoreVersions.HELIUM_1_VERSION);
1021
1022         verify(mockActorContext, Mockito.never()).resolvePath(eq(actorRef.path().toString()),
1023                 eq(actorRef.path().toString()));
1024     }
1025
1026     @Test
1027     public void testReadyWithRecordingOperationFailure() throws Exception {
1028         ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
1029
1030         NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1031
1032         doReturn(mergeSerializedDataReply()).when(mockActorContext).executeOperationAsync(
1033                 eq(actorSelection(actorRef)), eqSerializedMergeData(nodeToWrite));
1034
1035         doReturn(Futures.failed(new TestException())).when(mockActorContext).
1036                 executeOperationAsync(eq(actorSelection(actorRef)), eqSerializedWriteData(nodeToWrite));
1037
1038         doReturn(readySerializedTxReply(actorRef.path().toString())).when(mockActorContext).executeOperationAsync(
1039                 eq(actorSelection(actorRef)), isA(ReadyTransaction.SERIALIZABLE_CLASS));
1040
1041         doReturn(false).when(mockActorContext).isPathLocal(actorRef.path().toString());
1042
1043         TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
1044                 WRITE_ONLY);
1045
1046         transactionProxy.merge(TestModel.TEST_PATH, nodeToWrite);
1047
1048         transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
1049
1050         DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
1051
1052         assertTrue(ready instanceof ThreePhaseCommitCohortProxy);
1053
1054         ThreePhaseCommitCohortProxy proxy = (ThreePhaseCommitCohortProxy) ready;
1055
1056         verifyCohortFutures(proxy, TestException.class);
1057
1058         verifyRecordingOperationFutures(transactionProxy.getRecordedOperationFutures(),
1059                 MergeDataReply.class, TestException.class);
1060     }
1061
1062     @Test
1063     public void testReadyWithReplyFailure() throws Exception {
1064         ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
1065
1066         NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1067
1068         doReturn(mergeSerializedDataReply()).when(mockActorContext).executeOperationAsync(
1069                 eq(actorSelection(actorRef)), eqSerializedMergeData(nodeToWrite));
1070
1071         doReturn(Futures.failed(new TestException())).when(mockActorContext).
1072                 executeOperationAsync(eq(actorSelection(actorRef)),
1073                         isA(ReadyTransaction.SERIALIZABLE_CLASS));
1074
1075         TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
1076                 WRITE_ONLY);
1077
1078         transactionProxy.merge(TestModel.TEST_PATH, nodeToWrite);
1079
1080         DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
1081
1082         assertTrue(ready instanceof ThreePhaseCommitCohortProxy);
1083
1084         ThreePhaseCommitCohortProxy proxy = (ThreePhaseCommitCohortProxy) ready;
1085
1086         verifyRecordingOperationFutures(transactionProxy.getRecordedOperationFutures(),
1087                 MergeDataReply.class);
1088
1089         verifyCohortFutures(proxy, TestException.class);
1090     }
1091
1092     @Test
1093     public void testReadyWithInitialCreateTransactionFailure() throws Exception {
1094
1095         doReturn(Futures.failed(new PrimaryNotFoundException("mock"))).when(
1096                 mockActorContext).findPrimaryShardAsync(anyString());
1097
1098         TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
1099                 WRITE_ONLY);
1100
1101         NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1102
1103         transactionProxy.merge(TestModel.TEST_PATH, nodeToWrite);
1104
1105         transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
1106
1107         transactionProxy.delete(TestModel.TEST_PATH);
1108
1109         DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
1110
1111         assertTrue(ready instanceof ThreePhaseCommitCohortProxy);
1112
1113         ThreePhaseCommitCohortProxy proxy = (ThreePhaseCommitCohortProxy) ready;
1114
1115         verifyCohortFutures(proxy, PrimaryNotFoundException.class);
1116     }
1117
1118     @Test
1119     public void testReadyWithInvalidReplyMessageType() throws Exception {
1120         ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
1121
1122         NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1123
1124         doReturn(writeSerializedDataReply()).when(mockActorContext).executeOperationAsync(
1125                 eq(actorSelection(actorRef)), eqSerializedWriteData(nodeToWrite));
1126
1127         doReturn(Futures.successful(new Object())).when(mockActorContext).
1128                 executeOperationAsync(eq(actorSelection(actorRef)),
1129                         isA(ReadyTransaction.SERIALIZABLE_CLASS));
1130
1131         TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
1132                 WRITE_ONLY);
1133
1134         transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
1135
1136         DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
1137
1138         assertTrue(ready instanceof ThreePhaseCommitCohortProxy);
1139
1140         ThreePhaseCommitCohortProxy proxy = (ThreePhaseCommitCohortProxy) ready;
1141
1142         verifyCohortFutures(proxy, IllegalArgumentException.class);
1143     }
1144
1145     @Test
1146     public void testGetIdentifier() {
1147         setupActorContextWithInitialCreateTransaction(getSystem(), READ_ONLY);
1148         TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
1149                 TransactionProxy.TransactionType.READ_ONLY);
1150
1151         Object id = transactionProxy.getIdentifier();
1152         assertNotNull("getIdentifier returned null", id);
1153         assertTrue("Invalid identifier: " + id, id.toString().startsWith(memberName));
1154     }
1155
1156     @Test
1157     public void testClose() throws Exception{
1158         ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
1159
1160         doReturn(readSerializedDataReply(null)).when(mockActorContext).executeOperationAsync(
1161                 eq(actorSelection(actorRef)), eqSerializedReadData());
1162
1163         TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,
1164                 READ_WRITE);
1165
1166         transactionProxy.read(TestModel.TEST_PATH);
1167
1168         transactionProxy.close();
1169
1170         verify(mockActorContext).sendOperationAsync(
1171                 eq(actorSelection(actorRef)), isA(CloseTransaction.SERIALIZABLE_CLASS));
1172     }
1173
1174
1175     /**
1176      * Method to test a local Tx actor. The Tx paths are matched to decide if the
1177      * Tx actor is local or not. This is done by mocking the Tx actor path
1178      * and the caller paths and ensuring that the paths have the remote-address format
1179      *
1180      * Note: Since the default akka provider for test is not a RemoteActorRefProvider,
1181      * the paths returned for the actors for all the tests are not qualified remote paths.
1182      * Hence are treated as non-local/remote actors. In short, all tests except
1183      * few below run for remote actors
1184      *
1185      * @throws Exception
1186      */
1187     @Test
1188     public void testLocalTxActorRead() throws Exception {
1189         ActorSystem actorSystem = getSystem();
1190         ActorRef shardActorRef = actorSystem.actorOf(Props.create(DoNothingActor.class));
1191
1192         doReturn(actorSystem.actorSelection(shardActorRef.path())).
1193             when(mockActorContext).actorSelection(shardActorRef.path().toString());
1194
1195         doReturn(Futures.successful(actorSystem.actorSelection(shardActorRef.path()))).
1196             when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
1197
1198         String actorPath = "akka.tcp://system@127.0.0.1:2550/user/tx-actor";
1199         CreateTransactionReply createTransactionReply = CreateTransactionReply.newBuilder()
1200             .setTransactionId("txn-1")
1201             .setTransactionActorPath(actorPath)
1202             .build();
1203
1204         doReturn(Futures.successful(createTransactionReply)).when(mockActorContext).
1205             executeOperationAsync(eq(actorSystem.actorSelection(shardActorRef.path())),
1206                 eqCreateTransaction(memberName, READ_ONLY));
1207
1208         doReturn(true).when(mockActorContext).isPathLocal(actorPath);
1209
1210         TransactionProxy transactionProxy = new TransactionProxy(mockActorContext,READ_ONLY);
1211
1212         // negative test case with null as the reply
1213         doReturn(readDataReply(null)).when(mockActorContext).executeOperationAsync(
1214             any(ActorSelection.class), eqReadData());
1215
1216         Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(
1217             TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
1218
1219         assertEquals("NormalizedNode isPresent", false, readOptional.isPresent());
1220
1221         // test case with node as read data reply
1222         NormalizedNode<?, ?> expectedNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1223
1224         doReturn(readDataReply(expectedNode)).when(mockActorContext).executeOperationAsync(
1225             any(ActorSelection.class), eqReadData());
1226
1227         readOptional = transactionProxy.read(TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
1228
1229         assertEquals("NormalizedNode isPresent", true, readOptional.isPresent());
1230
1231         assertEquals("Response NormalizedNode", expectedNode, readOptional.get());
1232
1233         // test for local data exists
1234         doReturn(dataExistsReply(true)).when(mockActorContext).executeOperationAsync(
1235             any(ActorSelection.class), eqDataExists());
1236
1237         boolean exists = transactionProxy.exists(TestModel.TEST_PATH).checkedGet();
1238
1239         assertEquals("Exists response", true, exists);
1240     }
1241
1242     @Test
1243     public void testLocalTxActorWrite() throws Exception {
1244         ActorSystem actorSystem = getSystem();
1245         ActorRef shardActorRef = actorSystem.actorOf(Props.create(DoNothingActor.class));
1246
1247         doReturn(actorSystem.actorSelection(shardActorRef.path())).
1248             when(mockActorContext).actorSelection(shardActorRef.path().toString());
1249
1250         doReturn(Futures.successful(actorSystem.actorSelection(shardActorRef.path()))).
1251             when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
1252
1253         String actorPath = "akka.tcp://system@127.0.0.1:2550/user/tx-actor";
1254         CreateTransactionReply createTransactionReply = CreateTransactionReply.newBuilder()
1255             .setTransactionId("txn-1")
1256             .setTransactionActorPath(actorPath)
1257             .build();
1258
1259         doReturn(Futures.successful(createTransactionReply)).when(mockActorContext).
1260         executeOperationAsync(eq(actorSystem.actorSelection(shardActorRef.path())),
1261                 eqCreateTransaction(memberName, WRITE_ONLY));
1262
1263         doReturn(true).when(mockActorContext).isPathLocal(actorPath);
1264
1265         NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1266
1267         doReturn(writeDataReply()).when(mockActorContext).executeOperationAsync(
1268             any(ActorSelection.class), eqWriteData(nodeToWrite));
1269
1270         TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, WRITE_ONLY);
1271         transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
1272
1273         verify(mockActorContext).executeOperationAsync(
1274             any(ActorSelection.class), eqWriteData(nodeToWrite));
1275
1276         //testing local merge
1277         doReturn(mergeDataReply()).when(mockActorContext).executeOperationAsync(
1278             any(ActorSelection.class), eqMergeData(nodeToWrite));
1279
1280         transactionProxy.merge(TestModel.TEST_PATH, nodeToWrite);
1281
1282         verify(mockActorContext).executeOperationAsync(
1283             any(ActorSelection.class), eqMergeData(nodeToWrite));
1284
1285
1286         //testing local delete
1287         doReturn(deleteDataReply()).when(mockActorContext).executeOperationAsync(
1288             any(ActorSelection.class), eqDeleteData());
1289
1290         transactionProxy.delete(TestModel.TEST_PATH);
1291
1292         verify(mockActorContext).executeOperationAsync(any(ActorSelection.class), eqDeleteData());
1293
1294         verifyRecordingOperationFutures(transactionProxy.getRecordedOperationFutures(),
1295             WriteDataReply.class, MergeDataReply.class, DeleteDataReply.class);
1296
1297         // testing ready
1298         doReturn(readyTxReply(shardActorRef.path().toString())).when(mockActorContext).executeOperationAsync(
1299             any(ActorSelection.class), isA(ReadyTransaction.class));
1300
1301         DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
1302
1303         assertTrue(ready instanceof ThreePhaseCommitCohortProxy);
1304
1305         ThreePhaseCommitCohortProxy proxy = (ThreePhaseCommitCohortProxy) ready;
1306
1307         verifyCohortFutures(proxy, getSystem().actorSelection(shardActorRef.path()));
1308     }
1309
1310     private static interface TransactionProxyOperation {
1311         void run(TransactionProxy transactionProxy);
1312     }
1313
1314     private void throttleOperation(TransactionProxyOperation operation) {
1315         throttleOperation(operation, 1, true);
1316     }
1317
1318     private void throttleOperation(TransactionProxyOperation operation, int outstandingOpsLimit, boolean shardFound){
1319         ActorSystem actorSystem = getSystem();
1320         ActorRef shardActorRef = actorSystem.actorOf(Props.create(DoNothingActor.class));
1321
1322         doReturn(outstandingOpsLimit).when(mockActorContext).getTransactionOutstandingOperationLimit();
1323
1324         doReturn(actorSystem.actorSelection(shardActorRef.path())).
1325                 when(mockActorContext).actorSelection(shardActorRef.path().toString());
1326
1327         if(shardFound) {
1328             doReturn(Futures.successful(actorSystem.actorSelection(shardActorRef.path()))).
1329                     when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
1330         } else {
1331             doReturn(Futures.failed(new Exception("not found")))
1332                     .when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
1333         }
1334
1335         String actorPath = "akka.tcp://system@127.0.0.1:2550/user/tx-actor";
1336         CreateTransactionReply createTransactionReply = CreateTransactionReply.newBuilder()
1337                 .setTransactionId("txn-1")
1338                 .setTransactionActorPath(actorPath)
1339                 .build();
1340
1341         doReturn(Futures.successful(createTransactionReply)).when(mockActorContext).
1342                 executeOperationAsync(eq(actorSystem.actorSelection(shardActorRef.path())),
1343                         eqCreateTransaction(memberName, READ_WRITE));
1344
1345         doReturn(true).when(mockActorContext).isPathLocal(actorPath);
1346
1347         TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, READ_WRITE);
1348
1349         long start = System.nanoTime();
1350
1351         operation.run(transactionProxy);
1352
1353         long end = System.nanoTime();
1354
1355         Assert.assertTrue(String.format("took less time than expected %s was %s",
1356                 TimeUnit.SECONDS.toNanos(mockActorContext.getDatastoreContext().getOperationTimeoutInSeconds()),
1357                 (end-start)), (end - start) > TimeUnit.SECONDS.toNanos(mockActorContext.getDatastoreContext().getOperationTimeoutInSeconds()));
1358
1359     }
1360
1361     private void completeOperation(TransactionProxyOperation operation){
1362         completeOperation(operation, true);
1363     }
1364
1365     private void completeOperation(TransactionProxyOperation operation, boolean shardFound){
1366         ActorSystem actorSystem = getSystem();
1367         ActorRef shardActorRef = actorSystem.actorOf(Props.create(DoNothingActor.class));
1368
1369         doReturn(1).when(mockActorContext).getTransactionOutstandingOperationLimit();
1370
1371         doReturn(actorSystem.actorSelection(shardActorRef.path())).
1372                 when(mockActorContext).actorSelection(shardActorRef.path().toString());
1373
1374         if(shardFound) {
1375             doReturn(Futures.successful(actorSystem.actorSelection(shardActorRef.path()))).
1376                     when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
1377         } else {
1378             doReturn(Futures.failed(new Exception("not found")))
1379                     .when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
1380         }
1381
1382         String actorPath = "akka.tcp://system@127.0.0.1:2550/user/tx-actor";
1383         CreateTransactionReply createTransactionReply = CreateTransactionReply.newBuilder()
1384                 .setTransactionId("txn-1")
1385                 .setTransactionActorPath(actorPath)
1386                 .build();
1387
1388         doReturn(Futures.successful(createTransactionReply)).when(mockActorContext).
1389                 executeOperationAsync(eq(actorSystem.actorSelection(shardActorRef.path())),
1390                         eqCreateTransaction(memberName, READ_WRITE));
1391
1392         doReturn(true).when(mockActorContext).isPathLocal(actorPath);
1393
1394         TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, READ_WRITE);
1395
1396         long start = System.nanoTime();
1397
1398         operation.run(transactionProxy);
1399
1400         long end = System.nanoTime();
1401
1402         Assert.assertTrue(String.format("took more time than expected %s was %s",
1403                 TimeUnit.SECONDS.toNanos(mockActorContext.getDatastoreContext().getOperationTimeoutInSeconds()),
1404                 (end-start)), (end - start) <= TimeUnit.SECONDS.toNanos(mockActorContext.getDatastoreContext().getOperationTimeoutInSeconds()));
1405     }
1406
1407     public void testWriteThrottling(boolean shardFound){
1408
1409         throttleOperation(new TransactionProxyOperation() {
1410             @Override
1411             public void run(TransactionProxy transactionProxy) {
1412                 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1413
1414                 doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
1415                         any(ActorSelection.class), eqWriteData(nodeToWrite));
1416
1417                 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
1418
1419                 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
1420             }
1421         }, 1, shardFound);
1422     }
1423
1424     @Test
1425     public void testWriteThrottlingWhenShardFound(){
1426         throttleOperation(new TransactionProxyOperation() {
1427             @Override
1428             public void run(TransactionProxy transactionProxy) {
1429                 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1430
1431                 doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
1432                         any(ActorSelection.class), eqWriteData(nodeToWrite));
1433
1434                 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
1435
1436                 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
1437             }
1438         });
1439
1440     }
1441
1442     @Test
1443     public void testWriteThrottlingWhenShardNotFound(){
1444         // Confirm that there is no throttling when the Shard is not found
1445         completeOperation(new TransactionProxyOperation() {
1446             @Override
1447             public void run(TransactionProxy transactionProxy) {
1448                 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1449
1450                 doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
1451                         any(ActorSelection.class), eqWriteData(nodeToWrite));
1452
1453                 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
1454
1455                 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
1456             }
1457         }, false);
1458
1459     }
1460
1461
1462     @Test
1463     public void testWriteCompletion(){
1464         completeOperation(new TransactionProxyOperation() {
1465             @Override
1466             public void run(TransactionProxy transactionProxy) {
1467                 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1468
1469                 doReturn(writeSerializedDataReply()).when(mockActorContext).executeOperationAsync(
1470                         any(ActorSelection.class), eqSerializedWriteData(nodeToWrite));
1471
1472                 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
1473
1474                 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
1475             }
1476         });
1477
1478     }
1479
1480     @Test
1481     public void testMergeThrottlingWhenShardFound(){
1482
1483         throttleOperation(new TransactionProxyOperation() {
1484             @Override
1485             public void run(TransactionProxy transactionProxy) {
1486                 NormalizedNode<?, ?> nodeToMerge = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1487
1488                 doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
1489                         any(ActorSelection.class), eqMergeData(nodeToMerge));
1490
1491                 transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
1492
1493                 transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
1494             }
1495         });
1496     }
1497
1498     @Test
1499     public void testMergeThrottlingWhenShardNotFound(){
1500
1501         completeOperation(new TransactionProxyOperation() {
1502             @Override
1503             public void run(TransactionProxy transactionProxy) {
1504                 NormalizedNode<?, ?> nodeToMerge = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1505
1506                 doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
1507                         any(ActorSelection.class), eqMergeData(nodeToMerge));
1508
1509                 transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
1510
1511                 transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
1512             }
1513         }, false);
1514     }
1515
1516     @Test
1517     public void testMergeCompletion(){
1518         completeOperation(new TransactionProxyOperation() {
1519             @Override
1520             public void run(TransactionProxy transactionProxy) {
1521                 NormalizedNode<?, ?> nodeToMerge = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1522
1523                 doReturn(mergeDataReply()).when(mockActorContext).executeOperationAsync(
1524                         any(ActorSelection.class), eqMergeData(nodeToMerge));
1525
1526                 transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
1527
1528                 transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
1529             }
1530         });
1531
1532     }
1533
1534     @Test
1535     public void testDeleteThrottlingWhenShardFound(){
1536
1537         throttleOperation(new TransactionProxyOperation() {
1538             @Override
1539             public void run(TransactionProxy transactionProxy) {
1540                 doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
1541                         any(ActorSelection.class), eqDeleteData());
1542
1543                 transactionProxy.delete(TestModel.TEST_PATH);
1544
1545                 transactionProxy.delete(TestModel.TEST_PATH);
1546             }
1547         });
1548     }
1549
1550
1551     @Test
1552     public void testDeleteThrottlingWhenShardNotFound(){
1553
1554         completeOperation(new TransactionProxyOperation() {
1555             @Override
1556             public void run(TransactionProxy transactionProxy) {
1557                 doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
1558                         any(ActorSelection.class), eqDeleteData());
1559
1560                 transactionProxy.delete(TestModel.TEST_PATH);
1561
1562                 transactionProxy.delete(TestModel.TEST_PATH);
1563             }
1564         }, false);
1565     }
1566
1567     @Test
1568     public void testDeleteCompletion(){
1569         completeOperation(new TransactionProxyOperation() {
1570             @Override
1571             public void run(TransactionProxy transactionProxy) {
1572                 doReturn(deleteDataReply()).when(mockActorContext).executeOperationAsync(
1573                         any(ActorSelection.class), eqDeleteData());
1574
1575                 transactionProxy.delete(TestModel.TEST_PATH);
1576
1577                 transactionProxy.delete(TestModel.TEST_PATH);
1578             }
1579         });
1580
1581     }
1582
1583     @Test
1584     public void testReadThrottlingWhenShardFound(){
1585
1586         throttleOperation(new TransactionProxyOperation() {
1587             @Override
1588             public void run(TransactionProxy transactionProxy) {
1589                 doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
1590                         any(ActorSelection.class), eqReadData());
1591
1592                 transactionProxy.read(TestModel.TEST_PATH);
1593
1594                 transactionProxy.read(TestModel.TEST_PATH);
1595             }
1596         });
1597     }
1598
1599     @Test
1600     public void testReadThrottlingWhenShardNotFound(){
1601
1602         completeOperation(new TransactionProxyOperation() {
1603             @Override
1604             public void run(TransactionProxy transactionProxy) {
1605                 doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
1606                         any(ActorSelection.class), eqReadData());
1607
1608                 transactionProxy.read(TestModel.TEST_PATH);
1609
1610                 transactionProxy.read(TestModel.TEST_PATH);
1611             }
1612         }, false);
1613     }
1614
1615
1616     @Test
1617     public void testReadCompletion(){
1618         completeOperation(new TransactionProxyOperation() {
1619             @Override
1620             public void run(TransactionProxy transactionProxy) {
1621                 NormalizedNode<?, ?> nodeToRead = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1622
1623                 doReturn(readDataReply(nodeToRead)).when(mockActorContext).executeOperationAsync(
1624                         any(ActorSelection.class), eqReadData());
1625
1626                 transactionProxy.read(TestModel.TEST_PATH);
1627
1628                 transactionProxy.read(TestModel.TEST_PATH);
1629             }
1630         });
1631
1632     }
1633
1634     @Test
1635     public void testExistsThrottlingWhenShardFound(){
1636
1637         throttleOperation(new TransactionProxyOperation() {
1638             @Override
1639             public void run(TransactionProxy transactionProxy) {
1640                 doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
1641                         any(ActorSelection.class), eqDataExists());
1642
1643                 transactionProxy.exists(TestModel.TEST_PATH);
1644
1645                 transactionProxy.exists(TestModel.TEST_PATH);
1646             }
1647         });
1648     }
1649
1650     @Test
1651     public void testExistsThrottlingWhenShardNotFound(){
1652
1653         completeOperation(new TransactionProxyOperation() {
1654             @Override
1655             public void run(TransactionProxy transactionProxy) {
1656                 doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
1657                         any(ActorSelection.class), eqDataExists());
1658
1659                 transactionProxy.exists(TestModel.TEST_PATH);
1660
1661                 transactionProxy.exists(TestModel.TEST_PATH);
1662             }
1663         }, false);
1664     }
1665
1666
1667     @Test
1668     public void testExistsCompletion(){
1669         completeOperation(new TransactionProxyOperation() {
1670             @Override
1671             public void run(TransactionProxy transactionProxy) {
1672                 doReturn(dataExistsReply(true)).when(mockActorContext).executeOperationAsync(
1673                         any(ActorSelection.class), eqDataExists());
1674
1675                 transactionProxy.exists(TestModel.TEST_PATH);
1676
1677                 transactionProxy.exists(TestModel.TEST_PATH);
1678             }
1679         });
1680
1681     }
1682
1683     @Test
1684     public void testReadyThrottling(){
1685
1686         throttleOperation(new TransactionProxyOperation() {
1687             @Override
1688             public void run(TransactionProxy transactionProxy) {
1689                 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1690
1691                 doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
1692                         any(ActorSelection.class), eqWriteData(nodeToWrite));
1693
1694                 doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
1695                         any(ActorSelection.class), any(ReadyTransaction.class));
1696
1697                 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
1698
1699                 transactionProxy.ready();
1700             }
1701         });
1702     }
1703
1704     @Test
1705     public void testReadyThrottlingWithTwoTransactionContexts(){
1706
1707         throttleOperation(new TransactionProxyOperation() {
1708             @Override
1709             public void run(TransactionProxy transactionProxy) {
1710                 NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
1711                 NormalizedNode<?, ?> carsNode = ImmutableNodes.containerNode(CarsModel.BASE_QNAME);
1712
1713                 doReturn(writeDataReply()).when(mockActorContext).executeOperationAsync(
1714                         any(ActorSelection.class), eqWriteData(nodeToWrite));
1715
1716                 doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
1717                         any(ActorSelection.class), eqWriteData(carsNode));
1718
1719                 doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
1720                         any(ActorSelection.class), any(ReadyTransaction.class));
1721
1722                 transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
1723
1724                 transactionProxy.write(TestModel.TEST_PATH, carsNode);
1725
1726                 transactionProxy.ready();
1727             }
1728         }, 2, true);
1729     }
1730 }