BUG-2138: Make DistributedShardFactory return Futures.
[controller.git] / opendaylight / md-sal / sal-distributed-datastore / src / test / java / org / opendaylight / controller / cluster / datastore / TransactionProxyTest.java
index 4301a72d180273d79e868b0c8de2acf19f916ff9..5ab1e5ade3fc5a2333fe14f3f31d36733019d133 100644 (file)
@@ -1,3 +1,11 @@
+/*
+ * Copyright (c) 2014, 2015 Cisco Systems, Inc. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
 package org.opendaylight.controller.cluster.datastore;
 
 import static org.junit.Assert.assertEquals;
@@ -8,18 +16,21 @@ import static org.mockito.Matchers.anyString;
 import static org.mockito.Matchers.eq;
 import static org.mockito.Matchers.isA;
 import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
 import static org.opendaylight.controller.cluster.datastore.TransactionType.READ_ONLY;
 import static org.opendaylight.controller.cluster.datastore.TransactionType.READ_WRITE;
 import static org.opendaylight.controller.cluster.datastore.TransactionType.WRITE_ONLY;
+
 import akka.actor.ActorRef;
 import akka.actor.ActorSelection;
 import akka.actor.ActorSystem;
 import akka.actor.Props;
 import akka.dispatch.Futures;
+import akka.util.Timeout;
 import com.google.common.base.Optional;
+import com.google.common.base.Throwables;
 import com.google.common.collect.Sets;
 import com.google.common.util.concurrent.CheckedFuture;
 import com.google.common.util.concurrent.FutureCallback;
@@ -34,6 +45,8 @@ import org.junit.Assert;
 import org.junit.Test;
 import org.mockito.InOrder;
 import org.mockito.Mockito;
+import org.opendaylight.controller.cluster.access.concepts.MemberName;
+import org.opendaylight.controller.cluster.datastore.config.Configuration;
 import org.opendaylight.controller.cluster.datastore.exceptions.NoShardLeaderException;
 import org.opendaylight.controller.cluster.datastore.exceptions.NotInitializedException;
 import org.opendaylight.controller.cluster.datastore.exceptions.PrimaryNotFoundException;
@@ -41,19 +54,18 @@ import org.opendaylight.controller.cluster.datastore.exceptions.TimeoutException
 import org.opendaylight.controller.cluster.datastore.messages.BatchedModifications;
 import org.opendaylight.controller.cluster.datastore.messages.CloseTransaction;
 import org.opendaylight.controller.cluster.datastore.messages.CommitTransactionReply;
+import org.opendaylight.controller.cluster.datastore.messages.CreateTransactionReply;
 import org.opendaylight.controller.cluster.datastore.messages.PrimaryShardInfo;
-import org.opendaylight.controller.cluster.datastore.messages.ReadyTransaction;
 import org.opendaylight.controller.cluster.datastore.modification.DeleteModification;
 import org.opendaylight.controller.cluster.datastore.modification.MergeModification;
 import org.opendaylight.controller.cluster.datastore.modification.WriteModification;
 import org.opendaylight.controller.cluster.datastore.shardstrategy.DefaultShardStrategy;
-import org.opendaylight.controller.cluster.datastore.utils.DoNothingActor;
 import org.opendaylight.controller.cluster.datastore.utils.NormalizedNodeAggregatorTest;
+import org.opendaylight.controller.cluster.raft.utils.DoNothingActor;
 import org.opendaylight.controller.md.cluster.datastore.model.CarsModel;
 import org.opendaylight.controller.md.cluster.datastore.model.SchemaContextHelper;
 import org.opendaylight.controller.md.cluster.datastore.model.TestModel;
 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransactionReply;
 import org.opendaylight.controller.sal.core.spi.data.DOMStoreThreePhaseCommitCohort;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
@@ -72,7 +84,7 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest {
     static class TestException extends RuntimeException {
     }
 
-    static interface Invoker {
+    interface Invoker {
         CheckedFuture<?, ReadFailedException> invoke(TransactionProxy proxy) throws Exception;
     }
 
@@ -82,8 +94,8 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest {
 
         TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
 
-        doReturn(readSerializedDataReply(null)).when(mockActorContext).executeOperationAsync(
-                eq(actorSelection(actorRef)), eqSerializedReadData());
+        doReturn(readDataReply(null)).when(mockActorContext).executeOperationAsync(
+                eq(actorSelection(actorRef)), eqReadData(), any(Timeout.class));
 
         Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(
                 TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
@@ -92,8 +104,8 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest {
 
         NormalizedNode<?, ?> expectedNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
 
-        doReturn(readSerializedDataReply(expectedNode)).when(mockActorContext).executeOperationAsync(
-                eq(actorSelection(actorRef)), eqSerializedReadData());
+        doReturn(readDataReply(expectedNode)).when(mockActorContext).executeOperationAsync(
+                eq(actorSelection(actorRef)), eqReadData(), any(Timeout.class));
 
         readOptional = transactionProxy.read(TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
 
@@ -106,8 +118,8 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest {
     public void testReadWithInvalidReplyMessageType() throws Exception {
         ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_ONLY);
 
-        doReturn(Futures.successful(new Object())).when(mockActorContext).
-                executeOperationAsync(eq(actorSelection(actorRef)), eqSerializedReadData());
+        doReturn(Futures.successful(new Object())).when(mockActorContext)
+                .executeOperationAsync(eq(actorSelection(actorRef)), eqReadData(), any(Timeout.class));
 
         TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
 
@@ -115,71 +127,65 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest {
     }
 
     @Test(expected = TestException.class)
-    public void testReadWithAsyncRemoteOperatonFailure() throws Throwable {
+    public void testReadWithAsyncRemoteOperatonFailure() throws Exception {
         ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_ONLY);
 
-        doReturn(Futures.failed(new TestException())).when(mockActorContext).
-                executeOperationAsync(eq(actorSelection(actorRef)), eqSerializedReadData());
+        doReturn(Futures.failed(new TestException())).when(mockActorContext)
+                .executeOperationAsync(eq(actorSelection(actorRef)), eqReadData(), any(Timeout.class));
 
         TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
 
         propagateReadFailedExceptionCause(transactionProxy.read(TestModel.TEST_PATH));
     }
 
-    private void testExceptionOnInitialCreateTransaction(Exception exToThrow, Invoker invoker)
-            throws Throwable {
+    private void testExceptionOnInitialCreateTransaction(Exception exToThrow, Invoker invoker) throws Exception {
         ActorRef actorRef = getSystem().actorOf(Props.create(DoNothingActor.class));
 
         if (exToThrow instanceof PrimaryNotFoundException) {
             doReturn(Futures.failed(exToThrow)).when(mockActorContext).findPrimaryShardAsync(anyString());
         } else {
-            doReturn(primaryShardInfoReply(getSystem(), actorRef)).
-                    when(mockActorContext).findPrimaryShardAsync(anyString());
+            doReturn(primaryShardInfoReply(getSystem(), actorRef)).when(mockActorContext)
+                    .findPrimaryShardAsync(anyString());
         }
 
         doReturn(Futures.failed(exToThrow)).when(mockActorContext).executeOperationAsync(
-                any(ActorSelection.class), any());
+                any(ActorSelection.class), any(), any(Timeout.class));
 
         TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
 
         propagateReadFailedExceptionCause(invoker.invoke(transactionProxy));
     }
 
-    private void testReadWithExceptionOnInitialCreateTransaction(Exception exToThrow) throws Throwable {
-        testExceptionOnInitialCreateTransaction(exToThrow, new Invoker() {
-            @Override
-            public CheckedFuture<?, ReadFailedException> invoke(TransactionProxy proxy) throws Exception {
-                return proxy.read(TestModel.TEST_PATH);
-            }
-        });
+    private void testReadWithExceptionOnInitialCreateTransaction(Exception exToThrow) throws Exception {
+        testExceptionOnInitialCreateTransaction(exToThrow, proxy -> proxy.read(TestModel.TEST_PATH));
     }
 
     @Test(expected = PrimaryNotFoundException.class)
-    public void testReadWhenAPrimaryNotFoundExceptionIsThrown() throws Throwable {
+    public void testReadWhenAPrimaryNotFoundExceptionIsThrown() throws Exception {
         testReadWithExceptionOnInitialCreateTransaction(new PrimaryNotFoundException("test"));
     }
 
     @Test(expected = TimeoutException.class)
-    public void testReadWhenATimeoutExceptionIsThrown() throws Throwable {
+    public void testReadWhenATimeoutExceptionIsThrown() throws Exception {
         testReadWithExceptionOnInitialCreateTransaction(new TimeoutException("test",
                 new Exception("reason")));
     }
 
     @Test(expected = TestException.class)
-    public void testReadWhenAnyOtherExceptionIsThrown() throws Throwable {
+    public void testReadWhenAnyOtherExceptionIsThrown() throws Exception {
         testReadWithExceptionOnInitialCreateTransaction(new TestException());
     }
 
     @Test
-    public void testReadWithPriorRecordingOperationSuccessful() throws Throwable {
+    public void testReadWithPriorRecordingOperationSuccessful() throws Exception {
         ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
 
         NormalizedNode<?, ?> expectedNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
 
         expectBatchedModifications(actorRef, 1);
 
-        doReturn(readSerializedDataReply(expectedNode)).when(mockActorContext).executeOperationAsync(
-                eq(actorSelection(actorRef)), eqSerializedReadData());
+        doReturn(readDataReply(expectedNode)).when(mockActorContext).executeOperationAsync(
+                eq(actorSelection(actorRef)), eqReadData(), any(Timeout.class));
 
         TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
 
@@ -193,30 +199,31 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest {
 
         InOrder inOrder = Mockito.inOrder(mockActorContext);
         inOrder.verify(mockActorContext).executeOperationAsync(
-                eq(actorSelection(actorRef)), isA(BatchedModifications.class));
+                eq(actorSelection(actorRef)), isA(BatchedModifications.class), any(Timeout.class));
 
         inOrder.verify(mockActorContext).executeOperationAsync(
-                eq(actorSelection(actorRef)), eqSerializedReadData());
+                eq(actorSelection(actorRef)), eqReadData(), any(Timeout.class));
     }
 
-    @Test(expected=IllegalStateException.class)
+    @Test(expected = IllegalStateException.class)
     public void testReadPreConditionCheck() {
         TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY);
         transactionProxy.read(TestModel.TEST_PATH);
     }
 
-    @Test(expected=IllegalArgumentException.class)
-    public void testInvalidCreateTransactionReply() throws Throwable {
+    @Test(expected = IllegalArgumentException.class)
+    public void testInvalidCreateTransactionReply() throws Exception {
         ActorRef actorRef = getSystem().actorOf(Props.create(DoNothingActor.class));
 
-        doReturn(getSystem().actorSelection(actorRef.path())).when(mockActorContext).
-            actorSelection(actorRef.path().toString());
+        doReturn(getSystem().actorSelection(actorRef.path())).when(mockActorContext)
+                .actorSelection(actorRef.path().toString());
 
-        doReturn(primaryShardInfoReply(getSystem(), actorRef)).
-            when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
+        doReturn(primaryShardInfoReply(getSystem(), actorRef)).when(mockActorContext)
+                .findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
 
         doReturn(Futures.successful(new Object())).when(mockActorContext).executeOperationAsync(
-            eq(getSystem().actorSelection(actorRef.path())), eqCreateTransaction(memberName, READ_ONLY));
+            eq(getSystem().actorSelection(actorRef.path())), eqCreateTransaction(memberName, READ_ONLY),
+            any(Timeout.class));
 
         TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
 
@@ -229,15 +236,15 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest {
 
         TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
 
-        doReturn(dataExistsSerializedReply(false)).when(mockActorContext).executeOperationAsync(
-                eq(actorSelection(actorRef)), eqSerializedDataExists());
+        doReturn(dataExistsReply(false)).when(mockActorContext).executeOperationAsync(
+                eq(actorSelection(actorRef)), eqDataExists(), any(Timeout.class));
 
         Boolean exists = transactionProxy.exists(TestModel.TEST_PATH).checkedGet();
 
         assertEquals("Exists response", false, exists);
 
-        doReturn(dataExistsSerializedReply(true)).when(mockActorContext).executeOperationAsync(
-                eq(actorSelection(actorRef)), eqSerializedDataExists());
+        doReturn(dataExistsReply(true)).when(mockActorContext).executeOperationAsync(
+                eq(actorSelection(actorRef)), eqDataExists(), any(Timeout.class));
 
         exists = transactionProxy.exists(TestModel.TEST_PATH).checkedGet();
 
@@ -245,21 +252,17 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest {
     }
 
     @Test(expected = PrimaryNotFoundException.class)
-    public void testExistsWhenAPrimaryNotFoundExceptionIsThrown() throws Throwable {
-        testExceptionOnInitialCreateTransaction(new PrimaryNotFoundException("test"), new Invoker() {
-            @Override
-            public CheckedFuture<?, ReadFailedException> invoke(TransactionProxy proxy) throws Exception {
-                return proxy.exists(TestModel.TEST_PATH);
-            }
-        });
+    public void testExistsWhenAPrimaryNotFoundExceptionIsThrown() throws Exception {
+        testExceptionOnInitialCreateTransaction(new PrimaryNotFoundException("test"),
+            proxy -> proxy.exists(TestModel.TEST_PATH));
     }
 
     @Test(expected = ReadFailedException.class)
     public void testExistsWithInvalidReplyMessageType() throws Exception {
         ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_ONLY);
 
-        doReturn(Futures.successful(new Object())).when(mockActorContext).
-                executeOperationAsync(eq(actorSelection(actorRef)), eqSerializedDataExists());
+        doReturn(Futures.successful(new Object())).when(mockActorContext)
+                .executeOperationAsync(eq(actorSelection(actorRef)), eqDataExists(), any(Timeout.class));
 
         TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
 
@@ -267,11 +270,11 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest {
     }
 
     @Test(expected = TestException.class)
-    public void testExistsWithAsyncRemoteOperatonFailure() throws Throwable {
+    public void testExistsWithAsyncRemoteOperatonFailure() throws Exception {
         ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_ONLY);
 
-        doReturn(Futures.failed(new TestException())).when(mockActorContext).
-                executeOperationAsync(eq(actorSelection(actorRef)), eqSerializedDataExists());
+        doReturn(Futures.failed(new TestException())).when(mockActorContext)
+                .executeOperationAsync(eq(actorSelection(actorRef)), eqDataExists(), any(Timeout.class));
 
         TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
 
@@ -279,15 +282,15 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest {
     }
 
     @Test
-    public void testExistsWithPriorRecordingOperationSuccessful() throws Throwable {
+    public void testExistsWithPriorRecordingOperationSuccessful() throws Exception {
         ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
 
         NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
 
         expectBatchedModifications(actorRef, 1);
 
-        doReturn(dataExistsSerializedReply(true)).when(mockActorContext).executeOperationAsync(
-                eq(actorSelection(actorRef)), eqSerializedDataExists());
+        doReturn(dataExistsReply(true)).when(mockActorContext).executeOperationAsync(
+                eq(actorSelection(actorRef)), eqDataExists(), any(Timeout.class));
 
         TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
 
@@ -299,13 +302,13 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest {
 
         InOrder inOrder = Mockito.inOrder(mockActorContext);
         inOrder.verify(mockActorContext).executeOperationAsync(
-                eq(actorSelection(actorRef)), isA(BatchedModifications.class));
+                eq(actorSelection(actorRef)), isA(BatchedModifications.class), any(Timeout.class));
 
         inOrder.verify(mockActorContext).executeOperationAsync(
-                eq(actorSelection(actorRef)), eqSerializedDataExists());
+                eq(actorSelection(actorRef)), eqDataExists(), any(Timeout.class));
     }
 
-    @Test(expected=IllegalStateException.class)
+    @Test(expected = IllegalStateException.class)
     public void testExistsPreConditionCheck() {
         TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY);
         transactionProxy.exists(TestModel.TEST_PATH);
@@ -328,16 +331,18 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest {
     }
 
     @Test
-    public void testWriteAfterAsyncRead() throws Throwable {
-        ActorRef actorRef = setupActorContextWithoutInitialCreateTransaction(getSystem(), DefaultShardStrategy.DEFAULT_SHARD);
+    @SuppressWarnings("checkstyle:IllegalCatch")
+    public void testWriteAfterAsyncRead() throws Exception {
+        ActorRef actorRef = setupActorContextWithoutInitialCreateTransaction(getSystem(),
+                DefaultShardStrategy.DEFAULT_SHARD);
 
         Promise<Object> createTxPromise = akka.dispatch.Futures.promise();
         doReturn(createTxPromise).when(mockActorContext).executeOperationAsync(
                 eq(getSystem().actorSelection(actorRef.path())),
-                eqCreateTransaction(memberName, READ_WRITE));
+                eqCreateTransaction(memberName, READ_WRITE), any(Timeout.class));
 
-        doReturn(readSerializedDataReply(null)).when(mockActorContext).executeOperationAsync(
-                eq(actorSelection(actorRef)), eqSerializedReadData());
+        doReturn(readDataReply(null)).when(mockActorContext).executeOperationAsync(
+                eq(actorSelection(actorRef)), eqReadData(), any(Timeout.class));
 
         expectBatchedModificationsReady(actorRef);
 
@@ -361,8 +366,8 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest {
                     }
 
                     @Override
-                    public void onFailure(Throwable t) {
-                        caughtEx.set(t);
+                    public void onFailure(Throwable failure) {
+                        caughtEx.set(failure);
                         readComplete.countDown();
                     }
                 });
@@ -371,8 +376,9 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest {
 
         Uninterruptibles.awaitUninterruptibly(readComplete, 5, TimeUnit.SECONDS);
 
-        if(caughtEx.get() != null) {
-            throw caughtEx.get();
+        if (caughtEx.get() != null) {
+            Throwables.propagateIfInstanceOf(caughtEx.get(), Exception.class);
+            Throwables.propagate(caughtEx.get());
         }
 
         // This sends the batched modification.
@@ -381,13 +387,13 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest {
         verifyOneBatchedModification(actorRef, new WriteModification(TestModel.TEST_PATH, nodeToWrite), true);
     }
 
-    @Test(expected=IllegalStateException.class)
+    @Test(expected = IllegalStateException.class)
     public void testWritePreConditionCheck() {
         TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
         transactionProxy.write(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
     }
 
-    @Test(expected=IllegalStateException.class)
+    @Test(expected = IllegalStateException.class)
     public void testWriteAfterReadyPreConditionCheck() {
         TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY);
 
@@ -430,10 +436,10 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest {
     public void testReadWrite() throws Exception {
         ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
 
-        NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+        final NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
 
-        doReturn(readSerializedDataReply(null)).when(mockActorContext).executeOperationAsync(
-                eq(actorSelection(actorRef)), eqSerializedReadData());
+        doReturn(readDataReply(null)).when(mockActorContext).executeOperationAsync(
+                eq(actorSelection(actorRef)), eqReadData(), any(Timeout.class));
 
         expectBatchedModifications(actorRef, 1);
 
@@ -458,10 +464,10 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest {
     public void testReadyWithReadWrite() throws Exception {
         ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
 
-        NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+        final NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
 
-        doReturn(readSerializedDataReply(null)).when(mockActorContext).executeOperationAsync(
-                eq(actorSelection(actorRef)), eqSerializedReadData());
+        doReturn(readDataReply(null)).when(mockActorContext).executeOperationAsync(
+                eq(actorSelection(actorRef)), eqReadData(), any(Timeout.class));
 
         expectBatchedModificationsReady(actorRef, true);
 
@@ -490,8 +496,8 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest {
     public void testReadyWithNoModifications() throws Exception {
         ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
 
-        doReturn(readSerializedDataReply(null)).when(mockActorContext).executeOperationAsync(
-                eq(actorSelection(actorRef)), eqSerializedReadData());
+        doReturn(readDataReply(null)).when(mockActorContext).executeOperationAsync(
+                eq(actorSelection(actorRef)), eqReadData(), any(Timeout.class));
 
         expectBatchedModificationsReady(actorRef, true);
 
@@ -558,9 +564,6 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest {
 
         verifyBatchedModifications(batchedModifications.get(0), true, true,
                 new WriteModification(TestModel.TEST_PATH, nodeToWrite));
-
-        verify(mockActorContext, never()).executeOperationAsync(eq(actorSelection(actorRef)),
-                isA(ReadyTransaction.SERIALIZABLE_CLASS));
     }
 
     @Test
@@ -589,9 +592,6 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest {
                 new WriteModification(TestModel.TEST_PATH, nodeToWrite));
 
         verifyBatchedModifications(batchedModifications.get(1), true, true);
-
-        verify(mockActorContext, never()).executeOperationAsync(eq(actorSelection(actorRef)),
-                isA(ReadyTransaction.SERIALIZABLE_CLASS));
     }
 
     @Test
@@ -634,6 +634,54 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest {
         verifyCohortFutures((DebugThreePhaseCommitCohort)ready, new CommitTransactionReply().toSerializable());
     }
 
+    @Test
+    public void testReadyWithLocalTransaction() throws Exception {
+        ActorRef shardActorRef = getSystem().actorOf(Props.create(DoNothingActor.class));
+
+        doReturn(getSystem().actorSelection(shardActorRef.path())).when(mockActorContext)
+                .actorSelection(shardActorRef.path().toString());
+
+        doReturn(Futures.successful(newPrimaryShardInfo(shardActorRef, createDataTree()))).when(mockActorContext)
+                .findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
+
+        TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY);
+
+        expectReadyLocalTransaction(shardActorRef, true);
+
+        NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+        transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
+
+        DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
+        assertTrue(ready instanceof SingleCommitCohortProxy);
+        verifyCohortFutures((SingleCommitCohortProxy)ready, new CommitTransactionReply().toSerializable());
+    }
+
+    @Test
+    public void testReadyWithLocalTransactionWithFailure() throws Exception {
+        ActorRef shardActorRef = getSystem().actorOf(Props.create(DoNothingActor.class));
+
+        doReturn(getSystem().actorSelection(shardActorRef.path())).when(mockActorContext)
+                .actorSelection(shardActorRef.path().toString());
+
+        DataTree mockDataTree = createDataTree();
+        DataTreeModification mockModification = mockDataTree.takeSnapshot().newModification();
+        doThrow(new RuntimeException("mock")).when(mockModification).ready();
+
+        doReturn(Futures.successful(newPrimaryShardInfo(shardActorRef, mockDataTree))).when(mockActorContext)
+                .findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
+
+        TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY);
+
+        expectReadyLocalTransaction(shardActorRef, true);
+
+        NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+        transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
+
+        DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
+        assertTrue(ready instanceof SingleCommitCohortProxy);
+        verifyCohortFutures((SingleCommitCohortProxy)ready, RuntimeException.class);
+    }
+
     private void testWriteOnlyTxWithFindPrimaryShardFailure(Exception toThrow) throws Exception {
         doReturn(Futures.failed(toThrow)).when(mockActorContext).findPrimaryShardAsync(anyString());
 
@@ -676,8 +724,8 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest {
 
         ActorRef actorRef2 = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY, "junk");
 
-        doReturn(Futures.successful(new Object())).when(mockActorContext).
-                executeOperationAsync(eq(actorSelection(actorRef1)), isA(BatchedModifications.class));
+        doReturn(Futures.successful(new Object())).when(mockActorContext).executeOperationAsync(
+                eq(actorSelection(actorRef1)), isA(BatchedModifications.class), any(Timeout.class));
 
         expectBatchedModificationsReady(actorRef2);
 
@@ -701,15 +749,15 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest {
 
         Object id = transactionProxy.getIdentifier();
         assertNotNull("getIdentifier returned null", id);
-        assertTrue("Invalid identifier: " + id, id.toString().startsWith(memberName));
+        assertTrue("Invalid identifier: " + id, id.toString().contains(memberName));
     }
 
     @Test
-    public void testClose() throws Exception{
+    public void testClose() throws Exception {
         ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
 
-        doReturn(readSerializedDataReply(null)).when(mockActorContext).executeOperationAsync(
-                eq(actorSelection(actorRef)), eqSerializedReadData());
+        doReturn(readDataReply(null)).when(mockActorContext).executeOperationAsync(
+                eq(actorSelection(actorRef)), eqReadData(), any(Timeout.class));
 
         TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
 
@@ -718,134 +766,59 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest {
         transactionProxy.close();
 
         verify(mockActorContext).sendOperationAsync(
-                eq(actorSelection(actorRef)), isA(CloseTransaction.SERIALIZABLE_CLASS));
-    }
-
-
-    /**
-     * Method to test a local Tx actor. The Tx paths are matched to decide if the
-     * Tx actor is local or not. This is done by mocking the Tx actor path
-     * and the caller paths and ensuring that the paths have the remote-address format
-     *
-     * Note: Since the default akka provider for test is not a RemoteActorRefProvider,
-     * the paths returned for the actors for all the tests are not qualified remote paths.
-     * Hence are treated as non-local/remote actors. In short, all tests except
-     * few below run for remote actors
-     *
-     * @throws Exception
-     */
-    @Test
-    public void testLocalTxActorRead() throws Exception {
-        setupActorContextWithInitialCreateTransaction(getSystem(), READ_ONLY);
-        doReturn(true).when(mockActorContext).isPathLocal(anyString());
-
-        TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
-
-        // negative test case with null as the reply
-        doReturn(readDataReply(null)).when(mockActorContext).executeOperationAsync(
-            any(ActorSelection.class), eqReadData());
-
-        Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(
-            TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
-
-        assertEquals("NormalizedNode isPresent", false, readOptional.isPresent());
-
-        // test case with node as read data reply
-        NormalizedNode<?, ?> expectedNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
-
-        doReturn(readDataReply(expectedNode)).when(mockActorContext).executeOperationAsync(
-            any(ActorSelection.class), eqReadData());
-
-        readOptional = transactionProxy.read(TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
-
-        assertEquals("NormalizedNode isPresent", true, readOptional.isPresent());
-
-        assertEquals("Response NormalizedNode", expectedNode, readOptional.get());
-
-        // test for local data exists
-        doReturn(dataExistsReply(true)).when(mockActorContext).executeOperationAsync(
-            any(ActorSelection.class), eqDataExists());
-
-        boolean exists = transactionProxy.exists(TestModel.TEST_PATH).checkedGet();
-
-        assertEquals("Exists response", true, exists);
+                eq(actorSelection(actorRef)), isA(CloseTransaction.class));
     }
 
-    @Test
-    public void testLocalTxActorReady() throws Exception {
-        ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
-        doReturn(true).when(mockActorContext).isPathLocal(anyString());
-
-        expectBatchedModificationsReady(actorRef, true);
-
-        TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
-
-        NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
-        transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
-
-        DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
-
-        assertTrue(ready instanceof SingleCommitCohortProxy);
-
-        verifyCohortFutures((SingleCommitCohortProxy)ready, new CommitTransactionReply().toSerializable());
-    }
-
-    private static interface TransactionProxyOperation {
+    private interface TransactionProxyOperation {
         void run(TransactionProxy transactionProxy);
     }
 
-    private void throttleOperation(TransactionProxyOperation operation) {
-        throttleOperation(operation, 1, true);
-    }
-
-    private void throttleOperation(TransactionProxyOperation operation, int outstandingOpsLimit, boolean shardFound){
-        throttleOperation(operation, outstandingOpsLimit, shardFound, TimeUnit.SECONDS.toNanos(mockActorContext.getDatastoreContext().getOperationTimeoutInSeconds()));
+    private PrimaryShardInfo newPrimaryShardInfo(ActorRef actorRef) {
+        return new PrimaryShardInfo(getSystem().actorSelection(actorRef.path()), DataStoreVersions.CURRENT_VERSION);
     }
 
-    private PrimaryShardInfo newPrimaryShardInfo(ActorRef actorRef){
+    private PrimaryShardInfo newPrimaryShardInfo(ActorRef actorRef, DataTree dataTree) {
         return new PrimaryShardInfo(getSystem().actorSelection(actorRef.path()), DataStoreVersions.CURRENT_VERSION,
-                Optional.<DataTree>absent());
+                dataTree);
     }
 
-    private PrimaryShardInfo newPrimaryShardInfo(ActorRef actorRef, Optional<DataTree> dataTreeOptional){
-        return new PrimaryShardInfo(getSystem().actorSelection(actorRef.path()), DataStoreVersions.CURRENT_VERSION,
-                dataTreeOptional);
+    private void throttleOperation(TransactionProxyOperation operation) {
+        throttleOperation(operation, 1, true);
     }
 
+    private void throttleOperation(TransactionProxyOperation operation, int outstandingOpsLimit, boolean shardFound) {
+        throttleOperation(operation, outstandingOpsLimit, shardFound, TimeUnit.MILLISECONDS.toNanos(
+                mockActorContext.getDatastoreContext().getOperationTimeoutInMillis()));
+    }
 
-    private void throttleOperation(TransactionProxyOperation operation, int outstandingOpsLimit, boolean shardFound, long expectedCompletionTime){
+    private void throttleOperation(TransactionProxyOperation operation, int outstandingOpsLimit, boolean shardFound,
+            long expectedCompletionTime) {
         ActorSystem actorSystem = getSystem();
         ActorRef shardActorRef = actorSystem.actorOf(Props.create(DoNothingActor.class));
 
         // Note that we setting batchedModificationCount to one less than what we need because in TransactionProxy
         // we now allow one extra permit to be allowed for ready
-        doReturn(dataStoreContextBuilder.operationTimeoutInSeconds(2).
-                shardBatchedModificationCount(outstandingOpsLimit-1).build()).when(mockActorContext).getDatastoreContext();
+        doReturn(dataStoreContextBuilder.operationTimeoutInSeconds(2)
+                .shardBatchedModificationCount(outstandingOpsLimit - 1).build()).when(mockActorContext)
+                        .getDatastoreContext();
 
-        doReturn(actorSystem.actorSelection(shardActorRef.path())).
-                when(mockActorContext).actorSelection(shardActorRef.path().toString());
+        doReturn(actorSystem.actorSelection(shardActorRef.path())).when(mockActorContext)
+                .actorSelection(shardActorRef.path().toString());
 
-        if(shardFound) {
-            doReturn(Futures.successful(newPrimaryShardInfo(shardActorRef))).
-                    when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
-            doReturn(Futures.successful(newPrimaryShardInfo(shardActorRef))).
-                    when(mockActorContext).findPrimaryShardAsync(eq("cars"));
+        if (shardFound) {
+            doReturn(Futures.successful(newPrimaryShardInfo(shardActorRef))).when(mockActorContext)
+                    .findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
+            doReturn(Futures.successful(newPrimaryShardInfo(shardActorRef))).when(mockActorContext)
+                    .findPrimaryShardAsync(eq("cars"));
 
         } else {
             doReturn(Futures.failed(new Exception("not found")))
                     .when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
         }
 
-        String actorPath = "akka.tcp://system@127.0.0.1:2550/user/tx-actor";
-        CreateTransactionReply createTransactionReply = CreateTransactionReply.newBuilder().
-                setTransactionId("txn-1").setTransactionActorPath(actorPath).
-                setMessageVersion(DataStoreVersions.CURRENT_VERSION).build();
-
-        doReturn(Futures.successful(createTransactionReply)).when(mockActorContext).
-                executeOperationAsync(eq(actorSystem.actorSelection(shardActorRef.path())),
-                        eqCreateTransaction(memberName, READ_WRITE));
-
-        doReturn(true).when(mockActorContext).isPathLocal(actorPath);
+        doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
+                eq(actorSystem.actorSelection(shardActorRef.path())), eqCreateTransaction(memberName, READ_WRITE),
+                any(Timeout.class));
 
         TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
 
@@ -856,43 +829,40 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest {
         long end = System.nanoTime();
 
         Assert.assertTrue(String.format("Expected elapsed time: %s. Actual: %s",
-                expectedCompletionTime, (end-start)),
-                ((end - start) > expectedCompletionTime) && ((end - start) < expectedCompletionTime*2));
+                expectedCompletionTime, end - start),
+                end - start > expectedCompletionTime && end - start < expectedCompletionTime * 2);
 
     }
 
-    private void completeOperation(TransactionProxyOperation operation){
+    private void completeOperation(TransactionProxyOperation operation) {
         completeOperation(operation, true);
     }
 
-    private void completeOperation(TransactionProxyOperation operation, boolean shardFound){
+    private void completeOperation(TransactionProxyOperation operation, boolean shardFound) {
         ActorSystem actorSystem = getSystem();
         ActorRef shardActorRef = actorSystem.actorOf(Props.create(DoNothingActor.class));
 
-        doReturn(actorSystem.actorSelection(shardActorRef.path())).
-                when(mockActorContext).actorSelection(shardActorRef.path().toString());
+        doReturn(actorSystem.actorSelection(shardActorRef.path())).when(mockActorContext)
+                .actorSelection(shardActorRef.path().toString());
 
-        if(shardFound) {
-            doReturn(Futures.successful(newPrimaryShardInfo(shardActorRef))).
-                    when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
+        if (shardFound) {
+            doReturn(Futures.successful(newPrimaryShardInfo(shardActorRef))).when(mockActorContext)
+                    .findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
         } else {
-            doReturn(Futures.failed(new PrimaryNotFoundException("test")))
-                    .when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
+            doReturn(Futures.failed(new PrimaryNotFoundException("test"))).when(mockActorContext)
+                    .findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
         }
 
         ActorRef txActorRef = actorSystem.actorOf(Props.create(DoNothingActor.class));
         String actorPath = txActorRef.path().toString();
-        CreateTransactionReply createTransactionReply = CreateTransactionReply.newBuilder().
-                setTransactionId("txn-1").setTransactionActorPath(actorPath).
-                setMessageVersion(DataStoreVersions.CURRENT_VERSION).build();
+        CreateTransactionReply createTransactionReply = new CreateTransactionReply(actorPath, nextTransactionId(),
+                DataStoreVersions.CURRENT_VERSION);
 
         doReturn(actorSystem.actorSelection(actorPath)).when(mockActorContext).actorSelection(actorPath);
 
-        doReturn(Futures.successful(createTransactionReply)).when(mockActorContext).
-                executeOperationAsync(eq(actorSystem.actorSelection(shardActorRef.path())),
-                        eqCreateTransaction(memberName, READ_WRITE));
-
-        doReturn(true).when(mockActorContext).isPathLocal(anyString());
+        doReturn(Futures.successful(createTransactionReply)).when(mockActorContext).executeOperationAsync(
+                eq(actorSystem.actorSelection(shardActorRef.path())), eqCreateTransaction(memberName, READ_WRITE),
+                any(Timeout.class));
 
         TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
 
@@ -902,20 +872,21 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest {
 
         long end = System.nanoTime();
 
-        long expected = TimeUnit.SECONDS.toNanos(mockActorContext.getDatastoreContext().getOperationTimeoutInSeconds());
+        long expected = TimeUnit.MILLISECONDS.toNanos(mockActorContext.getDatastoreContext()
+                .getOperationTimeoutInMillis());
         Assert.assertTrue(String.format("Expected elapsed time: %s. Actual: %s",
-                expected, (end-start)), (end - start) <= expected);
+                expected, end - start), end - start <= expected);
     }
 
-    private void completeOperationLocal(TransactionProxyOperation operation, Optional<DataTree> dataTreeOptional){
+    private void completeOperationLocal(TransactionProxyOperation operation, DataTree dataTree) {
         ActorSystem actorSystem = getSystem();
         ActorRef shardActorRef = actorSystem.actorOf(Props.create(DoNothingActor.class));
 
-        doReturn(actorSystem.actorSelection(shardActorRef.path())).
-                when(mockActorContext).actorSelection(shardActorRef.path().toString());
+        doReturn(actorSystem.actorSelection(shardActorRef.path())).when(mockActorContext)
+                .actorSelection(shardActorRef.path().toString());
 
-        doReturn(Futures.successful(newPrimaryShardInfo(shardActorRef, dataTreeOptional))).
-                when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
+        doReturn(Futures.successful(newPrimaryShardInfo(shardActorRef, dataTree))).when(mockActorContext)
+                .findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD));
 
         TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
 
@@ -925,26 +896,25 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest {
 
         long end = System.nanoTime();
 
-        long expected = TimeUnit.SECONDS.toNanos(mockActorContext.getDatastoreContext().getOperationTimeoutInSeconds());
-        Assert.assertTrue(String.format("Expected elapsed time: %s. Actual: %s",
-                expected, (end-start)), (end - start) <= expected);
+        long expected = TimeUnit.MILLISECONDS.toNanos(mockActorContext.getDatastoreContext()
+                .getOperationTimeoutInMillis());
+        Assert.assertTrue(String.format("Expected elapsed time: %s. Actual: %s", expected, end - start),
+                end - start <= expected);
     }
 
-    private Optional<DataTree> createDataTree(){
+    private static DataTree createDataTree() {
         DataTree dataTree = mock(DataTree.class);
-        Optional<DataTree> dataTreeOptional = Optional.of(dataTree);
         DataTreeSnapshot dataTreeSnapshot = mock(DataTreeSnapshot.class);
         DataTreeModification dataTreeModification = mock(DataTreeModification.class);
 
         doReturn(dataTreeSnapshot).when(dataTree).takeSnapshot();
         doReturn(dataTreeModification).when(dataTreeSnapshot).newModification();
 
-        return dataTreeOptional;
+        return dataTree;
     }
 
-    private Optional<DataTree> createDataTree(NormalizedNode readResponse){
+    private static DataTree createDataTree(NormalizedNode<?, ?> readResponse) {
         DataTree dataTree = mock(DataTree.class);
-        Optional<DataTree> dataTreeOptional = Optional.of(dataTree);
         DataTreeSnapshot dataTreeSnapshot = mock(DataTreeSnapshot.class);
         DataTreeModification dataTreeModification = mock(DataTreeModification.class);
 
@@ -952,396 +922,320 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest {
         doReturn(dataTreeModification).when(dataTreeSnapshot).newModification();
         doReturn(Optional.of(readResponse)).when(dataTreeModification).readNode(any(YangInstanceIdentifier.class));
 
-        return dataTreeOptional;
+        return dataTree;
     }
 
 
     @Test
-    public void testWriteCompletionForLocalShard(){
-        completeOperationLocal(new TransactionProxyOperation() {
-            @Override
-            public void run(TransactionProxy transactionProxy) {
-                NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+    public void testWriteCompletionForLocalShard() {
+        completeOperationLocal(transactionProxy -> {
+            NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
 
-                transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
+            transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
 
-                transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
+            transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
 
-            }
         }, createDataTree());
     }
 
     @Test
-    public void testWriteThrottlingWhenShardFound(){
-        throttleOperation(new TransactionProxyOperation() {
-            @Override
-            public void run(TransactionProxy transactionProxy) {
-                NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+    public void testWriteThrottlingWhenShardFound() {
+        throttleOperation(transactionProxy -> {
+            NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
 
-                expectIncompleteBatchedModifications();
+            expectIncompleteBatchedModifications();
 
-                transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
+            transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
 
-                transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
-            }
+            transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
         });
     }
 
     @Test
-    public void testWriteThrottlingWhenShardNotFound(){
+    public void testWriteThrottlingWhenShardNotFound() {
         // Confirm that there is no throttling when the Shard is not found
-        completeOperation(new TransactionProxyOperation() {
-            @Override
-            public void run(TransactionProxy transactionProxy) {
-                NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+        completeOperation(transactionProxy -> {
+            NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
 
-                expectBatchedModifications(2);
+            expectBatchedModifications(2);
 
-                transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
+            transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
 
-                transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
-            }
+            transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
         }, false);
 
     }
 
 
     @Test
-    public void testWriteCompletion(){
-        completeOperation(new TransactionProxyOperation() {
-            @Override
-            public void run(TransactionProxy transactionProxy) {
-                NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+    public void testWriteCompletion() {
+        completeOperation(transactionProxy -> {
+            NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
 
-                expectBatchedModifications(2);
+            expectBatchedModifications(2);
 
-                transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
+            transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
 
-                transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
-            }
+            transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
         });
     }
 
     @Test
-    public void testMergeThrottlingWhenShardFound(){
-        throttleOperation(new TransactionProxyOperation() {
-            @Override
-            public void run(TransactionProxy transactionProxy) {
-                NormalizedNode<?, ?> nodeToMerge = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+    public void testMergeThrottlingWhenShardFound() {
+        throttleOperation(transactionProxy -> {
+            NormalizedNode<?, ?> nodeToMerge = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
 
-                expectIncompleteBatchedModifications();
+            expectIncompleteBatchedModifications();
 
-                transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
+            transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
 
-                transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
-            }
+            transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
         });
     }
 
     @Test
-    public void testMergeThrottlingWhenShardNotFound(){
-        completeOperation(new TransactionProxyOperation() {
-            @Override
-            public void run(TransactionProxy transactionProxy) {
-                NormalizedNode<?, ?> nodeToMerge = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+    public void testMergeThrottlingWhenShardNotFound() {
+        completeOperation(transactionProxy -> {
+            NormalizedNode<?, ?> nodeToMerge = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
 
-                expectBatchedModifications(2);
+            expectBatchedModifications(2);
 
-                transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
+            transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
 
-                transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
-            }
+            transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
         }, false);
     }
 
     @Test
-    public void testMergeCompletion(){
-        completeOperation(new TransactionProxyOperation() {
-            @Override
-            public void run(TransactionProxy transactionProxy) {
-                NormalizedNode<?, ?> nodeToMerge = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+    public void testMergeCompletion() {
+        completeOperation(transactionProxy -> {
+            NormalizedNode<?, ?> nodeToMerge = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
 
-                expectBatchedModifications(2);
+            expectBatchedModifications(2);
 
-                transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
+            transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
 
-                transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
-            }
+            transactionProxy.merge(TestModel.TEST_PATH, nodeToMerge);
         });
 
     }
 
     @Test
-    public void testMergeCompletionForLocalShard(){
-        completeOperationLocal(new TransactionProxyOperation() {
-            @Override
-            public void run(TransactionProxy transactionProxy) {
-                NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+    public void testMergeCompletionForLocalShard() {
+        completeOperationLocal(transactionProxy -> {
+            NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
 
-                transactionProxy.merge(TestModel.TEST_PATH, nodeToWrite);
+            transactionProxy.merge(TestModel.TEST_PATH, nodeToWrite);
 
-                transactionProxy.merge(TestModel.TEST_PATH, nodeToWrite);
+            transactionProxy.merge(TestModel.TEST_PATH, nodeToWrite);
 
-            }
         }, createDataTree());
     }
 
 
     @Test
-    public void testDeleteThrottlingWhenShardFound(){
+    public void testDeleteThrottlingWhenShardFound() {
 
-        throttleOperation(new TransactionProxyOperation() {
-            @Override
-            public void run(TransactionProxy transactionProxy) {
-                expectIncompleteBatchedModifications();
+        throttleOperation(transactionProxy -> {
+            expectIncompleteBatchedModifications();
 
-                transactionProxy.delete(TestModel.TEST_PATH);
+            transactionProxy.delete(TestModel.TEST_PATH);
 
-                transactionProxy.delete(TestModel.TEST_PATH);
-            }
+            transactionProxy.delete(TestModel.TEST_PATH);
         });
     }
 
 
     @Test
-    public void testDeleteThrottlingWhenShardNotFound(){
+    public void testDeleteThrottlingWhenShardNotFound() {
 
-        completeOperation(new TransactionProxyOperation() {
-            @Override
-            public void run(TransactionProxy transactionProxy) {
-                expectBatchedModifications(2);
+        completeOperation(transactionProxy -> {
+            expectBatchedModifications(2);
 
-                transactionProxy.delete(TestModel.TEST_PATH);
+            transactionProxy.delete(TestModel.TEST_PATH);
 
-                transactionProxy.delete(TestModel.TEST_PATH);
-            }
+            transactionProxy.delete(TestModel.TEST_PATH);
         }, false);
     }
 
     @Test
-    public void testDeleteCompletionForLocalShard(){
-        completeOperationLocal(new TransactionProxyOperation() {
-            @Override
-            public void run(TransactionProxy transactionProxy) {
+    public void testDeleteCompletionForLocalShard() {
+        completeOperationLocal(transactionProxy -> {
 
-                transactionProxy.delete(TestModel.TEST_PATH);
+            transactionProxy.delete(TestModel.TEST_PATH);
 
-                transactionProxy.delete(TestModel.TEST_PATH);
-            }
+            transactionProxy.delete(TestModel.TEST_PATH);
         }, createDataTree());
 
     }
 
     @Test
-    public void testDeleteCompletion(){
-        completeOperation(new TransactionProxyOperation() {
-            @Override
-            public void run(TransactionProxy transactionProxy) {
-                expectBatchedModifications(2);
+    public void testDeleteCompletion() {
+        completeOperation(transactionProxy -> {
+            expectBatchedModifications(2);
 
-                transactionProxy.delete(TestModel.TEST_PATH);
+            transactionProxy.delete(TestModel.TEST_PATH);
 
-                transactionProxy.delete(TestModel.TEST_PATH);
-            }
+            transactionProxy.delete(TestModel.TEST_PATH);
         });
 
     }
 
     @Test
-    public void testReadThrottlingWhenShardFound(){
+    public void testReadThrottlingWhenShardFound() {
 
-        throttleOperation(new TransactionProxyOperation() {
-            @Override
-            public void run(TransactionProxy transactionProxy) {
-                doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
-                        any(ActorSelection.class), eqReadData());
+        throttleOperation(transactionProxy -> {
+            doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
+                    any(ActorSelection.class), eqReadData());
 
-                transactionProxy.read(TestModel.TEST_PATH);
+            transactionProxy.read(TestModel.TEST_PATH);
 
-                transactionProxy.read(TestModel.TEST_PATH);
-            }
+            transactionProxy.read(TestModel.TEST_PATH);
         });
     }
 
     @Test
-    public void testReadThrottlingWhenShardNotFound(){
+    public void testReadThrottlingWhenShardNotFound() {
 
-        completeOperation(new TransactionProxyOperation() {
-            @Override
-            public void run(TransactionProxy transactionProxy) {
-                doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
-                        any(ActorSelection.class), eqReadData());
+        completeOperation(transactionProxy -> {
+            doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
+                    any(ActorSelection.class), eqReadData());
 
-                transactionProxy.read(TestModel.TEST_PATH);
+            transactionProxy.read(TestModel.TEST_PATH);
 
-                transactionProxy.read(TestModel.TEST_PATH);
-            }
+            transactionProxy.read(TestModel.TEST_PATH);
         }, false);
     }
 
 
     @Test
-    public void testReadCompletion(){
-        completeOperation(new TransactionProxyOperation() {
-            @Override
-            public void run(TransactionProxy transactionProxy) {
-                NormalizedNode<?, ?> nodeToRead = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+    public void testReadCompletion() {
+        completeOperation(transactionProxy -> {
+            NormalizedNode<?, ?> nodeToRead = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
 
-                doReturn(readDataReply(nodeToRead)).when(mockActorContext).executeOperationAsync(
-                        any(ActorSelection.class), eqReadData());
+            doReturn(readDataReply(nodeToRead)).when(mockActorContext).executeOperationAsync(
+                    any(ActorSelection.class), eqReadData(), any(Timeout.class));
 
-                transactionProxy.read(TestModel.TEST_PATH);
+            transactionProxy.read(TestModel.TEST_PATH);
 
-                transactionProxy.read(TestModel.TEST_PATH);
-            }
+            transactionProxy.read(TestModel.TEST_PATH);
         });
 
     }
 
     @Test
-    public void testReadCompletionForLocalShard(){
-        final NormalizedNode nodeToRead = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
-        completeOperationLocal(new TransactionProxyOperation() {
-            @Override
-            public void run(TransactionProxy transactionProxy) {
-                transactionProxy.read(TestModel.TEST_PATH);
-
-                transactionProxy.read(TestModel.TEST_PATH);
-            }
+    public void testReadCompletionForLocalShard() {
+        final NormalizedNode<?, ?> nodeToRead = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+        completeOperationLocal(transactionProxy -> {
+            transactionProxy.read(TestModel.TEST_PATH);
+
+            transactionProxy.read(TestModel.TEST_PATH);
         }, createDataTree(nodeToRead));
 
     }
 
     @Test
-    public void testReadCompletionForLocalShardWhenExceptionOccurs(){
-        completeOperationLocal(new TransactionProxyOperation() {
-            @Override
-            public void run(TransactionProxy transactionProxy) {
-                transactionProxy.read(TestModel.TEST_PATH);
-
-                transactionProxy.read(TestModel.TEST_PATH);
-            }
+    public void testReadCompletionForLocalShardWhenExceptionOccurs() {
+        completeOperationLocal(transactionProxy -> {
+            transactionProxy.read(TestModel.TEST_PATH);
+
+            transactionProxy.read(TestModel.TEST_PATH);
         }, createDataTree());
 
     }
 
     @Test
-    public void testExistsThrottlingWhenShardFound(){
+    public void testExistsThrottlingWhenShardFound() {
 
-        throttleOperation(new TransactionProxyOperation() {
-            @Override
-            public void run(TransactionProxy transactionProxy) {
-                doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
-                        any(ActorSelection.class), eqDataExists());
+        throttleOperation(transactionProxy -> {
+            doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
+                    any(ActorSelection.class), eqDataExists());
 
-                transactionProxy.exists(TestModel.TEST_PATH);
+            transactionProxy.exists(TestModel.TEST_PATH);
 
-                transactionProxy.exists(TestModel.TEST_PATH);
-            }
+            transactionProxy.exists(TestModel.TEST_PATH);
         });
     }
 
     @Test
-    public void testExistsThrottlingWhenShardNotFound(){
+    public void testExistsThrottlingWhenShardNotFound() {
 
-        completeOperation(new TransactionProxyOperation() {
-            @Override
-            public void run(TransactionProxy transactionProxy) {
-                doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
-                        any(ActorSelection.class), eqDataExists());
+        completeOperation(transactionProxy -> {
+            doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
+                    any(ActorSelection.class), eqDataExists());
 
-                transactionProxy.exists(TestModel.TEST_PATH);
+            transactionProxy.exists(TestModel.TEST_PATH);
 
-                transactionProxy.exists(TestModel.TEST_PATH);
-            }
+            transactionProxy.exists(TestModel.TEST_PATH);
         }, false);
     }
 
 
     @Test
-    public void testExistsCompletion(){
-        completeOperation(new TransactionProxyOperation() {
-            @Override
-            public void run(TransactionProxy transactionProxy) {
-                doReturn(dataExistsReply(true)).when(mockActorContext).executeOperationAsync(
-                        any(ActorSelection.class), eqDataExists());
+    public void testExistsCompletion() {
+        completeOperation(transactionProxy -> {
+            doReturn(dataExistsReply(true)).when(mockActorContext).executeOperationAsync(
+                    any(ActorSelection.class), eqDataExists(), any(Timeout.class));
 
-                transactionProxy.exists(TestModel.TEST_PATH);
+            transactionProxy.exists(TestModel.TEST_PATH);
 
-                transactionProxy.exists(TestModel.TEST_PATH);
-            }
+            transactionProxy.exists(TestModel.TEST_PATH);
         });
 
     }
 
     @Test
-    public void testExistsCompletionForLocalShard(){
-        final NormalizedNode nodeToRead = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
-        completeOperationLocal(new TransactionProxyOperation() {
-            @Override
-            public void run(TransactionProxy transactionProxy) {
-                transactionProxy.exists(TestModel.TEST_PATH);
-
-                transactionProxy.exists(TestModel.TEST_PATH);
-            }
+    public void testExistsCompletionForLocalShard() {
+        final NormalizedNode<?, ?> nodeToRead = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+        completeOperationLocal(transactionProxy -> {
+            transactionProxy.exists(TestModel.TEST_PATH);
+
+            transactionProxy.exists(TestModel.TEST_PATH);
         }, createDataTree(nodeToRead));
 
     }
 
     @Test
-    public void testExistsCompletionForLocalShardWhenExceptionOccurs(){
-        completeOperationLocal(new TransactionProxyOperation() {
-            @Override
-            public void run(TransactionProxy transactionProxy) {
-                transactionProxy.exists(TestModel.TEST_PATH);
-
-                transactionProxy.exists(TestModel.TEST_PATH);
-            }
+    public void testExistsCompletionForLocalShardWhenExceptionOccurs() {
+        completeOperationLocal(transactionProxy -> {
+            transactionProxy.exists(TestModel.TEST_PATH);
+
+            transactionProxy.exists(TestModel.TEST_PATH);
         }, createDataTree());
 
     }
-    @Test
-    public void testReadyThrottling(){
 
-        throttleOperation(new TransactionProxyOperation() {
-            @Override
-            public void run(TransactionProxy transactionProxy) {
-                NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+    @Test
+    public void testReadyThrottling() {
 
-                expectBatchedModifications(1);
+        throttleOperation(transactionProxy -> {
+            NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
 
-                doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
-                        any(ActorSelection.class), any(ReadyTransaction.class));
+            expectBatchedModifications(1);
 
-                transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
+            transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
 
-                transactionProxy.ready();
-            }
+            transactionProxy.ready();
         });
     }
 
     @Test
-    public void testReadyThrottlingWithTwoTransactionContexts(){
-        throttleOperation(new TransactionProxyOperation() {
-            @Override
-            public void run(TransactionProxy transactionProxy) {
-                NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
-                NormalizedNode<?, ?> carsNode = ImmutableNodes.containerNode(CarsModel.BASE_QNAME);
+    public void testReadyThrottlingWithTwoTransactionContexts() {
+        throttleOperation(transactionProxy -> {
+            NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+            NormalizedNode<?, ?> carsNode = ImmutableNodes.containerNode(CarsModel.BASE_QNAME);
 
-                expectBatchedModifications(2);
+            expectBatchedModifications(2);
 
-                doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
-                        any(ActorSelection.class), any(ReadyTransaction.class));
+            transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
 
-                transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
+            // Trying to write to Cars will cause another transaction context to get created
+            transactionProxy.write(CarsModel.BASE_PATH, carsNode);
 
-                // Trying to write to Cars will cause another transaction context to get created
-                transactionProxy.write(CarsModel.BASE_PATH, carsNode);
-
-                // Now ready should block for both transaction contexts
-                transactionProxy.ready();
-            }
-        }, 1, true, TimeUnit.SECONDS.toNanos(mockActorContext.getDatastoreContext().getOperationTimeoutInSeconds()) * 2);
+            // Now ready should block for both transaction contexts
+            transactionProxy.ready();
+        }, 1, true, TimeUnit.MILLISECONDS.toNanos(mockActorContext.getDatastoreContext()
+                .getOperationTimeoutInMillis()) * 2);
     }
 
     private void testModificationOperationBatching(TransactionType type) throws Exception {
@@ -1403,23 +1297,23 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest {
     }
 
     @Test
-    public void testReadWriteModificationOperationBatching() throws Throwable {
+    public void testReadWriteModificationOperationBatching() throws Exception {
         testModificationOperationBatching(READ_WRITE);
     }
 
     @Test
-    public void testWriteOnlyModificationOperationBatching() throws Throwable {
+    public void testWriteOnlyModificationOperationBatching() throws Exception {
         testModificationOperationBatching(WRITE_ONLY);
     }
 
     @Test
-    public void testOptimizedWriteOnlyModificationOperationBatching() throws Throwable {
+    public void testOptimizedWriteOnlyModificationOperationBatching() throws Exception {
         dataStoreContextBuilder.writeOnlyTransactionOptimizationsEnabled(true);
         testModificationOperationBatching(WRITE_ONLY);
     }
 
     @Test
-    public void testModificationOperationBatchingWithInterleavedReads() throws Throwable {
+    public void testModificationOperationBatchingWithInterleavedReads() throws Exception {
 
         int shardBatchedModificationCount = 10;
         dataStoreContextBuilder.shardBatchedModificationCount(shardBatchedModificationCount);
@@ -1428,36 +1322,35 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest {
 
         expectBatchedModifications(actorRef, shardBatchedModificationCount);
 
-        YangInstanceIdentifier writePath1 = TestModel.TEST_PATH;
-        NormalizedNode<?, ?> writeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+        final YangInstanceIdentifier writePath1 = TestModel.TEST_PATH;
+        final NormalizedNode<?, ?> writeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
 
         YangInstanceIdentifier writePath2 = TestModel.OUTER_LIST_PATH;
         NormalizedNode<?, ?> writeNode2 = ImmutableNodes.containerNode(TestModel.OUTER_LIST_QNAME);
 
-        YangInstanceIdentifier mergePath1 = TestModel.TEST_PATH;
-        NormalizedNode<?, ?> mergeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+        final YangInstanceIdentifier mergePath1 = TestModel.TEST_PATH;
+        final NormalizedNode<?, ?> mergeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
 
         YangInstanceIdentifier mergePath2 = TestModel.INNER_LIST_PATH;
         NormalizedNode<?, ?> mergeNode2 = ImmutableNodes.containerNode(TestModel.INNER_LIST_QNAME);
 
-        YangInstanceIdentifier deletePath = TestModel.OUTER_LIST_PATH;
+        final YangInstanceIdentifier deletePath = TestModel.OUTER_LIST_PATH;
 
-        doReturn(readSerializedDataReply(writeNode2)).when(mockActorContext).executeOperationAsync(
-                eq(actorSelection(actorRef)), eqSerializedReadData(writePath2));
+        doReturn(readDataReply(writeNode2)).when(mockActorContext).executeOperationAsync(
+                eq(actorSelection(actorRef)), eqReadData(writePath2), any(Timeout.class));
 
-        doReturn(readSerializedDataReply(mergeNode2)).when(mockActorContext).executeOperationAsync(
-                eq(actorSelection(actorRef)), eqSerializedReadData(mergePath2));
+        doReturn(readDataReply(mergeNode2)).when(mockActorContext).executeOperationAsync(
+                eq(actorSelection(actorRef)), eqReadData(mergePath2), any(Timeout.class));
 
-        doReturn(dataExistsSerializedReply(true)).when(mockActorContext).executeOperationAsync(
-                eq(actorSelection(actorRef)), eqSerializedDataExists());
+        doReturn(dataExistsReply(true)).when(mockActorContext).executeOperationAsync(
+                eq(actorSelection(actorRef)), eqDataExists(), any(Timeout.class));
 
         TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
 
         transactionProxy.write(writePath1, writeNode1);
         transactionProxy.write(writePath2, writeNode2);
 
-        Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(writePath2).
-                get(5, TimeUnit.SECONDS);
+        Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(writePath2).get(5, TimeUnit.SECONDS);
 
         assertEquals("NormalizedNode isPresent", true, readOptional.isPresent());
         assertEquals("Response NormalizedNode", writeNode2, readOptional.get());
@@ -1488,27 +1381,27 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest {
 
         InOrder inOrder = Mockito.inOrder(mockActorContext);
         inOrder.verify(mockActorContext).executeOperationAsync(
-                eq(actorSelection(actorRef)), isA(BatchedModifications.class));
+                eq(actorSelection(actorRef)), isA(BatchedModifications.class), any(Timeout.class));
 
         inOrder.verify(mockActorContext).executeOperationAsync(
-                eq(actorSelection(actorRef)), eqSerializedReadData(writePath2));
+                eq(actorSelection(actorRef)), eqReadData(writePath2), any(Timeout.class));
 
         inOrder.verify(mockActorContext).executeOperationAsync(
-                eq(actorSelection(actorRef)), isA(BatchedModifications.class));
+                eq(actorSelection(actorRef)), isA(BatchedModifications.class), any(Timeout.class));
 
         inOrder.verify(mockActorContext).executeOperationAsync(
-                eq(actorSelection(actorRef)), eqSerializedReadData(mergePath2));
+                eq(actorSelection(actorRef)), eqReadData(mergePath2), any(Timeout.class));
 
         inOrder.verify(mockActorContext).executeOperationAsync(
-                eq(actorSelection(actorRef)), isA(BatchedModifications.class));
+                eq(actorSelection(actorRef)), isA(BatchedModifications.class), any(Timeout.class));
 
         inOrder.verify(mockActorContext).executeOperationAsync(
-                eq(actorSelection(actorRef)), eqSerializedDataExists());
+                eq(actorSelection(actorRef)), eqDataExists(), any(Timeout.class));
     }
 
     @Test
-    public void testReadRoot() throws ReadFailedException, InterruptedException, ExecutionException, java.util.concurrent.TimeoutException {
-
+    public void testReadRoot() throws ReadFailedException, InterruptedException, ExecutionException,
+            java.util.concurrent.TimeoutException {
         SchemaContext schemaContext = SchemaContextHelper.full();
         Configuration configuration = mock(Configuration.class);
         doReturn(configuration).when(mockActorContext).getConfiguration();
@@ -1521,14 +1414,14 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest {
         setUpReadData("test", NormalizedNodeAggregatorTest.getRootNode(expectedNode1, schemaContext));
         setUpReadData("cars", NormalizedNodeAggregatorTest.getRootNode(expectedNode2, schemaContext));
 
-        doReturn(memberName).when(mockActorContext).getCurrentMemberName();
+        doReturn(MemberName.forName(memberName)).when(mockActorContext).getCurrentMemberName();
 
         doReturn(getSystem().dispatchers().defaultGlobalDispatcher()).when(mockActorContext).getClientDispatcher();
 
         TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
 
         Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(
-                YangInstanceIdentifier.builder().build()).get(5, TimeUnit.SECONDS);
+                YangInstanceIdentifier.EMPTY).get(5, TimeUnit.SECONDS);
 
         assertEquals("NormalizedNode isPresent", true, readOptional.isPresent());
 
@@ -1536,9 +1429,10 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest {
 
         assertTrue("Expect value to be a Collection", normalizedNode.getValue() instanceof Collection);
 
+        @SuppressWarnings("unchecked")
         Collection<NormalizedNode<?,?>> collection = (Collection<NormalizedNode<?,?>>) normalizedNode.getValue();
 
-        for(NormalizedNode<?,?> node : collection){
+        for (NormalizedNode<?,?> node : collection) {
             assertTrue("Expected " + node + " to be a ContainerNode", node instanceof ContainerNode);
         }
 
@@ -1558,24 +1452,22 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest {
         ActorSystem actorSystem = getSystem();
         ActorRef shardActorRef = getSystem().actorOf(Props.create(DoNothingActor.class));
 
-        doReturn(getSystem().actorSelection(shardActorRef.path())).
-                when(mockActorContext).actorSelection(shardActorRef.path().toString());
-
-        doReturn(primaryShardInfoReply(getSystem(), shardActorRef)).
-                when(mockActorContext).findPrimaryShardAsync(eq(shardName));
+        doReturn(getSystem().actorSelection(shardActorRef.path())).when(mockActorContext)
+                .actorSelection(shardActorRef.path().toString());
 
-        doReturn(true).when(mockActorContext).isPathLocal(shardActorRef.path().toString());
+        doReturn(primaryShardInfoReply(getSystem(), shardActorRef)).when(mockActorContext)
+                .findPrimaryShardAsync(eq(shardName));
 
         ActorRef txActorRef = actorSystem.actorOf(Props.create(DoNothingActor.class));
 
-        doReturn(actorSystem.actorSelection(txActorRef.path())).
-                when(mockActorContext).actorSelection(txActorRef.path().toString());
+        doReturn(actorSystem.actorSelection(txActorRef.path())).when(mockActorContext)
+                .actorSelection(txActorRef.path().toString());
 
-        doReturn(Futures.successful(createTransactionReply(txActorRef, DataStoreVersions.CURRENT_VERSION))).when(mockActorContext).
-                executeOperationAsync(eq(actorSystem.actorSelection(shardActorRef.path())),
-                        eqCreateTransaction(memberName, TransactionType.READ_ONLY));
+        doReturn(Futures.successful(createTransactionReply(txActorRef, DataStoreVersions.CURRENT_VERSION)))
+                .when(mockActorContext).executeOperationAsync(eq(actorSystem.actorSelection(shardActorRef.path())),
+                        eqCreateTransaction(memberName, TransactionType.READ_ONLY), any(Timeout.class));
 
-        doReturn(readSerializedDataReply(expectedNode)).when(mockActorContext).executeOperationAsync(
-                eq(actorSelection(txActorRef)), eqSerializedReadData(YangInstanceIdentifier.builder().build()));
+        doReturn(readDataReply(expectedNode)).when(mockActorContext).executeOperationAsync(
+                eq(actorSelection(txActorRef)), eqReadData(YangInstanceIdentifier.EMPTY), any(Timeout.class));
     }
 }