VCacheTestHelper

package com.atlassian.vcache.internal.test.utils;

import com.atlassian.marshalling.api.MarshallingPair;
import com.atlassian.marshalling.jdk.JavaSerializationMarshalling;
import com.atlassian.vcache.ChangeRate;
import com.atlassian.vcache.DirectExternalCache;
import com.atlassian.vcache.ExternalCacheSettings;
import com.atlassian.vcache.ExternalCacheSettingsBuilder;
import com.atlassian.vcache.JvmCache;
import com.atlassian.vcache.JvmCacheSettings;
import com.atlassian.vcache.JvmCacheSettingsBuilder;
import com.atlassian.vcache.TransactionalExternalCache;
import com.atlassian.vcache.VCacheFactory;
import com.atlassian.vcache.internal.RequestContext;
import com.atlassian.vcache.internal.core.DefaultVCacheCreationHandler;
import com.atlassian.vcache.internal.core.PlainExternalCacheKeyGenerator;
import com.atlassian.vcache.internal.core.WorkContextRequestContextSupplier;
import com.atlassian.vcache.internal.core.metrics.NoopMetricsCollector;
import com.atlassian.vcache.internal.guava.GuavaTestServiceSettings;
import com.atlassian.vcache.internal.guava.GuavaVCacheService;
import com.atlassian.vcache.internal.test.EmptyVCacheSettingsDefaultsProvider;
import com.atlassian.vcache.internal.test.ThreadLocalRequestContextSupplier;

import java.io.Serializable;
import java.time.Duration;
import java.util.function.Supplier;

import static org.mockito.Matchers.any;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.spy;

/**
 * Test helper provides functionality to help create appropriate vcache mocks for unit tests. Each test class will need to open
 * the WorkContext doorway using:
 * <p>
 * {@code @Rule public EstablishWorkContext context = new EstablishWorkContext();}
 * <p>
 * Example:
 * vcacheFactory = VCachesTestHelper.getProxiedFactory();
 * cache = VCachesTestHelper.getExternalCache(factory, "TestDECache", String.class);; //it also builds expectations for cache creation calls
 * ...
 * doReturn(result(cachedString)).when(cache).get(eq(key), any(Supplier.class));
 * ...
 * cache.put("key", value, PutPolicy.PUT_ALWAYS);
 *
 * @since 1.5.0
 */
@SuppressWarnings("checkstyle:MagicNumber")
public class VCacheTestHelper {

    private static final ThreadLocalRequestContextSupplier THREAD_LOCAL_REQUEST_CONTEXT_SUPPLIER = ThreadLocalRequestContextSupplier.strictSupplier();
    private static final WorkContextRequestContextSupplier workContextContextSupplier = new WorkContextRequestContextSupplier(() -> "myPartition");

    /**
     * Build {@link com.atlassian.vcache.VCacheFactory} and set-up all necessary context. Please don't forget to call
     * {@link #cleanContext()} after tests to clean up vcache context.
     *
     * @return {@link com.atlassian.vcache.VCacheFactory} suitable for testing.
     */
    public static VCacheFactory getFactory() {
        try {
            THREAD_LOCAL_REQUEST_CONTEXT_SUPPLIER.initThread("myPartition");
        } catch (IllegalStateException ignored) {
        }

        final DefaultVCacheCreationHandler handler = new DefaultVCacheCreationHandler(
                Integer.MAX_VALUE, Duration.ofDays(1), Integer.MAX_VALUE, ChangeRate.LOW_CHANGE, ChangeRate.LOW_CHANGE);

        return new GuavaVCacheService(THREAD_LOCAL_REQUEST_CONTEXT_SUPPLIER,
                workContextContextSupplier,
                new EmptyVCacheSettingsDefaultsProvider(),
                handler,
                new NoopMetricsCollector(),
                new PlainExternalCacheKeyGenerator("VCacheTest"),
                new GuavaTestServiceSettings(true, Duration.ofSeconds(30)),
                context -> { });
    }

    /**
     * Build {@link com.atlassian.vcache.VCacheFactory} and set-up all necessary context. Please don't forget to call
     * {@link #cleanContext()} after tests to clean up vcache context.
     *
     * @param contextSupplier the context supplier to be used when creating caches.
     * @return {@link com.atlassian.vcache.VCacheFactory} suitable for testing.
     */
    public static VCacheFactory getFactory(Supplier<RequestContext> contextSupplier) {

        final DefaultVCacheCreationHandler handler = new DefaultVCacheCreationHandler(
                Integer.MAX_VALUE, Duration.ofDays(1), Integer.MAX_VALUE, ChangeRate.LOW_CHANGE, ChangeRate.LOW_CHANGE);

        return new GuavaVCacheService(contextSupplier, contextSupplier,
                new EmptyVCacheSettingsDefaultsProvider(),
                handler,
                new NoopMetricsCollector(),
                new PlainExternalCacheKeyGenerator("VCacheTest"),
                new GuavaTestServiceSettings(true, Duration.ofSeconds(30)),
                context -> { });
    }


    /**
     * Build {@link com.atlassian.vcache.VCacheFactory} and set-up all necessary context. Please don't forget to call
     * {@link #cleanContext()} after tests to clean up vcache context.
     *
     * @return {@link com.atlassian.vcache.VCacheFactory} suitable for testing. Returned value is  mockito proxied object, so can be used
     * to build test expectations.
     */
    public static VCacheFactory getProxiedFactory() {
        return spy(getFactory());
    }

    /**
     * Build {@link DirectExternalCache} and set up mockito expectations for appropriate calls of {@link VCacheFactory}
     *
     * @param mockVcacheFactory mockito proxied or mocked {@link VCacheFactory}
     * @param name name of the cache
     * @param clazz class of cached objects
     * @param <T> type of cached objects
     * @return {@link DirectExternalCache} proxied by mockito.
     */
    public static <T extends Serializable> DirectExternalCache<T> getExternalCache(VCacheFactory mockVcacheFactory,
                                                                                   String name, Class<T> clazz) {
        return getExternalCache(mockVcacheFactory, name, clazz, new ExternalCacheSettingsBuilder().build());
    }

    /**
     * Build {@link DirectExternalCache} and set up mockito expectations for appropriate calls of {@link VCacheFactory}
     *
     * @param mockVcacheFactory mockito proxied or mocked {@link VCacheFactory}
     * @param name name of the cache
     * @param clazz class of cached objects
     * @param settings cache settings
     * @param <T> type of cached objects
     * @return {@link DirectExternalCache} proxied by mockito.
     */
    public static <T extends Serializable> DirectExternalCache<T> getExternalCache(VCacheFactory mockVcacheFactory,
                                                                                   String name, Class<T> clazz,
                                                                                   ExternalCacheSettings settings) {
        final DirectExternalCache<T> desiredCache = spy(mockVcacheFactory.getDirectExternalCache(name,
                JavaSerializationMarshalling.pair(clazz), settings));

        doReturn(desiredCache).when(mockVcacheFactory).getDirectExternalCache(eq(name), any(MarshallingPair.class),
                any(ExternalCacheSettings.class));

        return desiredCache;
    }

    /**
     * Build {@link JvmCache} and set up mockito expectations for appropriate calls of {@link VCacheFactory}
     *
     * @param mockVcacheFactory mockito proxied or mocked {@link VCacheFactory}
     * @param cacheName name of the cache
     * @param <K> type of cache keys
     * @param <V> type of cached objects
     * @return {@link JvmCache} proxied by mockito.
     */
    public static <K, V> JvmCache<K, V> getJvmCache(VCacheFactory mockVcacheFactory, String cacheName) {
        return  getJvmCache(mockVcacheFactory, cacheName, new JvmCacheSettingsBuilder().build());
    }

    /**
     * Build {@link JvmCache} and set up mockito expectations for appropriate calls of {@link VCacheFactory}
     *
     * @param mockVcacheFactory mockito proxied or mocked {@link VCacheFactory}
     * @param cacheName name of the cache
     * @param settings cache settings
     * @param <K> type of cache keys
     * @param <V> type of cached objects
     * @return {@link JvmCache} proxied by mockito.
     */
    public static <K, V> JvmCache<K, V> getJvmCache(VCacheFactory mockVcacheFactory, String cacheName,
                                                    JvmCacheSettings settings) {
        final JvmCache<K, V> desiredCache = spy(mockVcacheFactory.getJvmCache(cacheName, settings));
        doReturn(desiredCache).when(mockVcacheFactory).getJvmCache(eq(cacheName), any(JvmCacheSettings.class));
        return desiredCache;
    }

    /**
     * Build {@link TransactionalExternalCache} and set up mockito expectations for appropriate calls of {@link VCacheFactory}
     *
     * @param mockVcacheFactory mockito proxied or mocked {@link VCacheFactory}
     * @param name name of the cache
     * @param clazz class of cached objects
     * @param <T> type of cached objects
     * @return {@link TransactionalExternalCache} proxied by mockito.
     */
    public static <T extends Serializable> TransactionalExternalCache<T> getTransactionalCache(VCacheFactory mockVcacheFactory,
                                                                                               String name, Class<T> clazz) {
        return getTransactionalCache(mockVcacheFactory, name, clazz, new ExternalCacheSettingsBuilder().build());
    }

    /**
     * Build {@link TransactionalExternalCache} and set up mockito expectations for appropriate calls of {@link VCacheFactory}
     *
     * @param mockVcacheFactory mockito proxied or mocked {@link VCacheFactory}
     * @param name name of the cache
     * @param clazz class of cached objects
     * @param settings cache settings
     * @param <T> type of cached objects
     * @return {@link TransactionalExternalCache} proxied by mockito.
     */
    public static <T extends Serializable> TransactionalExternalCache<T> getTransactionalCache(VCacheFactory mockVcacheFactory,
                                                                                               String name, Class<T> clazz,
                                                                                               ExternalCacheSettings settings) {
        final TransactionalExternalCache<T> desiredCache = spy(mockVcacheFactory.getTransactionalExternalCache(name,
                JavaSerializationMarshalling.pair(clazz), settings));

        doReturn(desiredCache).when(mockVcacheFactory).getTransactionalExternalCache(eq(name), any(MarshallingPair.class),
                any(ExternalCacheSettings.class));

        return desiredCache;
    }

    /**
     * Clean up vcache context.
     */
    public static void cleanContext() {
        THREAD_LOCAL_REQUEST_CONTEXT_SUPPLIER.clearThread();
    }
}