MemoryCacheMXBeanImplTest

package com.atlassian.cache.memory.jmx;

import com.atlassian.cache.CacheManager;
import com.atlassian.cache.CacheStatisticsKey;
import com.atlassian.cache.ManagedCache;
import com.atlassian.cache.impl.StrongSupplier;
import java.util.function.Supplier;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;

import java.util.SortedMap;
import java.util.TreeMap;

import static org.junit.Assert.assertThat;
import static org.mockito.Mockito.when;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.closeTo;

/**
 * Test cases for {@link MemoryCacheMXBeanImpl}
 */
@RunWith(MockitoJUnitRunner.class)
public class MemoryCacheMXBeanImplTest
{

    private static final String EXISTING_CACHE_NAME = "SampleTestCache";
    private static final String NON_EXISTING_CACHE_NAME = "NonExistingSampleTestCache";
    private static final double PRECISION = 0.00001;

    private SortedMap<CacheStatisticsKey, Supplier<Long>> statistics;

    @Mock
    private CacheManager cacheManager;

    @Mock
    private ManagedCache cache;

    @Before
    public void setUp()
    {
        statistics = new TreeMap<>();
        when(cacheManager.getManagedCache(EXISTING_CACHE_NAME)).thenReturn(cache);
        when(cache.getStatistics()).thenReturn(statistics);
    }

    @Test
    public void testGetRequestCount()
    {
        long expectedRequestCount = 10L;
        statistics.put(CacheStatisticsKey.REQUEST_COUNT, new StrongSupplier<>(expectedRequestCount));
        MemoryCacheMXBean mbean = new MemoryCacheMXBeanImpl(cacheManager, EXISTING_CACHE_NAME);

        long requestCount = mbean.getRequestCount();


        assertThat(requestCount, is(expectedRequestCount));
    }

    @Test
    public void testGetRequestCountForMissingCache()
    {
        long expectedRequestCount = 0L;
        MemoryCacheMXBean mbean = new MemoryCacheMXBeanImpl(cacheManager, NON_EXISTING_CACHE_NAME);

        long requestCount = mbean.getRequestCount();

        assertThat(requestCount, is(expectedRequestCount));
    }

    @Test
    public void testGetRequestCountForMissingStat()
    {
        long expectedRequestCount = 0L;
        MemoryCacheMXBean mbean = new MemoryCacheMXBeanImpl(cacheManager, EXISTING_CACHE_NAME);

        long requestCount = mbean.getRequestCount();

        assertThat(requestCount, is(expectedRequestCount));
    }

    @Test
    public void testGetHitCount()
    {
        long expectedHitCount = 15L;
        statistics.put(CacheStatisticsKey.HIT_COUNT, new StrongSupplier<>(expectedHitCount));
        MemoryCacheMXBean mbean = new MemoryCacheMXBeanImpl(cacheManager, EXISTING_CACHE_NAME);

        long hitCount = mbean.getHitCount();

        assertThat(hitCount, is(expectedHitCount));
    }

    @Test
    public void testGetHitCountForMissingCache()
    {
        long expectedHitCount = 0L;
        MemoryCacheMXBean mbean = new MemoryCacheMXBeanImpl(cacheManager, NON_EXISTING_CACHE_NAME);

        long hitCount = mbean.getHitCount();

        assertThat(hitCount, is(expectedHitCount));
    }

    @Test
    public void testGetHitCountForMissingStat()
    {
        long expectedHitCount = 0L;
        MemoryCacheMXBean mbean = new MemoryCacheMXBeanImpl(cacheManager, EXISTING_CACHE_NAME);

        long hitCount = mbean.getHitCount();

        assertThat(hitCount, is(expectedHitCount));
    }

    @Test
    public void testGetHitRate()
    {
        double expectedHitRate = 1.0;
        statistics.put(CacheStatisticsKey.HIT_COUNT, new StrongSupplier<>(15L));
        statistics.put(CacheStatisticsKey.REQUEST_COUNT, new StrongSupplier<>(15L));
        MemoryCacheMXBean mbean = new MemoryCacheMXBeanImpl(cacheManager, EXISTING_CACHE_NAME);

        double hitRate = mbean.getHitRate();

        assertThat(hitRate, closeTo(expectedHitRate, PRECISION));
    }

    @Test
    public void testGetHitRateForRequestCount()
    {
        double expectedHitRate = 1.0;
        MemoryCacheMXBean mbean = new MemoryCacheMXBeanImpl(cacheManager, NON_EXISTING_CACHE_NAME);

        double hitRate = mbean.getHitRate();

        assertThat(hitRate, closeTo(expectedHitRate, PRECISION));
    }

    @Test
    public void testGetMissCount()
    {
        long expectedMissCount = 3L;
        statistics.put(CacheStatisticsKey.MISS_COUNT, new StrongSupplier<>(expectedMissCount));
        MemoryCacheMXBean mbean = new MemoryCacheMXBeanImpl(cacheManager, EXISTING_CACHE_NAME);

        long missCount = mbean.getMissCount();

        assertThat(missCount, is(expectedMissCount));
    }

    @Test
    public void testGetMissCountForMissingCache()
    {
        long expectedMissCount = 0L;
        MemoryCacheMXBean mbean = new MemoryCacheMXBeanImpl(cacheManager, NON_EXISTING_CACHE_NAME);

        long missCount = mbean.getMissCount();

        assertThat(missCount, is(expectedMissCount));
    }

    @Test
    public void testGetMissCountForMissingStat()
    {
        long expectedMissCount = 0L;
        MemoryCacheMXBean mbean = new MemoryCacheMXBeanImpl(cacheManager, EXISTING_CACHE_NAME);

        long missCount = mbean.getMissCount();

        assertThat(missCount, is(expectedMissCount));
    }

    @Test
    public void testGetMissRate()
    {
        double expectedMissRate = 1.0;
        statistics.put(CacheStatisticsKey.MISS_COUNT, new StrongSupplier<>(7L));
        statistics.put(CacheStatisticsKey.REQUEST_COUNT, new StrongSupplier<>(7L));
        MemoryCacheMXBean mbean = new MemoryCacheMXBeanImpl(cacheManager, EXISTING_CACHE_NAME);

        double missRate = mbean.getMissRate();

        assertThat(missRate, closeTo(expectedMissRate, PRECISION));
    }

    @Test
    public void testGetMissRateForMissingRequestCount()
    {
        double expectedMissRate = 0.0;
        MemoryCacheMXBean mbean = new MemoryCacheMXBeanImpl(cacheManager, NON_EXISTING_CACHE_NAME);

        double missRate = mbean.getMissRate();

        assertThat(missRate, closeTo(expectedMissRate, PRECISION));
    }

    @Test
    public void testGetLoadCount()
    {
        long expectedLoadCount = 11L;
        statistics.put(CacheStatisticsKey.LOAD_COUNT, new StrongSupplier<>(expectedLoadCount));
        MemoryCacheMXBean mbean = new MemoryCacheMXBeanImpl(cacheManager, EXISTING_CACHE_NAME);

        long loadCount = mbean.getLoadCount();

        assertThat(loadCount, is(expectedLoadCount));
    }

    @Test
    public void testGetLoadCountForMissingCache()
    {
        long expectedLoadCount = 0L;
        MemoryCacheMXBean mbean = new MemoryCacheMXBeanImpl(cacheManager, NON_EXISTING_CACHE_NAME);

        long loadCount = mbean.getLoadCount();

        assertThat(loadCount, is(expectedLoadCount));
    }

    @Test
    public void testGetLoadCountForMissingStat()
    {
        long expectedLoadCount = 0L;
        MemoryCacheMXBean mbean = new MemoryCacheMXBeanImpl(cacheManager, EXISTING_CACHE_NAME);

        long loadCount = mbean.getLoadCount();

        assertThat(loadCount, is(expectedLoadCount));
    }

    @Test
    public void testGetLoadSuccessCount()
    {
        long expectedLoadSuccessCount = 17L;
        statistics.put(CacheStatisticsKey.LOAD_SUCCESS_COUNT, new StrongSupplier<>(expectedLoadSuccessCount));
        MemoryCacheMXBean mbean = new MemoryCacheMXBeanImpl(cacheManager, EXISTING_CACHE_NAME);

        long loadSuccessCount = mbean.getLoadSuccessCount();

        assertThat(loadSuccessCount, is(expectedLoadSuccessCount));
    }

    @Test
    public void testGetLoadSuccessCountForMissingCache()
    {
        long expectedLoadSuccessCount = 0L;
        MemoryCacheMXBean mbean = new MemoryCacheMXBeanImpl(cacheManager, NON_EXISTING_CACHE_NAME);

        long loadSuccessCount = mbean.getLoadSuccessCount();

        assertThat(loadSuccessCount, is(expectedLoadSuccessCount));
    }

    @Test
    public void testGetLoadSuccessCountForMissingStat()
    {
        long expectedLoadSuccessCount = 0L;
        MemoryCacheMXBean mbean = new MemoryCacheMXBeanImpl(cacheManager, EXISTING_CACHE_NAME);

        long loadSuccessCount = mbean.getLoadSuccessCount();

        assertThat(loadSuccessCount, is(expectedLoadSuccessCount));
    }

    @Test
    public void testGetLoadExceptionCount()
    {
        long expectedLoadExceptionCount = 13L;
        statistics.put(CacheStatisticsKey.LOAD_EXCEPTION_COUNT, new StrongSupplier<>(expectedLoadExceptionCount));
        MemoryCacheMXBean mbean = new MemoryCacheMXBeanImpl(cacheManager, EXISTING_CACHE_NAME);

        long loadEExceptionCount = mbean.getLoadExceptionCount();

        assertThat(loadEExceptionCount, is(expectedLoadExceptionCount));
    }

    @Test
    public void testGetLoadExceptionCountForMissingCache()
    {
        long expectedLoadExceptionCount = 0L;
        MemoryCacheMXBean mbean = new MemoryCacheMXBeanImpl(cacheManager, NON_EXISTING_CACHE_NAME);

        long loadEExceptionCount = mbean.getLoadExceptionCount();

        assertThat(loadEExceptionCount, is(expectedLoadExceptionCount));
    }


    @Test
    public void testGetLoadExceptionCountForMissingStat()
    {
        long expectedLoadExceptionCount = 0L;
        MemoryCacheMXBean mbean = new MemoryCacheMXBeanImpl(cacheManager, EXISTING_CACHE_NAME);

        long loadEExceptionCount = mbean.getLoadExceptionCount();

        assertThat(loadEExceptionCount, is(expectedLoadExceptionCount));
    }

    @Test
    public void testLoadExceptionRate()
    {
        double expectedLoadExceptionRate = 1.0;
        statistics.put(CacheStatisticsKey.LOAD_EXCEPTION_COUNT, new StrongSupplier<>(5L));
        statistics.put(CacheStatisticsKey.LOAD_COUNT, new StrongSupplier<>(5L));
        MemoryCacheMXBean mbean = new MemoryCacheMXBeanImpl(cacheManager, EXISTING_CACHE_NAME);

        double loadExceptionRate = mbean.getLoadExceptionRate();

        assertThat(loadExceptionRate, closeTo(expectedLoadExceptionRate, PRECISION));
    }

    @Test
    public void testLoadExceptionRateForMissingLoadCount()
    {
        double expectedLoadExceptionRate = 0.0;
        MemoryCacheMXBean mbean = new MemoryCacheMXBeanImpl(cacheManager, NON_EXISTING_CACHE_NAME);

        double loadExceptionRate = mbean.getLoadExceptionRate();

        assertThat(loadExceptionRate, closeTo(expectedLoadExceptionRate, PRECISION));
    }

    @Test
    public void testGetTotalLoadCount()
    {
        long expectedTotalLoadCount = 13L;
        statistics.put(CacheStatisticsKey.TOTAL_LOAD_TIME, new StrongSupplier<>(expectedTotalLoadCount));
        MemoryCacheMXBean mbean = new MemoryCacheMXBeanImpl(cacheManager, EXISTING_CACHE_NAME);

        long totalLoadCount = mbean.getTotalLoadTime();

        assertThat(totalLoadCount, is(expectedTotalLoadCount));
    }

    @Test
    public void testGetTotalLoadCountForMissingCache()
    {
        long expectedTotalLoadCount = 0L;
        MemoryCacheMXBean mbean = new MemoryCacheMXBeanImpl(cacheManager, NON_EXISTING_CACHE_NAME);

        long loadEExceptionCount = mbean.getTotalLoadTime();

        assertThat(loadEExceptionCount, is(expectedTotalLoadCount));
    }

    @Test
    public void testGetTotalLoadCountForMissingStat()
    {
        long expectedTotalLoadCount = 0L;
        MemoryCacheMXBean mbean = new MemoryCacheMXBeanImpl(cacheManager, EXISTING_CACHE_NAME);

        long loadEExceptionCount = mbean.getTotalLoadTime();

        assertThat(loadEExceptionCount, is(expectedTotalLoadCount));
    }

    @Test
    public void testAverageLoadPenalty()
    {
        double expectedAverageLoadPenalty = 1.0;
        statistics.put(CacheStatisticsKey.LOAD_EXCEPTION_COUNT, new StrongSupplier<>(2L));
        statistics.put(CacheStatisticsKey.LOAD_SUCCESS_COUNT, new StrongSupplier<>(3L));
        statistics.put(CacheStatisticsKey.TOTAL_LOAD_TIME, new StrongSupplier<>(5L));
        MemoryCacheMXBean mbean = new MemoryCacheMXBeanImpl(cacheManager, EXISTING_CACHE_NAME);

        double averageLoadPenalty = mbean.getAverageLoadPenalty();

        assertThat(averageLoadPenalty, closeTo(expectedAverageLoadPenalty, PRECISION));
    }

    @Test
    public void testAverageLoadPenaltyForMissingLoadCount()
    {
        double expectedAverageLoadPenalty = 0.0;
        MemoryCacheMXBean mbean = new MemoryCacheMXBeanImpl(cacheManager, NON_EXISTING_CACHE_NAME);

        double averageLoadPenalty = mbean.getAverageLoadPenalty();

        assertThat(averageLoadPenalty, closeTo(expectedAverageLoadPenalty, PRECISION));
    }

    @Test
    public void testGetEvictionCount()
    {
        long expectedEvictionCount = 14L;
        statistics.put(CacheStatisticsKey.EVICTION_COUNT, new StrongSupplier<>(expectedEvictionCount));
        MemoryCacheMXBean mbean = new MemoryCacheMXBeanImpl(cacheManager, EXISTING_CACHE_NAME);

        long evictionCount = mbean.getEvictionCount();

        assertThat(evictionCount, is(expectedEvictionCount));
    }

    @Test
    public void testGetEvictionCountForMissingCache()
    {
        long expectedEvictionCount = 0L;
        MemoryCacheMXBean mbean = new MemoryCacheMXBeanImpl(cacheManager, NON_EXISTING_CACHE_NAME);

        long evictionCount = mbean.getEvictionCount();

        assertThat(evictionCount, is(expectedEvictionCount));
    }

    @Test
    public void testGetEvictionCountForMissingStat()
    {
        long expectedEvictionCount = 0L;
        MemoryCacheMXBean mbean = new MemoryCacheMXBeanImpl(cacheManager, EXISTING_CACHE_NAME);

        long evictionCount = mbean.getEvictionCount();

        assertThat(evictionCount, is(expectedEvictionCount));
    }

    @Test
    public void testSize()
    {
        long expectedSize = 14L;
        statistics.put(CacheStatisticsKey.SIZE, new StrongSupplier<>(expectedSize));
        MemoryCacheMXBean mbean = new MemoryCacheMXBeanImpl(cacheManager, EXISTING_CACHE_NAME);

        long size = mbean.getSize();

        assertThat(size, is(expectedSize));
    }

    @Test
    public void testSizeForMissingCache()
    {
        long expectedSize = 0L;
        MemoryCacheMXBean mbean = new MemoryCacheMXBeanImpl(cacheManager, NON_EXISTING_CACHE_NAME);

        long size = mbean.getSize();

        assertThat(size, is(expectedSize));
    }

    @Test
    public void testSizeForMissingStat()
    {
        long expectedSize = 0L;
        MemoryCacheMXBean mbean = new MemoryCacheMXBeanImpl(cacheManager, EXISTING_CACHE_NAME);

        long size = mbean.getSize();

        assertThat(size, is(expectedSize));
    }
}