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;
import akka.actor.ActorSystem;
import akka.actor.Props;
import akka.dispatch.Futures;
-import akka.testkit.JavaTestKit;
+import akka.testkit.javadsl.TestKit;
import akka.util.Timeout;
import com.codahale.metrics.MetricRegistry;
import com.codahale.metrics.Timer;
import com.google.common.base.Throwables;
import com.google.common.collect.ImmutableMap;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
-import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
+import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import org.junit.AfterClass;
import org.junit.Before;
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.controller.md.sal.common.api.data.ReadFailedException;
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;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
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.
protected final Logger log = LoggerFactory.getLogger(getClass());
private static ActorSystem system;
+ private static SchemaContext SCHEMA_CONTEXT;
private final Configuration configuration = new MockConfiguration() {
Map<String, ShardStrategy> strategyMap = ImmutableMap.<String, ShardStrategy>builder().put(
- "junk", new ShardStrategy() {
+ TestModel.JUNK_QNAME.getLocalName(), new ShardStrategy() {
@Override
public String findShard(final YangInstanceIdentifier path) {
- return "junk";
+ return TestModel.JUNK_QNAME.getLocalName();
}
@Override
public YangInstanceIdentifier getPrefixForPath(final YangInstanceIdentifier path) {
- return YangInstanceIdentifier.EMPTY;
+ return YangInstanceIdentifier.empty();
}
}).put(
- "cars", new ShardStrategy() {
+ CarsModel.BASE_QNAME.getLocalName(), new ShardStrategy() {
@Override
public String findShard(final YangInstanceIdentifier path) {
- return "cars";
+ return CarsModel.BASE_QNAME.getLocalName();
}
@Override
public YangInstanceIdentifier getPrefixForPath(final YangInstanceIdentifier path) {
- return YangInstanceIdentifier.EMPTY;
+ return YangInstanceIdentifier.empty();
}
}).build();
@Override
public String getModuleNameFromNameSpace(final String nameSpace) {
if (TestModel.JUNK_QNAME.getNamespace().toASCIIString().equals(nameSpace)) {
- return "junk";
+ return TestModel.JUNK_QNAME.getLocalName();
} else if (CarsModel.BASE_QNAME.getNamespace().toASCIIString().equals(nameSpace)) {
- return "cars";
+ return CarsModel.BASE_QNAME.getLocalName();
}
return null;
}
};
@Mock
- protected ActorContext mockActorContext;
+ protected ActorUtils mockActorContext;
protected TransactionContextFactory mockComponentFactory;
- private SchemaContext schemaContext;
-
@Mock
private ClusterWrapper mockClusterWrapper;
.operationTimeoutInSeconds(operationTimeoutInSeconds);
@BeforeClass
- public static void setUpClass() throws IOException {
+ public static void setUpClass() {
Config config = ConfigFactory.parseMap(ImmutableMap.<String, Object>builder()
.put("akka.actor.default-dispatcher.type",
"akka.testkit.CallingThreadDispatcherConfigurator").build())
.withFallback(ConfigFactory.load());
system = ActorSystem.create("test", config);
+ SCHEMA_CONTEXT = TestModel.createTestContext();
}
@AfterClass
- public static void tearDownClass() throws IOException {
- JavaTestKit.shutdownActorSystem(system);
+ public static void tearDownClass() {
+ TestKit.shutdownActorSystem(system);
system = null;
+ SCHEMA_CONTEXT = null;
}
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
- schemaContext = TestModel.createTestContext();
-
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(schemaContext).when(mockActorContext).getSchemaContext();
+ 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);
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(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(DataExists argument) {
+ return argument.getPath().equals(TestModel.TEST_PATH);
}
- };
+ }
- return argThat(matcher);
+ return argThat(new DataExistsArgumentMatcher());
}
protected ReadData eqReadData() {
}
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(ReadData argument) {
+ return argument.getPath().equals(path);
}
- };
+ }
- return argThat(matcher);
+ return argThat(new ReadDataArgumentMatcher());
}
protected Future<Object> readyTxReply(final String path) {
shardName);
}
- @SuppressWarnings("checkstyle:avoidHidingCauseException")
- protected void propagateReadFailedExceptionCause(final CheckedFuture<?, ReadFailedException> future)
- throws Exception {
+ @SuppressWarnings({"checkstyle:avoidHidingCauseException", "checkstyle:IllegalThrows"})
+ protected void propagateReadFailedExceptionCause(final FluentFuture<?> future) throws Throwable {
try {
- future.checkedGet(5, TimeUnit.SECONDS);
+ future.get(5, TimeUnit.SECONDS);
fail("Expected ReadFailedException");
- } catch (ReadFailedException e) {
- assertNotNull("Expected a cause", e.getCause());
- Throwable cause;
- if (e.getCause().getCause() != null) {
- cause = e.getCause().getCause();
- } else {
- cause = e.getCause();
- }
-
- Throwables.propagateIfPossible(cause, Exception.class);
- throw new RuntimeException(cause);
+ } catch (ExecutionException e) {
+ final Throwable cause = e.getCause();
+ assertTrue("Unexpected cause: " + cause.getClass(), cause instanceof ReadFailedException);
+ throw Throwables.getRootCause(cause);
}
}
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);
}
Code Review / controller.git / blobdiff