* 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;
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", "checkstyle:IllegalThrows", "checkstyle:AvoidHidingCauseException"})
}
interface Invoker {
- FluentFuture<?> invoke(TransactionProxy proxy) throws Exception;
+ FluentFuture<?> invoke(TransactionProxy proxy);
}
@Test
Optional<NormalizedNode<?, ?>> 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);
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());
}
Optional<NormalizedNode<?, ?>> 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);
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).get();
- assertEquals("Exists response", true, exists);
+ assertEquals("Exists response", Boolean.TRUE, exists);
}
@Test(expected = PrimaryNotFoundException.class)
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(
}
@Test
- public void testWrite() throws Exception {
+ public void testWrite() {
dataStoreContextBuilder.shardBatchedModificationCount(1);
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
}
@Test
- public void testMerge() throws Exception {
+ public void testMerge() {
dataStoreContextBuilder.shardBatchedModificationCount(1);
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
}
@Test
- public void testDelete() throws Exception {
+ public void testDelete() {
dataStoreContextBuilder.shardBatchedModificationCount(1);
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
}
@Test
- public void testReadWrite() throws Exception {
+ public void testReadWrite() {
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
final NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
}
@Test
- public void testReadyWithReadWrite() throws Exception {
+ public void testReadyWithReadWrite() {
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
final NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
}
@Test
- public void testReadyWithNoModifications() throws Exception {
+ public void testReadyWithNoModifications() {
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
doReturn(readDataReply(null)).when(mockActorContext).executeOperationAsync(
}
@Test
- public void testReadyWithMultipleShardWrites() throws Exception {
+ public void testReadyWithMultipleShardWrites() {
ActorRef actorRef1 = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
ActorRef actorRef2 = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY,
ArgumentCaptor<BatchedModifications> batchedMods = ArgumentCaptor.forClass(BatchedModifications.class);
verify(mockActorContext).executeOperationAsync(
eq(actorSelection(actorRef1)), batchedMods.capture(), any(Timeout.class));
- assertEquals("Participating shards present", true,
- batchedMods.getValue().getParticipatingShardNames().isPresent());
+ 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));
- assertEquals("Participating shards present", true,
- batchedMods.getValue().getParticipatingShardNames().isPresent());
+ assertTrue("Participating shards present", batchedMods.getValue().getParticipatingShardNames().isPresent());
assertEquals("Participating shards", expShardNames, batchedMods.getValue().getParticipatingShardNames().get());
ArgumentCaptor<ReadyLocalTransaction> readyLocalTx = ArgumentCaptor.forClass(ReadyLocalTransaction.class);
verify(mockActorContext).executeOperationAsync(
eq(actorSelection(actorRef3)), readyLocalTx.capture(), any(Timeout.class));
- assertEquals("Participating shards present", true,
- readyLocalTx.getValue().getParticipatingShardNames().isPresent());
+ 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);
}
@Test
- public void testReadyWithWriteOnlyAndLastBatchEmpty() throws Exception {
+ public void testReadyWithWriteOnlyAndLastBatchEmpty() {
dataStoreContextBuilder.shardBatchedModificationCount(1).writeOnlyTransactionOptimizationsEnabled(true);
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
}
@Test
- public void testReadyWithReplyFailure() throws Exception {
+ public void testReadyWithReplyFailure() {
dataStoreContextBuilder.writeOnlyTransactionOptimizationsEnabled(true);
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
}
@Test
- public void testReadyWithDebugContextEnabled() throws Exception {
+ public void testReadyWithDebugContextEnabled() {
dataStoreContextBuilder.transactionDebugContextEnabled(true);
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
}
@Test
- public void testReadyWithLocalTransaction() throws Exception {
+ public void testReadyWithLocalTransaction() {
ActorRef shardActorRef = getSystem().actorOf(Props.create(DoNothingActor.class));
doReturn(getSystem().actorSelection(shardActorRef.path())).when(mockActorContext)
ArgumentCaptor<ReadyLocalTransaction> readyLocalTx = ArgumentCaptor.forClass(ReadyLocalTransaction.class);
verify(mockActorContext).executeOperationAsync(
eq(actorSelection(shardActorRef)), readyLocalTx.capture(), any(Timeout.class));
- assertEquals("Participating shards present", false,
- readyLocalTx.getValue().getParticipatingShardNames().isPresent());
+ 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)
verifyCohortFutures((SingleCommitCohortProxy)ready, RuntimeException.class);
}
- private void testWriteOnlyTxWithFindPrimaryShardFailure(final 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);
}
@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);
}
@Test
- public void testClose() throws Exception {
+ public void testClose() {
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
doReturn(readDataReply(null)).when(mockActorContext).executeOperationAsync(
doReturn(dataTreeSnapshot).when(dataTree).takeSnapshot();
doReturn(dataTreeModification).when(dataTreeSnapshot).newModification();
- doReturn(java.util.Optional.of(readResponse)).when(dataTreeModification).readNode(
- any(YangInstanceIdentifier.class));
+ doReturn(Optional.of(readResponse)).when(dataTreeModification).readNode(any(YangInstanceIdentifier.class));
return dataTree;
}
.getOperationTimeoutInMillis()) * 2);
}
- private void testModificationOperationBatching(final TransactionType type) throws Exception {
+ private void testModificationOperationBatching(final TransactionType type) {
int shardBatchedModificationCount = 3;
dataStoreContextBuilder.shardBatchedModificationCount(shardBatchedModificationCount);
}
@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);
}
Optional<NormalizedNode<?, ?>> 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);
transactionProxy.delete(deletePath);
Boolean exists = transactionProxy.exists(TestModel.TEST_PATH).get();
- assertEquals("Exists response", true, exists);
+ 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> batchedModifications = captureBatchedModifications(actorRef);
}
@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();
TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(
- YangInstanceIdentifier.EMPTY).get(5, TimeUnit.SECONDS);
+ YangInstanceIdentifier.empty()).get(5, TimeUnit.SECONDS);
- assertEquals("NormalizedNode isPresent", true, readOptional.isPresent());
+ assertTrue("NormalizedNode isPresent", readOptional.isPresent());
NormalizedNode<?, ?> normalizedNode = readOptional.get();
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));
}
}