feat : add test using @RestClientTest

boot-ultimate-redis/pom.xml

@@ -38,6 +38,10 @@
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-data-redis</artifactId>
         </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-pool2</artifactId>
+        </dependency>
         <dependency>
             <groupId>commons-io</groupId>
             <artifactId>commons-io</artifactId>

boot-ultimate-redis/src/main/java/com/example/ultimateredis/UltimateRedisApplication.java

@@ -2,9 +2,7 @@
 
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
-import org.springframework.cache.annotation.EnableCaching;
 
-@EnableCaching
 @SpringBootApplication
 public class UltimateRedisApplication {
 

boot-ultimate-redis/src/main/java/com/example/ultimateredis/config/CacheConfig.java

@@ -1,89 +1,52 @@
 package com.example.ultimateredis.config;
 
+import io.lettuce.core.RedisURI;
 import java.time.Duration;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Map.Entry;
 import lombok.extern.slf4j.Slf4j;
+import org.springframework.boot.autoconfigure.cache.RedisCacheManagerBuilderCustomizer;
+import org.springframework.boot.autoconfigure.data.redis.LettuceClientConfigurationBuilderCustomizer;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.cache.Cache;
-import org.springframework.cache.CacheManager;
 import org.springframework.cache.annotation.CachingConfigurer;
+import org.springframework.cache.annotation.EnableCaching;
 import org.springframework.cache.interceptor.CacheErrorHandler;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
-import org.springframework.context.annotation.Primary;
 import org.springframework.data.redis.cache.RedisCacheConfiguration;
-import org.springframework.data.redis.cache.RedisCacheManager;
-import org.springframework.data.redis.connection.RedisConnectionFactory;
-import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
-import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
-import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.data.redis.serializer.RedisSerializationContext;
 
 @Configuration(proxyBeanMethods = false)
 @EnableConfigurationProperties(CacheConfigurationProperties.class)
+@EnableCaching
 @Slf4j
 public class CacheConfig implements CachingConfigurer {
 
     @Bean
-    @Primary
-    RedisCacheConfiguration defaultCacheConfig() {
+    RedisCacheManagerBuilderCustomizer redisCacheManagerBuilderCustomizer(
+            CacheConfigurationProperties cacheConfigurationProperties) {
         RedisCacheGZIPSerializer serializerGzip = new RedisCacheGZIPSerializer();
-
-        return RedisCacheConfiguration.defaultCacheConfig()
-                .serializeValuesWith(
-                        RedisSerializationContext.SerializationPair.fromSerializer(serializerGzip));
-    }
-
-    @Bean
-    LettuceConnectionFactory redisConnectionFactory(CacheConfigurationProperties properties) {
-        log.info(
-                "Redis (/Lettuce) configuration enabled. With cache timeout {} seconds.",
-                properties.getTimeoutSeconds());
-
-        RedisStandaloneConfiguration redisStandaloneConfiguration =
-                new RedisStandaloneConfiguration();
-        redisStandaloneConfiguration.setHostName(properties.getRedisHost());
-        redisStandaloneConfiguration.setPort(properties.getRedisPort());
-        return new LettuceConnectionFactory(redisStandaloneConfiguration);
-    }
-
-    @Bean
-    RedisTemplate<String, String> redisTemplate(RedisConnectionFactory cf) {
-        RedisTemplate<String, String> redisTemplate = new RedisTemplate<>();
-        redisTemplate.setConnectionFactory(cf);
-        return redisTemplate;
+        return builder -> {
+            builder.cacheDefaults()
+                    .disableCachingNullValues()
+                    .serializeValuesWith(
+                            RedisSerializationContext.SerializationPair.fromSerializer(
+                                    serializerGzip));
+            cacheConfigurationProperties
+                    .getCacheExpirations()
+                    .forEach(
+                            (cacheName, timeout) ->
+                                    builder.withCacheConfiguration(
+                                            cacheName,
+                                            RedisCacheConfiguration.defaultCacheConfig()
+                                                    .entryTtl(Duration.ofSeconds(timeout))));
+        };
     }
 
     @Bean
-    RedisCacheConfiguration defaultCacheConfiguration(CacheConfigurationProperties properties) {
-        return createCacheConfiguration(properties.getTimeoutSeconds());
-    }
-
-    private RedisCacheConfiguration createCacheConfiguration(long timeoutSeconds) {
-        return RedisCacheConfiguration.defaultCacheConfig()
-                .entryTtl(Duration.ofSeconds(timeoutSeconds));
-    }
-
-    @Bean
-    CacheManager cacheManager(
-            RedisConnectionFactory redisConnectionFactory,
-            CacheConfigurationProperties properties,
-            RedisCacheConfiguration defaultCacheConfiguration) {
-        Map<String, RedisCacheConfiguration> cacheConfigurations = new HashMap<>();
-
-        for (Entry<String, Long> cacheNameAndTimeout :
-                properties.getCacheExpirations().entrySet()) {
-            cacheConfigurations.put(
-                    cacheNameAndTimeout.getKey(),
-                    createCacheConfiguration(cacheNameAndTimeout.getValue()));
-        }
-
-        return RedisCacheManager.builder(redisConnectionFactory)
-                .cacheDefaults(defaultCacheConfiguration)
-                .withInitialCacheConfigurations(cacheConfigurations)
-                .build();
+    LettuceClientConfigurationBuilderCustomizer lettuceClientConfigurationBuilderCustomizer(
+            CacheConfigurationProperties properties) {
+        return clientConfigurationBuilder ->
+                clientConfigurationBuilder.apply(RedisURI.create(properties.getRedisURI()));
     }
 
     @Override

boot-ultimate-redis/src/main/java/com/example/ultimateredis/config/CacheConfigurationProperties.java

@@ -10,8 +10,7 @@
 public class CacheConfigurationProperties {
 
     private long timeoutSeconds = 60;
-    private int redisPort = 6379;
-    private String redisHost = "localhost";
+    private String redisURI;
     // Mapping of cacheNames to expire-after-write timeout in seconds
     private Map<String, Long> cacheExpirations = new HashMap<>();
 }

boot-ultimate-redis/src/main/java/com/example/ultimateredis/repository/ActorRepository.java

@@ -7,6 +7,7 @@
 
 @Repository
 public interface ActorRepository extends CrudRepository<Actor, String> {
+
     Optional<Actor> findByName(String name);
 
     Optional<Actor> findByNameAndAge(String name, Integer age);

boot-ultimate-redis/src/main/resources/application.properties

@@ -1,3 +1,6 @@
 cache.timeout=60
 cache.cacheExpirations.myControlledCache=180
+cache.redis-uri=redis://localhost:6379
+
+spring.mvc.problemdetails.enabled=true
 spring.threads.virtual.enabled=true

boot-ultimate-redis/src/test/java/com/example/ultimateredis/TestUltimateRedisApplication.java

@@ -19,8 +19,7 @@ RedisContainer redisContainer(DynamicPropertyRegistry dynamicPropertyRegistry) {
                 new RedisContainer(DockerImageName.parse("redis").withTag("7.2.5-alpine"))
                         .withStartupAttempts(5)
                         .withStartupTimeout(Duration.ofMinutes(10));
-        dynamicPropertyRegistry.add("cache.redis-port", redisContainer::getRedisPort);
-        dynamicPropertyRegistry.add("cache.redis-host", redisContainer::getRedisHost);
+        dynamicPropertyRegistry.add("cache.redis-uri", redisContainer::getRedisURI);
         return redisContainer;
     }
 

httpClients/boot-restclient/src/test/java/com/example/restclient/bootrestclient/services/PostServiceTest.java

@@ -0,0 +1,52 @@
+package com.example.restclient.bootrestclient.services;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.springframework.test.web.client.match.MockRestRequestMatchers.*;
+import static org.springframework.test.web.client.response.MockRestResponseCreators.withSuccess;
+
+import com.example.restclient.bootrestclient.config.RestClientConfiguration;
+import com.example.restclient.bootrestclient.model.response.PostDto;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import java.util.Optional;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.client.RestClientTest;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.MediaType;
+import org.springframework.test.web.client.MockRestServiceServer;
+
+@RestClientTest(
+        components = {PostService.class, HttpClientService.class, RestClientConfiguration.class})
+class PostServiceTest {
+
+    @Autowired private MockRestServiceServer mockRestServiceServer;
+
+    @Autowired private ObjectMapper objectMapper;
+
+    @Autowired private PostService postService;
+
+    @Test
+    void findPostById() throws JsonProcessingException {
+
+        PostDto postDto = new PostDto(1000L, 583L, "JunitTitle", "Response from RestClientTest");
+        this.mockRestServiceServer
+                .expect(requestTo("https://jsonplaceholder.typicode.com/posts/1"))
+                .andExpect(method(HttpMethod.GET))
+                .andExpect(header(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE))
+                .andExpect(header(HttpHeaders.ACCEPT, MediaType.APPLICATION_JSON_VALUE))
+                .andExpect(header("apiKey", "123456"))
+                .andRespond(
+                        withSuccess(
+                                objectMapper.writeValueAsString(postDto),
+                                MediaType.APPLICATION_JSON));
+
+        Optional<PostDto> optionalPostDto = postService.findPostById(1L);
+
+        assertThat(optionalPostDto).isPresent();
+        assertThat(optionalPostDto.get().title()).isEqualTo("JunitTitle");
+
+        mockRestServiceServer.verify();
+    }
+}