package com.atlassian.plugin.loaders;
   
   import java.io.File;
   import java.util.Arrays;
   
   import com.atlassian.plugin.ModuleDescriptorFactory;
   import com.atlassian.plugin.Plugin;
   import com.atlassian.plugin.PluginArtifact;
   import com.atlassian.plugin.PluginArtifactFactory;
  import com.atlassian.plugin.PluginException;
  import com.atlassian.plugin.event.PluginEventManager;
  import com.atlassian.plugin.event.events.PluginFrameworkShutdownEvent;
  import com.atlassian.plugin.factories.PluginFactory;
  import com.atlassian.plugin.impl.AbstractDelegatingPlugin;
  import com.atlassian.plugin.impl.UnloadablePlugin;
  import com.atlassian.plugin.loaders.classloading.DeploymentUnit;
  import com.atlassian.plugin.loaders.classloading.Scanner;
  
  import com.google.common.collect.Iterables;
  
  import org.junit.Before;
  import org.junit.Test;
  import org.junit.runner.RunWith;
  import org.mockito.Mock;
  import org.mockito.runners.MockitoJUnitRunner;
  
  import static org.hamcrest.Matchers.containsInAnyOrder;
  import static org.junit.Assert.assertEquals;
  import static org.junit.Assert.assertNotNull;
  import static org.junit.Assert.assertNotSame;
  import static org.junit.Assert.assertSame;
  import static org.junit.Assert.assertThat;
  import static org.junit.Assert.assertTrue;
  import static org.junit.Assert.fail;
  import static org.mockito.Mockito.mock;
  import static org.mockito.Mockito.never;
  import static org.mockito.Mockito.verify;
  import static org.mockito.Mockito.when;
  
  @RunWith (MockitoJUnitRunner.class)
  public class TestScanningPluginLoader
  {
      @Mock
      private PluginArtifactFactory pluginArtifactFactory;
  
      @Mock
      private PluginArtifact pluginArtifact;
  
      @Mock
      private PluginFactory pluginFactory;
  
      @Mock
      private ModuleDescriptorFactory moduleDescriptorFactory;
  
      @Mock
      private Plugin plugin;
  
      @Mock
      private Scanner scanner;
  
      @Mock
      private PluginEventManager pluginEventManager;
  
      @Before
      public void configureMocks()
      {
          DeploymentUnit unit = new DeploymentUnit(new File("foo.jar"));
          when(pluginArtifactFactory.create(unit.getPath().toURI())).thenReturn(pluginArtifact);
          when(pluginFactory.canCreate(pluginArtifact)).thenReturn("foo");
          when(scanner.getDeploymentUnits()).thenReturn(Arrays.asList(unit));
      }
  
      @Test
      public void loadAllPluginsLoadsPlugin()
      {
          when(pluginFactory.create(pluginArtifact, moduleDescriptorFactory)).thenReturn(plugin);
  
          ScanningPluginLoader loader = buildScanningPluginLoader();
          Iterable<Plugin> plugins = loader.loadAllPlugins(moduleDescriptorFactory);
          assertThat(plugins, containsInAnyOrder(plugin));
      }
  
      @Test
      public void discardedPluginIsNotTracked()
      {
          when(plugin.isUninstallable()).thenReturn(true);
          when(pluginFactory.create(pluginArtifact, moduleDescriptorFactory)).thenReturn(plugin);
  
          ScanningPluginLoader loader = buildScanningPluginLoader();
          Iterable<Plugin> plugins = loader.loadAllPlugins(moduleDescriptorFactory);
          assertThat(plugins, containsInAnyOrder(plugin));
          loader.discardPlugin(plugin);
          try
          {
              // Discarded, so removal should fail event though isUninstallable
              loader.removePlugin(plugin);
              fail();
          }
          catch(PluginException pe)
         {
             // Expected
         }
         // Shutdown should not result in uninstall of discarded plugin
         loader.onShutdown(mock(PluginFrameworkShutdownEvent.class));
         verify(plugin, never()).uninstall();
     }
 
     @Test
     public void shutdownUninstallsUninstallablePlugin()
     {
         when(plugin.isUninstallable()).thenReturn(true);
         when(pluginFactory.create(pluginArtifact, moduleDescriptorFactory)).thenReturn(plugin);
 
         ScanningPluginLoader loader = buildScanningPluginLoader();
         loader.loadAllPlugins(moduleDescriptorFactory);
         loader.onShutdown(mock(PluginFrameworkShutdownEvent.class));
         verify(plugin).uninstall();
     }
 
     @Test
     public void shutdownDoesNotUninstallNotUninstallablePlugin()
     {
         when(plugin.isUninstallable()).thenReturn(false);
         when(pluginFactory.create(pluginArtifact, moduleDescriptorFactory)).thenReturn(plugin);
 
         ScanningPluginLoader loader = buildScanningPluginLoader();
         loader.loadAllPlugins(moduleDescriptorFactory);
         loader.onShutdown(mock(PluginFrameworkShutdownEvent.class));
         verify(plugin, never()).uninstall();
     }
 
     @Test
     public void factoryThrowingRuntimeExceptionYieldsUnloadablePlugin()
     {
         factoryThrowingYieldsUnloadablePlugin(new IllegalArgumentException());
     }
 
     @Test
     public void factoryThrowingErrorYieldsUnloadablePlugin()
     {
         factoryThrowingYieldsUnloadablePlugin(new NoClassDefFoundError());
     }
 
     private void factoryThrowingYieldsUnloadablePlugin(final Throwable throwable)
     {
         when(pluginFactory.create(pluginArtifact, moduleDescriptorFactory)).thenThrow(throwable);
 
         ScanningPluginLoader loader = buildScanningPluginLoader();
         Iterable<Plugin> plugins = loader.loadAllPlugins(moduleDescriptorFactory);
         assertNotNull(plugins);
         assertEquals(1, Iterables.size(plugins));
         assertTrue(Iterables.getOnlyElement(plugins) instanceof UnloadablePlugin);
     }
 
     @Test
     public void pluginLoaderCallsPostProcess()
     {
         when(plugin.isUninstallable()).thenReturn(true);
         when(pluginFactory.create(pluginArtifact, moduleDescriptorFactory)).thenReturn(plugin);
 
         ScanningPluginLoader loader = new ScanningPluginLoader(
             scanner, Arrays.asList(pluginFactory), pluginArtifactFactory, pluginEventManager)
         {
             @Override
             protected Plugin postProcess(Plugin plugin)
             {
                 return new WrappedPlugin(plugin);
             }
         };
         Iterable<Plugin> allPlugins = loader.loadAllPlugins(moduleDescriptorFactory);
         assertPluginsIsWrapperFor(allPlugins, plugin);
 
         DeploymentUnit unitB = new DeploymentUnit(new File("bar.jar"));
         PluginArtifact pluginArtifactB = mock(PluginArtifact.class);
         Plugin pluginB = mock(Plugin.class);
         when(scanner.scan()).thenReturn(Arrays.asList(unitB));
         when(pluginArtifactFactory.create(unitB.getPath().toURI())).thenReturn(pluginArtifactB);
         when(pluginFactory.canCreate(pluginArtifactB)).thenReturn("bar");
         when(pluginFactory.create(pluginArtifactB, moduleDescriptorFactory)).thenReturn(pluginB);
 
         Iterable<Plugin> foundPlugins = loader.loadFoundPlugins(moduleDescriptorFactory);
         assertPluginsIsWrapperFor(foundPlugins, pluginB);
     }
 
     /**
      * A wrapper class for the postProcess test.
      *
      * By using a wrapper here, we guarantee postProcess is called, because no one else
      * could have an instance of this private class.
      */
     private class WrappedPlugin extends AbstractDelegatingPlugin
     {
         public WrappedPlugin(final Plugin plugin)
         {
             super(plugin);
         }
     }
 
     private void assertPluginsIsWrapperFor(final Iterable<Plugin> plugins, final Plugin originalPlugin)
     {
         assertNotNull(plugins);
         assertEquals(1, Iterables.size(plugins));
         Plugin loadedPlugin = Iterables.getOnlyElement(plugins);
         assertNotSame(loadedPlugin, originalPlugin);
         assertTrue(loadedPlugin instanceof WrappedPlugin);
         WrappedPlugin wrappedPlugin = (WrappedPlugin) loadedPlugin;
         assertSame(wrappedPlugin.getDelegate(), originalPlugin);
     }
 
     private ScanningPluginLoader buildScanningPluginLoader()
     {
         return new ScanningPluginLoader(scanner, Arrays.asList(pluginFactory), pluginArtifactFactory, pluginEventManager);
     }
 }