+/*
+ * 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.mockito.Mockito.doThrow;
+
import akka.actor.ActorRef;
import akka.actor.Props;
+import akka.actor.Status.Failure;
import akka.actor.Terminated;
+import akka.dispatch.Dispatchers;
import akka.testkit.JavaTestKit;
import akka.testkit.TestActorRef;
-import com.google.common.util.concurrent.MoreExecutors;
-import java.util.Collections;
+import com.google.common.base.Throwables;
import java.util.concurrent.TimeUnit;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InOrder;
import org.mockito.Mockito;
-import org.opendaylight.controller.cluster.datastore.ShardWriteTransaction.GetCompositeModificationReply;
-import org.opendaylight.controller.cluster.datastore.exceptions.UnknownMessageException;
+import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
import org.opendaylight.controller.cluster.datastore.identifiers.ShardIdentifier;
-import org.opendaylight.controller.cluster.datastore.jmx.mbeans.shard.ShardStats;
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.CloseTransactionReply;
-import org.opendaylight.controller.cluster.datastore.messages.CreateSnapshot;
+import org.opendaylight.controller.cluster.datastore.messages.CommitTransactionReply;
import org.opendaylight.controller.cluster.datastore.messages.DataExists;
import org.opendaylight.controller.cluster.datastore.messages.DataExistsReply;
-import org.opendaylight.controller.cluster.datastore.messages.DeleteData;
-import org.opendaylight.controller.cluster.datastore.messages.DeleteDataReply;
-import org.opendaylight.controller.cluster.datastore.messages.MergeData;
-import org.opendaylight.controller.cluster.datastore.messages.MergeDataReply;
import org.opendaylight.controller.cluster.datastore.messages.ReadData;
import org.opendaylight.controller.cluster.datastore.messages.ReadDataReply;
-import org.opendaylight.controller.cluster.datastore.messages.ReadyTransaction;
import org.opendaylight.controller.cluster.datastore.messages.ReadyTransactionReply;
-import org.opendaylight.controller.cluster.datastore.messages.WriteData;
-import org.opendaylight.controller.cluster.datastore.messages.WriteDataReply;
-import org.opendaylight.controller.cluster.datastore.modification.CompositeModification;
import org.opendaylight.controller.cluster.datastore.modification.DeleteModification;
import org.opendaylight.controller.cluster.datastore.modification.MergeModification;
-import org.opendaylight.controller.cluster.datastore.modification.Modification;
import org.opendaylight.controller.cluster.datastore.modification.WriteModification;
-import org.opendaylight.controller.cluster.datastore.node.NormalizedNodeToNodeCodec;
-import org.opendaylight.controller.cluster.datastore.node.NormalizedNodeToNodeCodec.Encoded;
-import org.opendaylight.controller.cluster.datastore.utils.SerializationUtils;
-import org.opendaylight.controller.cluster.raft.base.messages.CaptureSnapshotReply;
+import org.opendaylight.controller.cluster.raft.TestActorFactory;
import org.opendaylight.controller.md.cluster.datastore.model.TestModel;
-import org.opendaylight.controller.md.sal.dom.store.impl.InMemoryDOMDataStore;
-import org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages;
-import org.opendaylight.controller.sal.core.spi.data.DOMStoreTransaction;
-import org.opendaylight.controller.sal.core.spi.data.DOMStoreWriteTransaction;
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.DataTreeModification;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
public class ShardTransactionTest extends AbstractActorTest {
- private static final SchemaContext testSchemaContext = TestModel.createTestContext();
+ private static final TransactionType RO = TransactionType.READ_ONLY;
+ private static final TransactionType RW = TransactionType.READ_WRITE;
+ private static final TransactionType WO = TransactionType.WRITE_ONLY;
private static final ShardIdentifier SHARD_IDENTIFIER =
- ShardIdentifier.builder().memberName("member-1")
- .shardName("inventory").type("config").build();
+ ShardIdentifier.create("inventory", MEMBER_NAME, "config");
- private DatastoreContext datastoreContext = DatastoreContext.newBuilder().build();
+ private DatastoreContext datastoreContext = DatastoreContext.newBuilder().persistent(false).build();
- private final ShardStats shardStats = new ShardStats(SHARD_IDENTIFIER.toString(), "DataStore");
+ private final TestActorFactory actorFactory = new TestActorFactory(getSystem());
- private final InMemoryDOMDataStore store =
- new InMemoryDOMDataStore("OPER", MoreExecutors.sameThreadExecutor());
+ private TestActorRef<Shard> shard;
+ private ShardDataTree store;
@Before
- public void setup() {
- store.onGlobalContextUpdated(testSchemaContext);
- }
-
- private ActorRef createShard(){
- return getSystem().actorOf(Shard.props(SHARD_IDENTIFIER,
- Collections.<String, String>emptyMap(), datastoreContext, TestModel.createTestContext()));
- }
-
- private ActorRef newTransactionActor(DOMStoreTransaction transaction, String name) {
- return newTransactionActor(transaction, name, DataStoreVersions.CURRENT_VERSION);
+ public void setUp() {
+ shard = actorFactory.createTestActor(Shard.builder().id(SHARD_IDENTIFIER).datastoreContext(datastoreContext)
+ .schemaContext(TestModel.createTestContext()).props()
+ .withDispatcher(Dispatchers.DefaultDispatcherId()));
+ ShardTestKit.waitUntilLeader(shard);
+ store = shard.underlyingActor().getDataStore();
}
- private ActorRef newTransactionActor(DOMStoreTransaction transaction, String name, short version) {
- return newTransactionActor(transaction, null, name, version);
+ private ActorRef newTransactionActor(final TransactionType type,
+ final AbstractShardDataTreeTransaction<?> transaction, final String name) {
+ Props props = ShardTransaction.props(type, transaction, shard, datastoreContext,
+ shard.underlyingActor().getShardMBean());
+ return actorFactory.createActorNoVerify(props, name);
}
- private ActorRef newTransactionActor(DOMStoreTransaction transaction, ActorRef shard, String name) {
- return newTransactionActor(transaction, null, name, DataStoreVersions.CURRENT_VERSION);
+ private ReadOnlyShardDataTreeTransaction readOnlyTransaction() {
+ return store.newReadOnlyTransaction(nextTransactionId());
}
- private ActorRef newTransactionActor(DOMStoreTransaction transaction, ActorRef shard, String name,
- short version) {
- Props props = ShardTransaction.props(transaction, shard != null ? shard : createShard(),
- testSchemaContext, datastoreContext, shardStats, "txn", version);
- return getSystem().actorOf(props, name);
+ private ReadWriteShardDataTreeTransaction readWriteTransaction() {
+ return store.newReadWriteTransaction(nextTransactionId());
}
@Test
public void testOnReceiveReadData() throws Exception {
- new JavaTestKit(getSystem()) {{
- final ActorRef shard = createShard();
+ new JavaTestKit(getSystem()) {
+ {
+ testOnReceiveReadData(newTransactionActor(RO, readOnlyTransaction(), "testReadDataRO"));
- testOnReceiveReadData(newTransactionActor(store.newReadOnlyTransaction(), shard, "testReadDataRO"));
+ testOnReceiveReadData(newTransactionActor(RW, readWriteTransaction(), "testReadDataRW"));
+ }
- testOnReceiveReadData(newTransactionActor(store.newReadWriteTransaction(), shard, "testReadDataRW"));
- }
+ private void testOnReceiveReadData(final ActorRef transaction) {
+ transaction.tell(new ReadData(YangInstanceIdentifier.EMPTY, DataStoreVersions.CURRENT_VERSION),
+ getRef());
- private void testOnReceiveReadData(final ActorRef transaction) {
- //serialized read
- transaction.tell(new ReadData(YangInstanceIdentifier.builder().build()).toSerializable(),
- getRef());
+ ReadDataReply reply = expectMsgClass(duration("5 seconds"), ReadDataReply.class);
- Object replySerialized =
- expectMsgClass(duration("5 seconds"), ReadDataReply.SERIALIZABLE_CLASS);
-
- assertNotNull(ReadDataReply.fromSerializable(replySerialized).getNormalizedNode());
-
- // unserialized read
- transaction.tell(new ReadData(YangInstanceIdentifier.builder().build()),getRef());
-
- ReadDataReply reply = expectMsgClass(duration("5 seconds"), ReadDataReply.class);
-
- assertNotNull(reply.getNormalizedNode());
- }};
+ assertNotNull(reply.getNormalizedNode());
+ }
+ };
}
@Test
public void testOnReceiveReadDataWhenDataNotFound() throws Exception {
- new JavaTestKit(getSystem()) {{
- final ActorRef shard = createShard();
-
- testOnReceiveReadDataWhenDataNotFound(newTransactionActor(
- store.newReadOnlyTransaction(), shard, "testReadDataWhenDataNotFoundRO"));
-
- testOnReceiveReadDataWhenDataNotFound(newTransactionActor(
- store.newReadWriteTransaction(), shard, "testReadDataWhenDataNotFoundRW"));
- }
+ new JavaTestKit(getSystem()) {
+ {
+ testOnReceiveReadDataWhenDataNotFound(
+ newTransactionActor(RO, readOnlyTransaction(), "testReadDataWhenDataNotFoundRO"));
- private void testOnReceiveReadDataWhenDataNotFound(final ActorRef transaction) {
- // serialized read
- transaction.tell(new ReadData(TestModel.TEST_PATH).toSerializable(), getRef());
+ testOnReceiveReadDataWhenDataNotFound(
+ newTransactionActor(RW, readWriteTransaction(), "testReadDataWhenDataNotFoundRW"));
+ }
- Object replySerialized =
- expectMsgClass(duration("5 seconds"), ReadDataReply.SERIALIZABLE_CLASS);
+ private void testOnReceiveReadDataWhenDataNotFound(final ActorRef transaction) {
+ transaction.tell(new ReadData(TestModel.TEST_PATH, DataStoreVersions.CURRENT_VERSION), getRef());
- assertTrue(ReadDataReply.fromSerializable(replySerialized).getNormalizedNode() == null);
+ ReadDataReply reply = expectMsgClass(duration("5 seconds"), ReadDataReply.class);
- // unserialized read
- transaction.tell(new ReadData(TestModel.TEST_PATH),getRef());
-
- ReadDataReply reply = expectMsgClass(duration("5 seconds"), ReadDataReply.class);
-
- assertTrue(reply.getNormalizedNode() == null);
- }};
- }
-
- @Test
- public void testOnReceiveReadDataHeliumR1() throws Exception {
- new JavaTestKit(getSystem()) {{
- ActorRef transaction = newTransactionActor(store.newReadOnlyTransaction(),
- "testOnReceiveReadDataHeliumR1", DataStoreVersions.HELIUM_1_VERSION);
-
- transaction.tell(new ReadData(YangInstanceIdentifier.builder().build()).toSerializable(),
- getRef());
-
- ShardTransactionMessages.ReadDataReply replySerialized =
- expectMsgClass(duration("5 seconds"), ShardTransactionMessages.ReadDataReply.class);
-
- assertNotNull(ReadDataReply.fromSerializable(replySerialized).getNormalizedNode());
- }};
+ assertTrue(reply.getNormalizedNode() == null);
+ }
+ };
}
@Test
public void testOnReceiveDataExistsPositive() throws Exception {
- new JavaTestKit(getSystem()) {{
- final ActorRef shard = createShard();
-
- testOnReceiveDataExistsPositive(newTransactionActor(store.newReadOnlyTransaction(), shard,
- "testDataExistsPositiveRO"));
-
- testOnReceiveDataExistsPositive(newTransactionActor(store.newReadWriteTransaction(), shard,
- "testDataExistsPositiveRW"));
- }
-
- private void testOnReceiveDataExistsPositive(final ActorRef transaction) {
- transaction.tell(new DataExists(YangInstanceIdentifier.builder().build()).toSerializable(),
- getRef());
+ new JavaTestKit(getSystem()) {
+ {
+ testOnReceiveDataExistsPositive(
+ newTransactionActor(RO, readOnlyTransaction(), "testDataExistsPositiveRO"));
- ShardTransactionMessages.DataExistsReply replySerialized =
- expectMsgClass(duration("5 seconds"), ShardTransactionMessages.DataExistsReply.class);
+ testOnReceiveDataExistsPositive(
+ newTransactionActor(RW, readWriteTransaction(), "testDataExistsPositiveRW"));
+ }
- assertTrue(DataExistsReply.fromSerializable(replySerialized).exists());
+ private void testOnReceiveDataExistsPositive(final ActorRef transaction) {
+ transaction.tell(new DataExists(YangInstanceIdentifier.EMPTY, DataStoreVersions.CURRENT_VERSION),
+ getRef());
- // unserialized read
- transaction.tell(new DataExists(YangInstanceIdentifier.builder().build()),getRef());
+ DataExistsReply reply = expectMsgClass(duration("5 seconds"), DataExistsReply.class);
- DataExistsReply reply = expectMsgClass(duration("5 seconds"), DataExistsReply.class);
-
- assertTrue(reply.exists());
- }};
+ assertTrue(reply.exists());
+ }
+ };
}
@Test
public void testOnReceiveDataExistsNegative() throws Exception {
- new JavaTestKit(getSystem()) {{
- final ActorRef shard = createShard();
-
- testOnReceiveDataExistsNegative(newTransactionActor(store.newReadOnlyTransaction(), shard,
- "testDataExistsNegativeRO"));
-
- testOnReceiveDataExistsNegative(newTransactionActor(store.newReadWriteTransaction(), shard,
- "testDataExistsNegativeRW"));
- }
-
- private void testOnReceiveDataExistsNegative(final ActorRef transaction) {
- transaction.tell(new DataExists(TestModel.TEST_PATH).toSerializable(), getRef());
-
- ShardTransactionMessages.DataExistsReply replySerialized =
- expectMsgClass(duration("5 seconds"), ShardTransactionMessages.DataExistsReply.class);
-
- assertFalse(DataExistsReply.fromSerializable(replySerialized).exists());
-
- // unserialized read
- transaction.tell(new DataExists(TestModel.TEST_PATH),getRef());
-
- DataExistsReply reply = expectMsgClass(duration("5 seconds"), DataExistsReply.class);
-
- assertFalse(reply.exists());
- }};
- }
-
- private void assertModification(final ActorRef subject,
- final Class<? extends Modification> modificationType) {
- new JavaTestKit(getSystem()) {{
- subject.tell(new ShardWriteTransaction.GetCompositedModification(), getRef());
+ new JavaTestKit(getSystem()) {
+ {
+ testOnReceiveDataExistsNegative(
+ newTransactionActor(RO, readOnlyTransaction(), "testDataExistsNegativeRO"));
- CompositeModification compositeModification = expectMsgClass(duration("3 seconds"),
- GetCompositeModificationReply.class).getModification();
+ testOnReceiveDataExistsNegative(
+ newTransactionActor(RW, readWriteTransaction(), "testDataExistsNegativeRW"));
+ }
- assertTrue(compositeModification.getModifications().size() == 1);
- assertEquals(modificationType, compositeModification.getModifications().get(0).getClass());
- }};
- }
-
- @Test
- public void testOnReceiveWriteData() throws Exception {
- new JavaTestKit(getSystem()) {{
- final ActorRef transaction = newTransactionActor(store.newWriteOnlyTransaction(),
- "testOnReceiveWriteData");
-
- transaction.tell(new WriteData(TestModel.TEST_PATH,
- ImmutableNodes.containerNode(TestModel.TEST_QNAME), DataStoreVersions.HELIUM_2_VERSION).
- toSerializable(), getRef());
-
- expectMsgClass(duration("5 seconds"), ShardTransactionMessages.WriteDataReply.class);
-
- assertModification(transaction, WriteModification.class);
+ private void testOnReceiveDataExistsNegative(final ActorRef transaction) {
+ transaction.tell(new DataExists(TestModel.TEST_PATH, DataStoreVersions.CURRENT_VERSION), getRef());
- // unserialized write
- transaction.tell(new WriteData(TestModel.TEST_PATH,
- ImmutableNodes.containerNode(TestModel.TEST_QNAME), DataStoreVersions.CURRENT_VERSION),
- getRef());
+ DataExistsReply reply = expectMsgClass(duration("5 seconds"), DataExistsReply.class);
- expectMsgClass(duration("5 seconds"), WriteDataReply.class);
- }};
+ assertFalse(reply.exists());
+ }
+ };
}
@Test
- public void testOnReceiveHeliumR1WriteData() throws Exception {
- new JavaTestKit(getSystem()) {{
- final ActorRef transaction = newTransactionActor(store.newWriteOnlyTransaction(),
- "testOnReceiveHeliumR1WriteData", DataStoreVersions.HELIUM_1_VERSION);
-
- Encoded encoded = new NormalizedNodeToNodeCodec(null).encode(TestModel.TEST_PATH,
- ImmutableNodes.containerNode(TestModel.TEST_QNAME));
- ShardTransactionMessages.WriteData serialized = ShardTransactionMessages.WriteData.newBuilder()
- .setInstanceIdentifierPathArguments(encoded.getEncodedPath())
- .setNormalizedNode(encoded.getEncodedNode().getNormalizedNode()).build();
-
- transaction.tell(serialized, getRef());
-
- expectMsgClass(duration("5 seconds"), ShardTransactionMessages.WriteDataReply.class);
-
- assertModification(transaction, WriteModification.class);
- }};
- }
-
- @Test
- public void testOnReceiveMergeData() throws Exception {
- new JavaTestKit(getSystem()) {{
- final ActorRef transaction = newTransactionActor(store.newReadWriteTransaction(),
- "testMergeData");
-
- transaction.tell(new MergeData(TestModel.TEST_PATH,
- ImmutableNodes.containerNode(TestModel.TEST_QNAME), DataStoreVersions.HELIUM_2_VERSION).
- toSerializable(), getRef());
-
- expectMsgClass(duration("5 seconds"), ShardTransactionMessages.MergeDataReply.class);
-
- assertModification(transaction, MergeModification.class);
-
- //unserialized merge
- transaction.tell(new MergeData(TestModel.TEST_PATH,
- ImmutableNodes.containerNode(TestModel.TEST_QNAME), DataStoreVersions.CURRENT_VERSION),
- getRef());
-
- expectMsgClass(duration("5 seconds"), MergeDataReply.class);
- }};
+ public void testOnReceiveBatchedModifications() throws Exception {
+ new JavaTestKit(getSystem()) {
+ {
+ ShardDataTreeTransactionParent parent = Mockito.mock(ShardDataTreeTransactionParent.class);
+ DataTreeModification mockModification = Mockito.mock(DataTreeModification.class);
+ ReadWriteShardDataTreeTransaction mockWriteTx = new ReadWriteShardDataTreeTransaction(parent,
+ nextTransactionId(), mockModification);
+ final ActorRef transaction = newTransactionActor(RW, mockWriteTx, "testOnReceiveBatchedModifications");
+
+ YangInstanceIdentifier writePath = TestModel.TEST_PATH;
+ NormalizedNode<?, ?> writeData = ImmutableContainerNodeBuilder.create()
+ .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME))
+ .withChild(ImmutableNodes.leafNode(TestModel.DESC_QNAME, "foo")).build();
+
+ YangInstanceIdentifier mergePath = TestModel.OUTER_LIST_PATH;
+ NormalizedNode<?, ?> mergeData = ImmutableContainerNodeBuilder.create()
+ .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TestModel.OUTER_LIST_QNAME))
+ .build();
+
+ YangInstanceIdentifier deletePath = TestModel.TEST_PATH;
+
+ BatchedModifications batched = new BatchedModifications(nextTransactionId(),
+ DataStoreVersions.CURRENT_VERSION);
+ batched.addModification(new WriteModification(writePath, writeData));
+ batched.addModification(new MergeModification(mergePath, mergeData));
+ batched.addModification(new DeleteModification(deletePath));
+
+ transaction.tell(batched, getRef());
+
+ BatchedModificationsReply reply = expectMsgClass(duration("5 seconds"),
+ BatchedModificationsReply.class);
+ assertEquals("getNumBatched", 3, reply.getNumBatched());
+
+ InOrder inOrder = Mockito.inOrder(mockModification);
+ inOrder.verify(mockModification).write(writePath, writeData);
+ inOrder.verify(mockModification).merge(mergePath, mergeData);
+ inOrder.verify(mockModification).delete(deletePath);
+ }
+ };
}
@Test
- public void testOnReceiveHeliumR1MergeData() throws Exception {
- new JavaTestKit(getSystem()) {{
- final ActorRef transaction = newTransactionActor(store.newWriteOnlyTransaction(),
- "testOnReceiveHeliumR1MergeData", DataStoreVersions.HELIUM_1_VERSION);
-
- Encoded encoded = new NormalizedNodeToNodeCodec(null).encode(TestModel.TEST_PATH,
- ImmutableNodes.containerNode(TestModel.TEST_QNAME));
- ShardTransactionMessages.MergeData serialized = ShardTransactionMessages.MergeData.newBuilder()
- .setInstanceIdentifierPathArguments(encoded.getEncodedPath())
- .setNormalizedNode(encoded.getEncodedNode().getNormalizedNode()).build();
-
- transaction.tell(serialized, getRef());
-
- expectMsgClass(duration("5 seconds"), ShardTransactionMessages.MergeDataReply.class);
-
- assertModification(transaction, MergeModification.class);
- }};
+ public void testOnReceiveBatchedModificationsReadyWithoutImmediateCommit() throws Exception {
+ new JavaTestKit(getSystem()) {
+ {
+ final ActorRef transaction = newTransactionActor(WO, readWriteTransaction(),
+ "testOnReceiveBatchedModificationsReadyWithoutImmediateCommit");
+
+ JavaTestKit watcher = new JavaTestKit(getSystem());
+ watcher.watch(transaction);
+
+ YangInstanceIdentifier writePath = TestModel.TEST_PATH;
+ NormalizedNode<?, ?> writeData = ImmutableContainerNodeBuilder.create()
+ .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME))
+ .withChild(ImmutableNodes.leafNode(TestModel.DESC_QNAME, "foo")).build();
+
+ final TransactionIdentifier tx1 = nextTransactionId();
+ BatchedModifications batched = new BatchedModifications(tx1, DataStoreVersions.CURRENT_VERSION);
+ batched.addModification(new WriteModification(writePath, writeData));
+
+ transaction.tell(batched, getRef());
+ BatchedModificationsReply reply = expectMsgClass(duration("5 seconds"),
+ BatchedModificationsReply.class);
+ assertEquals("getNumBatched", 1, reply.getNumBatched());
+
+ batched = new BatchedModifications(tx1, DataStoreVersions.CURRENT_VERSION);
+ batched.setReady(true);
+ batched.setTotalMessagesSent(2);
+
+ transaction.tell(batched, getRef());
+ expectMsgClass(duration("5 seconds"), ReadyTransactionReply.class);
+ watcher.expectMsgClass(duration("5 seconds"), Terminated.class);
+ }
+ };
}
@Test
- public void testOnReceiveDeleteData() throws Exception {
- new JavaTestKit(getSystem()) {{
- final ActorRef transaction = newTransactionActor(store.newWriteOnlyTransaction(),
- "testDeleteData");
-
- transaction.tell(new DeleteData(TestModel.TEST_PATH, DataStoreVersions.HELIUM_2_VERSION).
- toSerializable(), getRef());
-
- expectMsgClass(duration("5 seconds"), ShardTransactionMessages.DeleteDataReply.class);
-
- assertModification(transaction, DeleteModification.class);
-
- //unserialized
- transaction.tell(new DeleteData(TestModel.TEST_PATH, DataStoreVersions.CURRENT_VERSION), getRef());
-
- expectMsgClass(duration("5 seconds"), DeleteDataReply.class);
- }};
+ public void testOnReceiveBatchedModificationsReadyWithImmediateCommit() throws Exception {
+ new JavaTestKit(getSystem()) {
+ {
+ final ActorRef transaction = newTransactionActor(WO, readWriteTransaction(),
+ "testOnReceiveBatchedModificationsReadyWithImmediateCommit");
+
+ JavaTestKit watcher = new JavaTestKit(getSystem());
+ watcher.watch(transaction);
+
+ YangInstanceIdentifier writePath = TestModel.TEST_PATH;
+ NormalizedNode<?, ?> writeData = ImmutableContainerNodeBuilder.create()
+ .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME))
+ .withChild(ImmutableNodes.leafNode(TestModel.DESC_QNAME, "foo")).build();
+
+ BatchedModifications batched = new BatchedModifications(nextTransactionId(),
+ DataStoreVersions.CURRENT_VERSION);
+ batched.addModification(new WriteModification(writePath, writeData));
+ batched.setReady(true);
+ batched.setDoCommitOnReady(true);
+ batched.setTotalMessagesSent(1);
+
+ transaction.tell(batched, getRef());
+ expectMsgClass(duration("5 seconds"), CommitTransactionReply.class);
+ watcher.expectMsgClass(duration("5 seconds"), Terminated.class);
+ }
+ };
}
- @Test
- public void testOnReceiveBatchedModifications() throws Exception {
- new JavaTestKit(getSystem()) {{
-
- DOMStoreWriteTransaction mockWriteTx = Mockito.mock(DOMStoreWriteTransaction.class);
- final ActorRef transaction = newTransactionActor(mockWriteTx, "testOnReceiveBatchedModifications");
-
- YangInstanceIdentifier writePath = TestModel.TEST_PATH;
- NormalizedNode<?, ?> writeData = ImmutableContainerNodeBuilder.create().withNodeIdentifier(
- new YangInstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME)).
- withChild(ImmutableNodes.leafNode(TestModel.DESC_QNAME, "foo")).build();
-
- YangInstanceIdentifier mergePath = TestModel.OUTER_LIST_PATH;
- NormalizedNode<?, ?> mergeData = ImmutableContainerNodeBuilder.create().withNodeIdentifier(
- new YangInstanceIdentifier.NodeIdentifier(TestModel.OUTER_LIST_QNAME)).build();
+ @Test(expected = TestException.class)
+ public void testOnReceiveBatchedModificationsFailure() throws Exception {
+ new JavaTestKit(getSystem()) {
+ {
- YangInstanceIdentifier deletePath = TestModel.TEST_PATH;
+ ShardDataTreeTransactionParent parent = Mockito.mock(ShardDataTreeTransactionParent.class);
+ DataTreeModification mockModification = Mockito.mock(DataTreeModification.class);
+ ReadWriteShardDataTreeTransaction mockWriteTx = new ReadWriteShardDataTreeTransaction(parent,
+ nextTransactionId(), mockModification);
+ final ActorRef transaction = newTransactionActor(RW, mockWriteTx,
+ "testOnReceiveBatchedModificationsFailure");
- BatchedModifications batched = new BatchedModifications("tx1", DataStoreVersions.CURRENT_VERSION, null);
- batched.addModification(new WriteModification(writePath, writeData));
- batched.addModification(new MergeModification(mergePath, mergeData));
- batched.addModification(new DeleteModification(deletePath));
+ JavaTestKit watcher = new JavaTestKit(getSystem());
+ watcher.watch(transaction);
- transaction.tell(batched, getRef());
+ YangInstanceIdentifier path = TestModel.TEST_PATH;
+ ContainerNode node = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
- BatchedModificationsReply reply = expectMsgClass(duration("5 seconds"), BatchedModificationsReply.class);
- assertEquals("getNumBatched", 3, reply.getNumBatched());
+ doThrow(new TestException()).when(mockModification).write(path, node);
- JavaTestKit verification = new JavaTestKit(getSystem());
- transaction.tell(new ShardWriteTransaction.GetCompositedModification(), verification.getRef());
+ final TransactionIdentifier tx1 = nextTransactionId();
+ BatchedModifications batched = new BatchedModifications(tx1, DataStoreVersions.CURRENT_VERSION);
+ batched.addModification(new WriteModification(path, node));
- CompositeModification compositeModification = verification.expectMsgClass(duration("5 seconds"),
- GetCompositeModificationReply.class).getModification();
+ transaction.tell(batched, getRef());
+ expectMsgClass(duration("5 seconds"), akka.actor.Status.Failure.class);
- assertEquals("CompositeModification size", 3, compositeModification.getModifications().size());
+ batched = new BatchedModifications(tx1, DataStoreVersions.CURRENT_VERSION);
+ batched.setReady(true);
+ batched.setTotalMessagesSent(2);
- WriteModification write = (WriteModification)compositeModification.getModifications().get(0);
- assertEquals("getPath", writePath, write.getPath());
- assertEquals("getData", writeData, write.getData());
+ transaction.tell(batched, getRef());
+ Failure failure = expectMsgClass(duration("5 seconds"), akka.actor.Status.Failure.class);
+ watcher.expectMsgClass(duration("5 seconds"), Terminated.class);
- MergeModification merge = (MergeModification)compositeModification.getModifications().get(1);
- assertEquals("getPath", mergePath, merge.getPath());
- assertEquals("getData", mergeData, merge.getData());
-
- DeleteModification delete = (DeleteModification)compositeModification.getModifications().get(2);
- assertEquals("getPath", deletePath, delete.getPath());
-
- InOrder inOrder = Mockito.inOrder(mockWriteTx);
- inOrder.verify(mockWriteTx).write(writePath, writeData);
- inOrder.verify(mockWriteTx).merge(mergePath, mergeData);
- inOrder.verify(mockWriteTx).delete(deletePath);
- }};
- }
-
- @Test
- public void testOnReceiveReadyTransaction() throws Exception {
- new JavaTestKit(getSystem()) {{
- final ActorRef transaction = newTransactionActor(store.newReadWriteTransaction(),
- "testReadyTransaction");
-
- watch(transaction);
-
- transaction.tell(new ReadyTransaction().toSerializable(), getRef());
-
- expectMsgAnyClassOf(duration("5 seconds"), ReadyTransactionReply.SERIALIZABLE_CLASS,
- Terminated.class);
- expectMsgAnyClassOf(duration("5 seconds"), ReadyTransactionReply.SERIALIZABLE_CLASS,
- Terminated.class);
- }};
-
- // test
- new JavaTestKit(getSystem()) {{
- final ActorRef transaction = newTransactionActor(store.newReadWriteTransaction(),
- "testReadyTransaction2");
-
- watch(transaction);
-
- transaction.tell(new ReadyTransaction(), getRef());
-
- expectMsgAnyClassOf(duration("5 seconds"), ReadyTransactionReply.class,
- Terminated.class);
- expectMsgAnyClassOf(duration("5 seconds"), ReadyTransactionReply.class,
- Terminated.class);
- }};
+ if (failure != null) {
+ Throwables.propagateIfInstanceOf(failure.cause(), Exception.class);
+ Throwables.propagate(failure.cause());
+ }
+ }
+ };
}
- @Test
- public void testOnReceiveCreateSnapshot() throws Exception {
- new JavaTestKit(getSystem()) {{
- ShardTest.writeToStore(store, TestModel.TEST_PATH,
- ImmutableNodes.containerNode(TestModel.TEST_QNAME));
-
- NormalizedNode<?,?> expectedRoot = ShardTest.readStore(store,
- YangInstanceIdentifier.builder().build());
+ @Test(expected = IllegalStateException.class)
+ public void testOnReceiveBatchedModificationsReadyWithIncorrectTotalMessageCount() throws Exception {
+ new JavaTestKit(getSystem()) {
+ {
- final ActorRef transaction = newTransactionActor(store.newReadOnlyTransaction(),
- "testOnReceiveCreateSnapshot");
+ final ActorRef transaction = newTransactionActor(WO, readWriteTransaction(),
+ "testOnReceiveBatchedModificationsReadyWithIncorrectTotalMessageCount");
- watch(transaction);
+ JavaTestKit watcher = new JavaTestKit(getSystem());
+ watcher.watch(transaction);
- transaction.tell(CreateSnapshot.INSTANCE, getRef());
+ BatchedModifications batched = new BatchedModifications(nextTransactionId(),
+ DataStoreVersions.CURRENT_VERSION);
+ batched.setReady(true);
+ batched.setTotalMessagesSent(2);
- CaptureSnapshotReply reply = expectMsgClass(duration("3 seconds"), CaptureSnapshotReply.class);
+ transaction.tell(batched, getRef());
- assertNotNull("getSnapshot is null", reply.getSnapshot());
+ Failure failure = expectMsgClass(duration("5 seconds"), akka.actor.Status.Failure.class);
+ watcher.expectMsgClass(duration("5 seconds"), Terminated.class);
- NormalizedNode<?,?> actualRoot = SerializationUtils.deserializeNormalizedNode(
- reply.getSnapshot());
-
- assertEquals("Root node", expectedRoot, actualRoot);
-
- expectTerminated(duration("3 seconds"), transaction);
- }};
+ if (failure != null) {
+ Throwables.propagateIfInstanceOf(failure.cause(), Exception.class);
+ Throwables.propagate(failure.cause());
+ }
+ }
+ };
}
@Test
public void testReadWriteTxOnReceiveCloseTransaction() throws Exception {
- new JavaTestKit(getSystem()) {{
- final ActorRef transaction = newTransactionActor(store.newReadWriteTransaction(),
- "testReadWriteTxOnReceiveCloseTransaction");
+ new JavaTestKit(getSystem()) {
+ {
+ final ActorRef transaction = newTransactionActor(RW, readWriteTransaction(),
+ "testReadWriteTxOnReceiveCloseTransaction");
- watch(transaction);
+ watch(transaction);
- transaction.tell(new CloseTransaction().toSerializable(), getRef());
+ transaction.tell(new CloseTransaction().toSerializable(), getRef());
- expectMsgClass(duration("3 seconds"), CloseTransactionReply.SERIALIZABLE_CLASS);
- expectTerminated(duration("3 seconds"), transaction);
- }};
+ expectMsgClass(duration("3 seconds"), CloseTransactionReply.class);
+ expectTerminated(duration("3 seconds"), transaction);
+ }
+ };
}
@Test
public void testWriteOnlyTxOnReceiveCloseTransaction() throws Exception {
- new JavaTestKit(getSystem()) {{
- final ActorRef transaction = newTransactionActor(store.newWriteOnlyTransaction(),
- "testWriteTxOnReceiveCloseTransaction");
+ new JavaTestKit(getSystem()) {
+ {
+ final ActorRef transaction = newTransactionActor(WO, readWriteTransaction(),
+ "testWriteTxOnReceiveCloseTransaction");
- watch(transaction);
+ watch(transaction);
- transaction.tell(new CloseTransaction().toSerializable(), getRef());
+ transaction.tell(new CloseTransaction().toSerializable(), getRef());
- expectMsgClass(duration("3 seconds"), CloseTransactionReply.SERIALIZABLE_CLASS);
- expectTerminated(duration("3 seconds"), transaction);
- }};
+ expectMsgClass(duration("3 seconds"), CloseTransactionReply.class);
+ expectTerminated(duration("3 seconds"), transaction);
+ }
+ };
}
@Test
public void testReadOnlyTxOnReceiveCloseTransaction() throws Exception {
- new JavaTestKit(getSystem()) {{
- final ActorRef transaction = newTransactionActor(store.newReadOnlyTransaction(),
- "testReadOnlyTxOnReceiveCloseTransaction");
+ new JavaTestKit(getSystem()) {
+ {
+ final ActorRef transaction = newTransactionActor(TransactionType.READ_ONLY, readOnlyTransaction(),
+ "testReadOnlyTxOnReceiveCloseTransaction");
- watch(transaction);
+ watch(transaction);
- transaction.tell(new CloseTransaction().toSerializable(), getRef());
+ transaction.tell(new CloseTransaction().toSerializable(), getRef());
- expectMsgClass(duration("3 seconds"), Terminated.class);
- }};
- }
-
- @Test(expected=UnknownMessageException.class)
- public void testNegativePerformingWriteOperationOnReadTransaction() throws Exception {
- final ActorRef shard = createShard();
- final Props props = ShardTransaction.props(store.newReadOnlyTransaction(), shard,
- testSchemaContext, datastoreContext, shardStats, "txn",
- DataStoreVersions.CURRENT_VERSION);
- final TestActorRef<ShardTransaction> transaction = TestActorRef.apply(props,getSystem());
-
- transaction.receive(new DeleteData(TestModel.TEST_PATH, DataStoreVersions.CURRENT_VERSION).
- toSerializable(), ActorRef.noSender());
+ expectMsgClass(duration("3 seconds"), Terminated.class);
+ }
+ };
}
@Test
public void testShardTransactionInactivity() {
-
datastoreContext = DatastoreContext.newBuilder().shardTransactionIdleTimeout(
500, TimeUnit.MILLISECONDS).build();
- new JavaTestKit(getSystem()) {{
- final ActorRef transaction = newTransactionActor(store.newReadWriteTransaction(),
- "testShardTransactionInactivity");
+ new JavaTestKit(getSystem()) {
+ {
+ final ActorRef transaction = newTransactionActor(RW, readWriteTransaction(),
+ "testShardTransactionInactivity");
- watch(transaction);
+ watch(transaction);
+
+ expectMsgClass(duration("3 seconds"), Terminated.class);
+ }
+ };
+ }
- expectMsgClass(duration("3 seconds"), Terminated.class);
- }};
+ public static class TestException extends RuntimeException {
+ private static final long serialVersionUID = 1L;
}
}
Code Review / controller.git / blobdiff