1 package org.opendaylight.controller.cluster.datastore;
3 import akka.actor.ActorRef;
4 import akka.actor.Props;
5 import com.google.common.base.Optional;
6 import com.google.common.util.concurrent.ListenableFuture;
7 import junit.framework.Assert;
9 import org.opendaylight.controller.cluster.datastore.messages.CloseTransaction;
10 import org.opendaylight.controller.cluster.datastore.messages.CreateTransactionReply;
11 import org.opendaylight.controller.cluster.datastore.messages.DeleteData;
12 import org.opendaylight.controller.cluster.datastore.messages.MergeData;
13 import org.opendaylight.controller.cluster.datastore.messages.ReadDataReply;
14 import org.opendaylight.controller.cluster.datastore.messages.ReadyTransactionReply;
15 import org.opendaylight.controller.cluster.datastore.messages.WriteData;
16 import org.opendaylight.controller.cluster.datastore.utils.ActorContext;
17 import org.opendaylight.controller.cluster.datastore.utils.DoNothingActor;
18 import org.opendaylight.controller.cluster.datastore.utils.MessageCollectorActor;
19 import org.opendaylight.controller.cluster.datastore.utils.MockActorContext;
20 import org.opendaylight.controller.md.cluster.datastore.model.TestModel;
21 import org.opendaylight.controller.sal.core.spi.data.DOMStoreThreePhaseCommitCohort;
22 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
23 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
25 import java.util.List;
27 public class TransactionProxyTest extends AbstractActorTest {
30 public void testRead() throws Exception {
31 final Props props = Props.create(DoNothingActor.class);
32 final ActorRef actorRef = getSystem().actorOf(props);
34 final MockActorContext actorContext = new MockActorContext(this.getSystem());
35 actorContext.setExecuteShardOperationResponse(new CreateTransactionReply(actorRef.path()));
36 actorContext.setExecuteRemoteOperationResponse("message");
38 TransactionProxy transactionProxy =
39 new TransactionProxy(actorContext,
40 TransactionProxy.TransactionType.READ_ONLY);
43 ListenableFuture<Optional<NormalizedNode<?, ?>>> read =
44 transactionProxy.read(TestModel.TEST_PATH);
46 Optional<NormalizedNode<?, ?>> normalizedNodeOptional = read.get();
48 Assert.assertFalse(normalizedNodeOptional.isPresent());
50 actorContext.setExecuteRemoteOperationResponse(new ReadDataReply(
51 ImmutableNodes.containerNode(TestModel.TEST_QNAME)));
53 read = transactionProxy.read(TestModel.TEST_PATH);
55 normalizedNodeOptional = read.get();
57 Assert.assertTrue(normalizedNodeOptional.isPresent());
61 public void testReadWhenANullIsReturned() throws Exception {
62 final Props props = Props.create(DoNothingActor.class);
63 final ActorRef actorRef = getSystem().actorOf(props);
65 final MockActorContext actorContext = new MockActorContext(this.getSystem());
66 actorContext.setExecuteShardOperationResponse(new CreateTransactionReply(actorRef.path()));
67 actorContext.setExecuteRemoteOperationResponse("message");
69 TransactionProxy transactionProxy =
70 new TransactionProxy(actorContext,
71 TransactionProxy.TransactionType.READ_ONLY);
74 ListenableFuture<Optional<NormalizedNode<?, ?>>> read =
75 transactionProxy.read(TestModel.TEST_PATH);
77 Optional<NormalizedNode<?, ?>> normalizedNodeOptional = read.get();
79 Assert.assertFalse(normalizedNodeOptional.isPresent());
81 actorContext.setExecuteRemoteOperationResponse(new ReadDataReply(
84 read = transactionProxy.read(TestModel.TEST_PATH);
86 normalizedNodeOptional = read.get();
88 Assert.assertFalse(normalizedNodeOptional.isPresent());
92 public void testWrite() throws Exception {
93 final Props props = Props.create(MessageCollectorActor.class);
94 final ActorRef actorRef = getSystem().actorOf(props);
96 final MockActorContext actorContext = new MockActorContext(this.getSystem());
97 actorContext.setExecuteShardOperationResponse(new CreateTransactionReply(actorRef.path()));
98 actorContext.setExecuteRemoteOperationResponse("message");
100 TransactionProxy transactionProxy =
101 new TransactionProxy(actorContext,
102 TransactionProxy.TransactionType.READ_ONLY);
104 transactionProxy.write(TestModel.TEST_PATH,
105 ImmutableNodes.containerNode(TestModel.NAME_QNAME));
107 ActorContext testContext = new ActorContext(getSystem(), getSystem().actorOf(Props.create(DoNothingActor.class)));
108 Object messages = testContext
109 .executeLocalOperation(actorRef, "messages",
110 ActorContext.ASK_DURATION);
112 Assert.assertNotNull(messages);
114 Assert.assertTrue(messages instanceof List);
116 List<Object> listMessages = (List<Object>) messages;
118 Assert.assertEquals(1, listMessages.size());
120 Assert.assertTrue(listMessages.get(0) instanceof WriteData);
124 public void testMerge() throws Exception {
125 final Props props = Props.create(MessageCollectorActor.class);
126 final ActorRef actorRef = getSystem().actorOf(props);
128 final MockActorContext actorContext = new MockActorContext(this.getSystem());
129 actorContext.setExecuteShardOperationResponse(new CreateTransactionReply(actorRef.path()));
130 actorContext.setExecuteRemoteOperationResponse("message");
132 TransactionProxy transactionProxy =
133 new TransactionProxy(actorContext,
134 TransactionProxy.TransactionType.READ_ONLY);
136 transactionProxy.merge(TestModel.TEST_PATH,
137 ImmutableNodes.containerNode(TestModel.NAME_QNAME));
139 ActorContext testContext = new ActorContext(getSystem(), getSystem().actorOf(Props.create(DoNothingActor.class)));
140 Object messages = testContext
141 .executeLocalOperation(actorRef, "messages",
142 ActorContext.ASK_DURATION);
144 Assert.assertNotNull(messages);
146 Assert.assertTrue(messages instanceof List);
148 List<Object> listMessages = (List<Object>) messages;
150 Assert.assertEquals(1, listMessages.size());
152 Assert.assertTrue(listMessages.get(0) instanceof MergeData);
156 public void testDelete() throws Exception {
157 final Props props = Props.create(MessageCollectorActor.class);
158 final ActorRef actorRef = getSystem().actorOf(props);
160 final MockActorContext actorContext = new MockActorContext(this.getSystem());
161 actorContext.setExecuteShardOperationResponse(new CreateTransactionReply(actorRef.path()));
162 actorContext.setExecuteRemoteOperationResponse("message");
164 TransactionProxy transactionProxy =
165 new TransactionProxy(actorContext,
166 TransactionProxy.TransactionType.READ_ONLY);
168 transactionProxy.delete(TestModel.TEST_PATH);
170 ActorContext testContext = new ActorContext(getSystem(), getSystem().actorOf(Props.create(DoNothingActor.class)));
171 Object messages = testContext
172 .executeLocalOperation(actorRef, "messages",
173 ActorContext.ASK_DURATION);
175 Assert.assertNotNull(messages);
177 Assert.assertTrue(messages instanceof List);
179 List<Object> listMessages = (List<Object>) messages;
181 Assert.assertEquals(1, listMessages.size());
183 Assert.assertTrue(listMessages.get(0) instanceof DeleteData);
187 public void testReady() throws Exception {
188 final Props props = Props.create(DoNothingActor.class);
189 final ActorRef doNothingActorRef = getSystem().actorOf(props);
191 final MockActorContext actorContext = new MockActorContext(this.getSystem());
192 actorContext.setExecuteShardOperationResponse(new CreateTransactionReply(doNothingActorRef.path()));
193 actorContext.setExecuteRemoteOperationResponse(new ReadyTransactionReply(doNothingActorRef.path()));
195 TransactionProxy transactionProxy =
196 new TransactionProxy(actorContext,
197 TransactionProxy.TransactionType.READ_ONLY);
200 DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
202 Assert.assertTrue(ready instanceof ThreePhaseCommitCohortProxy);
204 ThreePhaseCommitCohortProxy proxy = (ThreePhaseCommitCohortProxy) ready;
206 Assert.assertTrue("No cohort paths returned", proxy.getCohortPaths().size() > 0);
211 public void testGetIdentifier(){
212 final Props props = Props.create(DoNothingActor.class);
213 final ActorRef doNothingActorRef = getSystem().actorOf(props);
215 final MockActorContext actorContext = new MockActorContext(this.getSystem());
216 actorContext.setExecuteShardOperationResponse(
217 new CreateTransactionReply(doNothingActorRef.path()));
219 TransactionProxy transactionProxy =
220 new TransactionProxy(actorContext,
221 TransactionProxy.TransactionType.READ_ONLY);
223 Assert.assertNotNull(transactionProxy.getIdentifier());
227 public void testClose(){
228 final Props props = Props.create(MessageCollectorActor.class);
229 final ActorRef actorRef = getSystem().actorOf(props);
231 final MockActorContext actorContext = new MockActorContext(this.getSystem());
232 actorContext.setExecuteShardOperationResponse(new CreateTransactionReply(actorRef.path()));
233 actorContext.setExecuteRemoteOperationResponse("message");
235 TransactionProxy transactionProxy =
236 new TransactionProxy(actorContext,
237 TransactionProxy.TransactionType.READ_ONLY);
239 transactionProxy.close();
241 ActorContext testContext = new ActorContext(getSystem(), getSystem().actorOf(Props.create(DoNothingActor.class)));
242 Object messages = testContext
243 .executeLocalOperation(actorRef, "messages",
244 ActorContext.ASK_DURATION);
246 Assert.assertNotNull(messages);
248 Assert.assertTrue(messages instanceof List);
250 List<Object> listMessages = (List<Object>) messages;
252 Assert.assertEquals(1, listMessages.size());
254 Assert.assertTrue(listMessages.get(0) instanceof CloseTransaction);