X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-distributed-datastore%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fcluster%2Fdatastore%2FTransactionProxyTest.java;h=dd0c9879db71803a31007dfa2164f900ba84b3cc;hp=a2471001864c1571a8a52d4abf0b8f41e7571ea3;hb=2fd1fa721510a30f58b3bc277deb05fce58badd6;hpb=78527e81f8cc82140af5cb2649863a597f380291 diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/TransactionProxyTest.java b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/TransactionProxyTest.java index a247100186..dd0c9879db 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/TransactionProxyTest.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/TransactionProxyTest.java @@ -1,150 +1,174 @@ +/* + * 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; +import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertTrue; -import static org.junit.Assert.fail; -import static org.mockito.Matchers.any; -import static org.mockito.Matchers.anyString; -import static org.mockito.Matchers.eq; -import static org.mockito.Matchers.isA; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.ArgumentMatchers.isA; import static org.mockito.Mockito.doReturn; -import static org.mockito.Mockito.never; +import static org.mockito.Mockito.doThrow; +import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; -import static org.opendaylight.controller.cluster.datastore.TransactionProxy.TransactionType.READ_ONLY; -import static org.opendaylight.controller.cluster.datastore.TransactionProxy.TransactionType.READ_WRITE; -import static org.opendaylight.controller.cluster.datastore.TransactionProxy.TransactionType.WRITE_ONLY; +import static org.opendaylight.controller.cluster.datastore.TransactionType.READ_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 com.google.common.base.Optional; -import com.google.common.util.concurrent.CheckedFuture; +import akka.util.Timeout; +import com.google.common.base.Throwables; +import com.google.common.collect.ImmutableSortedSet; +import com.google.common.collect.Sets; +import com.google.common.util.concurrent.FluentFuture; import com.google.common.util.concurrent.FutureCallback; +import com.google.common.util.concurrent.MoreExecutors; import com.google.common.util.concurrent.Uninterruptibles; +import java.util.Collection; import java.util.List; +import java.util.Optional; +import java.util.SortedSet; import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutionException; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicReference; import org.junit.Assert; import org.junit.Test; +import org.mockito.ArgumentCaptor; import org.mockito.InOrder; import org.mockito.Mockito; -import org.opendaylight.controller.cluster.datastore.TransactionProxy.TransactionType; +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; import org.opendaylight.controller.cluster.datastore.exceptions.TimeoutException; import org.opendaylight.controller.cluster.datastore.messages.BatchedModifications; -import org.opendaylight.controller.cluster.datastore.messages.BatchedModificationsReply; import org.opendaylight.controller.cluster.datastore.messages.CloseTransaction; -import org.opendaylight.controller.cluster.datastore.messages.ReadyTransaction; +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.ReadyLocalTransaction; 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.mdsal.common.api.ReadFailedException; +import org.opendaylight.mdsal.dom.spi.store.DOMStoreThreePhaseCommitCohort; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; +import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; +import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree; +import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification; +import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshot; import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes; -import scala.concurrent.Await; -import scala.concurrent.Future; +import org.opendaylight.yangtools.yang.model.api.SchemaContext; import scala.concurrent.Promise; -import scala.concurrent.duration.Duration; -@SuppressWarnings("resource") +@SuppressWarnings({"resource", "checkstyle:IllegalThrows", "checkstyle:AvoidHidingCauseException"}) public class TransactionProxyTest extends AbstractTransactionProxyTest { @SuppressWarnings("serial") static class TestException extends RuntimeException { } - static interface Invoker { - CheckedFuture invoke(TransactionProxy proxy) throws Exception; + interface Invoker { + FluentFuture invoke(TransactionProxy proxy); } @Test public void testRead() throws Exception { ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_ONLY); - TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, READ_ONLY); + 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> readOptional = transactionProxy.read( TestModel.TEST_PATH).get(5, TimeUnit.SECONDS); - assertEquals("NormalizedNode isPresent", false, readOptional.isPresent()); + assertFalse("NormalizedNode isPresent", readOptional.isPresent()); 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); - assertEquals("NormalizedNode isPresent", true, readOptional.isPresent()); + assertTrue("NormalizedNode isPresent", readOptional.isPresent()); assertEquals("Response NormalizedNode", expectedNode, readOptional.get()); } @Test(expected = ReadFailedException.class) - public void testReadWithInvalidReplyMessageType() throws Exception { + public void testReadWithInvalidReplyMessageType() throws Throwable { 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(mockActorContext, READ_ONLY); + TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY); - transactionProxy.read(TestModel.TEST_PATH).checkedGet(5, TimeUnit.SECONDS); + try { + transactionProxy.read(TestModel.TEST_PATH).get(5, TimeUnit.SECONDS); + } catch (ExecutionException e) { + throw e.getCause(); + } } @Test(expected = TestException.class) public void testReadWithAsyncRemoteOperatonFailure() throws Throwable { 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(mockActorContext, READ_ONLY); + TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY); propagateReadFailedExceptionCause(transactionProxy.read(TestModel.TEST_PATH)); } - private void testExceptionOnInitialCreateTransaction(Exception exToThrow, Invoker invoker) + private void testExceptionOnInitialCreateTransaction(final Exception exToThrow, final Invoker invoker) throws Throwable { ActorRef actorRef = getSystem().actorOf(Props.create(DoNothingActor.class)); if (exToThrow instanceof PrimaryNotFoundException) { doReturn(Futures.failed(exToThrow)).when(mockActorContext).findPrimaryShardAsync(anyString()); } else { - doReturn(Futures.successful(getSystem().actorSelection(actorRef.path()))). - 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(mockActorContext, READ_ONLY); + 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 invoke(TransactionProxy proxy) throws Exception { - return proxy.read(TestModel.TEST_PATH); - } - }); + private void testReadWithExceptionOnInitialCreateTransaction(final Exception exToThrow) throws Throwable { + testExceptionOnInitialCreateTransaction(exToThrow, proxy -> proxy.read(TestModel.TEST_PATH)); } @Test(expected = PrimaryNotFoundException.class) @@ -152,10 +176,10 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { testReadWithExceptionOnInitialCreateTransaction(new PrimaryNotFoundException("test")); } - @Test(expected = TimeoutException.class) + @Test(expected = TestException.class) public void testReadWhenATimeoutExceptionIsThrown() throws Throwable { testReadWithExceptionOnInitialCreateTransaction(new TimeoutException("test", - new Exception("reason"))); + new TestException())); } @Test(expected = TestException.class) @@ -164,54 +188,55 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { } @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(mockActorContext, READ_WRITE); + TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE); transactionProxy.write(TestModel.TEST_PATH, expectedNode); Optional> readOptional = transactionProxy.read( TestModel.TEST_PATH).get(5, TimeUnit.SECONDS); - assertEquals("NormalizedNode isPresent", true, readOptional.isPresent()); + assertTrue("NormalizedNode isPresent", readOptional.isPresent()); assertEquals("Response NormalizedNode", expectedNode, readOptional.get()); 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(mockActorContext, WRITE_ONLY); + TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY); transactionProxy.read(TestModel.TEST_PATH); } - @Test(expected=IllegalArgumentException.class) + @Test(expected = IllegalArgumentException.class) public void testInvalidCreateTransactionReply() throws Throwable { 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(Futures.successful(getSystem().actorSelection(actorRef.path()))). - 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(mockActorContext, READ_ONLY); + TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY); propagateReadFailedExceptionCause(transactionProxy.read(TestModel.TEST_PATH)); } @@ -220,116 +245,92 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { public void testExists() throws Exception { ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_ONLY); - TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, READ_ONLY); + 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(); + Boolean exists = transactionProxy.exists(TestModel.TEST_PATH).get(); - assertEquals("Exists response", false, exists); + assertEquals("Exists response", Boolean.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(); + exists = transactionProxy.exists(TestModel.TEST_PATH).get(); - assertEquals("Exists response", true, exists); + assertEquals("Exists response", Boolean.TRUE, exists); } @Test(expected = PrimaryNotFoundException.class) public void testExistsWhenAPrimaryNotFoundExceptionIsThrown() throws Throwable { - testExceptionOnInitialCreateTransaction(new PrimaryNotFoundException("test"), new Invoker() { - @Override - public CheckedFuture invoke(TransactionProxy proxy) throws Exception { - return proxy.exists(TestModel.TEST_PATH); - } - }); + testExceptionOnInitialCreateTransaction(new PrimaryNotFoundException("test"), + proxy -> proxy.exists(TestModel.TEST_PATH)); } @Test(expected = ReadFailedException.class) - public void testExistsWithInvalidReplyMessageType() throws Exception { + public void testExistsWithInvalidReplyMessageType() throws Throwable { 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(mockActorContext, - READ_ONLY); + TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY); - transactionProxy.exists(TestModel.TEST_PATH).checkedGet(5, TimeUnit.SECONDS); + try { + transactionProxy.exists(TestModel.TEST_PATH).get(5, TimeUnit.SECONDS); + } catch (ExecutionException e) { + throw e.getCause(); + } } @Test(expected = TestException.class) public void testExistsWithAsyncRemoteOperatonFailure() throws Throwable { 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(mockActorContext, READ_ONLY); + TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY); propagateReadFailedExceptionCause(transactionProxy.exists(TestModel.TEST_PATH)); } @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(mockActorContext, READ_WRITE); + TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE); transactionProxy.write(TestModel.TEST_PATH, nodeToWrite); - Boolean exists = transactionProxy.exists(TestModel.TEST_PATH).checkedGet(); + Boolean exists = transactionProxy.exists(TestModel.TEST_PATH).get(); - assertEquals("Exists response", true, exists); + assertEquals("Exists response", Boolean.TRUE, exists); 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(mockActorContext, WRITE_ONLY); + TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY); transactionProxy.exists(TestModel.TEST_PATH); } - private void verifyRecordingOperationFutures(List> futures, - Class... expResultTypes) throws Exception { - assertEquals("getRecordingOperationFutures size", expResultTypes.length, futures.size()); - - int i = 0; - for( Future future: futures) { - assertNotNull("Recording operation Future is null", future); - - Class expResultType = expResultTypes[i++]; - if(Throwable.class.isAssignableFrom(expResultType)) { - try { - Await.result(future, Duration.create(5, TimeUnit.SECONDS)); - fail("Expected exception from recording operation Future"); - } catch(Exception e) { - // Expected - } - } else { - assertEquals(String.format("Recording operation %d Future result type", i +1 ), expResultType, - Await.result(future, Duration.create(5, TimeUnit.SECONDS)).getClass()); - } - } - } - @Test - public void testWrite() throws Exception { + public void testWrite() { dataStoreContextBuilder.shardBatchedModificationCount(1); ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY); @@ -337,7 +338,7 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { expectBatchedModifications(actorRef, 1); - TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, WRITE_ONLY); + TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY); transactionProxy.write(TestModel.TEST_PATH, nodeToWrite); @@ -345,30 +346,31 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { } @Test - public void testWriteAfterAsyncRead() throws Throwable { - ActorRef actorRef = setupActorContextWithoutInitialCreateTransaction(getSystem()); + @SuppressWarnings("checkstyle:IllegalCatch") + public void testWriteAfterAsyncRead() throws Exception { + ActorRef actorRef = setupActorContextWithoutInitialCreateTransaction(getSystem(), + DefaultShardStrategy.DEFAULT_SHARD); Promise 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)); - expectBatchedModifications(actorRef, 1); - expectReadyTransaction(actorRef); + expectBatchedModificationsReady(actorRef); final NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); - final TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, READ_WRITE); + final TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE); final CountDownLatch readComplete = new CountDownLatch(1); final AtomicReference caughtEx = new AtomicReference<>(); com.google.common.util.concurrent.Futures.addCallback(transactionProxy.read(TestModel.TEST_PATH), new FutureCallback>>() { @Override - public void onSuccess(Optional> result) { + public void onSuccess(final Optional> result) { try { transactionProxy.write(TestModel.TEST_PATH, nodeToWrite); } catch (Exception e) { @@ -379,38 +381,37 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { } @Override - public void onFailure(Throwable t) { - caughtEx.set(t); + public void onFailure(final Throwable failure) { + caughtEx.set(failure); readComplete.countDown(); } - }); + }, MoreExecutors.directExecutor()); createTxPromise.success(createTransactionReply(actorRef, DataStoreVersions.CURRENT_VERSION)); Uninterruptibles.awaitUninterruptibly(readComplete, 5, TimeUnit.SECONDS); - if(caughtEx.get() != null) { - throw caughtEx.get(); + final Throwable t = caughtEx.get(); + if (t != null) { + Throwables.propagateIfPossible(t, Exception.class); + throw new RuntimeException(t); } // This sends the batched modification. transactionProxy.ready(); - verifyOneBatchedModification(actorRef, new WriteModification(TestModel.TEST_PATH, nodeToWrite), false); - - verifyRecordingOperationFutures(transactionProxy.getRecordedOperationFutures(), - BatchedModificationsReply.class); + verifyOneBatchedModification(actorRef, new WriteModification(TestModel.TEST_PATH, nodeToWrite), true); } - @Test(expected=IllegalStateException.class) + @Test(expected = IllegalStateException.class) public void testWritePreConditionCheck() { - TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, READ_ONLY); + 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(mockActorContext, WRITE_ONLY); + TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY); transactionProxy.ready(); @@ -418,7 +419,7 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { } @Test - public void testMerge() throws Exception { + public void testMerge() { dataStoreContextBuilder.shardBatchedModificationCount(1); ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY); @@ -426,7 +427,7 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { expectBatchedModifications(actorRef, 1); - TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, WRITE_ONLY); + TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY); transactionProxy.merge(TestModel.TEST_PATH, nodeToWrite); @@ -434,13 +435,13 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { } @Test - public void testDelete() throws Exception { + public void testDelete() { dataStoreContextBuilder.shardBatchedModificationCount(1); ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY); expectBatchedModifications(actorRef, 1); - TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, WRITE_ONLY); + TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY); transactionProxy.delete(TestModel.TEST_PATH); @@ -448,98 +449,191 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { } @Test - public void testReadyWithReadWrite() throws Exception { + public void testReadWrite() { 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); - expectReadyTransaction(actorRef); - TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, READ_WRITE); + TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE); transactionProxy.read(TestModel.TEST_PATH); transactionProxy.write(TestModel.TEST_PATH, nodeToWrite); + transactionProxy.read(TestModel.TEST_PATH); + + transactionProxy.read(TestModel.TEST_PATH); + + List batchedModifications = captureBatchedModifications(actorRef); + assertEquals("Captured BatchedModifications count", 1, batchedModifications.size()); + + verifyBatchedModifications(batchedModifications.get(0), false, + new WriteModification(TestModel.TEST_PATH, nodeToWrite)); + } + + @Test + public void testReadyWithReadWrite() { + ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE); + + final NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); + + doReturn(readDataReply(null)).when(mockActorContext).executeOperationAsync( + eq(actorSelection(actorRef)), eqReadData(), any(Timeout.class)); + + expectBatchedModificationsReady(actorRef, true); + + TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE); + + transactionProxy.read(TestModel.TEST_PATH); + + transactionProxy.write(TestModel.TEST_PATH, nodeToWrite); + + DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready(); + + assertTrue(ready instanceof SingleCommitCohortProxy); + + verifyCohortFutures((SingleCommitCohortProxy)ready, new CommitTransactionReply().toSerializable()); + + List batchedModifications = captureBatchedModifications(actorRef); + assertEquals("Captured BatchedModifications count", 1, batchedModifications.size()); + + verifyBatchedModifications(batchedModifications.get(0), true, true, + new WriteModification(TestModel.TEST_PATH, nodeToWrite)); + + assertEquals("getTotalMessageCount", 1, batchedModifications.get(0).getTotalMessagesSent()); + } + + @Test + public void testReadyWithNoModifications() { + ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE); + + doReturn(readDataReply(null)).when(mockActorContext).executeOperationAsync( + eq(actorSelection(actorRef)), eqReadData(), any(Timeout.class)); + + expectBatchedModificationsReady(actorRef, true); + + TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE); + + transactionProxy.read(TestModel.TEST_PATH); + + DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready(); + + assertTrue(ready instanceof SingleCommitCohortProxy); + + verifyCohortFutures((SingleCommitCohortProxy)ready, new CommitTransactionReply().toSerializable()); + + List batchedModifications = captureBatchedModifications(actorRef); + assertEquals("Captured BatchedModifications count", 1, batchedModifications.size()); + + verifyBatchedModifications(batchedModifications.get(0), true, true); + } + + @Test + public void testReadyWithMultipleShardWrites() { + ActorRef actorRef1 = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY); + + ActorRef actorRef2 = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY, + TestModel.JUNK_QNAME.getLocalName()); + + expectBatchedModificationsReady(actorRef1); + expectBatchedModificationsReady(actorRef2); + + ActorRef actorRef3 = getSystem().actorOf(Props.create(DoNothingActor.class)); + + doReturn(getSystem().actorSelection(actorRef3.path())).when(mockActorContext) + .actorSelection(actorRef3.path().toString()); + + doReturn(Futures.successful(newPrimaryShardInfo(actorRef3, createDataTree()))).when(mockActorContext) + .findPrimaryShardAsync(eq(CarsModel.BASE_QNAME.getLocalName())); + + expectReadyLocalTransaction(actorRef3, false); + + TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY); + + transactionProxy.write(TestModel.JUNK_PATH, ImmutableNodes.containerNode(TestModel.JUNK_QNAME)); + transactionProxy.write(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME)); + transactionProxy.write(CarsModel.BASE_PATH, ImmutableNodes.containerNode(CarsModel.BASE_QNAME)); + DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready(); assertTrue(ready instanceof ThreePhaseCommitCohortProxy); - ThreePhaseCommitCohortProxy proxy = (ThreePhaseCommitCohortProxy) ready; + verifyCohortFutures((ThreePhaseCommitCohortProxy)ready, actorSelection(actorRef1), + actorSelection(actorRef2), actorSelection(actorRef3)); - verifyRecordingOperationFutures(transactionProxy.getRecordedOperationFutures(), - BatchedModificationsReply.class); + SortedSet expShardNames = + ImmutableSortedSet.of(DefaultShardStrategy.DEFAULT_SHARD, + TestModel.JUNK_QNAME.getLocalName(), CarsModel.BASE_QNAME.getLocalName()); - verifyCohortFutures(proxy, getSystem().actorSelection(actorRef.path())); + ArgumentCaptor batchedMods = ArgumentCaptor.forClass(BatchedModifications.class); + verify(mockActorContext).executeOperationAsync( + eq(actorSelection(actorRef1)), batchedMods.capture(), any(Timeout.class)); + assertTrue("Participating shards present", batchedMods.getValue().getParticipatingShardNames().isPresent()); + assertEquals("Participating shards", expShardNames, batchedMods.getValue().getParticipatingShardNames().get()); - verify(mockActorContext).executeOperationAsync(eq(actorSelection(actorRef)), - isA(BatchedModifications.class)); + batchedMods = ArgumentCaptor.forClass(BatchedModifications.class); + verify(mockActorContext).executeOperationAsync( + eq(actorSelection(actorRef2)), batchedMods.capture(), any(Timeout.class)); + assertTrue("Participating shards present", batchedMods.getValue().getParticipatingShardNames().isPresent()); + assertEquals("Participating shards", expShardNames, batchedMods.getValue().getParticipatingShardNames().get()); - verify(mockActorContext).executeOperationAsync(eq(actorSelection(actorRef)), - isA(ReadyTransaction.SERIALIZABLE_CLASS)); + ArgumentCaptor readyLocalTx = ArgumentCaptor.forClass(ReadyLocalTransaction.class); + verify(mockActorContext).executeOperationAsync( + eq(actorSelection(actorRef3)), readyLocalTx.capture(), any(Timeout.class)); + assertTrue("Participating shards present", readyLocalTx.getValue().getParticipatingShardNames().isPresent()); + assertEquals("Participating shards", expShardNames, readyLocalTx.getValue().getParticipatingShardNames().get()); } @Test - public void testReadyWithWriteOnlyAndLastBatchPending() throws Exception { + public void testReadyWithWriteOnlyAndLastBatchPending() { dataStoreContextBuilder.writeOnlyTransactionOptimizationsEnabled(true); ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY); NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); - expectBatchedModificationsReady(actorRef, 1); + expectBatchedModificationsReady(actorRef, true); - TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, WRITE_ONLY); + TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY); transactionProxy.write(TestModel.TEST_PATH, nodeToWrite); DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready(); - assertTrue(ready instanceof ThreePhaseCommitCohortProxy); - - ThreePhaseCommitCohortProxy proxy = (ThreePhaseCommitCohortProxy) ready; - - verifyRecordingOperationFutures(transactionProxy.getRecordedOperationFutures()); + assertTrue(ready instanceof SingleCommitCohortProxy); - verifyCohortFutures(proxy, getSystem().actorSelection(actorRef.path())); + verifyCohortFutures((SingleCommitCohortProxy)ready, new CommitTransactionReply().toSerializable()); List batchedModifications = captureBatchedModifications(actorRef); assertEquals("Captured BatchedModifications count", 1, batchedModifications.size()); - verifyBatchedModifications(batchedModifications.get(0), true, + verifyBatchedModifications(batchedModifications.get(0), true, true, new WriteModification(TestModel.TEST_PATH, nodeToWrite)); - - verify(mockActorContext, never()).executeOperationAsync(eq(actorSelection(actorRef)), - isA(ReadyTransaction.SERIALIZABLE_CLASS)); } @Test - public void testReadyWithWriteOnlyAndLastBatchEmpty() throws Exception { + public void testReadyWithWriteOnlyAndLastBatchEmpty() { dataStoreContextBuilder.shardBatchedModificationCount(1).writeOnlyTransactionOptimizationsEnabled(true); ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY); NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); - expectBatchedModificationsReady(actorRef, 1); + expectBatchedModificationsReady(actorRef, true); - TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, WRITE_ONLY); + TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY); transactionProxy.write(TestModel.TEST_PATH, nodeToWrite); DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready(); - assertTrue(ready instanceof ThreePhaseCommitCohortProxy); - - ThreePhaseCommitCohortProxy proxy = (ThreePhaseCommitCohortProxy) ready; + assertTrue(ready instanceof SingleCommitCohortProxy); - verifyRecordingOperationFutures(transactionProxy.getRecordedOperationFutures(), - BatchedModificationsReply.class); - - verifyCohortFutures(proxy, getSystem().actorSelection(actorRef.path())); + verifyCohortFutures((SingleCommitCohortProxy)ready, new CommitTransactionReply().toSerializable()); List batchedModifications = captureBatchedModifications(actorRef); assertEquals("Captured BatchedModifications count", 2, batchedModifications.size()); @@ -547,15 +641,12 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { verifyBatchedModifications(batchedModifications.get(0), false, new WriteModification(TestModel.TEST_PATH, nodeToWrite)); - verifyBatchedModifications(batchedModifications.get(1), true); - - verify(mockActorContext, never()).executeOperationAsync(eq(actorSelection(actorRef)), - isA(ReadyTransaction.SERIALIZABLE_CLASS)); + verifyBatchedModifications(batchedModifications.get(1), true, true); } @Test - public void testReadyWithRecordingOperationFailure() throws Exception { - dataStoreContextBuilder.shardBatchedModificationCount(1).writeOnlyTransactionOptimizationsEnabled(true); + public void testReadyWithReplyFailure() { + dataStoreContextBuilder.writeOnlyTransactionOptimizationsEnabled(true); ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY); @@ -563,50 +654,93 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { expectFailedBatchedModifications(actorRef); - doReturn(false).when(mockActorContext).isPathLocal(actorRef.path().toString()); + TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY); - TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, WRITE_ONLY); - - transactionProxy.write(TestModel.TEST_PATH, nodeToWrite); + transactionProxy.merge(TestModel.TEST_PATH, nodeToWrite); DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready(); - assertTrue(ready instanceof ThreePhaseCommitCohortProxy); + assertTrue(ready instanceof SingleCommitCohortProxy); + + verifyCohortFutures((SingleCommitCohortProxy)ready, TestException.class); + } + + @Test + public void testReadyWithDebugContextEnabled() { + dataStoreContextBuilder.transactionDebugContextEnabled(true); + + ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE); + + expectBatchedModificationsReady(actorRef, true); - ThreePhaseCommitCohortProxy proxy = (ThreePhaseCommitCohortProxy) ready; + TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE); - verifyCohortFutures(proxy, TestException.class); + transactionProxy.merge(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME)); - verifyRecordingOperationFutures(transactionProxy.getRecordedOperationFutures(), TestException.class); + DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready(); + + assertTrue(ready instanceof DebugThreePhaseCommitCohort); + + verifyCohortFutures((DebugThreePhaseCommitCohort)ready, new CommitTransactionReply().toSerializable()); } @Test - public void testReadyWithReplyFailure() throws Exception { - dataStoreContextBuilder.writeOnlyTransactionOptimizationsEnabled(true); + public void testReadyWithLocalTransaction() { + ActorRef shardActorRef = getSystem().actorOf(Props.create(DoNothingActor.class)); - ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY); + doReturn(getSystem().actorSelection(shardActorRef.path())).when(mockActorContext) + .actorSelection(shardActorRef.path().toString()); - NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); + doReturn(Futures.successful(newPrimaryShardInfo(shardActorRef, createDataTree()))).when(mockActorContext) + .findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD)); - expectFailedBatchedModifications(actorRef); + TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY); - TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, WRITE_ONLY); + expectReadyLocalTransaction(shardActorRef, true); - transactionProxy.merge(TestModel.TEST_PATH, nodeToWrite); + 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()); - assertTrue(ready instanceof ThreePhaseCommitCohortProxy); + ArgumentCaptor readyLocalTx = ArgumentCaptor.forClass(ReadyLocalTransaction.class); + verify(mockActorContext).executeOperationAsync( + eq(actorSelection(shardActorRef)), readyLocalTx.capture(), any(Timeout.class)); + assertFalse("Participating shards present", readyLocalTx.getValue().getParticipatingShardNames().isPresent()); + } + + @Test + public void testReadyWithLocalTransactionWithFailure() { + 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); - ThreePhaseCommitCohortProxy proxy = (ThreePhaseCommitCohortProxy) ready; + expectReadyLocalTransaction(shardActorRef, true); - verifyCohortFutures(proxy, TestException.class); + 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 { + private void testWriteOnlyTxWithFindPrimaryShardFailure(final Exception toThrow) { doReturn(Futures.failed(toThrow)).when(mockActorContext).findPrimaryShardAsync(anyString()); - TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, WRITE_ONLY); + TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY); NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); @@ -618,195 +752,132 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready(); - assertTrue(ready instanceof ThreePhaseCommitCohortProxy); + assertTrue(ready instanceof SingleCommitCohortProxy); - ThreePhaseCommitCohortProxy proxy = (ThreePhaseCommitCohortProxy) ready; - - verifyCohortFutures(proxy, toThrow.getClass()); + verifyCohortFutures((SingleCommitCohortProxy)ready, toThrow.getClass()); } @Test - public void testWriteOnlyTxWithPrimaryNotFoundException() throws Exception { + public void testWriteOnlyTxWithPrimaryNotFoundException() { testWriteOnlyTxWithFindPrimaryShardFailure(new PrimaryNotFoundException("mock")); } @Test - public void testWriteOnlyTxWithNotInitializedException() throws Exception { + public void testWriteOnlyTxWithNotInitializedException() { testWriteOnlyTxWithFindPrimaryShardFailure(new NotInitializedException("mock")); } @Test - public void testWriteOnlyTxWithNoShardLeaderException() throws Exception { + public void testWriteOnlyTxWithNoShardLeaderException() { testWriteOnlyTxWithFindPrimaryShardFailure(new NoShardLeaderException("mock")); } @Test - public void testReadyWithInvalidReplyMessageType() throws Exception { + public void testReadyWithInvalidReplyMessageType() { dataStoreContextBuilder.writeOnlyTransactionOptimizationsEnabled(true); - ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY); + ActorRef actorRef1 = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY); - NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); + ActorRef actorRef2 = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY, + TestModel.JUNK_QNAME.getLocalName()); - //expectBatchedModifications(actorRef, 1); + doReturn(Futures.successful(new Object())).when(mockActorContext).executeOperationAsync( + eq(actorSelection(actorRef1)), isA(BatchedModifications.class), any(Timeout.class)); - doReturn(Futures.successful(new Object())).when(mockActorContext). - executeOperationAsync(eq(actorSelection(actorRef)), - isA(BatchedModifications.class)); + expectBatchedModificationsReady(actorRef2); - TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, WRITE_ONLY); + TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY); - transactionProxy.write(TestModel.TEST_PATH, nodeToWrite); + transactionProxy.write(TestModel.JUNK_PATH, ImmutableNodes.containerNode(TestModel.JUNK_QNAME)); + transactionProxy.write(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME)); DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready(); assertTrue(ready instanceof ThreePhaseCommitCohortProxy); - ThreePhaseCommitCohortProxy proxy = (ThreePhaseCommitCohortProxy) ready; - - verifyCohortFutures(proxy, IllegalArgumentException.class); + verifyCohortFutures((ThreePhaseCommitCohortProxy)ready, actorSelection(actorRef2), + IllegalArgumentException.class); } @Test public void testGetIdentifier() { setupActorContextWithInitialCreateTransaction(getSystem(), READ_ONLY); - TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, - TransactionProxy.TransactionType.READ_ONLY); + TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY); 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() { 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(mockActorContext, READ_WRITE); + TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE); transactionProxy.read(TestModel.TEST_PATH); 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(mockActorContext,READ_ONLY); - - // negative test case with null as the reply - doReturn(readDataReply(null)).when(mockActorContext).executeOperationAsync( - any(ActorSelection.class), eqReadData()); - - Optional> 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()); - - doReturn(batchedModificationsReply(1)).when(mockActorContext).executeOperationAsync( - any(ActorSelection.class), isA(BatchedModifications.class)); - - TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, READ_WRITE); - - NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); - transactionProxy.write(TestModel.TEST_PATH, nodeToWrite); - - // testing ready - doReturn(readyTxReply(actorRef.path().toString())).when(mockActorContext).executeOperationAsync( - eq(actorSelection(actorRef)), isA(ReadyTransaction.class)); - - DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready(); - - assertTrue(ready instanceof ThreePhaseCommitCohortProxy); - - ThreePhaseCommitCohortProxy proxy = (ThreePhaseCommitCohortProxy) ready; + private interface TransactionProxyOperation { + void run(TransactionProxy transactionProxy); + } - verifyCohortFutures(proxy, getSystem().actorSelection(actorRef.path())); + private PrimaryShardInfo newPrimaryShardInfo(final ActorRef actorRef) { + return new PrimaryShardInfo(getSystem().actorSelection(actorRef.path()), DataStoreVersions.CURRENT_VERSION); } - private static interface TransactionProxyOperation { - void run(TransactionProxy transactionProxy); + private PrimaryShardInfo newPrimaryShardInfo(final ActorRef actorRef, final DataTree dataTree) { + return new PrimaryShardInfo(getSystem().actorSelection(actorRef.path()), DataStoreVersions.CURRENT_VERSION, + dataTree); } - private void throttleOperation(TransactionProxyOperation operation) { + private void throttleOperation(final TransactionProxyOperation operation) { throttleOperation(operation, 1, true); } - private void throttleOperation(TransactionProxyOperation operation, int outstandingOpsLimit, boolean shardFound){ + private void throttleOperation(final TransactionProxyOperation operation, final int outstandingOpsLimit, + final boolean shardFound) { + throttleOperation(operation, outstandingOpsLimit, shardFound, TimeUnit.MILLISECONDS.toNanos( + mockActorContext.getDatastoreContext().getOperationTimeoutInMillis())); + } + + private void throttleOperation(final TransactionProxyOperation operation, final int outstandingOpsLimit, + final boolean shardFound, final long expectedCompletionTime) { ActorSystem actorSystem = getSystem(); ActorRef shardActorRef = actorSystem.actorOf(Props.create(DoNothingActor.class)); - doReturn(outstandingOpsLimit).when(mockActorContext).getTransactionOutstandingOperationLimit(); + // 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(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(actorSystem.actorSelection(shardActorRef.path()))). - when(mockActorContext).findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD)); } 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(incompleteFuture()).when(mockActorContext).executeOperationAsync( + eq(actorSystem.actorSelection(shardActorRef.path())), eqCreateTransaction(memberName, READ_WRITE), + any(Timeout.class)); - doReturn(Futures.successful(createTransactionReply)).when(mockActorContext). - executeOperationAsync(eq(actorSystem.actorSelection(shardActorRef.path())), - eqCreateTransaction(memberName, READ_WRITE)); - - doReturn(true).when(mockActorContext).isPathLocal(actorPath); - - TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, READ_WRITE); + TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE); long start = System.nanoTime(); @@ -814,48 +885,43 @@ 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); + expectedCompletionTime, end - start), + end - start > expectedCompletionTime && end - start < expectedCompletionTime * 2); } - private void completeOperation(TransactionProxyOperation operation){ + private void completeOperation(final TransactionProxyOperation operation) { completeOperation(operation, true); } - private void completeOperation(TransactionProxyOperation operation, boolean shardFound){ + private void completeOperation(final TransactionProxyOperation operation, final boolean shardFound) { ActorSystem actorSystem = getSystem(); ActorRef shardActorRef = actorSystem.actorOf(Props.create(DoNothingActor.class)); - doReturn(1).when(mockActorContext).getTransactionOutstandingOperationLimit(); - - 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(actorSystem.actorSelection(shardActorRef.path()))). - 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(mockActorContext, READ_WRITE); + TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE); long start = System.nanoTime(); @@ -863,324 +929,374 @@ 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); } - public void testWriteThrottling(boolean shardFound){ + private void completeOperationLocal(final TransactionProxyOperation operation, final 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(Futures.successful(newPrimaryShardInfo(shardActorRef, dataTree))).when(mockActorContext) + .findPrimaryShardAsync(eq(DefaultShardStrategy.DEFAULT_SHARD)); - throttleOperation(new TransactionProxyOperation() { - @Override - public void run(TransactionProxy transactionProxy) { - NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); + TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE); - expectBatchedModifications(2); + long start = System.nanoTime(); - transactionProxy.write(TestModel.TEST_PATH, nodeToWrite); + operation.run(transactionProxy); - transactionProxy.write(TestModel.TEST_PATH, nodeToWrite); - } - }, 1, shardFound); + long end = System.nanoTime(); + + 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 static DataTree createDataTree() { + DataTree dataTree = mock(DataTree.class); + DataTreeSnapshot dataTreeSnapshot = mock(DataTreeSnapshot.class); + DataTreeModification dataTreeModification = mock(DataTreeModification.class); + + doReturn(dataTreeSnapshot).when(dataTree).takeSnapshot(); + doReturn(dataTreeModification).when(dataTreeSnapshot).newModification(); + + return dataTree; + } + + private static DataTree createDataTree(final NormalizedNode readResponse) { + DataTree dataTree = mock(DataTree.class); + DataTreeSnapshot dataTreeSnapshot = mock(DataTreeSnapshot.class); + DataTreeModification dataTreeModification = mock(DataTreeModification.class); + + doReturn(dataTreeSnapshot).when(dataTree).takeSnapshot(); + doReturn(dataTreeModification).when(dataTreeSnapshot).newModification(); + doReturn(java.util.Optional.of(readResponse)).when(dataTreeModification).readNode( + any(YangInstanceIdentifier.class)); + + return dataTree; + } + + @Test - public void testWriteThrottlingWhenShardFound(){ - dataStoreContextBuilder.shardBatchedModificationCount(1); - throttleOperation(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); - expectIncompleteBatchedModifications(); + transactionProxy.write(TestModel.TEST_PATH, nodeToWrite); - transactionProxy.write(TestModel.TEST_PATH, nodeToWrite); + transactionProxy.write(TestModel.TEST_PATH, nodeToWrite); + + }, createDataTree()); + } + + @Test + public void testWriteThrottlingWhenShardFound() { + throttleOperation(transactionProxy -> { + NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); - transactionProxy.write(TestModel.TEST_PATH, nodeToWrite); - } + expectIncompleteBatchedModifications(); + + 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 - dataStoreContextBuilder.shardBatchedModificationCount(1); - 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(){ - dataStoreContextBuilder.shardBatchedModificationCount(1); - 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(){ - dataStoreContextBuilder.shardBatchedModificationCount(1); - 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(){ - dataStoreContextBuilder.shardBatchedModificationCount(1); - 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(){ - dataStoreContextBuilder.shardBatchedModificationCount(1); - 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 testDeleteThrottlingWhenShardFound(){ + public void testMergeCompletionForLocalShard() { + completeOperationLocal(transactionProxy -> { + NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); + + transactionProxy.merge(TestModel.TEST_PATH, nodeToWrite); + + transactionProxy.merge(TestModel.TEST_PATH, nodeToWrite); + + }, createDataTree()); + } + + + @Test + 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 testDeleteCompletion(){ - dataStoreContextBuilder.shardBatchedModificationCount(1); - completeOperation(new TransactionProxyOperation() { - @Override - public void run(TransactionProxy transactionProxy) { - expectBatchedModifications(2); + public void testDeleteCompletionForLocalShard() { + completeOperationLocal(transactionProxy -> { + + transactionProxy.delete(TestModel.TEST_PATH); + + transactionProxy.delete(TestModel.TEST_PATH); + }, createDataTree()); - transactionProxy.delete(TestModel.TEST_PATH); + } + + @Test + public void testDeleteCompletion() { + completeOperation(transactionProxy -> { + expectBatchedModifications(2); - 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 testExistsThrottlingWhenShardFound(){ + 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(transactionProxy -> { + transactionProxy.read(TestModel.TEST_PATH); - throttleOperation(new TransactionProxyOperation() { - @Override - public void run(TransactionProxy transactionProxy) { - doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync( - any(ActorSelection.class), eqDataExists()); + transactionProxy.read(TestModel.TEST_PATH); + }, createDataTree()); - transactionProxy.exists(TestModel.TEST_PATH); + } + + @Test + public void testExistsThrottlingWhenShardFound() { + + 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); }); } @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 testReadyThrottling(){ + public void testExistsCompletionForLocalShard() { + final NormalizedNode nodeToRead = ImmutableNodes.containerNode(TestModel.TEST_QNAME); + completeOperationLocal(transactionProxy -> { + transactionProxy.exists(TestModel.TEST_PATH); - throttleOperation(new TransactionProxyOperation() { - @Override - public void run(TransactionProxy transactionProxy) { - NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); + transactionProxy.exists(TestModel.TEST_PATH); + }, createDataTree(nodeToRead)); - expectBatchedModifications(1); + } - doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync( - any(ActorSelection.class), any(ReadyTransaction.class)); + @Test + public void testExistsCompletionForLocalShardWhenExceptionOccurs() { + completeOperationLocal(transactionProxy -> { + transactionProxy.exists(TestModel.TEST_PATH); - transactionProxy.write(TestModel.TEST_PATH, nodeToWrite); + transactionProxy.exists(TestModel.TEST_PATH); + }, createDataTree()); - transactionProxy.ready(); - } - }); } @Test - public void testReadyThrottlingWithTwoTransactionContexts(){ + public void testReadyThrottling() { + + throttleOperation(transactionProxy -> { + NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); - throttleOperation(new TransactionProxyOperation() { - @Override - public void run(TransactionProxy transactionProxy) { - NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); - NormalizedNode carsNode = ImmutableNodes.containerNode(CarsModel.BASE_QNAME); + expectBatchedModifications(1); - expectBatchedModifications(2); + transactionProxy.write(TestModel.TEST_PATH, nodeToWrite); - doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync( - any(ActorSelection.class), any(ReadyTransaction.class)); + transactionProxy.ready(); + }); + } + + @Test + public void testReadyThrottlingWithTwoTransactionContexts() { + throttleOperation(transactionProxy -> { + NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); + NormalizedNode carsNode = ImmutableNodes.containerNode(CarsModel.BASE_QNAME); + + expectBatchedModifications(2); - transactionProxy.write(TestModel.TEST_PATH, nodeToWrite); + transactionProxy.write(TestModel.TEST_PATH, nodeToWrite); - transactionProxy.write(TestModel.TEST_PATH, carsNode); + // Trying to write to Cars will cause another transaction context to get created + transactionProxy.write(CarsModel.BASE_PATH, carsNode); - transactionProxy.ready(); - } - }, 2, true); + // 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 { + private void testModificationOperationBatching(final TransactionType type) { int shardBatchedModificationCount = 3; dataStoreContextBuilder.shardBatchedModificationCount(shardBatchedModificationCount); @@ -1188,8 +1304,6 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { expectBatchedModifications(actorRef, shardBatchedModificationCount); - expectReadyTransaction(actorRef); - YangInstanceIdentifier writePath1 = TestModel.TEST_PATH; NormalizedNode writeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME); @@ -1211,7 +1325,7 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { YangInstanceIdentifier deletePath1 = TestModel.TEST_PATH; YangInstanceIdentifier deletePath2 = TestModel.OUTER_LIST_PATH; - TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, type); + TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, type); transactionProxy.write(writePath1, writeNode1); transactionProxy.write(writePath2, writeNode2); @@ -1234,37 +1348,30 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { verifyBatchedModifications(batchedModifications.get(1), false, new MergeModification(mergePath1, mergeNode1), new MergeModification(mergePath2, mergeNode2), new WriteModification(writePath3, writeNode3)); - boolean optimizedWriteOnly = type == WRITE_ONLY && dataStoreContextBuilder.build().isWriteOnlyTransactionOptimizationsEnabled(); - verifyBatchedModifications(batchedModifications.get(2), optimizedWriteOnly, new MergeModification(mergePath3, mergeNode3), - new DeleteModification(deletePath2)); + verifyBatchedModifications(batchedModifications.get(2), true, true, + new MergeModification(mergePath3, mergeNode3), new DeleteModification(deletePath2)); - if(optimizedWriteOnly) { - verifyRecordingOperationFutures(transactionProxy.getRecordedOperationFutures(), - BatchedModificationsReply.class, BatchedModificationsReply.class); - } else { - verifyRecordingOperationFutures(transactionProxy.getRecordedOperationFutures(), - BatchedModificationsReply.class, BatchedModificationsReply.class, BatchedModificationsReply.class); - } + assertEquals("getTotalMessageCount", 3, batchedModifications.get(2).getTotalMessagesSent()); } @Test - public void testReadWriteModificationOperationBatching() throws Throwable { + public void testReadWriteModificationOperationBatching() { testModificationOperationBatching(READ_WRITE); } @Test - public void testWriteOnlyModificationOperationBatching() throws Throwable { + public void testWriteOnlyModificationOperationBatching() { testModificationOperationBatching(WRITE_ONLY); } @Test - public void testOptimizedWriteOnlyModificationOperationBatching() throws Throwable { + public void testOptimizedWriteOnlyModificationOperationBatching() { dataStoreContextBuilder.writeOnlyTransactionOptimizationsEnabled(true); testModificationOperationBatching(WRITE_ONLY); } @Test - public void testModificationOperationBatchingWithInterleavedReads() throws Throwable { + public void testModificationOperationBatchingWithInterleavedReads() throws Exception { int shardBatchedModificationCount = 10; dataStoreContextBuilder.shardBatchedModificationCount(shardBatchedModificationCount); @@ -1273,38 +1380,37 @@ 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(mockActorContext, READ_WRITE); + TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE); transactionProxy.write(writePath1, writeNode1); transactionProxy.write(writePath2, writeNode2); - Optional> readOptional = transactionProxy.read(writePath2). - get(5, TimeUnit.SECONDS); + Optional> readOptional = transactionProxy.read(writePath2).get(5, TimeUnit.SECONDS); - assertEquals("NormalizedNode isPresent", true, readOptional.isPresent()); + assertTrue("NormalizedNode isPresent", readOptional.isPresent()); assertEquals("Response NormalizedNode", writeNode2, readOptional.get()); transactionProxy.merge(mergePath1, mergeNode1); @@ -1314,10 +1420,10 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { transactionProxy.delete(deletePath); - Boolean exists = transactionProxy.exists(TestModel.TEST_PATH).checkedGet(); - assertEquals("Exists response", true, exists); + Boolean exists = transactionProxy.exists(TestModel.TEST_PATH).get(); + assertEquals("Exists response", Boolean.TRUE, exists); - assertEquals("NormalizedNode isPresent", true, readOptional.isPresent()); + assertTrue("NormalizedNode isPresent", readOptional.isPresent()); assertEquals("Response NormalizedNode", mergeNode2, readOptional.get()); List batchedModifications = captureBatchedModifications(actorRef); @@ -1333,24 +1439,93 @@ 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 InterruptedException, ExecutionException, + java.util.concurrent.TimeoutException { + SchemaContext schemaContext = SchemaContextHelper.full(); + Configuration configuration = mock(Configuration.class); + doReturn(configuration).when(mockActorContext).getConfiguration(); + doReturn(schemaContext).when(mockActorContext).getSchemaContext(); + doReturn(Sets.newHashSet("test", "cars")).when(configuration).getAllShardNames(); + + NormalizedNode expectedNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME); + NormalizedNode expectedNode2 = ImmutableNodes.containerNode(CarsModel.CARS_QNAME); + + setUpReadData("test", NormalizedNodeAggregatorTest.getRootNode(expectedNode1, schemaContext)); + setUpReadData("cars", NormalizedNodeAggregatorTest.getRootNode(expectedNode2, schemaContext)); + + doReturn(MemberName.forName(memberName)).when(mockActorContext).getCurrentMemberName(); + + doReturn(getSystem().dispatchers().defaultGlobalDispatcher()).when(mockActorContext).getClientDispatcher(); + + TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY); + + Optional> readOptional = transactionProxy.read( + YangInstanceIdentifier.EMPTY).get(5, TimeUnit.SECONDS); + + assertTrue("NormalizedNode isPresent", readOptional.isPresent()); + + NormalizedNode normalizedNode = readOptional.get(); + + assertTrue("Expect value to be a Collection", normalizedNode.getValue() instanceof Collection); + + @SuppressWarnings("unchecked") + Collection> collection = (Collection>) normalizedNode.getValue(); - verifyRecordingOperationFutures(transactionProxy.getRecordedOperationFutures(), - BatchedModificationsReply.class, BatchedModificationsReply.class, BatchedModificationsReply.class); + for (NormalizedNode node : collection) { + assertTrue("Expected " + node + " to be a ContainerNode", node instanceof ContainerNode); + } + + assertTrue("Child with QName = " + TestModel.TEST_QNAME + " not found", + NormalizedNodeAggregatorTest.findChildWithQName(collection, TestModel.TEST_QNAME) != null); + + assertEquals(expectedNode1, NormalizedNodeAggregatorTest.findChildWithQName(collection, TestModel.TEST_QNAME)); + + assertTrue("Child with QName = " + CarsModel.BASE_QNAME + " not found", + NormalizedNodeAggregatorTest.findChildWithQName(collection, CarsModel.BASE_QNAME) != null); + + assertEquals(expectedNode2, NormalizedNodeAggregatorTest.findChildWithQName(collection, CarsModel.BASE_QNAME)); + } + + + private void setUpReadData(final String shardName, final NormalizedNode expectedNode) { + 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)); + + ActorRef txActorRef = actorSystem.actorOf(Props.create(DoNothingActor.class)); + + 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), any(Timeout.class)); + + doReturn(readDataReply(expectedNode)).when(mockActorContext).executeOperationAsync( + eq(actorSelection(txActorRef)), eqReadData(YangInstanceIdentifier.EMPTY), any(Timeout.class)); } }