X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-distributed-datastore%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fcluster%2Fdatastore%2FTransactionProxyTest.java;h=ce1d6f6948482102fdd83ea211b5428a60f0c577;hb=24ee386f244cafa9bd3126ddbba1435969aa76c2;hp=5ab1e5ade3fc5a2333fe14f3f31d36733019d133;hpb=5464f50be733df1bbbe31cf05665d542d3b7c5e7;p=controller.git 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 5ab1e5ade3..ce1d6f6948 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 @@ -5,16 +5,16 @@ * 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.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.doThrow; import static org.mockito.Mockito.mock; @@ -29,20 +29,24 @@ 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.ImmutableSortedSet; import com.google.common.collect.Sets; -import com.google.common.util.concurrent.CheckedFuture; +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.access.concepts.MemberName; @@ -56,6 +60,7 @@ 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.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; @@ -65,8 +70,8 @@ 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.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; @@ -74,10 +79,10 @@ 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 org.opendaylight.yangtools.yang.model.api.SchemaContext; +import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext; import scala.concurrent.Promise; -@SuppressWarnings("resource") +@SuppressWarnings({"resource", "checkstyle:IllegalThrows", "checkstyle:AvoidHidingCauseException"}) public class TransactionProxyTest extends AbstractTransactionProxyTest { @SuppressWarnings("serial") @@ -85,7 +90,7 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { } interface Invoker { - CheckedFuture invoke(TransactionProxy proxy) throws Exception; + FluentFuture invoke(TransactionProxy proxy); } @Test @@ -97,25 +102,25 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { doReturn(readDataReply(null)).when(mockActorContext).executeOperationAsync( eq(actorSelection(actorRef)), eqReadData(), any(Timeout.class)); - Optional> readOptional = transactionProxy.read( + 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); + NormalizedNode expectedNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME); 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) @@ -123,11 +128,15 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { 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 Exception { + public void testReadWithAsyncRemoteOperatonFailure() throws Throwable { ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_ONLY); doReturn(Futures.failed(new TestException())).when(mockActorContext) @@ -138,7 +147,8 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { propagateReadFailedExceptionCause(transactionProxy.read(TestModel.TEST_PATH)); } - private void testExceptionOnInitialCreateTransaction(Exception exToThrow, Invoker invoker) throws Exception { + private void testExceptionOnInitialCreateTransaction(final Exception exToThrow, final Invoker invoker) + throws Throwable { ActorRef actorRef = getSystem().actorOf(Props.create(DoNothingActor.class)); if (exToThrow instanceof PrimaryNotFoundException) { @@ -156,23 +166,23 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { propagateReadFailedExceptionCause(invoker.invoke(transactionProxy)); } - private void testReadWithExceptionOnInitialCreateTransaction(Exception exToThrow) throws Exception { + private void testReadWithExceptionOnInitialCreateTransaction(final Exception exToThrow) throws Throwable { testExceptionOnInitialCreateTransaction(exToThrow, proxy -> proxy.read(TestModel.TEST_PATH)); } @Test(expected = PrimaryNotFoundException.class) - public void testReadWhenAPrimaryNotFoundExceptionIsThrown() throws Exception { + public void testReadWhenAPrimaryNotFoundExceptionIsThrown() throws Throwable { testReadWithExceptionOnInitialCreateTransaction(new PrimaryNotFoundException("test")); } - @Test(expected = TimeoutException.class) - public void testReadWhenATimeoutExceptionIsThrown() throws Exception { + @Test(expected = TestException.class) + public void testReadWhenATimeoutExceptionIsThrown() throws Throwable { testReadWithExceptionOnInitialCreateTransaction(new TimeoutException("test", - new Exception("reason"))); + new TestException())); } @Test(expected = TestException.class) - public void testReadWhenAnyOtherExceptionIsThrown() throws Exception { + public void testReadWhenAnyOtherExceptionIsThrown() throws Throwable { testReadWithExceptionOnInitialCreateTransaction(new TestException()); } @@ -180,7 +190,7 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { public void testReadWithPriorRecordingOperationSuccessful() throws Exception { ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE); - NormalizedNode expectedNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME); + NormalizedNode expectedNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME); expectBatchedModifications(actorRef, 1); @@ -191,10 +201,10 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { transactionProxy.write(TestModel.TEST_PATH, expectedNode); - Optional> readOptional = transactionProxy.read( + 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); @@ -212,7 +222,7 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { } @Test(expected = IllegalArgumentException.class) - public void testInvalidCreateTransactionReply() throws Exception { + public void testInvalidCreateTransactionReply() throws Throwable { ActorRef actorRef = getSystem().actorOf(Props.create(DoNothingActor.class)); doReturn(getSystem().actorSelection(actorRef.path())).when(mockActorContext) @@ -239,26 +249,26 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { 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(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 Exception { + public void testExistsWhenAPrimaryNotFoundExceptionIsThrown() throws Throwable { 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) @@ -266,11 +276,15 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { 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 Exception { + public void testExistsWithAsyncRemoteOperatonFailure() throws Throwable { ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_ONLY); doReturn(Futures.failed(new TestException())).when(mockActorContext) @@ -285,7 +299,7 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { public void testExistsWithPriorRecordingOperationSuccessful() throws Exception { ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE); - NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); + NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); expectBatchedModifications(actorRef, 1); @@ -296,9 +310,9 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { 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( @@ -315,11 +329,11 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { } @Test - public void testWrite() throws Exception { + public void testWrite() { dataStoreContextBuilder.shardBatchedModificationCount(1); ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY); - NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); + NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); expectBatchedModifications(actorRef, 1); @@ -346,16 +360,16 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { expectBatchedModificationsReady(actorRef); - final NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); + final NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); 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>>() { + new FutureCallback>() { @Override - public void onSuccess(Optional> result) { + public void onSuccess(final Optional result) { try { transactionProxy.write(TestModel.TEST_PATH, nodeToWrite); } catch (Exception e) { @@ -366,19 +380,20 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { } @Override - public void onFailure(Throwable failure) { + 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) { - Throwables.propagateIfInstanceOf(caughtEx.get(), Exception.class); - Throwables.propagate(caughtEx.get()); + final Throwable t = caughtEx.get(); + if (t != null) { + Throwables.propagateIfPossible(t, Exception.class); + throw new RuntimeException(t); } // This sends the batched modification. @@ -403,11 +418,11 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { } @Test - public void testMerge() throws Exception { + public void testMerge() { dataStoreContextBuilder.shardBatchedModificationCount(1); ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY); - NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); + NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); expectBatchedModifications(actorRef, 1); @@ -419,7 +434,7 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { } @Test - public void testDelete() throws Exception { + public void testDelete() { dataStoreContextBuilder.shardBatchedModificationCount(1); ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY); @@ -433,10 +448,10 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { } @Test - public void testReadWrite() throws Exception { + public void testReadWrite() { ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE); - final NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); + final NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); doReturn(readDataReply(null)).when(mockActorContext).executeOperationAsync( eq(actorSelection(actorRef)), eqReadData(), any(Timeout.class)); @@ -461,10 +476,10 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { } @Test - public void testReadyWithReadWrite() throws Exception { + public void testReadyWithReadWrite() { ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE); - final NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); + final NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); doReturn(readDataReply(null)).when(mockActorContext).executeOperationAsync( eq(actorSelection(actorRef)), eqReadData(), any(Timeout.class)); @@ -493,7 +508,7 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { } @Test - public void testReadyWithNoModifications() throws Exception { + public void testReadyWithNoModifications() { ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE); doReturn(readDataReply(null)).when(mockActorContext).executeOperationAsync( @@ -518,34 +533,68 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { } @Test - public void testReadyWithMultipleShardWrites() throws Exception { + public void testReadyWithMultipleShardWrites() { ActorRef actorRef1 = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY); - ActorRef actorRef2 = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY, "junk"); + 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); verifyCohortFutures((ThreePhaseCommitCohortProxy)ready, actorSelection(actorRef1), - actorSelection(actorRef2)); + actorSelection(actorRef2), actorSelection(actorRef3)); + + SortedSet expShardNames = + ImmutableSortedSet.of(DefaultShardStrategy.DEFAULT_SHARD, + TestModel.JUNK_QNAME.getLocalName(), CarsModel.BASE_QNAME.getLocalName()); + + 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()); + + 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()); + + 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); + NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); expectBatchedModificationsReady(actorRef, true); @@ -567,11 +616,11 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { } @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); + NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); expectBatchedModificationsReady(actorRef, true); @@ -595,12 +644,12 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { } @Test - public void testReadyWithReplyFailure() throws Exception { + public void testReadyWithReplyFailure() { dataStoreContextBuilder.writeOnlyTransactionOptimizationsEnabled(true); ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY); - NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); + NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); expectFailedBatchedModifications(actorRef); @@ -616,7 +665,7 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { } @Test - public void testReadyWithDebugContextEnabled() throws Exception { + public void testReadyWithDebugContextEnabled() { dataStoreContextBuilder.transactionDebugContextEnabled(true); ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE); @@ -635,7 +684,7 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { } @Test - public void testReadyWithLocalTransaction() throws Exception { + public void testReadyWithLocalTransaction() { ActorRef shardActorRef = getSystem().actorOf(Props.create(DoNothingActor.class)); doReturn(getSystem().actorSelection(shardActorRef.path())).when(mockActorContext) @@ -648,16 +697,21 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { expectReadyLocalTransaction(shardActorRef, true); - NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); + 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()); + + 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() throws Exception { + public void testReadyWithLocalTransactionWithFailure() { ActorRef shardActorRef = getSystem().actorOf(Props.create(DoNothingActor.class)); doReturn(getSystem().actorSelection(shardActorRef.path())).when(mockActorContext) @@ -674,7 +728,7 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { expectReadyLocalTransaction(shardActorRef, true); - NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); + NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); transactionProxy.write(TestModel.TEST_PATH, nodeToWrite); DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready(); @@ -682,12 +736,12 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { 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(mockComponentFactory, WRITE_ONLY); - NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); + NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); transactionProxy.merge(TestModel.TEST_PATH, nodeToWrite); @@ -703,26 +757,27 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { } @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 actorRef1 = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY); - ActorRef actorRef2 = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY, "junk"); + ActorRef actorRef2 = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY, + TestModel.JUNK_QNAME.getLocalName()); doReturn(Futures.successful(new Object())).when(mockActorContext).executeOperationAsync( eq(actorSelection(actorRef1)), isA(BatchedModifications.class), any(Timeout.class)); @@ -753,7 +808,7 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { } @Test - public void testClose() throws Exception { + public void testClose() { ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE); doReturn(readDataReply(null)).when(mockActorContext).executeOperationAsync( @@ -773,26 +828,27 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { void run(TransactionProxy transactionProxy); } - private PrimaryShardInfo newPrimaryShardInfo(ActorRef actorRef) { + private PrimaryShardInfo newPrimaryShardInfo(final ActorRef actorRef) { return new PrimaryShardInfo(getSystem().actorSelection(actorRef.path()), DataStoreVersions.CURRENT_VERSION); } - private PrimaryShardInfo newPrimaryShardInfo(ActorRef actorRef, DataTree dataTree) { + 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(TransactionProxyOperation operation, int outstandingOpsLimit, boolean shardFound, - long expectedCompletionTime) { + 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)); @@ -834,11 +890,11 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { } - 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)); @@ -878,7 +934,7 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { expected, end - start), end - start <= expected); } - private void completeOperationLocal(TransactionProxyOperation operation, DataTree dataTree) { + private void completeOperationLocal(final TransactionProxyOperation operation, final DataTree dataTree) { ActorSystem actorSystem = getSystem(); ActorRef shardActorRef = actorSystem.actorOf(Props.create(DoNothingActor.class)); @@ -913,7 +969,7 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { return dataTree; } - private static DataTree createDataTree(NormalizedNode readResponse) { + private static DataTree createDataTree(final NormalizedNode readResponse) { DataTree dataTree = mock(DataTree.class); DataTreeSnapshot dataTreeSnapshot = mock(DataTreeSnapshot.class); DataTreeModification dataTreeModification = mock(DataTreeModification.class); @@ -929,7 +985,7 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { @Test public void testWriteCompletionForLocalShard() { completeOperationLocal(transactionProxy -> { - NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); + NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); transactionProxy.write(TestModel.TEST_PATH, nodeToWrite); @@ -941,7 +997,7 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { @Test public void testWriteThrottlingWhenShardFound() { throttleOperation(transactionProxy -> { - NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); + NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); expectIncompleteBatchedModifications(); @@ -955,7 +1011,7 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { public void testWriteThrottlingWhenShardNotFound() { // Confirm that there is no throttling when the Shard is not found completeOperation(transactionProxy -> { - NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); + NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); expectBatchedModifications(2); @@ -970,7 +1026,7 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { @Test public void testWriteCompletion() { completeOperation(transactionProxy -> { - NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); + NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); expectBatchedModifications(2); @@ -983,7 +1039,7 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { @Test public void testMergeThrottlingWhenShardFound() { throttleOperation(transactionProxy -> { - NormalizedNode nodeToMerge = ImmutableNodes.containerNode(TestModel.TEST_QNAME); + NormalizedNode nodeToMerge = ImmutableNodes.containerNode(TestModel.TEST_QNAME); expectIncompleteBatchedModifications(); @@ -996,7 +1052,7 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { @Test public void testMergeThrottlingWhenShardNotFound() { completeOperation(transactionProxy -> { - NormalizedNode nodeToMerge = ImmutableNodes.containerNode(TestModel.TEST_QNAME); + NormalizedNode nodeToMerge = ImmutableNodes.containerNode(TestModel.TEST_QNAME); expectBatchedModifications(2); @@ -1009,7 +1065,7 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { @Test public void testMergeCompletion() { completeOperation(transactionProxy -> { - NormalizedNode nodeToMerge = ImmutableNodes.containerNode(TestModel.TEST_QNAME); + NormalizedNode nodeToMerge = ImmutableNodes.containerNode(TestModel.TEST_QNAME); expectBatchedModifications(2); @@ -1023,7 +1079,7 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { @Test public void testMergeCompletionForLocalShard() { completeOperationLocal(transactionProxy -> { - NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); + NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); transactionProxy.merge(TestModel.TEST_PATH, nodeToWrite); @@ -1111,7 +1167,7 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { @Test public void testReadCompletion() { completeOperation(transactionProxy -> { - NormalizedNode nodeToRead = ImmutableNodes.containerNode(TestModel.TEST_QNAME); + NormalizedNode nodeToRead = ImmutableNodes.containerNode(TestModel.TEST_QNAME); doReturn(readDataReply(nodeToRead)).when(mockActorContext).executeOperationAsync( any(ActorSelection.class), eqReadData(), any(Timeout.class)); @@ -1125,7 +1181,7 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { @Test public void testReadCompletionForLocalShard() { - final NormalizedNode nodeToRead = ImmutableNodes.containerNode(TestModel.TEST_QNAME); + final NormalizedNode nodeToRead = ImmutableNodes.containerNode(TestModel.TEST_QNAME); completeOperationLocal(transactionProxy -> { transactionProxy.read(TestModel.TEST_PATH); @@ -1186,7 +1242,7 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { @Test public void testExistsCompletionForLocalShard() { - final NormalizedNode nodeToRead = ImmutableNodes.containerNode(TestModel.TEST_QNAME); + final NormalizedNode nodeToRead = ImmutableNodes.containerNode(TestModel.TEST_QNAME); completeOperationLocal(transactionProxy -> { transactionProxy.exists(TestModel.TEST_PATH); @@ -1209,7 +1265,7 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { public void testReadyThrottling() { throttleOperation(transactionProxy -> { - NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); + NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); expectBatchedModifications(1); @@ -1222,8 +1278,8 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { @Test public void testReadyThrottlingWithTwoTransactionContexts() { throttleOperation(transactionProxy -> { - NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); - NormalizedNode carsNode = ImmutableNodes.containerNode(CarsModel.BASE_QNAME); + NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME); + NormalizedNode carsNode = ImmutableNodes.containerNode(CarsModel.BASE_QNAME); expectBatchedModifications(2); @@ -1238,7 +1294,7 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { .getOperationTimeoutInMillis()) * 2); } - private void testModificationOperationBatching(TransactionType type) throws Exception { + private void testModificationOperationBatching(final TransactionType type) { int shardBatchedModificationCount = 3; dataStoreContextBuilder.shardBatchedModificationCount(shardBatchedModificationCount); @@ -1247,22 +1303,22 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { expectBatchedModifications(actorRef, shardBatchedModificationCount); YangInstanceIdentifier writePath1 = TestModel.TEST_PATH; - NormalizedNode writeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME); + NormalizedNode writeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME); YangInstanceIdentifier writePath2 = TestModel.OUTER_LIST_PATH; - NormalizedNode writeNode2 = ImmutableNodes.containerNode(TestModel.OUTER_LIST_QNAME); + NormalizedNode writeNode2 = ImmutableNodes.containerNode(TestModel.OUTER_LIST_QNAME); YangInstanceIdentifier writePath3 = TestModel.INNER_LIST_PATH; - NormalizedNode writeNode3 = ImmutableNodes.containerNode(TestModel.INNER_LIST_QNAME); + NormalizedNode writeNode3 = ImmutableNodes.containerNode(TestModel.INNER_LIST_QNAME); YangInstanceIdentifier mergePath1 = TestModel.TEST_PATH; - NormalizedNode mergeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME); + NormalizedNode mergeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME); YangInstanceIdentifier mergePath2 = TestModel.OUTER_LIST_PATH; - NormalizedNode mergeNode2 = ImmutableNodes.containerNode(TestModel.OUTER_LIST_QNAME); + NormalizedNode mergeNode2 = ImmutableNodes.containerNode(TestModel.OUTER_LIST_QNAME); YangInstanceIdentifier mergePath3 = TestModel.INNER_LIST_PATH; - NormalizedNode mergeNode3 = ImmutableNodes.containerNode(TestModel.INNER_LIST_QNAME); + NormalizedNode mergeNode3 = ImmutableNodes.containerNode(TestModel.INNER_LIST_QNAME); YangInstanceIdentifier deletePath1 = TestModel.TEST_PATH; YangInstanceIdentifier deletePath2 = TestModel.OUTER_LIST_PATH; @@ -1297,17 +1353,17 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { } @Test - public void testReadWriteModificationOperationBatching() throws Exception { + public void testReadWriteModificationOperationBatching() { testModificationOperationBatching(READ_WRITE); } @Test - public void testWriteOnlyModificationOperationBatching() throws Exception { + public void testWriteOnlyModificationOperationBatching() { testModificationOperationBatching(WRITE_ONLY); } @Test - public void testOptimizedWriteOnlyModificationOperationBatching() throws Exception { + public void testOptimizedWriteOnlyModificationOperationBatching() { dataStoreContextBuilder.writeOnlyTransactionOptimizationsEnabled(true); testModificationOperationBatching(WRITE_ONLY); } @@ -1323,16 +1379,16 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { expectBatchedModifications(actorRef, shardBatchedModificationCount); final YangInstanceIdentifier writePath1 = TestModel.TEST_PATH; - final NormalizedNode writeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME); + final NormalizedNode writeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME); YangInstanceIdentifier writePath2 = TestModel.OUTER_LIST_PATH; - NormalizedNode writeNode2 = ImmutableNodes.containerNode(TestModel.OUTER_LIST_QNAME); + NormalizedNode writeNode2 = ImmutableNodes.containerNode(TestModel.OUTER_LIST_QNAME); final YangInstanceIdentifier mergePath1 = TestModel.TEST_PATH; - final NormalizedNode mergeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME); + final NormalizedNode mergeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME); YangInstanceIdentifier mergePath2 = TestModel.INNER_LIST_PATH; - NormalizedNode mergeNode2 = ImmutableNodes.containerNode(TestModel.INNER_LIST_QNAME); + NormalizedNode mergeNode2 = ImmutableNodes.containerNode(TestModel.INNER_LIST_QNAME); final YangInstanceIdentifier deletePath = TestModel.OUTER_LIST_PATH; @@ -1350,9 +1406,9 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { 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); @@ -1362,10 +1418,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); @@ -1400,16 +1456,15 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { } @Test - public void testReadRoot() throws ReadFailedException, InterruptedException, ExecutionException, - java.util.concurrent.TimeoutException { - SchemaContext schemaContext = SchemaContextHelper.full(); + public void testReadRoot() throws InterruptedException, ExecutionException, java.util.concurrent.TimeoutException { + EffectiveModelContext 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); + 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)); @@ -1420,19 +1475,19 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY); - Optional> readOptional = transactionProxy.read( - YangInstanceIdentifier.EMPTY).get(5, TimeUnit.SECONDS); + Optional readOptional = transactionProxy.read( + YangInstanceIdentifier.empty()).get(5, TimeUnit.SECONDS); - assertEquals("NormalizedNode isPresent", true, readOptional.isPresent()); + assertTrue("NormalizedNode isPresent", readOptional.isPresent()); - NormalizedNode normalizedNode = readOptional.get(); + NormalizedNode normalizedNode = readOptional.get(); - assertTrue("Expect value to be a Collection", normalizedNode.getValue() instanceof Collection); + assertTrue("Expect value to be a Collection", normalizedNode.body() instanceof Collection); @SuppressWarnings("unchecked") - Collection> collection = (Collection>) normalizedNode.getValue(); + Collection collection = (Collection) normalizedNode.body(); - for (NormalizedNode node : collection) { + for (NormalizedNode node : collection) { assertTrue("Expected " + node + " to be a ContainerNode", node instanceof ContainerNode); } @@ -1448,7 +1503,7 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { } - private void setUpReadData(String shardName, NormalizedNode expectedNode) { + private void setUpReadData(final String shardName, final NormalizedNode expectedNode) { ActorSystem actorSystem = getSystem(); ActorRef shardActorRef = getSystem().actorOf(Props.create(DoNothingActor.class)); @@ -1468,6 +1523,6 @@ public class TransactionProxyTest extends AbstractTransactionProxyTest { eqCreateTransaction(memberName, TransactionType.READ_ONLY), any(Timeout.class)); doReturn(readDataReply(expectedNode)).when(mockActorContext).executeOperationAsync( - eq(actorSelection(txActorRef)), eqReadData(YangInstanceIdentifier.EMPTY), any(Timeout.class)); + eq(actorSelection(txActorRef)), eqReadData(YangInstanceIdentifier.empty()), any(Timeout.class)); } }