package com.atlassian.plugin.manager;
   
   import java.util.Arrays;
   import java.util.HashSet;
   import java.util.Set;
   
   import com.atlassian.plugin.MockPluginAccessor;
   import com.atlassian.plugin.Plugin;
   import com.atlassian.plugin.PluginAccessor;
  import com.atlassian.plugin.PluginController;
  import com.atlassian.plugin.PluginException;
  import com.atlassian.plugin.PluginState;
  import com.atlassian.plugin.exception.PluginExceptionInterception;
  import com.atlassian.plugin.impl.StaticPlugin;
  
  import org.junit.Before;
  import org.junit.Rule;
  import org.junit.Test;
  import org.junit.contrib.java.lang.system.RestoreSystemProperties;
  import org.junit.runner.RunWith;
  import org.mockito.Mock;
  import org.mockito.runners.MockitoJUnitRunner;
  
  import static com.atlassian.plugin.util.PluginUtils.ATLASSIAN_PLUGINS_ENABLE_WAIT;
  import static org.hamcrest.MatcherAssert.assertThat;
  import static org.hamcrest.Matchers.is;
  import static org.hamcrest.Matchers.lessThan;
  import static org.mockito.Mockito.mock;
  import static org.mockito.Mockito.verify;
  import static org.mockito.Mockito.withSettings;
  
  @RunWith (MockitoJUnitRunner.class)
  public class TestPluginEnabler
  {
      @Rule public RestoreSystemProperties restoreSystemProperties =
              new RestoreSystemProperties(ATLASSIAN_PLUGINS_ENABLE_WAIT);
  
      @Mock private PluginAccessor pluginAccessor;
      @Mock private PluginController pluginController;
      @Mock private PluginExceptionInterception pluginExceptionInterception;
  
      private PluginEnabler pluginEnabler;
  
      @Before
      public void setUp()
      {
          pluginEnabler = new PluginEnabler(pluginAccessor, pluginController, pluginExceptionInterception);
      }
  
      @Test
      public void enablePlugin()
      {
          final Plugin plugin = new MyPlugin("foo");
  
          pluginEnabler.enable(Arrays.asList(plugin));
          assertThat(plugin.getPluginState(), is(PluginState.ENABLED));
      }
  
      @Test
      public void enableResolvesResolvablePlugins()
      {
          final Plugin resolvablePlugin = mock(Plugin.class, withSettings().extraInterfaces(Plugin.Resolvable.class));
          pluginEnabler.enable(Arrays.asList(resolvablePlugin));
          verify((Plugin.Resolvable) resolvablePlugin).resolve();
          verify(resolvablePlugin).enable();
      }
  
      @Test
      public void customTimeoutTimesOut()
      {
          final Plugin plugin = new MyPlugin("foo")
          {
              @Override
              protected PluginState enableInternal() throws PluginException
              {
                  return PluginState.ENABLING;
              }
          };
  
          System.setProperty(ATLASSIAN_PLUGINS_ENABLE_WAIT, "1");
          final long start = System.currentTimeMillis();
          pluginEnabler = new PluginEnabler(mock(PluginAccessor.class), mock(PluginController.class), pluginExceptionInterception);
          pluginEnabler.enable(Arrays.asList(plugin));
          final long end = System.currentTimeMillis();
          assertThat(end - start, lessThan(5000L));
          assertThat(plugin.getPluginState(), is(PluginState.ENABLING));
      }
  
      @Test
      public void enableMultiplePluginsWithDependencies()
      {
          final Plugin plugin = new MyPlugin("foo", "foo2");
          final Plugin plugin2 = new MyPlugin("foo2", "foo3");
          final Plugin plugin3 = new MyPlugin("foo3");
  
          pluginEnabler.enable(Arrays.asList(plugin, plugin2, plugin3));
          assertThat(plugin.getPluginState(), is(PluginState.ENABLED));
          assertThat(plugin2.getPluginState(), is(PluginState.ENABLED));
          assertThat(plugin3.getPluginState(), is(PluginState.ENABLED));
     }
 
     @Test
     public void enablingPluginAlsoEnablesRequiredPluginsTransitively()
     {
         final Plugin plugin = new MyPlugin("foo", "foo2");
         final Plugin plugin2 = new MyPlugin("foo2", "foo3");
         final Plugin plugin3 = new MyPlugin("foo3");
         final MockPluginAccessor accessor = new MockPluginAccessor();
         accessor.addPlugin(plugin);
         accessor.addPlugin(plugin2);
         accessor.addPlugin(plugin3);
 
         pluginEnabler = new PluginEnabler(accessor, mock(PluginController.class), pluginExceptionInterception);
 
         // Enable a single plugin, which will recursively enable all deps
         pluginEnabler.enableAllRecursively(Arrays.asList(plugin));
         assertThat(plugin.getPluginState(), is(PluginState.ENABLED));
         assertThat(plugin2.getPluginState(), is(PluginState.ENABLED));
         assertThat(plugin3.getPluginState(), is(PluginState.ENABLED));
     }
 
     @Test
     public void canEnableCircularlyDependentPlugins()
     {
         final Plugin plugin = new MyPlugin("foo", "foo2");
         final Plugin plugin2 = new MyPlugin("foo2", "foo3");
         final Plugin plugin3 = new MyPlugin("foo3", "foo");
 
         pluginEnabler.enable(Arrays.asList(plugin, plugin2, plugin3));
         assertThat(plugin.getPluginState(), is(PluginState.ENABLED));
         assertThat(plugin2.getPluginState(), is(PluginState.ENABLED));
         assertThat(plugin3.getPluginState(), is(PluginState.ENABLED));
     }
 
     @Test
     public void failedEnableIsPassedToPluginInterception()
     {
         final RuntimeException runtimeException = new RuntimeException();
         final Plugin plugin = new MyPlugin("foo")
         {
             @Override
             protected PluginState enableInternal() throws PluginException
             {
                 throw runtimeException;
             }
         };
 
         pluginEnabler.enable(Arrays.asList(plugin));
         verify(pluginExceptionInterception).onEnableException(plugin, runtimeException);
     }
 
     public static class MyPlugin extends StaticPlugin
     {
         private final Set<String> deps;
 
         public MyPlugin(final String key, final String... deps)
         {
             setKey(key);
             this.deps = new HashSet<String>(Arrays.asList(deps));
             setPluginState(PluginState.DISABLED);
         }
 
         @Override
         public Set<String> getRequiredPlugins()
         {
             return deps;
         }
     }
 }