Bump upstream versions

[controller.git] / opendaylight / md-sal / sal-distributed-datastore / src / test / java / org / opendaylight / controller / cluster / datastore / AbstractTransactionProxyTest.java

diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/AbstractTransactionProxyTest.java b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/AbstractTransactionProxyTest.java
index 41881575ac366656b1e7e0ea15d868379344b0b9..d3ae761b599198a06b12b63774d51d955c19af7b 100644 (file)
--- a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/AbstractTransactionProxyTest.java
+++ b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/AbstractTransactionProxyTest.java
@@ -11,10 +11,10 @@ import static org.junit.Assert.assertEquals;
 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.argThat;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Matchers.isA;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isA;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
@@ -71,12 +71,11 @@ import org.opendaylight.controller.cluster.datastore.modification.WriteModificat
 import org.opendaylight.controller.cluster.datastore.shardstrategy.DefaultShardStrategy;
 import org.opendaylight.controller.cluster.datastore.shardstrategy.ShardStrategy;
 import org.opendaylight.controller.cluster.datastore.shardstrategy.ShardStrategyFactory;
-import org.opendaylight.controller.cluster.datastore.utils.ActorContext;
+import org.opendaylight.controller.cluster.datastore.utils.ActorUtils;
 import org.opendaylight.controller.cluster.datastore.utils.MockConfiguration;
 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.TestModel;
-import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
 import org.opendaylight.mdsal.common.api.ReadFailedException;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
@@ -85,7 +84,7 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import scala.concurrent.Await;
 import scala.concurrent.Future;
-import scala.concurrent.duration.Duration;
+import scala.concurrent.duration.FiniteDuration;
 
 /**
  * Abstract base class for TransactionProxy unit tests.
@@ -105,22 +104,12 @@ public abstract class AbstractTransactionProxyTest extends AbstractTest {
                     public String findShard(final YangInstanceIdentifier path) {
                         return TestModel.JUNK_QNAME.getLocalName();
                     }
-
-                    @Override
-                    public YangInstanceIdentifier getPrefixForPath(final YangInstanceIdentifier path) {
-                        return YangInstanceIdentifier.EMPTY;
-                    }
                 }).put(
                 CarsModel.BASE_QNAME.getLocalName(), new ShardStrategy() {
                     @Override
                     public String findShard(final YangInstanceIdentifier path) {
                         return CarsModel.BASE_QNAME.getLocalName();
                     }
-
-                    @Override
-                    public YangInstanceIdentifier getPrefixForPath(final YangInstanceIdentifier path) {
-                        return YangInstanceIdentifier.EMPTY;
-                    }
                 }).build();
 
         @Override
@@ -130,9 +119,9 @@ public abstract class AbstractTransactionProxyTest extends AbstractTest {
 
         @Override
         public String getModuleNameFromNameSpace(final String nameSpace) {
-            if (TestModel.JUNK_QNAME.getNamespace().toASCIIString().equals(nameSpace)) {
+            if (TestModel.JUNK_QNAME.getNamespace().toString().equals(nameSpace)) {
                 return TestModel.JUNK_QNAME.getLocalName();
-            } else if (CarsModel.BASE_QNAME.getNamespace().toASCIIString().equals(nameSpace)) {
+            } else if (CarsModel.BASE_QNAME.getNamespace().toString().equals(nameSpace)) {
                 return CarsModel.BASE_QNAME.getLocalName();
             }
             return null;
@@ -140,7 +129,7 @@ public abstract class AbstractTransactionProxyTest extends AbstractTest {
     };
 
     @Mock
-    protected ActorContext mockActorContext;
+    protected ActorUtils mockActorContext;
 
     protected TransactionContextFactory mockComponentFactory;
 
@@ -178,13 +167,13 @@ public abstract class AbstractTransactionProxyTest extends AbstractTest {
         doReturn(getSystem()).when(mockActorContext).getActorSystem();
         doReturn(getSystem().dispatchers().defaultGlobalDispatcher()).when(mockActorContext).getClientDispatcher();
         doReturn(MemberName.forName(memberName)).when(mockActorContext).getCurrentMemberName();
-        doReturn(new ShardStrategyFactory(configuration,
-                LogicalDatastoreType.CONFIGURATION)).when(mockActorContext).getShardStrategyFactory();
+        doReturn(new ShardStrategyFactory(configuration)).when(mockActorContext).getShardStrategyFactory();
         doReturn(SCHEMA_CONTEXT).when(mockActorContext).getSchemaContext();
         doReturn(new Timeout(operationTimeoutInSeconds, TimeUnit.SECONDS)).when(mockActorContext).getOperationTimeout();
         doReturn(mockClusterWrapper).when(mockActorContext).getClusterWrapper();
         doReturn(mockClusterWrapper).when(mockActorContext).getClusterWrapper();
         doReturn(dataStoreContextBuilder.build()).when(mockActorContext).getDatastoreContext();
+        doReturn(new Timeout(5, TimeUnit.SECONDS)).when(mockActorContext).getTransactionCommitOperationTimeout();
 
         final ClientIdentifier mockClientId = MockIdentifiers.clientIdentifier(getClass(), memberName);
         mockComponentFactory = new TransactionContextFactory(mockActorContext, mockClientId);
@@ -199,31 +188,26 @@ public abstract class AbstractTransactionProxyTest extends AbstractTest {
 
     protected CreateTransaction eqCreateTransaction(final String expMemberName,
             final TransactionType type) {
-        ArgumentMatcher<CreateTransaction> matcher = new ArgumentMatcher<CreateTransaction>() {
+        class CreateTransactionArgumentMatcher implements ArgumentMatcher<CreateTransaction> {
             @Override
-            public boolean matches(final Object argument) {
-                if (CreateTransaction.class.equals(argument.getClass())) {
-                    CreateTransaction obj = CreateTransaction.fromSerializable(argument);
-                    return obj.getTransactionId().getHistoryId().getClientId().getFrontendId().getMemberName()
-                            .getName().equals(expMemberName) && obj.getTransactionType() == type.ordinal();
-                }
-
-                return false;
+            public boolean matches(final CreateTransaction argument) {
+                return argument.getTransactionId().getHistoryId().getClientId().getFrontendId().getMemberName()
+                        .getName().equals(expMemberName) && argument.getTransactionType() == type.ordinal();
             }
-        };
+        }
 
-        return argThat(matcher);
+        return argThat(new CreateTransactionArgumentMatcher());
     }
 
     protected DataExists eqDataExists() {
-        ArgumentMatcher<DataExists> matcher = new ArgumentMatcher<DataExists>() {
+        class DataExistsArgumentMatcher implements ArgumentMatcher<DataExists> {
             @Override
-            public boolean matches(final Object argument) {
-                return argument instanceof DataExists && ((DataExists)argument).getPath().equals(TestModel.TEST_PATH);
+            public boolean matches(final DataExists argument) {
+                return argument.getPath().equals(TestModel.TEST_PATH);
             }
-        };
+        }
 
-        return argThat(matcher);
+        return argThat(new DataExistsArgumentMatcher());
     }
 
     protected ReadData eqReadData() {
@@ -231,14 +215,14 @@ public abstract class AbstractTransactionProxyTest extends AbstractTest {
     }
 
     protected ReadData eqReadData(final YangInstanceIdentifier path) {
-        ArgumentMatcher<ReadData> matcher = new ArgumentMatcher<ReadData>() {
+        class ReadDataArgumentMatcher implements ArgumentMatcher<ReadData> {
             @Override
-            public boolean matches(final Object argument) {
-                return argument instanceof ReadData && ((ReadData)argument).getPath().equals(path);
+            public boolean matches(final ReadData argument) {
+                return argument.getPath().equals(path);
             }
-        };
+        }
 
-        return argThat(matcher);
+        return argThat(new ReadDataArgumentMatcher());
     }
 
     protected Future<Object> readyTxReply(final String path) {
@@ -246,7 +230,7 @@ public abstract class AbstractTransactionProxyTest extends AbstractTest {
     }
 
 
-    protected Future<ReadDataReply> readDataReply(final NormalizedNode<?, ?> data) {
+    protected Future<ReadDataReply> readDataReply(final NormalizedNode data) {
         return Futures.successful(new ReadDataReply(data, DataStoreVersions.CURRENT_VERSION));
     }
 
@@ -462,7 +446,7 @@ public abstract class AbstractTransactionProxyTest extends AbstractTest {
         for (Future<?> future : proxy.getCohortFutures()) {
             assertNotNull("Ready operation Future is null", future);
             try {
-                futureResults.add(Await.result(future, Duration.create(5, TimeUnit.SECONDS)));
+                futureResults.add(Await.result(future, FiniteDuration.create(5, TimeUnit.SECONDS)));
             } catch (Exception e) {
                 futureResults.add(e);
             }
@@ -474,9 +458,8 @@ public abstract class AbstractTransactionProxyTest extends AbstractTest {
             while (iter.hasNext()) {
                 Object actual = iter.next();
                 if (CommitTransactionReply.isSerializedType(expReply)
-                        && CommitTransactionReply.isSerializedType(actual)) {
-                    found = true;
-                } else if (expReply instanceof ActorSelection && Objects.equals(expReply, actual)) {
+                        && CommitTransactionReply.isSerializedType(actual)
+                        || expReply instanceof ActorSelection && Objects.equals(expReply, actual)) {
                     found = true;
                 } else if (expReply instanceof Class && ((Class<?>) expReply).isInstance(actual)) {
                     found = true;