package com.atlassian.cache.memory.jmx;
   
   import com.atlassian.cache.CacheManager;
   import org.junit.Before;
   import org.junit.Test;
   import org.junit.runner.RunWith;
   import org.mockito.ArgumentCaptor;
   import org.mockito.Mock;
   import org.mockito.junit.MockitoJUnitRunner;
  
  import javax.management.MBeanServer;
  import javax.management.ObjectName;
  
  import java.util.HashSet;
  import java.util.Set;
  
  import static org.hamcrest.Matchers.is;
  import static org.junit.Assert.assertThat;
  import static org.mockito.ArgumentMatchers.any;
  import static org.mockito.Mockito.doThrow;
  import static org.mockito.Mockito.never;
  import static org.mockito.Mockito.times;
  import static org.mockito.Mockito.verify;
  import static org.mockito.Mockito.when;
  
  /**
   * Test cases for {@link MemoryCacheMXBeanRegistrar}
   */
  @RunWith(MockitoJUnitRunner.Silent.class)
  public class MemoryCacheMXBeanRegistrarTest
  {
      private static final String MBEAN_NAME_PATTERN = "com.google.common.cache:CacheManager=JIRA Cache Manager,name=%s,type=CacheStatistics";
      private static final String CACHE_NAME = "TestCache";
      private static final String EXPECTED_MBEAN_NAME = String.format(MBEAN_NAME_PATTERN, CACHE_NAME);
  
      private MemoryCacheMXBeanRegistrar mbeansRegistrar;
  
      @Mock
      private MBeanServer mBeanServer;
  
      @Mock
      private CacheManager cacheManager;
  
      @Before
      public void setUp()
      {
          mbeansRegistrar = new MemoryCacheMXBeanRegistrar();
      }
  
      @Test
      public void testRegistration() throws Exception
      {
          when(mBeanServer.isRegistered(any(ObjectName.class))).thenReturn(false);
          mbeansRegistrar.enableCollectingJMXMetrics(mBeanServer, cacheManager);
  
          mbeansRegistrar.registerMBean(CACHE_NAME);
  
          ArgumentCaptor<ObjectName> objectNameArg = ArgumentCaptor.forClass(ObjectName.class);
          verify(mBeanServer).registerMBean(any(Object.class), objectNameArg.capture());
          assertThat(objectNameArg.getValue().getCanonicalName(), is(EXPECTED_MBEAN_NAME));
      }
  
      @Test
      public void testRegistrationForExistingName() throws Exception
      {
          when(mBeanServer.isRegistered(any(ObjectName.class))).thenReturn(true);
          mbeansRegistrar.enableCollectingJMXMetrics(mBeanServer, cacheManager);
          mbeansRegistrar.registerMBean(CACHE_NAME);
  
          mbeansRegistrar.registerMBean(CACHE_NAME);
  
          verify(mBeanServer, times(1)).registerMBean(any(Object.class), any(ObjectName.class));
      }
  
      @Test
      public void testRegistrationForDisabledMetrics() throws Exception
      {
          when(mBeanServer.isRegistered(any(ObjectName.class))).thenReturn(false);
  
          mbeansRegistrar.registerMBean(CACHE_NAME);
  
          verify(mBeanServer, never()).registerMBean(any(Object.class), any(ObjectName.class));
      }
  
      @Test
      public void testRegistrationWithException() throws Exception
      {
          when(mBeanServer.isRegistered(any(ObjectName.class))).thenReturn(false);
          when(mBeanServer.registerMBean(any(Object.class), any(ObjectName.class))).thenThrow(new NullPointerException("Test message"));
          mbeansRegistrar.enableCollectingJMXMetrics(mBeanServer, cacheManager);
  
          mbeansRegistrar.registerMBean(CACHE_NAME);
  
          verify(mBeanServer, times(1)).registerMBean(any(Object.class), any(ObjectName.class));
      }
  
      @Test
      public void testUnregistration() throws Exception
      {
         when(mBeanServer.isRegistered(any(ObjectName.class))).thenReturn(true);
         mbeansRegistrar.enableCollectingJMXMetrics(mBeanServer, cacheManager);
         mbeansRegistrar.registerMBean(CACHE_NAME);
 
         mbeansRegistrar.unregisterMBeans();
 
         ArgumentCaptor<ObjectName> objectNameArg = ArgumentCaptor.forClass(ObjectName.class);
         verify(mBeanServer).unregisterMBean(objectNameArg.capture());
         assertThat(objectNameArg.getValue().getCanonicalName(), is(EXPECTED_MBEAN_NAME));
     }
 
     @Test
     public void testUnregisteringNonExistingMBean() throws Exception
     {
         when(mBeanServer.isRegistered(any(ObjectName.class))).thenReturn(false);
         Set<String> cacheNames = new HashSet<>();
         cacheNames.add(CACHE_NAME);
         mbeansRegistrar.enableCollectingJMXMetrics(mBeanServer, cacheManager);
 
         mbeansRegistrar.unregisterMBeans();
 
         ArgumentCaptor<ObjectName> objectNameArg = ArgumentCaptor.forClass(ObjectName.class);
         verify(mBeanServer, never()).unregisterMBean(any(ObjectName.class));
     }
 
     @Test
     public void testUnregisteringForDisabledMetrics() throws Exception
     {
         when(mBeanServer.isRegistered(any(ObjectName.class))).thenReturn(true);
         Set<String> cachesNames = new HashSet<>();
         cachesNames.add(CACHE_NAME);
 
         mbeansRegistrar.unregisterMBeans();
 
         verify(mBeanServer, never()).unregisterMBean(any(ObjectName.class));
     }
 
     @Test
     public void testUnregisteringWithException() throws Exception
     {
         when(mBeanServer.isRegistered(any(ObjectName.class))).thenReturn(true);
         doThrow(new NullPointerException("Test message")).when(mBeanServer).unregisterMBean(any(ObjectName.class));
         mbeansRegistrar.enableCollectingJMXMetrics(mBeanServer, cacheManager);
         mbeansRegistrar.registerMBean(CACHE_NAME);
 
         mbeansRegistrar.unregisterMBeans();
 
         verify(mBeanServer, times(1)).unregisterMBean(any(ObjectName.class));
     }
 
 }