https://jira.baeldung.com/browse/BAEL-7787

Author: Michaelin007

spring-reactive-modules/spring-reactive-client-2/src/main/java/com/baeldung/memoization/FibonacciMemoization.java

@@ -9,9 +9,9 @@
 public class FibonacciMemoization {
 
     private static final Map<Integer, Long> cache = new HashMap<>();
-    private static Logger logger = LoggerFactory.getLogger(FibonacciMemoization.class);
+    private static final Logger logger = LoggerFactory.getLogger(FibonacciMemoization.class);
 
-    static long fibonacci(int n) {
+    public static long fibonacci(int n) {
         if (n <= 1) {
             return n;
         }

spring-reactive-modules/spring-reactive-client-2/src/main/java/com/baeldung/memoization/MemoizationWithMonoCache.java

@@ -2,18 +2,15 @@
 
 import org.springframework.web.reactive.function.client.WebClient;
 import reactor.core.publisher.Mono;
-
-import java.io.IOException;
-import java.time.Duration;
 import java.util.concurrent.atomic.AtomicInteger;
 
 public class MemoizationWithMonoCache {
 
-    static WebClient client = WebClient.create("https://jsonplaceholder.typicode.com/users");
+    WebClient client = WebClient.create("https://jsonplaceholder.typicode.com/users");
 
-    static AtomicInteger counter = new AtomicInteger(0);
+    AtomicInteger counter = new AtomicInteger(0);
 
-    static Mono<User> retrieveOneUser(int id) {
+    public  Mono<User> retrieveOneUser(int id) {
         return client.get()
             .uri("/{id}", id)
             .retrieve()

spring-reactive-modules/spring-reactive-client-2/src/test/java/com/baeldung/memoization/FibonacciMemoizationUnitTest.java

@@ -8,7 +8,6 @@ class FibonacciMemoizationUnitTest {
 
     @Test
     void givenFibonacciNumber_whenFirstOccurenceIscache_thenReturnCacheResultOnSecondCall() {
-
         assertEquals(5, FibonacciMemoization.fibonacci(5));
         assertEquals(2, FibonacciMemoization.fibonacci(3));
         assertEquals(55, FibonacciMemoization.fibonacci(10));

spring-reactive-modules/spring-reactive-client-2/src/test/java/com/baeldung/memoization/MemoizationWithMonoCacheUnitTest.java

@@ -3,31 +3,84 @@
 import org.junit.jupiter.api.Test;
 import reactor.core.Disposable;
 import reactor.core.publisher.Mono;
-import reactor.test.StepVerifier;
 
+import java.time.Duration;
 import java.util.concurrent.atomic.AtomicReference;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
 class MemoizationWithMonoCacheUnitTest {
 
+    @Test
+    void givenRetrievedUser_whenTheCallToRemoteIsNotCache_thenReturnInvocationCountAndCompareResult() {
+
+        MemoizationWithMonoCache memoizationWithMonoCache = new MemoizationWithMonoCache();
+
+        Mono<User> retrieveOneUser = memoizationWithMonoCache.retrieveOneUser(1);
+        AtomicReference<User> firstUser = new AtomicReference<>();
+        AtomicReference<User> secondUser = new AtomicReference<>();
+
+        Disposable firstUserCall = retrieveOneUser.map(user -> {
+                firstUser.set(user);
+                return user.getName();
+            })
+            .subscribe();
+
+        Disposable secondUserCall = retrieveOneUser.map(user -> {
+                secondUser.set(user);
+                return user.getName();
+            })
+            .subscribe();
+
+        assertEquals(2, memoizationWithMonoCache.getCounter());
+        assertEquals(firstUser.get(), secondUser.get());
+
+    }
+
     @Test
     void givenRetrievedUser_whenTheCallToRemoteIsCache_thenReturnInvocationCountAndCompareResult() {
 
         MemoizationWithMonoCache memoizationWithMonoCache = new MemoizationWithMonoCache();
 
-        Mono<User> userCall = MemoizationWithMonoCache.retrieveOneUser(1)
+        Mono<User> retrieveOneUser = memoizationWithMonoCache.retrieveOneUser(1)
             .cache();
         AtomicReference<User> firstUser = new AtomicReference<>();
         AtomicReference<User> secondUser = new AtomicReference<>();
 
-        Disposable firstUserCall = userCall.map(user -> {
+        Disposable firstUserCall = retrieveOneUser.map(user -> {
+                firstUser.set(user);
+                return user.getName();
+            })
+            .subscribe();
+
+        Disposable secondUserCall = retrieveOneUser.map(user -> {
+                secondUser.set(user);
+                return user.getName();
+            })
+            .subscribe();
+
+        assertEquals(1, memoizationWithMonoCache.getCounter());
+        assertEquals(firstUser.get(), secondUser.get());
+
+    }
+
+    @Test
+    void givenRetrievedUser_whenTheCallToRemoteIsCacheWithSuration_thenReturnInvocationCountAndCompareResult() {
+
+        MemoizationWithMonoCache memoizationWithMonoCache = new MemoizationWithMonoCache();
+
+        Mono<User> retrieveOneUser = memoizationWithMonoCache.retrieveOneUser(1)
+            .cache(Duration.ofMinutes(5));
+        AtomicReference<User> firstUser = new AtomicReference<>();
+        AtomicReference<User> secondUser = new AtomicReference<>();
+
+        Disposable firstUserCall = retrieveOneUser.map(user -> {
                 firstUser.set(user);
                 return user.getName();
             })
             .subscribe();
 
-        Disposable secondUserCall = userCall.map(user -> {
+        Disposable secondUserCall = retrieveOneUser.map(user -> {
                 secondUser.set(user);
                 return user.getName();
             })