6b8658cc4989e39be2f42a935c227389a08be07c
[controller.git] / opendaylight / md-sal / sal-distributed-datastore / src / test / java / org / opendaylight / controller / cluster / datastore / DataTreeChangeListenerActorTest.java
1 /*
2  * Copyright (c) 2015 Cisco Systems, Inc. and others.  All rights reserved.
3  *
4  * This program and the accompanying materials are made available under the
5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6  * and is available at http://www.eclipse.org/legal/epl-v10.html
7  */
8 package org.opendaylight.controller.cluster.datastore;
9
10 import akka.actor.ActorRef;
11 import akka.actor.DeadLetter;
12 import akka.actor.Props;
13 import akka.testkit.JavaTestKit;
14 import com.google.common.collect.ImmutableList;
15 import org.junit.Assert;
16 import org.junit.Test;
17 import org.mockito.Matchers;
18 import org.mockito.Mockito;
19 import org.opendaylight.controller.cluster.datastore.messages.DataTreeChanged;
20 import org.opendaylight.controller.cluster.datastore.messages.DataTreeChangedReply;
21 import org.opendaylight.controller.cluster.datastore.messages.EnableNotification;
22 import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeChangeListener;
23 import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
24
25 public class DataTreeChangeListenerActorTest extends AbstractActorTest {
26
27     @Test
28     public void testDataChangedWhenNotificationsAreEnabled() {
29         new JavaTestKit(getSystem()) {
30             {
31                 final DataTreeCandidate mockTreeCandidate = Mockito.mock(DataTreeCandidate.class);
32                 final ImmutableList<DataTreeCandidate> mockCandidates = ImmutableList.of(mockTreeCandidate);
33                 final DOMDataTreeChangeListener mockListener = Mockito.mock(DOMDataTreeChangeListener.class);
34                 final Props props = DataTreeChangeListenerActor.props(mockListener);
35                 final ActorRef subject = getSystem().actorOf(props, "testDataTreeChangedNotificationsEnabled");
36
37                 // Let the DataChangeListener know that notifications should be
38                 // enabled
39                 subject.tell(new EnableNotification(true), getRef());
40
41                 subject.tell(new DataTreeChanged(mockCandidates), getRef());
42
43                 expectMsgClass(DataTreeChangedReply.class);
44
45                 Mockito.verify(mockListener).onDataTreeChanged(mockCandidates);
46             }
47         };
48     }
49
50     @Test
51     public void testDataChangedWhenNotificationsAreDisabled() {
52         new JavaTestKit(getSystem()) {
53             {
54                 final DataTreeCandidate mockTreeCandidate = Mockito.mock(DataTreeCandidate.class);
55                 final ImmutableList<DataTreeCandidate> mockCandidates = ImmutableList.of(mockTreeCandidate);
56                 final DOMDataTreeChangeListener mockListener = Mockito.mock(DOMDataTreeChangeListener.class);
57                 final Props props = DataTreeChangeListenerActor.props(mockListener);
58                 final ActorRef subject = getSystem().actorOf(props, "testDataTreeChangedNotificationsDisabled");
59
60                 subject.tell(new DataTreeChanged(mockCandidates), getRef());
61
62                 new Within(duration("1 seconds")) {
63                     @Override
64                     protected void run() {
65                         expectNoMsg();
66
67                         Mockito.verify(mockListener, Mockito.never())
68                                 .onDataTreeChanged(Matchers.anyCollectionOf(DataTreeCandidate.class));
69                     }
70                 };
71             }
72         };
73     }
74
75     @Test
76     public void testDataChangedWithNoSender() {
77         new JavaTestKit(getSystem()) {
78             {
79                 final DataTreeCandidate mockTreeCandidate = Mockito.mock(DataTreeCandidate.class);
80                 final ImmutableList<DataTreeCandidate> mockCandidates = ImmutableList.of(mockTreeCandidate);
81                 final DOMDataTreeChangeListener mockListener = Mockito.mock(DOMDataTreeChangeListener.class);
82                 final Props props = DataTreeChangeListenerActor.props(mockListener);
83                 final ActorRef subject = getSystem().actorOf(props, "testDataTreeChangedWithNoSender");
84
85                 getSystem().eventStream().subscribe(getRef(), DeadLetter.class);
86
87                 subject.tell(new DataTreeChanged(mockCandidates), ActorRef.noSender());
88
89                 // Make sure no DataChangedReply is sent to DeadLetters.
90                 while (true) {
91                     DeadLetter deadLetter;
92                     try {
93                         deadLetter = expectMsgClass(duration("1 seconds"), DeadLetter.class);
94                     } catch (AssertionError e) {
95                         // Timed out - got no DeadLetter - this is good
96                         break;
97                     }
98
99                     // We may get DeadLetters for other messages we don't care
100                     // about.
101                     Assert.assertFalse("Unexpected DataTreeChangedReply",
102                             deadLetter.message() instanceof DataTreeChangedReply);
103                 }
104             }
105         };
106     }
107
108     @Test
109     public void testDataChangedWithListenerRuntimeEx() {
110         new JavaTestKit(getSystem()) {
111             {
112                 final DataTreeCandidate mockTreeCandidate1 = Mockito.mock(DataTreeCandidate.class);
113                 final ImmutableList<DataTreeCandidate> mockCandidates1 = ImmutableList.of(mockTreeCandidate1);
114                 final DataTreeCandidate mockTreeCandidate2 = Mockito.mock(DataTreeCandidate.class);
115                 final ImmutableList<DataTreeCandidate> mockCandidates2 = ImmutableList.of(mockTreeCandidate2);
116                 final DataTreeCandidate mockTreeCandidate3 = Mockito.mock(DataTreeCandidate.class);
117                 final ImmutableList<DataTreeCandidate> mockCandidates3 = ImmutableList.of(mockTreeCandidate3);
118
119                 final DOMDataTreeChangeListener mockListener = Mockito.mock(DOMDataTreeChangeListener.class);
120                 Mockito.doThrow(new RuntimeException("mock")).when(mockListener).onDataTreeChanged(mockCandidates2);
121
122                 Props props = DataTreeChangeListenerActor.props(mockListener);
123                 ActorRef subject = getSystem().actorOf(props, "testDataTreeChangedWithListenerRuntimeEx");
124
125                 // Let the DataChangeListener know that notifications should be
126                 // enabled
127                 subject.tell(new EnableNotification(true), getRef());
128
129                 subject.tell(new DataTreeChanged(mockCandidates1), getRef());
130                 expectMsgClass(DataTreeChangedReply.class);
131
132                 subject.tell(new DataTreeChanged(mockCandidates2), getRef());
133                 expectMsgClass(DataTreeChangedReply.class);
134
135                 subject.tell(new DataTreeChanged(mockCandidates3), getRef());
136                 expectMsgClass(DataTreeChangedReply.class);
137
138                 Mockito.verify(mockListener).onDataTreeChanged(mockCandidates1);
139                 Mockito.verify(mockListener).onDataTreeChanged(mockCandidates2);
140                 Mockito.verify(mockListener).onDataTreeChanged(mockCandidates3);
141             }
142         };
143     }
144 }

©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.