package com.atlassian.plugin.osgi.factory;
   
   import java.io.File;
   import java.io.IOException;
   import java.io.InputStream;
   import java.net.URL;
   import java.net.URLConnection;
   import java.net.URLStreamHandler;
   import java.util.Hashtable;
  import java.util.concurrent.TimeUnit;
  
  import com.atlassian.plugin.IllegalPluginStateException;
  import com.atlassian.plugin.JarPluginArtifact;
  import com.atlassian.plugin.Plugin;
  import com.atlassian.plugin.PluginArtifact;
  import com.atlassian.plugin.osgi.container.OsgiContainerException;
  import com.atlassian.plugin.osgi.container.OsgiContainerManager;
  import com.atlassian.plugin.test.PluginJarBuilder;
  
  import com.google.common.collect.ImmutableMap;
  
  import org.junit.Before;
  import org.junit.Rule;
  import org.junit.Test;
  import org.junit.rules.ExpectedException;
  import org.junit.runner.RunWith;
  import org.mockito.Mock;
  import org.mockito.runners.MockitoJUnitRunner;
  import org.osgi.framework.Bundle;
  import org.osgi.framework.BundleContext;
  import org.osgi.framework.Constants;
  
  import static com.atlassian.plugin.PluginArtifact.AllowsReference.ReferenceMode.PERMIT_REFERENCE;
  import static org.hamcrest.MatcherAssert.assertThat;
  import static org.hamcrest.Matchers.greaterThanOrEqualTo;
  import static org.hamcrest.Matchers.is;
  import static org.hamcrest.Matchers.lessThanOrEqualTo;
  import static org.hamcrest.Matchers.nullValue;
  import static org.hamcrest.Matchers.sameInstance;
  import static org.mockito.Mockito.mock;
  import static org.mockito.Mockito.verify;
  import static org.mockito.Mockito.when;
  import static org.mockito.Mockito.withSettings;
  
  // An IntelliJ pattern to run both tests in this class
  // com.atlassian.plugin.osgi.factory.TestOsgiBundlePlugin$Modern||com.atlassian.plugin.osgi.factory.TestOsgiBundlePlugin$Legacy
  
  /**
   * Tests for OsgiBundlePlugin.
   * <p/>
   * This is an abstract base class for the common functionality between instances created with the preferred constructor {@link
   * OsgiBundlePlugin#OsgiBundlePlugin(OsgiContainerManager, String, PluginArtifact)} and the legacy constructor {@link
   * OsgiBundlePlugin#OsgiBundlePlugin(Bundle, String, PluginArtifact)}. Static inner classes subclass it to configure for the
   * actual tests, and to add additional tests.
   */
  @RunWith (MockitoJUnitRunner.class)
  public abstract class TestOsgiBundlePlugin
  {
      public static final String DESCRIPTION = "A Bundle for Testing";
      public static final String NAME = "Test Bundle";
      public static final String SYMBOLIC_NAME = TestOsgiBundlePlugin.class.getName() + ".testBundle";
      public static final String VENDOR = "Some Bundle Vendor";
      public static final String VERSION = "1.2";
      public static final String PLUGIN_KEY = SYMBOLIC_NAME + "-" + VERSION;
  
      private long testStarted;
  
      @Mock Bundle bundle;
      PluginArtifact pluginArtifact;
  
      OsgiBundlePlugin osgiBundlePlugin;
  
      @Before
      public void setUp() throws Exception
      {
          testStarted = System.currentTimeMillis();
          when(bundle.getHeaders()).thenReturn(new Hashtable<String, String>(getBundleManifest()));
          pluginArtifact = getBundleJarPluginArtifact();
          osgiBundlePlugin = getOsgiBundlePlugin();
      }
  
      protected abstract OsgiBundlePlugin getOsgiBundlePlugin();
  
      @Test
      public void constructorConfiguresPluginCorrectly()
      {
          assertThatPluginIsConfigured(osgiBundlePlugin);
      }
  
      @Test
      public void getDateLoadedIsRecent()
      {
          final long timeLoaded = osgiBundlePlugin.getDateLoaded().getTime();
          final long now = System.currentTimeMillis();
          assertThat(timeLoaded, greaterThanOrEqualTo(testStarted));
          assertThat(timeLoaded, lessThanOrEqualTo(now));
      }
  
      @Test
     public void getDateInstalledMatchesFileTimestamp()
     {
         final long timeInstalled = osgiBundlePlugin.getDateInstalled().getTime();
         assertThat(timeInstalled, is(pluginArtifact.toFile().lastModified()));
     }
 
     @Test
     public void isUninstallableIsTrue()
     {
         assertThat(osgiBundlePlugin.isUninstallable(), is(true));
     }
 
     @Test
     public void isDeleteableIsTrue()
     {
         assertThat(osgiBundlePlugin.isDeleteable(), is(true));
     }
 
     @Test
     public void isDynamicallyLoadedIsTrue()
     {
         assertThat(osgiBundlePlugin.isDynamicallyLoaded(), is(true));
     }
 
     @Test
     public void loadClassForwardsToBundle() throws Exception
     {
         osgiBundlePlugin.install();
         // We're not stressing the class loader here, just checking the api works.
         final String className = "java.lang.String";
         final Class expected = String.class;
         when(bundle.loadClass(className)).thenReturn(expected);
         final Class actual = (Class) osgiBundlePlugin.loadClass(className, getClass());
         verify(bundle).loadClass(className);
         assertThat(actual, sameInstance(expected));
     }
 
     @Test
     public void getResourceForwardsToBundle() throws Exception
     {
         osgiBundlePlugin.install();
         final String resourceName = "someResource";
         final URL expected = new URL("mock", null, 0, "some/resource", mock(URLStreamHandler.class));
         when(bundle.getResource(resourceName)).thenReturn(expected);
         final URL actual = osgiBundlePlugin.getResource(resourceName);
         verify(bundle).getResource(resourceName);
         assertThat(actual, sameInstance(expected));
     }
 
     @Test
     public void getResourceAsStreamForwardsToBundle() throws Exception
     {
         osgiBundlePlugin.install();
         final String resourceName = "someResource";
         final InputStream expected = mock(InputStream.class);
         final URLConnection urlConnection = mock(URLConnection.class);
         when(urlConnection.getInputStream()).thenReturn(expected);
         final URLStreamHandler urlStreamHandler = new URLStreamHandler()
         {
             @Override
             protected URLConnection openConnection(final URL u) throws IOException
             {
                 return urlConnection;
             }
         };
         final URL resourceUrl = new URL("mock", null, 0, "some/resource", urlStreamHandler);
         when(bundle.getResource(resourceName)).thenReturn(resourceUrl);
         final InputStream actual = osgiBundlePlugin.getResourceAsStream(resourceName);
         verify(bundle).getResource(resourceName);
         assertThat(actual, sameInstance(expected));
     }
 
     @Test
     public void getClassLoaderReturnsClassLoaderThatUsesBundle() throws Exception
     {
         osgiBundlePlugin.install();
         // Need a class name which won't be owned by a parent class loader
         final String className = "com.atlassian.plugin.test.some.fake.class.name";
         // Doesn't really matter what class we use, but we can't mock a final like Class
         final Class expected = String.class;
         when(bundle.loadClass(className)).thenReturn(expected);
         final Class actual = osgiBundlePlugin.getClassLoader().loadClass(className);
         verify(bundle).loadClass(className);
         assertThat(actual, sameInstance(expected));
     }
 
     @Test
     public void getPluginArtifactReturnsPluginArtifact()
     {
         assertThat(osgiBundlePlugin.getPluginArtifact(), is(pluginArtifact));
     }
 
     @Test
     public void executeBasicLifeCycle() throws Exception
     {
         final BundleContext bundleContext = mock(BundleContext.class);
         when(bundle.getBundleContext()).thenReturn(bundleContext);
         // Just a smoke test that we can drive the plugin through the typical states
         osgiBundlePlugin.install();
         osgiBundlePlugin.enable();
         verify(bundle).start();
         when(bundle.getState()).thenReturn(Bundle.ACTIVE);
         osgiBundlePlugin.disable();
         verify(bundle).stop();
         osgiBundlePlugin.uninstall();
     }
 
     static void assertThatPluginIsConfigured(final Plugin plugin)
     {
         assertThat(plugin.getKey(), is(PLUGIN_KEY));
         assertThat(plugin.getPluginInformation().getDescription(), is(DESCRIPTION));
         assertThat(plugin.getName(), is(NAME));
         assertThat(plugin.getPluginInformation().getVendorName(), is(VENDOR));
         assertThat(plugin.getPluginInformation().getVersion(), is(VERSION));
         assertThat(plugin.getI18nNameKey(), nullValue());
     }
 
     static PluginArtifact getBundleJarPluginArtifact() throws IOException
     {
         // For historic and convenience reasons, we just make a test jar rather than mocking out PluginArtifact
         final File bundleJar = new PluginJarBuilder("somebundle")
                 .manifest(getBundleManifest())
                 .build();
         // Backdate the jar so we can meaningfully test getDateInstalled vs getDateLoaded
         if (!bundleJar.setLastModified(System.currentTimeMillis() - TimeUnit.DAYS.toMillis(1)))
         {
             throw new IOException("Test broken, cannot backdate bundleJar '" + bundleJar + "'");
         }
         return new JarPluginArtifact(bundleJar);
     }
 
     static ImmutableMap<String, String> getBundleManifest()
     {
         return ImmutableMap.<String, String>builder()
                 .put(Constants.BUNDLE_DESCRIPTION, DESCRIPTION)
                 .put(Constants.BUNDLE_NAME, NAME)
                 .put(Constants.BUNDLE_SYMBOLICNAME, SYMBOLIC_NAME)
                 .put(Constants.BUNDLE_VENDOR, VENDOR)
                 .put(Constants.BUNDLE_VERSION, VERSION)
                 .build();
     }
 
     public static class Modern extends TestOsgiBundlePlugin
     {
         @Rule
         public ExpectedException expectedException = ExpectedException.none();
 
         @Mock private OsgiContainerManager osgiContainerManager;
 
         @Override
         public void setUp() throws Exception
         {
             super.setUp();
             // Ensure that we can install the plugin
             when(osgiContainerManager.installBundle(pluginArtifact.toFile())).thenReturn(bundle);
         }
 
         @Override
         protected OsgiBundlePlugin getOsgiBundlePlugin()
         {
             return new OsgiBundlePlugin(osgiContainerManager, PLUGIN_KEY, pluginArtifact);
         }
 
         @Test
         public void loadClassThrowsBeforeInstall() throws Exception
         {
             expectedException.expect(IllegalPluginStateException.class);
             osgiBundlePlugin.loadClass("java.lang.String", getClass());
         }
 
         @Test
         public void getResourceThrowsBeforeInstall() throws Exception
         {
             expectedException.expect(IllegalPluginStateException.class);
             osgiBundlePlugin.getResource("someResource");
         }
 
         @Test
         public void getResourceAsStreamThrowsBeforeInstall() throws Exception
         {
             expectedException.expect(IllegalPluginStateException.class);
             osgiBundlePlugin.getResourceAsStream("someResource");
         }
 
         @Test
         public void getClassLoaderThrowsBeforeInstall() throws Exception
         {
             expectedException.expect(IllegalPluginStateException.class);
             osgiBundlePlugin.getClassLoader();
         }
 
         @Test
         public void loadClassThrowsAfterUninstall() throws Exception
         {
             osgiBundlePlugin.install();
             osgiBundlePlugin.uninstall();
             expectedException.expect(IllegalPluginStateException.class);
             osgiBundlePlugin.loadClass("java.lang.String", getClass());
         }
 
         @Test
         public void getResourceThrowsAfterUninstall() throws Exception
         {
             osgiBundlePlugin.install();
             osgiBundlePlugin.uninstall();
             expectedException.expect(IllegalPluginStateException.class);
             osgiBundlePlugin.getResource("someResource");
         }
 
         @Test
         public void getResourceAsStreamThrowsAfterUninstall() throws Exception
         {
             osgiBundlePlugin.install();
             osgiBundlePlugin.uninstall();
             expectedException.expect(IllegalPluginStateException.class);
             osgiBundlePlugin.getResourceAsStream("someResource");
         }
 
         @Test
         public void getClassLoaderThrowsAfterUninstall() throws Exception
         {
             osgiBundlePlugin.install();
             osgiBundlePlugin.uninstall();
             expectedException.expect(IllegalPluginStateException.class);
             osgiBundlePlugin.getClassLoader();
         }
 
         @Test
         public void installFailsIfOsgiContainerManagerInstallBundleFails()
         {
             final OsgiContainerException osgiContainerException = new OsgiContainerException("Intentional fail for test");
             when(osgiContainerManager.installBundle(pluginArtifact.toFile())).thenThrow(osgiContainerException);
             // For now expect the exception to be directly propagated. Given that the type matches what our container throws,
             // and what OsgiPlugin (rethrows), this type should be ok, we can rethink if we need to wrap / adjust the exception.
             expectedException.expect(is(osgiContainerException));
             osgiBundlePlugin.install();
         }
 
         @Test
         public void pluginArtifactThatAllowsReferenceIsInstalledByReference() throws Exception
         {
             final File bundleJar = pluginArtifact.toFile();
             pluginArtifact = new JarPluginArtifact(bundleJar, PERMIT_REFERENCE);
             osgiContainerManager = mock(OsgiContainerManager.class,
                     withSettings().extraInterfaces(OsgiContainerManager.AllowsReferenceInstall.class));
             // Have our mock OsgiContainerManager respond only to a reference install (the true in the next line)
             when(((OsgiContainerManager.AllowsReferenceInstall) osgiContainerManager)
                     .installBundle(bundleJar, true)).thenReturn(bundle);
             osgiBundlePlugin = new OsgiBundlePlugin(osgiContainerManager, PLUGIN_KEY, pluginArtifact);
             osgiBundlePlugin.install();
             // We know, and tested above, that getClassLoader only works once installed, but in fact the previous call with have
             // thrown if we don't perform a reference install, since our mock can't respond.
             osgiBundlePlugin.getClassLoader();
         }
     }
 
     public static class Legacy extends TestOsgiBundlePlugin
     {
         @Override
         protected OsgiBundlePlugin getOsgiBundlePlugin()
         {
             //noinspection deprecation
             return new OsgiBundlePlugin(bundle, PLUGIN_KEY, pluginArtifact);
         }
     }
 }