package com.atlassian.plugin.osgi.util;
   
   import com.atlassian.plugin.JarPluginArtifact;
   import com.atlassian.plugin.osgi.factory.transform.StubHostComponentRegistration;
   import com.atlassian.plugin.osgi.factory.OsgiPlugin;
   import com.atlassian.plugin.osgi.hostcomponents.HostComponentRegistration;
   import com.atlassian.plugin.osgi.hostcomponents.impl.MockRegistration;
   import com.atlassian.plugin.test.PluginJarBuilder;
   import com.google.common.collect.Sets;
  
  import java.io.File;
  import java.io.IOException;
  import java.io.InputStream;
  import java.util.*;
  import java.util.jar.Manifest;
  
  import org.junit.Assert;
  import org.junit.Test;
  import org.mockito.Mockito;
  import org.osgi.framework.Bundle;
  import org.osgi.framework.Constants;
  import org.osgi.framework.Version;
  
  import static junit.framework.Assert.assertEquals;
  import static junit.framework.Assert.assertFalse;
  import static junit.framework.Assert.assertTrue;
  import static org.hamcrest.core.Is.is;
  import static org.hamcrest.core.IsEqual.equalTo;
  import static org.junit.Assert.assertThat;
  import static org.mockito.Mockito.mock;
  import static org.mockito.Mockito.when;
  
  public class TestOsgiHeaderUtil
  {
  
      @Test(expected = NullPointerException.class)
      public void shouldAssertValueShouldNotBeNull()
      {
          Manifest manifest = new Manifest();
          OsgiHeaderUtil.getValidatedAttribute(manifest, "some-random-key");
      }
  
  
      @Test(expected = IllegalArgumentException.class)
      public void shouldAssertValueShouldNotBeEmpty() throws IOException
      {
          Manifest manifest = generateManifest();
          OsgiHeaderUtil.getValidatedAttribute(manifest, "Some-other");
      }
  
      @Test(expected = IllegalArgumentException.class)
      public void shouldRaiseAnExceptionWhenValueIsMissing() throws IOException
      {
          Manifest manifest = generateManifest();
          OsgiHeaderUtil.getNonEmptyAttribute(manifest,"Some-other");
      }
  
      @Test
      public void shouldGetValidatedAttribute() throws IOException
      {
          Manifest manifestFile = generateManifest();
          assertThat(OsgiHeaderUtil.getValidatedAttribute(manifestFile, "Import-Package"), equalTo("javax.swing"));
      }
  
      @Test
      public void shouldGetEmptyAttributeWithoutValidation() throws IOException
      {
          Manifest manifest = generateManifest();
          assertThat(OsgiHeaderUtil.getAttributeWithoutValidation(manifest, "Some-other"), is(""));
      }
  
      @Test
      public void shouldGetNullAttributeWithoutValidation() throws IOException
      {
          Manifest manifest = generateManifest();
          Assert.assertNull(OsgiHeaderUtil.getAttributeWithoutValidation(manifest, "some-random"));
      }
  
      private Manifest generateManifest() throws IOException
      {
          File bundle = new PluginJarBuilder("someplugin")
                  .addResource("META-INF/MANIFEST.MF", "Manifest-Version: 1.0\n" +
                          "Import-Package: javax.swing\n" +
                          "Bundle-SymbolicName: my.foo.symbolicName\n" +
                          "Some-other: \n" +
                          "Bundle-Version: 1.0\n")
                  .build();
          JarPluginArtifact jarPluginArtifact = new JarPluginArtifact(bundle);
          InputStream descriptorClassStream = jarPluginArtifact.getResourceAsStream("META-INF/MANIFEST.MF");
          return new Manifest(descriptorClassStream);
      }
  
      @Test
      public void testFindReferredPackages() throws IOException
      {
          Set<String> foundPackages = OsgiHeaderUtil.findReferredPackageNames(new ArrayList<HostComponentRegistration>()
          {{
                  add(new StubHostComponentRegistration(OsgiHeaderUtil.class));
              }});
 
         assertTrue(foundPackages.contains(HostComponentRegistration.class.getPackage().getName()));
     }
 
     @Test
     public void testFindReferredPackagesMustNotReturnJavaPackages() throws IOException
     {
         List<HostComponentRegistration> regs = Arrays.<HostComponentRegistration>asList(new MockRegistration(Mockito.mock(DummyClass.class), DummyClass.class));
 
         Set<String> foundPackages = OsgiHeaderUtil.findReferredPackageNames(regs);
 
         assertFalse(foundPackages.contains("java.lang"));
     }
 
     @Test
     public void testFindReferredPackagesWithVersion() throws IOException
     {
         Map<String, String> foundPackages = OsgiHeaderUtil.findReferredPackageVersions(new ArrayList<HostComponentRegistration>()
         {{
                 add(new StubHostComponentRegistration(OsgiHeaderUtil.class));
             }}, Collections.singletonMap(HostComponentRegistration.class.getPackage().getName(), "1.0.45"));
 
         assertTrue(foundPackages.containsKey(HostComponentRegistration.class.getPackage().getName()));
         assertEquals(foundPackages.get(HostComponentRegistration.class.getPackage().getName()), "1.0.45");
     }
 
     @Test
     public void testGetPluginKeyBundle()
     {
         Dictionary headers = new Hashtable();
         headers.put(Constants.BUNDLE_VERSION, "1.0");
         headers.put(Constants.BUNDLE_SYMBOLICNAME, "foo");
 
         Bundle bundle = mock(Bundle.class);
         when(bundle.getSymbolicName()).thenReturn("foo");
         when(bundle.getHeaders()).thenReturn(headers);
 
         assertEquals("foo-1.0", OsgiHeaderUtil.getPluginKey(bundle));
 
         headers.put(OsgiPlugin.ATLASSIAN_PLUGIN_KEY, "bar");
         assertEquals("bar", OsgiHeaderUtil.getPluginKey(bundle));
     }
 
     @Test
     public void testGetPluginKeyManifest()
     {
         Manifest mf = new Manifest();
         mf.getMainAttributes().putValue(Constants.BUNDLE_VERSION, "1.0");
         mf.getMainAttributes().putValue(Constants.BUNDLE_SYMBOLICNAME, "foo");
 
         assertEquals("foo-1.0", OsgiHeaderUtil.getPluginKey(mf));
 
         mf.getMainAttributes().putValue(OsgiPlugin.ATLASSIAN_PLUGIN_KEY, "bar");
         assertEquals("bar", OsgiHeaderUtil.getPluginKey(mf));
     }
 
     @Test
     public void testGeneratePackageVersionString()
     {
         Map<String, String> input = new HashMap<String, String>();
         input.put("foo.bar", "1.2");
         input.put("foo.baz", Version.emptyVersion.toString());
 
         String output = OsgiHeaderUtil.generatePackageVersionString(input);
 
         Set<String> set = Sets.newHashSet(output.split("[,]"));
 
         assertTrue(set.contains("foo.bar;version=1.2"));
         assertTrue(set.contains("foo.baz"));
         assertEquals(2, set.size());
     }
 
     private static interface DummyClass
     {
         void doSomething(Object obj);
     }
 
 }