package com.atlassian.plugin.metadata;
   
   import com.atlassian.plugin.MockModuleDescriptor;
   import com.atlassian.plugin.ModuleDescriptor;
   import com.atlassian.plugin.Plugin;
   import com.atlassian.plugin.descriptors.CannotDisable;
   
   import junit.framework.TestCase;
   
  public class TestDefaultPluginMetadataManager extends TestCase
  {
      public void testIsUserInstalledPlugin()
      {
          final Plugin plugin = new MockPlugin("my.plugin");
          assertTrue(new DefaultPluginMetadataManager(new EmptyPluginMetadata()).isUserInstalled(plugin));
      }
  
      public void testIsNotUserInstalledPluginIfApplicationSupplied()
      {
          final Plugin plugin = new MockPlugin("my.plugin");
          assertFalse(new DefaultPluginMetadataManager(new ApplicationPluginMetadata()).isUserInstalled(plugin));
      }
  
      public void testPluginIsNotUserInstalledBecauseItIsBundled()
      {
          final Plugin plugin = new MockBundledPlugin("my.plugin");
          assertFalse(new DefaultPluginMetadataManager(new EmptyPluginMetadata()).isUserInstalled(plugin));
      }
  
      public void testPluginIsRequired()
      {
          final Plugin plugin = new MockPlugin("my.plugin");
          assertFalse(new DefaultPluginMetadataManager(new RequiredPluginMetadata()).isOptional(plugin));
      }
  
      public void testPluginIsOptional()
      {
          final Plugin plugin = new MockPlugin("my.plugin");
          assertTrue(new DefaultPluginMetadataManager(new EmptyPluginMetadata()).isOptional(plugin));
      }
  
      public void testPluginWithModulesIsOptional()
      {
          final Plugin plugin = new MockPlugin("my.plugin");
          final ModuleDescriptor<?> moduleDescriptor = new MockModuleDescriptor<Object>(plugin, "my.plugin.c-mod3", null);
          plugin.addModuleDescriptor(moduleDescriptor);
          assertTrue(new DefaultPluginMetadataManager(new EmptyPluginMetadata()).isOptional(plugin));
      }
  
      public void testPluginIsRequiredBecauseOfRequiredModule()
      {
          final Plugin plugin = new MockPlugin("my.plugin");
          final ModuleDescriptor<?> moduleDescriptor = new MockModuleDescriptor<Object>(plugin, "my.plugin.c-mod3", null);
          plugin.addModuleDescriptor(moduleDescriptor);
          assertFalse(new DefaultPluginMetadataManager(new ModuleRequiredPluginMetadata()).isOptional(plugin));
      }
  
      public void testModuleIsRequired()
      {
          final ModuleDescriptor<?> moduleDescriptor = new MockModuleDescriptor<Object>(null, "my.plugin.c-mod3", null);
          assertFalse(new DefaultPluginMetadataManager(new ModuleRequiredPluginMetadata()).isOptional(moduleDescriptor));
      }
  
      public void testModuleIsRequiredBecauseParentPluginIsRequired()
      {
          final Plugin plugin = new MockPlugin("my.plugin");
          final ModuleDescriptor<?> moduleDescriptor = new MockModuleDescriptor<Object>(plugin, "my.plugin.c-mod3", null);
          plugin.addModuleDescriptor(moduleDescriptor);
          assertFalse(new DefaultPluginMetadataManager(new RequiredPluginMetadata()).isOptional(moduleDescriptor));
      }
  
      public void testModuleIsNotMadeRequiredBecauseSiblingModuleIsRequired()
      {
          final Plugin plugin = new MockPlugin("my.plugin");
          final MockModuleDescriptor<Object> required = new MockModuleDescriptor<Object>(plugin, "required", null);
          plugin.addModuleDescriptor(required);
          final ModuleDescriptor<?> moduleDescriptor = new MockModuleDescriptor<Object>(plugin, "not-required", null);
          plugin.addModuleDescriptor(moduleDescriptor);
          assertTrue(new DefaultPluginMetadataManager(new EmptyPluginMetadata()
          {
              @Override
              public boolean required(final ModuleDescriptor<?> descriptor)
              {
                  return descriptor == required;
              }
          }).isOptional(moduleDescriptor));
      }
  
      public void testModuleIsRequiredTypeMarkedByAnnotation()
      {
          final Plugin plugin = new MockPlugin("my.plugin");
          // Looked a bit, do not think mockito can create a mock such that it has a class-level annotation
          final ModuleDescriptor<?> moduleDescriptor = new CannotDisableModuleDescriptorType(plugin, "my.plugin.c-mod3");
  
          assertFalse(new DefaultPluginMetadataManager(new EmptyPluginMetadata()).isOptional(moduleDescriptor));
      }
  
      public void testModuleIsOptional()
      {
         final Plugin plugin = new MockPlugin("my.plugin");
         final ModuleDescriptor<?> moduleDescriptor = new MockModuleDescriptor<Object>(plugin, "my.plugin.c-mod3", null);
         plugin.addModuleDescriptor(moduleDescriptor);
         assertTrue(new DefaultPluginMetadataManager(new EmptyPluginMetadata()).isOptional(moduleDescriptor));
     }
 
     public void testIsOptionalPluginNullPlugin()
     {
         try
         {
             new DefaultPluginMetadataManager(new EmptyPluginMetadata()).isOptional((Plugin) null);
             fail("Expected NPE");
         }
         catch (final NullPointerException expected)
         {}
     }
 
     public void testIsOptionalModuleNullModule()
     {
         try
         {
             new DefaultPluginMetadataManager(new EmptyPluginMetadata()).isOptional((ModuleDescriptor<?>) null);
             fail("Expected NPE");
         }
         catch (final NullPointerException expected)
         {}
     }
 
     public void testIsUserInstalledPluginNullPlugin()
     {
         try
         {
             new DefaultPluginMetadataManager(new EmptyPluginMetadata()).isUserInstalled(null);
             fail("Expected NPE");
         }
         catch (final NullPointerException expected)
         {}
     }
 
     class MockPlugin extends com.atlassian.plugin.MockPlugin
     {
         MockPlugin(final String key)
         {
             super(key, TestDefaultPluginMetadataManager.this.getClass().getClassLoader());
         }
     }
 
     class MockBundledPlugin extends MockPlugin
     {
         public MockBundledPlugin(final String key)
         {
             super(key);
         }
 
         @Override
         public boolean isBundledPlugin()
         {
             return true;
         }
     }
 
     @CannotDisable
     class CannotDisableModuleDescriptorType extends MockModuleDescriptor<Object> implements ModuleDescriptor<Object>
     {
         CannotDisableModuleDescriptorType(final Plugin plugin, final String completeKey)
         {
             super(plugin, completeKey, null);
         }
     }
 
     class EmptyPluginMetadata implements PluginMetadata
     {
         public boolean applicationProvided(final Plugin plugin)
         {
             return false;
         }
 
         public boolean required(final Plugin plugin)
         {
             return false;
         }
 
         public boolean required(final ModuleDescriptor<?> descriptor)
         {
             return false;
         }
     }
 
     class ApplicationPluginMetadata extends EmptyPluginMetadata
     {
         @Override
         public boolean applicationProvided(final Plugin plugin)
         {
             return true;
         }
     }
 
     class RequiredPluginMetadata extends EmptyPluginMetadata
     {
         @Override
         public boolean required(final Plugin plugin)
         {
             return true;
         }
     }
 
     class ModuleRequiredPluginMetadata extends EmptyPluginMetadata
     {
         @Override
         public boolean required(final ModuleDescriptor<?> descriptor)
         {
             return true;
         }
     }
 }