package com.atlassian.plugin.event.impl;
   
   import com.atlassian.event.api.EventListener;
   import com.atlassian.event.api.EventPublisher;
   import com.atlassian.plugin.event.PluginEventListener;
   import org.junit.After;
   import org.junit.Before;
   import org.junit.Test;
   import org.junit.runner.RunWith;
  import org.mockito.Mock;
  import org.mockito.runners.MockitoJUnitRunner;
  
  import java.lang.reflect.Method;
  
  import static org.hamcrest.core.IsNull.notNullValue;
  import static org.junit.Assert.assertEquals;
  import static org.junit.Assert.assertThat;
  import static org.junit.Assert.fail;
  import static org.mockito.Matchers.anyObject;
  import static org.mockito.Matchers.anyString;
  import static org.mockito.Mockito.mock;
  import static org.mockito.Mockito.never;
  import static org.mockito.Mockito.times;
  import static org.mockito.Mockito.verify;
  
  @RunWith(MockitoJUnitRunner.class)
  public class TestDefaultPluginEventManager {
      private final Object someObject = new Object();
      private final String someString = "string";
  
      @Mock
      private MethodTestListener methodTestListener;
  
      private DefaultPluginEventManager defaultPluginEventManager;
  
      @Before
      public void createDefaultPluginEventManager() {
          defaultPluginEventManager = new DefaultPluginEventManager();
          assertThat(defaultPluginEventManager.getEventPublisher(), notNullValue(EventPublisher.class));
      }
  
      @After
      public void discardDefaultPluginEventManager() {
          defaultPluginEventManager = null;
      }
  
      @Test
      public void broadcastCallsListenerChannelForType() {
          defaultPluginEventManager.register(methodTestListener);
          defaultPluginEventManager.broadcast(someObject);
          verify(methodTestListener).channel(someObject);
          verify(methodTestListener, never()).channel(anyString());
      }
  
      @Test
      public void broadcastCallsListenerChannelForSupertype() {
          final Integer someInteger = 0;
          defaultPluginEventManager.register(methodTestListener);
          defaultPluginEventManager.broadcast(someInteger);
          verify(methodTestListener).channel(someInteger);
          verify(methodTestListener, never()).channel(anyString());
      }
  
      @Test
      public void broadcastCallsListenerChannelForTypeAndSupertype() {
          defaultPluginEventManager.register(methodTestListener);
          defaultPluginEventManager.broadcast(someString);
          // The cast ensures we verify both overloads are called
          verify(methodTestListener).channel((Object) someString);
          verify(methodTestListener).channel(someString);
      }
  
      @Test
      public void listenerCalledOnceEvenIfRegisteredTwice() {
          defaultPluginEventManager.register(methodTestListener);
          defaultPluginEventManager.register(methodTestListener);
          defaultPluginEventManager.broadcast(someObject);
          verify(methodTestListener).channel(someObject);
          verify(methodTestListener, never()).channel(anyString());
      }
  
      @Test
      public void registerUnmatchingListenerThrows() {
          BadListener badListener = mock(BadListener.class);
          try {
              defaultPluginEventManager.register(badListener);
              fail();
          } catch (IllegalArgumentException ex) {
              // test passed
          }
          verify(badListener, never()).someMethod();
      }
  
      @Test
      public void customSelectorMatchesAndOverridesDefault() {
          ListenerMethodSelector onEventSelector = new ListenerMethodSelector() {
              public boolean isListenerMethod(Method method) {
                  return "onEvent".equals(method.getName());
              }
         };
         defaultPluginEventManager = new DefaultPluginEventManager(onEventSelector);
         defaultPluginEventManager.register(methodTestListener);
         defaultPluginEventManager.broadcast(someString);
         verify(methodTestListener).onEvent(someString);
         verify(methodTestListener, never()).channel(anyObject());
         verify(methodTestListener, never()).channel(anyString());
     }
 
     @Test
     public void overlappingSelectorsBothMatch() {
         ListenerMethodSelector firstSelector = new MethodNameListenerMethodSelector();
         ListenerMethodSelector secondSelector = new MethodNameListenerMethodSelector();
         defaultPluginEventManager = new DefaultPluginEventManager(firstSelector, secondSelector);
         defaultPluginEventManager.register(methodTestListener);
         defaultPluginEventManager.broadcast(someObject);
         verify(methodTestListener, times(2)).channel(someObject);
     }
 
     @Test
     public void broadcastCallsAnnotatedMethods() {
         // I don't believe this can be done with mocks, because the stub
         // is not annotated, and i don't see a way of getting it annotated.
         AnnotationTestListener listener = new AnnotationTestListener();
         defaultPluginEventManager.register(listener);
         defaultPluginEventManager.broadcast(someObject);
         assertEquals(1, listener.eventListenerCalled);
         assertEquals(1, listener.pluginEventListenerCalled);
     }
 
     @Test
     public void unregisterStopsBroadcastSendingEvents() {
         defaultPluginEventManager.register(methodTestListener);
         defaultPluginEventManager.broadcast(someObject);
         verify(methodTestListener).channel(someObject);
         defaultPluginEventManager.unregister(methodTestListener);
         defaultPluginEventManager.broadcast(someObject);
         // This checks it was called once, i.e. first broadcast
         verify(methodTestListener).channel(someObject);
     }
 
     @Test(expected = IllegalArgumentException.class)
     public void registerNullThrows() {
         defaultPluginEventManager.register(null);
     }
 
     @Test(expected = IllegalArgumentException.class)
     public void unregisterNullThrows() {
         defaultPluginEventManager.unregister(null);
     }
 
     public static class AnnotationTestListener {
         int pluginEventListenerCalled = 0;
         int eventListenerCalled = 0;
 
         @PluginEventListener
         public void doEventOld(Object obj) {
             ++pluginEventListenerCalled;
         }
 
         @EventListener
         public void doEventNew(Object obj) {
             ++eventListenerCalled;
         }
     }
 
     public static class MethodTestListener {
         public void channel(Object object) {
         }
 
         public void channel(String string) {
         }
 
         public void onEvent(String string) {
         }
     }
 
     public static class BadListener {
         public void someMethod() {
         }
     }
 }