пытаюсь проверить весеннее кеширование.мне нужно проверить аннотацию @cacheble в моем хранилище - PullRequest
0 голосов
/ 15 мая 2019

Я на самом деле пытаюсь проверить мой механизм кэширования. я использую кэш кэффин. Тест: я вызываю метод кэширования дважды и ожидаю того же результата для вызова нескольких методов. Т.е. когда я вызываю метод во второй раз с той же сигнатурой, он не должен вызывать метод, он должен получать данные из кеша. Проблема: мой код фактически вызывает метод дважды. Я издеваюсь над своим хранилищем. Пожалуйста, направьте меня, если кто-нибудь решил эту проблему.

мой репо:

public class TemplateRepositoryOracle implements TemplateRepository 
 @Cacheable("Templates")
    @Override
    public Optional<NotificationTemplate> getNotificationTemplate(String eventTypeId, String destinationType, String destinationSubType) {}

Тест:

import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.Ticker;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;

import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;

import org.mockito.Mockito;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.cache.caffeine.CaffeineCache;
import org.springframework.cache.support.SimpleCacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;



import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
public class TemplateRepositoyOracleTest {

    interface TemplateRepository {
        @Cacheable("Templates")
        Optional<Template> getNotificationTemplate(String eventTypeId, String destinationType, String destinationSubType);
    }

        @Configuration
        @ConfigurationProperties(prefix = "caching")
        @Data
        @Slf4j
        static class CacheConfiguration {

            @Data
            public static class CacheSpec {
                private Integer expireAfterWrite;
            }

            private Map<String, CacheSpec> specs;

            @Bean
            public CacheManager cacheManager(Ticker ticker) {
                SimpleCacheManager manager = new SimpleCacheManager();
                if (specs != null) {
                    List<CaffeineCache> caches =
                            specs.entrySet().stream()
                                    .map(entry -> buildCache(entry.getKey(),
                                            entry.getValue(),
                                            ticker))
                                    .collect(Collectors.toList());
                    manager.setCaches(caches);
                }
                return manager;
            }

            private CaffeineCache buildCache(String name, CacheSpec cacheSpec, Ticker ticker) {
                log.info("Cache {} specified timeout of {} min", name, cacheSpec.getExpireAfterWrite());
                final Caffeine<Object, Object> caffeineBuilder
                        = Caffeine.newBuilder()
                        .expireAfterWrite(cacheSpec.getExpireAfterWrite(), TimeUnit.MINUTES)
                        .ticker(ticker);
                return new CaffeineCache(name, caffeineBuilder.build());
            }

            @Bean
            public Ticker ticker() {
                return Ticker.systemTicker();
            }

            @Bean
            TemplateRepository myRepo() {
                return Mockito.mock(TemplateRepository.class);
            }

        }
    @Autowired
    CacheManager manager;

    @Autowired
    TemplateRepository repo;

    @Test
    public void methodInvocationShouldBeCached() {



        Optional<Template> third = Optional.of(new NotificationTemplate(UUID.randomUUID(),"Test",DestinationType.SMS,"test","test",Optional.empty(),Optional.empty()));
        Optional<Template> fourth = Optional.of(new NotificationTemplate(UUID.randomUUID(),"Test2",DestinationType.SMS,"test2","test2",Optional.empty(),Optional.empty()));

        // the mock to return *different* objects for the first and second call
        Mockito.when(repo.getNotificationTemplate(Mockito.any(String.class),Mockito.any(String.class),Mockito.any(String.class))).thenReturn(third);

        // First invocation returns object returned by the method
        Object result = repo.getNotificationTemplate("1","1","1");
        assertThat(result, is(third));

        // Second invocation should return cached value, *not* second (as set up above)
        result = repo.getNotificationTemplate("1","1","1");
        assertThat(result, is(third));

        // Verify repository method was invoked once
        Mockito.verify(repo, Mockito.times(1)).getNotificationTemplate("1","1","1");
        assertThat(manager.getCache("notificationTemplates").get(""), is(notNullValue()));

        // Third invocation with different key is triggers the second invocation of the repo method
        result = repo.getNotificationTemplate("2","2","2");
        assertThat(result, is(fourth));
    }

}

Файл объекта:

кэширование: спецификации: Шаблоны: expireAfterWrite: 1440

Добро пожаловать на сайт PullRequest, где вы можете задавать вопросы и получать ответы от других членов сообщества.
...