package com.atlassian.event.internal;
   
   
   import com.atlassian.event.api.EventListener;
   import com.atlassian.event.api.EventPublisher;
   import com.atlassian.plugin.ModuleDescriptor;
   import com.atlassian.plugin.Plugin;
   import com.atlassian.plugin.eventlistener.descriptors.EventListenerModuleDescriptor;
   import com.atlassian.plugin.module.ModuleFactory;
  import com.atlassian.plugin.scope.ScopeManager;
  import org.dom4j.Element;
  import org.junit.Before;
  import org.junit.Test;
  import org.junit.runner.RunWith;
  import org.mockito.Mock;
  import org.mockito.runners.MockitoJUnitRunner;
  
  import java.util.Collections;
  import java.util.Optional;
  
  import static java.util.Collections.singleton;
  import static org.mockito.Matchers.any;
  import static org.mockito.Matchers.anyString;
  import static org.mockito.Mockito.never;
  import static org.mockito.Mockito.verify;
  import static org.mockito.Mockito.when;
  
  @RunWith(MockitoJUnitRunner.class)
  public class EventPublisherImplScopeTest {
  
      @Mock
      Object event;
  
      @Mock
      Runnable op;
  
      @Mock
      Plugin licensedPlugin;
  
      @Mock
      Element element;
  
      @Mock
      ScopeManager scopeManager;
  
      @Mock
      ModuleFactory moduleFactory;
  
      private static class UnscopedListener {
          final Runnable runnable;
  
          UnscopedListener(Runnable runnable) {
              this.runnable = runnable;
          }
  
          @EventListener
          public void onObjectEvent(final Object event) {
              runnable.run();
          }
      }
  
      private static class ScopedListener {
          final Runnable runnable;
  
          ScopedListener(Runnable runnable) {
              this.runnable = runnable;
          }
  
          @EventListener(scope = "atlassian-event")
          public void onObjectEvent(final Object event) {
              runnable.run();
          }
      }
  
      private EventPublisher eventPublisher;
  
      @Before
      public final void setUp() {
          eventPublisher = new EventPublisherImpl(new StubEventDispatcher(),
                  () -> Collections.singletonList(new AnnotatedMethodsListenerHandler())
                  , scopeManager);
      }
  
      private void registerListenerViaModuleWithScope(Object listener, Optional<String> scope) {
          when(moduleFactory.createModule(anyString(), any(ModuleDescriptor.class))).thenReturn(listener);
          final EventListenerModuleDescriptor licensedDescriptor = new EventListenerModuleDescriptor(moduleFactory, eventPublisher);
          when(licensedPlugin.getActivePermissions()).thenReturn(singleton("execute_java"));
  
          when(licensedPlugin.getScopeKey()).thenReturn(scope);
  
          licensedDescriptor.init(licensedPlugin, element);
  
          eventPublisher.register(licensedDescriptor);
      }
  
      @Test
      public final void testScopedModuleDescriptorIfNoActiveLicense() {
          when(scopeManager.isScopeActive(anyString())).thenReturn(false);
  
         registerListenerViaModuleWithScope(new UnscopedListener(op), Optional.of("events"));
 
         eventPublisher.publish(event);
 
         verify(op, never()).run();
     }
 
     @Test
     public final void testScopedModuleDescriptorWithActiveLicense() {
         when(scopeManager.isScopeActive(anyString())).thenReturn(true);
 
         registerListenerViaModuleWithScope(new UnscopedListener(op), Optional.of("events"));
 
         eventPublisher.publish(event);
 
         verify(op).run();
     }
 
     @Test
     public final void testUnScopedModuleDescriptorWithNoActiveLicense() {
         when(scopeManager.isScopeActive(anyString())).thenReturn(false);
 
         registerListenerViaModuleWithScope(new UnscopedListener(op), Optional.empty());
 
         eventPublisher.publish(event);
 
         verify(op).run();
     }
 
     @Test
     public final void verifyUnscopedListenersRunWhenNoScopesAreNotActive() {
         when(scopeManager.isScopeActive(anyString())).thenReturn(false);
 
         eventPublisher.register(new UnscopedListener(op));
 
         eventPublisher.publish(event);
 
         verify(op).run();
     }
 
     @Test
     public final void verifyUnscopedListenersNotRunWhenNoScopesAreActive() {
         when(scopeManager.isScopeActive(anyString())).thenReturn(false);
 
         eventPublisher.register(new ScopedListener(op));
 
         eventPublisher.publish(event);
 
         verify(op, never()).run();
     }
 
     @Test
     public final void verifyUnscopedListenersRunWhenScopesAreActive() {
         when(scopeManager.isScopeActive(anyString())).thenReturn(true);
 
         eventPublisher.register(new ScopedListener(op));
 
         eventPublisher.publish(event);
 
         verify(op).run();
     }
 
     @Test(expected = IllegalArgumentException.class)
     public final void verifyScopedOverrideFails() {
         when(scopeManager.isScopeActive(anyString())).thenReturn(false);
 
         registerListenerViaModuleWithScope(new ScopedListener(op), Optional.of("not-atlassian-event"));
 
         eventPublisher.publish(event);
 
         verify(op, never()).run();
     }
 
     @Test
     public final void verifyScopedOverrideOkWhenScopeIsTheSame() {
         when(scopeManager.isScopeActive(anyString())).thenReturn(true);
 
         registerListenerViaModuleWithScope(new ScopedListener(op), Optional.of("atlassian-event"));
 
         eventPublisher.publish(event);
 
         verify(op).run();
     }
 }