Kill Dynamic Actors when we're done with them
[controller.git] / opendaylight / md-sal / sal-distributed-datastore / src / test / java / org / opendaylight / controller / cluster / datastore / ShardTransactionTest.java
1 package org.opendaylight.controller.cluster.datastore;
2
3 import akka.actor.ActorRef;
4 import akka.actor.Props;
5 import akka.actor.Terminated;
6 import akka.testkit.JavaTestKit;
7 import com.google.common.util.concurrent.ListeningExecutorService;
8 import com.google.common.util.concurrent.MoreExecutors;
9 import org.junit.Test;
10 import org.opendaylight.controller.cluster.datastore.messages.CloseTransaction;
11 import org.opendaylight.controller.cluster.datastore.messages.CloseTransactionReply;
12 import org.opendaylight.controller.cluster.datastore.messages.DeleteData;
13 import org.opendaylight.controller.cluster.datastore.messages.DeleteDataReply;
14 import org.opendaylight.controller.cluster.datastore.messages.MergeData;
15 import org.opendaylight.controller.cluster.datastore.messages.MergeDataReply;
16 import org.opendaylight.controller.cluster.datastore.messages.ReadData;
17 import org.opendaylight.controller.cluster.datastore.messages.ReadDataReply;
18 import org.opendaylight.controller.cluster.datastore.messages.ReadyTransaction;
19 import org.opendaylight.controller.cluster.datastore.messages.ReadyTransactionReply;
20 import org.opendaylight.controller.cluster.datastore.messages.WriteData;
21 import org.opendaylight.controller.cluster.datastore.messages.WriteDataReply;
22 import org.opendaylight.controller.cluster.datastore.modification.CompositeModification;
23 import org.opendaylight.controller.cluster.datastore.modification.DeleteModification;
24 import org.opendaylight.controller.cluster.datastore.modification.MergeModification;
25 import org.opendaylight.controller.cluster.datastore.modification.Modification;
26 import org.opendaylight.controller.cluster.datastore.modification.WriteModification;
27 import org.opendaylight.controller.md.cluster.datastore.model.TestModel;
28 import org.opendaylight.controller.md.sal.dom.store.impl.InMemoryDOMDataStore;
29 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
30 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
31
32 import static org.junit.Assert.assertEquals;
33 import static org.junit.Assert.assertTrue;
34
35 public class ShardTransactionTest extends AbstractActorTest {
36     private static ListeningExecutorService storeExecutor =
37         MoreExecutors.listeningDecorator(MoreExecutors.sameThreadExecutor());
38
39     private static final InMemoryDOMDataStore store =
40         new InMemoryDOMDataStore("OPER", storeExecutor);
41
42     static {
43         store.onGlobalContextUpdated(TestModel.createTestContext());
44     }
45
46     @Test
47     public void testOnReceiveReadData() throws Exception {
48         new JavaTestKit(getSystem()) {{
49             final ActorRef shard = getSystem().actorOf(Shard.props("config"));
50             final Props props =
51                 ShardTransaction.props(store.newReadWriteTransaction(), shard);
52             final ActorRef subject = getSystem().actorOf(props, "testReadData");
53
54             new Within(duration("1 seconds")) {
55                 protected void run() {
56
57                     subject.tell(
58                         new ReadData(InstanceIdentifier.builder().build()),
59                         getRef());
60
61                     final String out = new ExpectMsg<String>("match hint") {
62                         // do not put code outside this method, will run afterwards
63                         protected String match(Object in) {
64                             if (in instanceof ReadDataReply) {
65                                 if (((ReadDataReply) in).getNormalizedNode()
66                                     != null) {
67                                     return "match";
68                                 }
69                                 return null;
70                             } else {
71                                 throw noMatch();
72                             }
73                         }
74                     }.get(); // this extracts the received message
75
76                     assertEquals("match", out);
77
78                     expectNoMsg();
79                 }
80
81
82             };
83         }};
84     }
85
86     @Test
87     public void testOnReceiveReadDataWhenDataNotFound() throws Exception {
88         new JavaTestKit(getSystem()) {{
89             final ActorRef shard = getSystem().actorOf(Shard.props("config"));
90             final Props props =
91                 ShardTransaction.props(store.newReadWriteTransaction(), shard);
92             final ActorRef subject = getSystem().actorOf(props, "testReadDataWhenDataNotFound");
93
94             new Within(duration("1 seconds")) {
95                 protected void run() {
96
97                     subject.tell(
98                         new ReadData(TestModel.TEST_PATH),
99                         getRef());
100
101                     final String out = new ExpectMsg<String>("match hint") {
102                         // do not put code outside this method, will run afterwards
103                         protected String match(Object in) {
104                             if (in instanceof ReadDataReply) {
105                                 if (((ReadDataReply) in).getNormalizedNode()
106                                     == null) {
107                                     return "match";
108                                 }
109                                 return null;
110                             } else {
111                                 throw noMatch();
112                             }
113                         }
114                     }.get(); // this extracts the received message
115
116                     assertEquals("match", out);
117
118                     expectNoMsg();
119                 }
120
121
122             };
123         }};
124     }
125
126     private void assertModification(final ActorRef subject,
127         final Class<? extends Modification> modificationType) {
128         new JavaTestKit(getSystem()) {{
129             new Within(duration("1 seconds")) {
130                 protected void run() {
131                     subject
132                         .tell(new ShardTransaction.GetCompositedModification(),
133                             getRef());
134
135                     final CompositeModification compositeModification =
136                         new ExpectMsg<CompositeModification>("match hint") {
137                             // do not put code outside this method, will run afterwards
138                             protected CompositeModification match(Object in) {
139                                 if (in instanceof ShardTransaction.GetCompositeModificationReply) {
140                                     return ((ShardTransaction.GetCompositeModificationReply) in)
141                                         .getModification();
142                                 } else {
143                                     throw noMatch();
144                                 }
145                             }
146                         }.get(); // this extracts the received message
147
148                     assertTrue(
149                         compositeModification.getModifications().size() == 1);
150                     assertEquals(modificationType,
151                         compositeModification.getModifications().get(0)
152                             .getClass());
153
154                 }
155             };
156         }};
157     }
158
159     @Test
160     public void testOnReceiveWriteData() throws Exception {
161         new JavaTestKit(getSystem()) {{
162             final ActorRef shard = getSystem().actorOf(Shard.props("config"));
163             final Props props =
164                 ShardTransaction.props(store.newReadWriteTransaction(), shard);
165             final ActorRef subject =
166                 getSystem().actorOf(props, "testWriteData");
167
168             new Within(duration("1 seconds")) {
169                 protected void run() {
170
171                     subject.tell(new WriteData(TestModel.TEST_PATH,
172                         ImmutableNodes.containerNode(TestModel.TEST_QNAME)),
173                         getRef());
174
175                     final String out = new ExpectMsg<String>("match hint") {
176                         // do not put code outside this method, will run afterwards
177                         protected String match(Object in) {
178                             if (in instanceof WriteDataReply) {
179                                 return "match";
180                             } else {
181                                 throw noMatch();
182                             }
183                         }
184                     }.get(); // this extracts the received message
185
186                     assertEquals("match", out);
187
188                     assertModification(subject, WriteModification.class);
189                     expectNoMsg();
190                 }
191
192
193             };
194         }};
195     }
196
197     @Test
198     public void testOnReceiveMergeData() throws Exception {
199         new JavaTestKit(getSystem()) {{
200             final ActorRef shard = getSystem().actorOf(Shard.props("config"));
201             final Props props =
202                 ShardTransaction.props(store.newReadWriteTransaction(), shard);
203             final ActorRef subject =
204                 getSystem().actorOf(props, "testMergeData");
205
206             new Within(duration("1 seconds")) {
207                 protected void run() {
208
209                     subject.tell(new MergeData(TestModel.TEST_PATH,
210                         ImmutableNodes.containerNode(TestModel.TEST_QNAME)),
211                         getRef());
212
213                     final String out = new ExpectMsg<String>("match hint") {
214                         // do not put code outside this method, will run afterwards
215                         protected String match(Object in) {
216                             if (in instanceof MergeDataReply) {
217                                 return "match";
218                             } else {
219                                 throw noMatch();
220                             }
221                         }
222                     }.get(); // this extracts the received message
223
224                     assertEquals("match", out);
225
226                     assertModification(subject, MergeModification.class);
227
228                     expectNoMsg();
229                 }
230
231
232             };
233         }};
234     }
235
236     @Test
237     public void testOnReceiveDeleteData() throws Exception {
238         new JavaTestKit(getSystem()) {{
239             final ActorRef shard = getSystem().actorOf(Shard.props("config"));
240             final Props props =
241                 ShardTransaction.props(store.newReadWriteTransaction(), shard);
242             final ActorRef subject =
243                 getSystem().actorOf(props, "testDeleteData");
244
245             new Within(duration("1 seconds")) {
246                 protected void run() {
247
248                     subject.tell(new DeleteData(TestModel.TEST_PATH), getRef());
249
250                     final String out = new ExpectMsg<String>("match hint") {
251                         // do not put code outside this method, will run afterwards
252                         protected String match(Object in) {
253                             if (in instanceof DeleteDataReply) {
254                                 return "match";
255                             } else {
256                                 throw noMatch();
257                             }
258                         }
259                     }.get(); // this extracts the received message
260
261                     assertEquals("match", out);
262
263                     assertModification(subject, DeleteModification.class);
264                     expectNoMsg();
265                 }
266
267
268             };
269         }};
270     }
271
272
273     @Test
274     public void testOnReceiveReadyTransaction() throws Exception {
275         new JavaTestKit(getSystem()) {{
276             final ActorRef shard = getSystem().actorOf(Shard.props("config"));
277             final Props props =
278                 ShardTransaction.props(store.newReadWriteTransaction(), shard);
279             final ActorRef subject =
280                 getSystem().actorOf(props, "testReadyTransaction");
281
282             new Within(duration("1 seconds")) {
283                 protected void run() {
284
285                     subject.tell(new ReadyTransaction(), getRef());
286
287                     final String out = new ExpectMsg<String>("match hint") {
288                         // do not put code outside this method, will run afterwards
289                         protected String match(Object in) {
290                             if (in instanceof ReadyTransactionReply) {
291                                 return "match";
292                             } else {
293                                 throw noMatch();
294                             }
295                         }
296                     }.get(); // this extracts the received message
297
298                     assertEquals("match", out);
299
300                     expectNoMsg();
301                 }
302
303
304             };
305         }};
306
307     }
308
309     @Test
310     public void testOnReceiveCloseTransaction() throws Exception {
311         new JavaTestKit(getSystem()) {{
312             final ActorRef shard = getSystem().actorOf(Shard.props("config"));
313             final Props props =
314                 ShardTransaction.props(store.newReadWriteTransaction(), shard);
315             final ActorRef subject =
316                 getSystem().actorOf(props, "testCloseTransaction");
317
318             watch(subject);
319
320             new Within(duration("2 seconds")) {
321                 protected void run() {
322
323                     subject.tell(new CloseTransaction(), getRef());
324
325                     final String out = new ExpectMsg<String>("match hint") {
326                         // do not put code outside this method, will run afterwards
327                         protected String match(Object in) {
328                             if (in instanceof CloseTransactionReply) {
329                                 return "match";
330                             } else {
331                                 throw noMatch();
332                             }
333                         }
334                     }.get(); // this extracts the received message
335
336                     assertEquals("match", out);
337
338                     final String termination = new ExpectMsg<String>("match hint") {
339                         // do not put code outside this method, will run afterwards
340                         protected String match(Object in) {
341                             if (in instanceof Terminated) {
342                                 return "match";
343                             } else {
344                                 throw noMatch();
345                             }
346                         }
347                     }.get(); // this extracts the received message
348
349
350                     expectNoMsg();
351                 }
352
353
354             };
355         }};
356
357     }
358
359
360 }

©2013 OpenDaylight, A Linux Foundation Collaborative Project. All Rights Reserved.
OpenDaylight is a registered trademark of The OpenDaylight Project, Inc.
Linux Foundation and OpenDaylight are registered trademarks of the Linux Foundation.
Linux is a registered trademark of Linus Torvalds.