package com.atlassian.plugin.manager;
   
   import com.atlassian.plugin.Plugin;
   import com.atlassian.plugin.PluginInformation;
   import com.atlassian.plugin.jmx.PluginManagerMXBean;
   
   import com.google.common.collect.ImmutableList;
   
   import org.hamcrest.Description;
  import org.hamcrest.Matcher;
  import org.hamcrest.TypeSafeMatcher;
  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.MatcherAssert.assertThat;
  import static org.hamcrest.Matchers.arrayContaining;
  import static org.hamcrest.Matchers.equalTo;
  import static org.hamcrest.Matchers.is;
  import static org.mockito.Mockito.mock;
  import static org.mockito.Mockito.when;
  
  @RunWith (MockitoJUnitRunner.class)
  public class TestDefaultPluginManagerJmxBridge
  {
      @Mock private DefaultPluginManager defaultPluginManager;
  
      // Hold this via the interface class so we provide usages of its methods
      private PluginManagerMXBean defaultPluginManagerJmxBridge;
  
      @Before
      public void setUp() throws Exception
      {
          defaultPluginManagerJmxBridge = new DefaultPluginManagerJmxBridge(defaultPluginManager);
      }
  
      @Test
      public void getPluginsReturnsPlugins()
      {
          final String pluginKey = "alpha";
          final Plugin plugin = mock(Plugin.class);
          when(plugin.getKey()).thenReturn(pluginKey);
          final String version = "1.2.3";
          final PluginInformation pluginInformation = mock(PluginInformation.class);
          when(pluginInformation.getVersion()).thenReturn(version);
          when(plugin.getPluginInformation()).thenReturn(pluginInformation);
          when(defaultPluginManager.isPluginEnabled(pluginKey)).thenReturn(true);
  
          final Plugin nullPlugin = mock(Plugin.class);
  
          when(defaultPluginManager.getPlugins()).thenReturn(ImmutableList.of(plugin, nullPlugin));
          final PluginManagerMXBean.PluginData[] pluginDatas = defaultPluginManagerJmxBridge.getPlugins();
          assertThat(pluginDatas, arrayContaining(pluginData(pluginKey, version, true), pluginData(null, null, false)));
      }
  
      private Matcher<PluginManagerMXBean.PluginData> pluginData(final String key, final String version, final boolean enabled)
      {
          final Matcher<String> keyMatcher = equalTo(key);
          final Matcher<String> versionMatcher = equalTo(version);
          final Matcher<Boolean> enabledMatcher = equalTo(enabled);
          return new TypeSafeMatcher<PluginManagerMXBean.PluginData>()
          {
              @Override
              protected boolean matchesSafely(final PluginManagerMXBean.PluginData item)
              {
                  return keyMatcher.matches(item.getKey())
                          && versionMatcher.matches(item.getVersion())
                          && enabledMatcher.matches(item.isEnabled());
              }
  
              @Override
              public void describeTo(final Description description)
              {
                  description.appendText("PluginData with key ");
                  keyMatcher.describeTo(description);
                  description.appendText(" and version ");
                  versionMatcher.describeTo(description);
                  description.appendText(" and enabled ");
                  enabledMatcher.describeTo(description);
  
              }
          };
      }
  
      @Test
      public void scanForNewPluginsDoesScanForNewPlugins()
      {
          final int expected = 1;
          when(defaultPluginManager.scanForNewPlugins()).thenReturn(expected);
          final int actual = defaultPluginManagerJmxBridge.scanForNewPlugins();
          assertThat(actual, is(expected));
      }
  }