package com.atlassian.plugin.loaders;
   
   import java.io.File;
   import java.io.IOException;
   import java.net.URISyntaxException;
   import java.util.Collection;
   import java.util.Collections;
   import java.util.List;
   
  import com.atlassian.plugin.ModuleDescriptorFactory;
  import com.atlassian.plugin.Plugin;
  import com.atlassian.plugin.PluginArtifact;
  import com.atlassian.plugin.PluginException;
  import com.atlassian.plugin.event.PluginEventManager;
  import com.atlassian.plugin.loaders.classloading.DeploymentUnit;
  import com.atlassian.plugin.loaders.classloading.Scanner;
  import com.atlassian.plugin.test.PluginJarBuilder;
  import com.atlassian.plugin.factories.PluginFactory;
  import com.atlassian.plugin.test.PluginTestUtils;
  
  import com.google.common.base.Function;
  import com.google.common.collect.ImmutableList;
  import com.google.common.collect.Iterables;
  import com.google.common.collect.Lists;
  
  import org.apache.commons.io.FileUtils;
  import org.junit.After;
  import org.junit.Before;
  import org.junit.Test;
  import org.mockito.ArgumentCaptor;
  
  
  import static org.hamcrest.Matchers.containsInAnyOrder;
  import static org.hamcrest.Matchers.instanceOf;
  import static org.junit.Assert.assertEquals;
  import static org.junit.Assert.assertThat;
  import static org.junit.Assert.assertTrue;
  import static org.junit.Assert.fail;
  import static org.mockito.Matchers.isA;
  import static org.mockito.Matchers.same;
  import static org.mockito.Mockito.mock;
  import static org.mockito.Mockito.verify;
  import static org.mockito.Mockito.when;
  
  
  public class TestBundledPluginLoader
  {
      private File pluginDir;
  
      private static final String fooXml = "foo.xml";
  
      @Before
      public void createTemporaryDirectory() throws IOException, URISyntaxException
      {
          pluginDir = PluginTestUtils.createTempDirectory(TestBundledPluginLoader.class);
      }
  
      @After
      public void deleteTemporaryDirectory() throws Exception
      {
          FileUtils.deleteDirectory(pluginDir);
          pluginDir = null;
      }
  
      @Test
      public void loaderFromZipContainsExpectedFiles() throws IOException
      {
          File bundledZip = buildBundledZip();
          final BundledPluginLoader loader = buildBundledPluginLoader(bundledZip, Collections.<PluginFactory>emptyList());
          assertLoaderContains(loader, fooXml);
      }
  
      @Test
      public void loaderFromDirectoryContainsExpectedFiles() throws IOException
      {
          final File dir = PluginTestUtils.createTempDirectory(TestBundledPluginLoader.class);
          FileUtils.writeStringToFile(new File(dir, "foo.txt"), "hello");
  
          final BundledPluginLoader loader = buildBundledPluginLoader(dir, Collections.<PluginFactory>emptyList());
          assertLoaderContains(loader, "foo.txt");
      }
  
      @Test
      public void loaderFromFileListContainsExpectedFiles() throws IOException
      {
          final File dir = PluginTestUtils.createTempDirectory(TestBundledPluginLoader.class);
          FileUtils.writeStringToFile(new File(dir, "foo.txt"), "hello");
          FileUtils.writeStringToFile(new File(dir, "bar.txt"), "world");
          File listFile = new File(dir, "bundled-plugins.list");
          FileUtils.writeStringToFile(listFile, "foo.txt\nbar.txt");
  
          final BundledPluginLoader loader = buildBundledPluginLoader(listFile, Collections.<PluginFactory>emptyList());
          assertLoaderContains(loader, "foo.txt", "bar.txt");
      }
  
      @Test
      public void loaderScannerDoesNotRemoveUnderlyingFiles() throws IOException
      {
          File bundledZip = buildBundledZip();
 
         final BundledPluginLoader loader = buildBundledPluginLoader(bundledZip, Collections.<PluginFactory>emptyList());
         final Scanner scanner = loader.scanner;
         assertLoaderContains(loader, fooXml);
         final Collection<DeploymentUnit> units = scanner.getDeploymentUnits();
         final int countBefore = units.size();
         int found = 0;
         for (DeploymentUnit unit : units)
         {
             final File file = unit.getPath();
             if (fooXml.equals(file.getName()))
             {
                 found += 1;
                 assertTrue(file.exists());
                 scanner.remove(unit);
                 // Yes, it should still exist
                 assertTrue(file.exists());
             }
         }
         // We should have found a foo.txt
         assertEquals(1, found);
         // We should not have actually removed it from the scanner
         assertEquals(countBefore, scanner.getDeploymentUnits().size());
     }
 
     @Test
     public void loaderRemoveDoesUninstallPlugin() throws IOException
     {
         File bundledZip = buildBundledZip();
         Plugin mockPlugin = mock(Plugin.class);
         PluginFactory pluginFactory = mock(PluginFactory.class);
         ModuleDescriptorFactory moduleDescriptorFactory = mock(ModuleDescriptorFactory.class);
 
         final String key = "plugin.key.foo";
         ArgumentCaptor<PluginArtifact> pluginArtifact = ArgumentCaptor.forClass(PluginArtifact.class);
 
         when(mockPlugin.getKey()).thenReturn(key);
         when(mockPlugin.isDeleteable()).thenReturn(true);
         when(mockPlugin.isUninstallable()).thenReturn(true);
         when(pluginFactory.canCreate(isA(PluginArtifact.class))).thenReturn(key);
         when(pluginFactory.create(pluginArtifact.capture(), same(moduleDescriptorFactory))).thenReturn(mockPlugin);
 
         final BundledPluginLoader loader = buildBundledPluginLoader(bundledZip, ImmutableList.of(pluginFactory));
         Collection<Plugin> plugins = Lists.newArrayList(loader.loadAllPlugins(moduleDescriptorFactory));
         assertEquals(1, plugins.size());
         // Note that the plugin we get back is actually wrapped, so we don't test equality
         Plugin bundledPlugin = Iterables.getOnlyElement(plugins);
         assertEquals(key, bundledPlugin.getKey());
         assertTrue(bundledPlugin.isBundledPlugin());
         assertTrue(bundledPlugin.isDeleteable());
         verify(mockPlugin).isDeleteable();
 
         // Remove it, and check Plugin was uninstalled
         loader.removePlugin(bundledPlugin);
         verify(mockPlugin).isUninstallable();
         verify(mockPlugin).uninstall();
         // Check file on disk didn't get removed
         assertTrue(pluginArtifact.getValue().toFile().exists());
 
         try
         {
             // There's no way to query a loader for its plugins, so we try to unload again and look
             // for the exception. This currently throws because the Plugin is gone. This is a little
             // brittle, because code evolution in the test subject means it might throw because the
             // Plugin state changed, but since the Plugin is a mock, it's state doesn't change
             // without us asking. So it's likely to be good. We could check the exception text, but
             // i reckon this is even more brittle.
             loader.removePlugin(bundledPlugin);
             fail();
         }
         catch (PluginException pe)
         {
             // Yep, all good.
         }
     }
 
     @Test
     public void pluginArtifactsAllowReference() throws IOException
     {
         // Use a list file for the bundle to make it easy to get a jar filename in there
         final File dir = PluginTestUtils.createTempDirectory(TestBundledPluginLoader.class);
         final File bundleList = new File(dir, "bundled-plugins.list");
         FileUtils.writeStringToFile(bundleList, "some.jar\n");
         final Plugin mockPlugin = mock(Plugin.class);
         final PluginFactory pluginFactory = mock(PluginFactory.class);
         final ModuleDescriptorFactory moduleDescriptorFactory = mock(ModuleDescriptorFactory.class);
 
         final String key = "plugin.key.foo";
         final ArgumentCaptor<PluginArtifact> pluginArtifact = ArgumentCaptor.forClass(PluginArtifact.class);
 
         when(mockPlugin.getKey()).thenReturn(key);
         when(pluginFactory.canCreate(isA(PluginArtifact.class))).thenReturn(key);
         when(pluginFactory.create(pluginArtifact.capture(), same(moduleDescriptorFactory))).thenReturn(mockPlugin);
 
         final BundledPluginLoader loader = buildBundledPluginLoader(bundleList, ImmutableList.of(pluginFactory));
         loader.loadAllPlugins(moduleDescriptorFactory);
         assertThat(pluginArtifact.getValue(), instanceOf(PluginArtifact.AllowsReference.class));
         assertTrue(((PluginArtifact.AllowsReference) pluginArtifact.getValue()).allowsReference());
     }
 
     private File buildBundledZip() throws IOException
     {
         return new PluginJarBuilder("bundledPlugins")
             .addResource(fooXml, "<foo/>")
             .buildWithNoManifest();
     }
 
     private BundledPluginLoader buildBundledPluginLoader(File bundle, List<PluginFactory> pluginFactories) throws IOException
     {
         return new BundledPluginLoader(bundle.toURI().toURL(), pluginDir, pluginFactories, mock(PluginEventManager.class));
     }
 
     private void assertLoaderContains(final BundledPluginLoader loader, String ... expectedEntries)
     {
         final Collection<DeploymentUnit> scanned = loader.scanner.scan();
         final Iterable<String> actualEntries = Iterables.transform(scanned, new Function<DeploymentUnit, String>()
         {
             @Override
             public String apply(DeploymentUnit unit)
             {
                 return unit.getPath().getName();
             }
         });
         assertThat(actualEntries, containsInAnyOrder(expectedEntries));
     }
 }