test: add tests related to evictCache()

chenggangpro · Aug 18, 2023 · d8f9d8f · d8f9d8f
1 parent eed49d8
commit d8f9d8f
Show file tree

Hide file tree

Showing 4 changed files with 170 additions and 4 deletions.
diff --git a/.../chenggang/project/reactive/cache/support/defaults/executor/DefaultReactiveFluxCache.java b/.../chenggang/project/reactive/cache/support/defaults/executor/DefaultReactiveFluxCache.java
@@ -163,7 +163,7 @@ public Mono<Void> evictCache(@NonNull String cacheKey) {
                                 operationId,
                                 currentOperationId
                         ))
-                        .then(Mono.error(throwable))
+                        .then()
                 ,
                 (currentOperationId) -> this.reactiveCacheLock.releaseInitializeLock(cacheName, cacheKey)
                         .doOnNext(operationId -> log.debug(

diff --git a/.../chenggang/project/reactive/cache/support/defaults/executor/DefaultReactiveMonoCache.java b/.../chenggang/project/reactive/cache/support/defaults/executor/DefaultReactiveMonoCache.java
@@ -162,7 +162,7 @@ public Mono<Void> evictCache(@NonNull String cacheKey) {
                                 operationId,
                                 currentOperationId
                         ))
-                        .then(Mono.error(throwable))
+                        .then()
                 ,
                 (currentOperationId) -> this.reactiveCacheLock.releaseInitializeLock(cacheName, cacheKey)
                         .doOnNext(operationId -> log.debug(

diff --git a/...active/cache/support/defaults/executor/inmemory/InmemoryDefaultReactiveFluxCacheTest.java b/...active/cache/support/defaults/executor/inmemory/InmemoryDefaultReactiveFluxCacheTest.java
@@ -1,12 +1,15 @@
 package pro.chenggang.project.reactive.cache.support.defaults.executor.inmemory;
 
+import lombok.NonNull;
 import org.junit.jupiter.api.Test;
 import pro.chenggang.project.reactive.cache.support.BaseTest;
+import pro.chenggang.project.reactive.cache.support.core.adapter.ReactiveCacheFluxAdapter;
 import pro.chenggang.project.reactive.cache.support.defaults.executor.DefaultReactiveFluxCache;
 import pro.chenggang.project.reactive.cache.support.defaults.inmemory.InmemoryReactiveCacheFluxAdapter;
 import pro.chenggang.project.reactive.cache.support.defaults.inmemory.InmemoryReactiveCacheLock;
 import pro.chenggang.project.reactive.cache.support.exception.NoSuchCachedReactiveDataException;
 import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
 import reactor.test.StepVerifier;
 
 import java.time.Duration;
@@ -79,9 +82,89 @@ void cacheIfNecessaryWithError() {
 
     @Test
     void evictCache() {
-        defaultReactiveFluxCache
-                .evictCache(cacheKey)
+        defaultReactiveFluxCache.evictCache(cacheKey)
                 .as(StepVerifier::create)
                 .verifyComplete();
     }
+
+    @Test
+    void evictCacheWithError(){
+        DefaultReactiveFluxCache defaultReactiveFluxCache = new DefaultReactiveFluxCache(cacheName,
+                maxWaitingDuration,
+                new InmemoryReactiveCacheLock(),
+                new ErrorReactiveCacheFluxAdapter()
+        );
+        defaultReactiveFluxCache.evictCache(cacheKey)
+                .as(StepVerifier::create)
+                .expectError(IllegalStateException.class)
+                .verify();
+    }
+
+    @Test
+    void evictCacheWithCancel(){
+        DefaultReactiveFluxCache defaultReactiveFluxCache = new DefaultReactiveFluxCache(cacheName,
+                maxWaitingDuration,
+                new InmemoryReactiveCacheLock(),
+                new CancelReactiveCacheFluxAdapter()
+        );
+        defaultReactiveFluxCache.evictCache(cacheKey)
+                .delayElement(Duration.ofMillis(500))
+                .as(StepVerifier::create)
+                .thenAwait(Duration.ofMillis(500))
+                .thenCancel()
+                .verify();
+    }
+
+    private static class ErrorReactiveCacheFluxAdapter implements ReactiveCacheFluxAdapter {
+
+        @Override
+        public Mono<Boolean> hasData(@NonNull String cacheKey) {
+            return Mono.just(true);
+        }
+
+        @Override
+        public <T> Flux<T> loadData(@NonNull String cacheKey) {
+            return Flux.empty();
+        }
+
+        @Override
+        public <T> Flux<T> cacheData(@NonNull String cacheKey,
+                                     @NonNull Duration cacheDuration,
+                                     @NonNull Flux<T> sourcePublisher) {
+            return sourcePublisher;
+        }
+
+        @Override
+        public Mono<Void> cleanupData(@NonNull String cacheKey) {
+            return Mono.error(new IllegalStateException())
+                    .then();
+        }
+    }
+
+    private static class CancelReactiveCacheFluxAdapter implements ReactiveCacheFluxAdapter {
+
+        @Override
+        public Mono<Boolean> hasData(@NonNull String cacheKey) {
+            return Mono.just(true);
+        }
+
+        @Override
+        public <T> Flux<T> loadData(@NonNull String cacheKey) {
+            return Flux.empty();
+        }
+
+        @Override
+        public <T> Flux<T> cacheData(@NonNull String cacheKey,
+                                     @NonNull Duration cacheDuration,
+                                     @NonNull Flux<T> sourcePublisher) {
+            return sourcePublisher;
+        }
+
+        @Override
+        public Mono<Void> cleanupData(@NonNull String cacheKey) {
+            return Mono.defer(() -> Mono.just(true)
+                    .delayElement(Duration.ofSeconds(1)))
+                    .then();
+        }
+    }
 }
diff --git a/...active/cache/support/defaults/executor/inmemory/InmemoryDefaultReactiveMonoCacheTest.java b/...active/cache/support/defaults/executor/inmemory/InmemoryDefaultReactiveMonoCacheTest.java
@@ -1,7 +1,9 @@
 package pro.chenggang.project.reactive.cache.support.defaults.executor.inmemory;
 
+import lombok.NonNull;
 import org.junit.jupiter.api.Test;
 import pro.chenggang.project.reactive.cache.support.BaseTest;
+import pro.chenggang.project.reactive.cache.support.core.adapter.ReactiveCacheMonoAdapter;
 import pro.chenggang.project.reactive.cache.support.defaults.executor.DefaultReactiveMonoCache;
 import pro.chenggang.project.reactive.cache.support.defaults.inmemory.InmemoryReactiveCacheLock;
 import pro.chenggang.project.reactive.cache.support.defaults.inmemory.InmemoryReactiveCacheMonoAdapter;
@@ -82,4 +84,85 @@ void evictCache() {
                 .as(StepVerifier::create)
                 .verifyComplete();
     }
+
+    @Test
+    void evictCacheWithError(){
+        DefaultReactiveMonoCache defaultReactiveMonoCache = new DefaultReactiveMonoCache(cacheName,
+                maxWaitingDuration,
+                new InmemoryReactiveCacheLock(),
+                new ErrorReactiveCacheMonoAdapter()
+        );
+        defaultReactiveMonoCache.evictCache(cacheKey)
+                .as(StepVerifier::create)
+                .expectError(IllegalStateException.class)
+                .verify();
+    }
+
+    @Test
+    void evictCacheWithCancel(){
+        DefaultReactiveMonoCache defaultReactiveMonoCache = new DefaultReactiveMonoCache(cacheName,
+                maxWaitingDuration,
+                new InmemoryReactiveCacheLock(),
+                new CancelReactiveCacheMonoAdapter()
+        );
+        defaultReactiveMonoCache.evictCache(cacheKey)
+                .delayElement(Duration.ofMillis(500))
+                .as(StepVerifier::create)
+                .thenAwait(Duration.ofMillis(500))
+                .thenCancel()
+                .verify();
+    }
+
+    private static class ErrorReactiveCacheMonoAdapter implements ReactiveCacheMonoAdapter {
+
+        @Override
+        public Mono<Boolean> hasData(@NonNull String cacheKey) {
+            return Mono.just(true);
+        }
+
+        @Override
+        public <T> Mono<T> loadData(@NonNull String cacheKey) {
+            return Mono.empty();
+        }
+
+        @Override
+        public <T> Mono<T> cacheData(@NonNull String cacheKey,
+                                     @NonNull Duration cacheDuration,
+                                     @NonNull Mono<T> sourcePublisher) {
+            return sourcePublisher;
+        }
+
+        @Override
+        public Mono<Void> cleanupData(@NonNull String cacheKey) {
+            return Mono.error(new IllegalStateException())
+                    .then();
+        }
+    }
+
+    private static class CancelReactiveCacheMonoAdapter implements ReactiveCacheMonoAdapter {
+
+        @Override
+        public Mono<Boolean> hasData(@NonNull String cacheKey) {
+            return Mono.just(true);
+        }
+
+        @Override
+        public <T> Mono<T> loadData(@NonNull String cacheKey) {
+            return Mono.empty();
+        }
+
+        @Override
+        public <T> Mono<T> cacheData(@NonNull String cacheKey,
+                                     @NonNull Duration cacheDuration,
+                                     @NonNull Mono<T> sourcePublisher) {
+            return sourcePublisher;
+        }
+
+        @Override
+        public Mono<Void> cleanupData(@NonNull String cacheKey) {
+            return Mono.defer(() -> Mono.just(true)
+                            .delayElement(Duration.ofSeconds(1)))
+                    .then();
+        }
+    }
 }