1. Project Clover database Tue Dec 20 2016 21:24:09 CET
  2. Package org.xwiki.observation

File ObservationManagerTest.java

 

Code metrics

0
94
9
1
237
159
9
0.1
10.44
9
1

Classes

Class Line # Actions
ObservationManagerTest 50 94 0% 9 0
1.0100%
 

Contributing tests

This file is covered by 9 tests. .

Source view

1    /*
2    * See the NOTICE file distributed with this work for additional
3    * information regarding copyright ownership.
4    *
5    * This is free software; you can redistribute it and/or modify it
6    * under the terms of the GNU Lesser General Public License as
7    * published by the Free Software Foundation; either version 2.1 of
8    * the License, or (at your option) any later version.
9    *
10    * This software is distributed in the hope that it will be useful,
11    * but WITHOUT ANY WARRANTY; without even the implied warranty of
12    * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13    * Lesser General Public License for more details.
14    *
15    * You should have received a copy of the GNU Lesser General Public
16    * License along with this software; if not, write to the Free
17    * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
18    * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
19    */
20    package org.xwiki.observation;
21   
22    import java.util.Arrays;
23    import java.util.Collections;
24   
25    import org.junit.Assert;
26    import org.junit.Rule;
27    import org.junit.Test;
28    import org.mockito.Mockito;
29    import org.slf4j.Logger;
30    import org.xwiki.component.manager.ComponentLookupException;
31    import org.xwiki.observation.event.ActionExecutionEvent;
32    import org.xwiki.observation.event.AllEvent;
33    import org.xwiki.observation.event.Event;
34    import org.xwiki.observation.internal.DefaultObservationManager;
35    import org.xwiki.test.mockito.MockitoComponentMockingRule;
36   
37    import static org.mockito.ArgumentMatchers.any;
38    import static org.mockito.ArgumentMatchers.contains;
39    import static org.mockito.ArgumentMatchers.same;
40    import static org.mockito.Mockito.mock;
41    import static org.mockito.Mockito.never;
42    import static org.mockito.Mockito.verify;
43    import static org.mockito.Mockito.when;
44   
45    /**
46    * Unit tests for {@link ObservationManager}.
47    *
48    * @version $Id: 5050e20f7c46021b9d0eea5fd971c94a12795d36 $
49    */
 
50    public class ObservationManagerTest
51    {
52    @Rule
53    public final MockitoComponentMockingRule<ObservationManager> mocker =
54    new MockitoComponentMockingRule<ObservationManager>(DefaultObservationManager.class);
55   
 
56  1 toggle @Test
57    public void testNotifyWhenMatching() throws ComponentLookupException
58    {
59  1 final EventListener listener = mock(EventListener.class);
60  1 final Event event = mock(Event.class);
61   
62  1 when(listener.getName()).thenReturn("mylistener");
63  1 when(listener.getEvents()).thenReturn(Arrays.asList(event));
64  1 when(event.matches(event)).thenReturn(true);
65   
66  1 this.mocker.getComponentUnderTest().addListener(listener);
67  1 Assert.assertSame(listener, this.mocker.getComponentUnderTest().getListener("mylistener"));
68  1 this.mocker.getComponentUnderTest().notify(event, "some source", "some data");
69  1 verify(listener).onEvent(event, "some source", "some data");
70    }
71   
 
72  1 toggle @Test
73    public void testRemoveListener() throws ComponentLookupException
74    {
75  1 final EventListener listener = mock(EventListener.class);
76  1 final Event event = mock(Event.class);
77   
78  1 when(listener.getName()).thenReturn("mylistener");
79  1 when(listener.getEvents()).thenReturn(Arrays.asList(event));
80   
81  1 this.mocker.getComponentUnderTest().addListener(listener);
82  1 this.mocker.getComponentUnderTest().removeListener("mylistener");
83  1 this.mocker.getComponentUnderTest().notify(event, null);
84  1 verify(listener, never()).onEvent(any(Event.class), any(), any());
85    }
86   
 
87  1 toggle @Test
88    public void testAddEvent() throws Exception
89    {
90  1 final EventListener listener = mock(EventListener.class);
91  1 final Event initialEvent = mock(Event.class, "initial");
92  1 final Event afterEvent = mock(Event.class, "after");
93  1 final Event notifyEvent = mock(Event.class, "notify");
94   
95  1 when(listener.getName()).thenReturn("mylistener");
96  1 when(listener.getEvents()).thenReturn(Arrays.asList(initialEvent));
97   
98    // Since the observation returns the first matching event, return false from initialEvent so that
99    // afterEvent is called.
100  1 when(initialEvent.matches(notifyEvent)).thenReturn(false);
101  1 when(afterEvent.matches(notifyEvent)).thenReturn(true);
102   
103  1 this.mocker.getComponentUnderTest().addListener(listener);
104  1 this.mocker.getComponentUnderTest().addEvent("mylistener", afterEvent);
105  1 this.mocker.getComponentUnderTest().notify(notifyEvent, null);
106  1 verify(listener).onEvent(notifyEvent, null, null);
107    }
108   
 
109  1 toggle @Test
110    public void testAddEventWithNoInitialEvent() throws Exception
111    {
112  1 final EventListener listener = mock(EventListener.class);
113  1 final Event afterEvent = mock(Event.class, "after");
114  1 final Event notifyEvent = mock(Event.class, "notify");
115   
116  1 when(listener.getName()).thenReturn("mylistener");
117  1 when(listener.getEvents()).thenReturn(Collections.<Event>emptyList());
118   
119  1 when(afterEvent.matches(notifyEvent)).thenReturn(true);
120   
121  1 this.mocker.getComponentUnderTest().addListener(listener);
122  1 this.mocker.getComponentUnderTest().addEvent("mylistener", afterEvent);
123  1 this.mocker.getComponentUnderTest().notify(notifyEvent, null);
124  1 verify(listener).onEvent(notifyEvent, null, null);
125    }
126   
 
127  1 toggle @Test
128    public void testRemoveEvent() throws ComponentLookupException
129    {
130  1 final EventListener listener = mock(EventListener.class);
131  1 final Event initialEvent = mock(Event.class, "initial");
132  1 final Event afterEvent = mock(Event.class, "after");
133  1 final Event notifyEvent = mock(Event.class, "notify");
134   
135  1 when(listener.getName()).thenReturn("mylistener");
136  1 when(listener.getEvents()).thenReturn(Arrays.asList(initialEvent));
137   
138    // Since the observation returns the first matching event, return false from initialEvent so that
139    // the second event can be called (if there's a second event - in our case it'll be removed but
140    // we still want the test to fail if that doesn't work).
141  1 when(initialEvent.matches(same(notifyEvent))).thenReturn(false);
142   
143  1 this.mocker.getComponentUnderTest().addListener(listener);
144  1 this.mocker.getComponentUnderTest().addEvent("mylistener", afterEvent);
145  1 this.mocker.getComponentUnderTest().removeEvent("mylistener", afterEvent);
146  1 this.mocker.getComponentUnderTest().notify(notifyEvent, null);
147    // Ensure that the afterEvent is never called since we're adding it and removing it
148  1 verify(afterEvent, never()).matches(same(notifyEvent));
149  1 verify(listener, never()).onEvent(afterEvent, null, null);
150    }
151   
152    /** Verify that we can register two listeners on the same event and they'll both receive the event. */
 
153  1 toggle @Test
154    public void testRegisterSeveralListenersForSameEvent() throws ComponentLookupException
155    {
156  1 final EventListener listener1 = mock(EventListener.class, "listener1");
157  1 final EventListener listener2 = mock(EventListener.class, "listener2");
158  1 final Event event = mock(Event.class, "event");
159  1 final Event notifyEvent = mock(Event.class, "notify");
160   
161  1 when(listener1.getName()).thenReturn("listener 1");
162  1 when(listener2.getName()).thenReturn("listener 2");
163  1 when(listener1.getEvents()).thenReturn(Arrays.asList(event));
164  1 when(listener2.getEvents()).thenReturn(Arrays.asList(event));
165   
166  1 when(event.matches(notifyEvent)).thenReturn(true);
167   
168  1 this.mocker.getComponentUnderTest().addListener(listener1);
169  1 this.mocker.getComponentUnderTest().addListener(listener2);
170  1 this.mocker.getComponentUnderTest().notify(notifyEvent, null);
171  1 verify(listener1).onEvent(notifyEvent, null, null);
172  1 verify(listener2).onEvent(notifyEvent, null, null);
173    }
174   
175    /** Verify that we can register a listener to receive any kind of event using AllEvent event type. */
 
176  1 toggle @Test
177    public void testRegisterListenerForAllEvents() throws ComponentLookupException
178    {
179  1 final EventListener listener = mock(EventListener.class);
180  1 final Event event = mock(Event.class);
181   
182  1 when(listener.getName()).thenReturn("mylistener");
183  1 when(listener.getEvents()).thenReturn(Arrays.asList(AllEvent.ALLEVENT));
184   
185  1 this.mocker.getComponentUnderTest().addListener(listener);
186  1 Assert.assertSame(listener, this.mocker.getComponentUnderTest().getListener("mylistener"));
187  1 this.mocker.getComponentUnderTest().notify(event, "some source", "some data");
188  1 verify(listener).onEvent(event, "some source", "some data");
189    }
190   
191    /** Verify that a warning is logged is we try to register a listener with the same name. */
 
192  1 toggle @Test
193    public void testRegisterSameListenerSeveralTimes() throws ComponentLookupException
194    {
195  1 final EventListener listener = mock(EventListener.class);
196   
197  1 when(listener.getName()).thenReturn("mylistener");
198  1 when(listener.getEvents()).thenReturn(Arrays.asList(AllEvent.ALLEVENT));
199    // The check is performed here, we verify that a warning is correctly logged
200   
201  1 this.mocker.getComponentUnderTest().addListener(listener);
202    // Will raise log warning on the next line
203  1 this.mocker.getComponentUnderTest().addListener(listener);
204   
205  1 final Logger logger = this.mocker.getMockedLogger();
206  1 verify(logger).warn(contains("listener is overwritting a previously registered listener"), any(), any(), any());
207   
208    // Verify that no log is logged if we remove the listener before re-registering it
209  1 this.mocker.getComponentUnderTest().removeListener("mylistener");
210    // Next line will not log any warning
211  1 this.mocker.getComponentUnderTest().addListener(listener);
212  1 Mockito.verifyNoMoreInteractions(logger);
213    }
214   
215    /**
216    * Verify that we can register a listener with two events of the same type but with not matching the same thing and
217    * it will receive both events.
218    */
 
219  1 toggle @Test
220    public void testRegisterListenerForTwoEventsOfSameType() throws ComponentLookupException
221    {
222  1 final EventListener listener = mock(EventListener.class);
223  1 @SuppressWarnings("deprecation")
224    final Event eventMatcher1 = new ActionExecutionEvent("action1");
225  1 @SuppressWarnings("deprecation")
226    final Event eventMatcher2 = new ActionExecutionEvent("action2");
227   
228  1 when(listener.getName()).thenReturn("mylistener");
229  1 when(listener.getEvents()).thenReturn(Arrays.asList(eventMatcher1, eventMatcher2));
230   
231  1 this.mocker.getComponentUnderTest().addListener(listener);
232  1 this.mocker.getComponentUnderTest().notify(eventMatcher1, "some source", "some data");
233  1 this.mocker.getComponentUnderTest().notify(eventMatcher2, "some source", "some data");
234  1 verify(listener).onEvent(eventMatcher1, "some source", "some data");
235  1 verify(listener).onEvent(eventMatcher2, "some source", "some data");
236    }
237    }