Модульные тесты реализации Caffeine LoadingCache проходят индивидуально, но один из них не проходит при совместном запуске - PullRequest
Новая
       12

Модульные тесты реализации Caffeine LoadingCache проходят индивидуально, но один из них не проходит при совместном запуске

0 голосов
/ 21 марта 2019

Модульные тесты (JUnit, Mockito), которые я написал для своей реализации Caffeine CacheLoader, все проходят успешно, когда я запускаю их по отдельности, но один из них не проходит, когда я запускаю их все вместе. Я считаю, что следую рекомендациям по использованию @Before для всех моих настроек тестового объекта.

При запуске с остальными тест testGet_WhenCalledASecondAndThirdTimeBeyondCacheDuration_LoadingMethodCalledASecondTime каждый раз завершается ошибкой со следующей ошибкой: 

org.mockito.exceptions.verification.TooLittleActualInvocations: 
testDataSource.getObjectWithKey(
    "mountain-bikes"
);
Wanted 2 times:
-> at ErrorHandlingLoadingCacheFactoryTest.testGet_WhenCalledASecondAndThirdTimeBeyondCacheDuration_LoadingMethodCalledASecondTime(ErrorHandlingLoadingCacheFactoryTest.java:67)
But was 1 time:
-> at ErrorHandlingCacheLoader.load(ErrorHandlingCacheLoader.java:41)

Может показаться, что что-то переносится между тестами, но, учитывая то, что я делаю в моем методе @Before, я не уверен, как это могло быть. Я попытался вызвать следующее в @After методе:

  • invalidateAll()
  • cleanUp()
  • Mockito.reset(testDataSource)

Я также пытался вручную передать singleThreadExecutor в кеш-компоновщик и ждать, пока он завершит все, что он делает в @After в случае, если это как-то связано с ним.

Моя реализация Caffeine CacheLoader просто переопределяет метод reload, чтобы вернуть текущее кэшированное значение, если попытка обновить его не удалась (выдает исключение). Кроме того, это довольно ваниль. 

@Component
public class ErrorHandlingLoadingCacheFactory {

    private final Ticker ticker;

    @Autowired
    public ErrorHandlingLoadingCacheFactory(Ticker ticker) {
        this.ticker = ticker;
    }

    public <T> LoadingCache<String, T> buildCache(String cacheName,
                                                        long duration,
                                                        TimeUnit timeUnit,
                                                        Function<String, T> valueResolver) {
        return Caffeine.newBuilder()
                .refreshAfterWrite(duration, timeUnit)
                .ticker(ticker)
                .build(new ErrorHandlingCacheLoader<>(cacheName, valueResolver));
    }
}

/**
 *  a LoadingCache that retains stale cache values if
 *  an attempt to retrieve a fresh value for a given key fails.
 *
 * @param <K> the cache key type
 * @param <V> the cache value type
 */
class ErrorHandlingCacheLoader<K, V> implements CacheLoader<K, V> {
    private final static Logger logger = LoggerFactory.getLogger(ErrorHandlingCacheLoader.class);

    private final String cacheName;
    private final Function<K, V> valueResolver;

    /**
     * Create a cache.
     *
     * @param cacheName the cache name
     * @param valueResolver the method used to get a value for a key
     */
    public ErrorHandlingCacheLoader(String cacheName, Function<K, V> valueResolver) {
        this.cacheName = cacheName;
        this.valueResolver = valueResolver;
    }

    /**
     * Load the initial cache value for a given key.
     * @param key the cache key
     * @return the initial value to cache
     */
    @Override
    public V load(@NonNull K key) {
        return valueResolver.apply(key);
    }

    /**
     * Attempt to reload a value for a given key.
     * @param key the cache key
     * @param oldValue the currently cached value for the given key
     * @return
     */
    @Override
    public V reload(@NonNull K key, V oldValue) {
        V value = oldValue;
        try {
            value = valueResolver.apply(key);
        } catch (RuntimeException e) {
            logger.warn("Failed to retrieve value for key '{}' in cache '{}'. Returning currently cached value '{}'.", key, cacheName, oldValue);
        }
        return value;
    }
}

public class ErrorHandlingLoadingCacheFactoryTest {

    private ErrorHandlingLoadingCacheFactory errorHandlingLoadingCacheFactory;

    private FakeTicker fakeTicker;
    private TestDataSource testDataSource;

    private LoadingCache<String, TestObject> loadingCache;

    @Before
    public void setUp() {
        fakeTicker = new FakeTicker();
        testDataSource = mock(TestDataSource.class);
        errorHandlingLoadingCacheFactory = new ErrorHandlingLoadingCacheFactory(fakeTicker::read);
        loadingCache = errorHandlingLoadingCacheFactory.buildCache("testCache", 1, TimeUnit.HOURS, testDataSource::getObjectWithKey);
    }

    @After
    public void tearDown() {
        validateMockitoUsage();
    }

    @Test
    public void testGet_WhenCalledTwiceWithinCachePeriod_LoadingMethodCalledOnce() {
        // Arrange
        TestObject testObject = new TestObject("Mountain Bikes");
        when(testDataSource.getObjectWithKey("mountain-bikes")).thenReturn(testObject);

        // Act
        TestObject result1 = loadingCache.get("mountain-bikes");
        TestObject result2 = loadingCache.get("mountain-bikes");

        // Assert
        verify(testDataSource, times(1)).getObjectWithKey("mountain-bikes");
        assertThat(result1).isEqualTo(testObject);
        assertThat(result2).isEqualTo(testObject);
    }

    @Test
    public void testGet_WhenCalledASecondAndThirdTimeBeyondCacheDuration_LoadingMethodCalledASecondTime() {
        // Arrange
        TestObject testObject1 = new TestObject("Mountain Bikes 1");
        TestObject testObject2 = new TestObject("Mountain Bikes 2");
        when(testDataSource.getObjectWithKey("mountain-bikes")).thenReturn(testObject1, testObject2);

        // Act
        TestObject result1 = loadingCache.get("mountain-bikes");
        fakeTicker.advance(2, TimeUnit.HOURS);
        TestObject result2 = loadingCache.get("mountain-bikes");
        TestObject result3 = loadingCache.get("mountain-bikes");

        // Assert
        verify(testDataSource, times(2)).getObjectWithKey("mountain-bikes");
        assertThat(result1).isEqualTo(testObject1);
        assertThat(result2).isEqualTo(testObject1);
        assertThat(result3).isEqualTo(testObject2);
    }

    @Test(expected = RuntimeException.class)
    public void testGet_WhenFirstLoadCallThrowsRuntimeException_ThrowsRuntimeException() {
        // Arrange
        when(testDataSource.getObjectWithKey("mountain-bikes")).thenThrow(new RuntimeException());

        // Act
        loadingCache.get("mountain-bikes");
    }

    @Test
    public void testGet_WhenFirstLoadCallSuccessfulButSecondThrowsRuntimeException_ReturnsCachedValueFromFirstCall() {
        // Arrange
        TestObject testObject1 = new TestObject("Mountain Bikes 1");
        when(testDataSource.getObjectWithKey("mountain-bikes")).thenReturn(testObject1).thenThrow(new RuntimeException());

        // Act
        TestObject result1 = loadingCache.get("mountain-bikes");
        fakeTicker.advance(2, TimeUnit.HOURS);
        TestObject result2 = loadingCache.get("mountain-bikes");

        // Assert
        verify(testDataSource, times(2)).getObjectWithKey("mountain-bikes");
        assertThat(result1).isEqualTo(testObject1);
        assertThat(result2).isEqualTo(testObject1);
    }

    @Test
    public void testGet_WhenFirstLoadCallSuccessfulButSecondThrowsRuntimeException_SubsequentGetsReturnCachedValueFromFirstCall() {
        // Arrange
        TestObject testObject1 = new TestObject("Mountain Bikes 1");
        when(testDataSource.getObjectWithKey("mountain-bikes")).thenReturn(testObject1).thenThrow(new RuntimeException());

        // Act
        TestObject result1 = loadingCache.get("mountain-bikes");
        fakeTicker.advance(2, TimeUnit.HOURS);
        TestObject result2 = loadingCache.get("mountain-bikes");
        TestObject result3 = loadingCache.get("mountain-bikes");

        // Assert
        verify(testDataSource, times(2)).getObjectWithKey("mountain-bikes");
        assertThat(result1).isEqualTo(testObject1);
        assertThat(result2).isEqualTo(testObject1);
        assertThat(result3).isEqualTo(testObject1);
    }

    @Test(expected = NullPointerException.class)
    public void testGet_WhenKeyIsNull_ThrowsNullPointerException() {
        // Arrange
        String key = null;

        // Act
        loadingCache.get(key);
    }

    @Test
    public void testGet_WhenFirstLoadCallReturnsNull_DoesNotCacheResult() {
        // Arrange
        TestObject testObject1 = new TestObject("Mountain Bikes 1");
        when(testDataSource.getObjectWithKey("mountain-bikes")).thenReturn(null).thenReturn(testObject1);

        // Act
        TestObject result1 = loadingCache.get("mountain-bikes");
        TestObject result2 = loadingCache.get("mountain-bikes");

        // Assert
        verify(testDataSource, times(2)).getObjectWithKey("mountain-bikes");
        assertThat(result1).isEqualTo(null);
        assertThat(result2).isEqualTo(testObject1);
    }

    @Data
    class TestObject {
        private String id;
        public TestObject(String id) {
            this.id = id;
        }
    }

    interface TestDataSource {
        TestObject getObjectWithKey(String key);
    }
}

1 Ответ

1 голос
/ 21 марта 2019

Бен Манес предложил в своем комментарии, чтобы я использовал Runnable::run в качестве исполнителя LoadingCache при запуске модульных тестов, что и помогло!

Я реализовал второй защищенный метод buildCache на своей фабрике, который дополнительно требуетпараметр Executor, который мой тестовый класс использует для передачи Runnable::run.

обновленного ErrorHandlingLoadingCacheFactory : 

public class ErrorHandlingLoadingCacheFactory {

    private final Ticker ticker;

    @Autowired
    public ErrorHandlingLoadingCacheFactory(Ticker ticker) {
        this.ticker = ticker;
    }

    /**
     * Create an in-memory LoadingCache
     *
     * @param cacheName the name of the cache
     * @param duration how long to keep values in the cache before attempting to refresh them
     * @param timeUnit the unit of time of the given duration
     * @param valueResolver the method to call to get a value to load into the cache for a given key
     * @param <T> the type of object to store into the cache
     * @return the newly created cache
     */
    public <T> LoadingCache<String, T> buildCache(String cacheName,
                                                        long duration,
                                                        TimeUnit timeUnit,
                                                        Function<String, T> valueResolver) {
        return buildCache(cacheName, duration, timeUnit, valueResolver, ForkJoinPool.commonPool());
    }

    /**
     * Create an in-memory LoadingCache
     *
     * @param cacheName the name of the cache
     * @param duration how long to keep values in the cache before attempting to refresh them
     * @param timeUnit the unit of time of the given duration
     * @param valueResolver the method to call to get a value to load into the cache for a given key
     * @param executor the executor for the cache to use
     * @param <T> the type of object to store into the cache
     * @return the newly created cache
     */
    protected <T> LoadingCache<String, T> buildCache(String cacheName,
                                                     long duration,
                                                     TimeUnit timeUnit,
                                                     Function<String, T> valueResolver,
                                                     Executor executor) {
        return Caffeine.newBuilder()
                .refreshAfterWrite(duration, timeUnit)
                .ticker(ticker)
                .executor(executor)
                .build(new ErrorHandlingCacheLoader<>(cacheName, valueResolver));
    }
}

обновленного метода setUp() в ErrorHandlingLoadingCacheFactoryTest : 

...
@Before
    public void setUp() {
        fakeTicker = new FakeTicker();
        testDataSource = mock(TestDataSource.class);
        errorHandlingLoadingCacheFactory = new ErrorHandlingLoadingCacheFactory(fakeTicker::read);
        loadingCache = errorHandlingLoadingCacheFactory.buildCache("testCache", 1, TimeUnit.HOURS, testDataSource::getObjectWithKey, Runnable::run);
    }
...

Должно быть, между моими тестами произошла гонка, которую мой однопоточный исполнитель не перехватил, возможно потому, что я не дождался, пока он завершится в моем@After метод.Бен предположил, что если бы я использовал awaitTermination на однопоточном исполнителе, это также могло бы сработать.

...