This is an automated email from the ASF dual-hosted git repository. rcordier pushed a commit to branch master in repository https://gitbox.apache.org/repos/asf/james-project.git
commit 4e217b2bdb8ccc5176e5407e43540055312f54d4 Author: Tung Tran <[email protected]> AuthorDate: Thu Apr 6 08:10:07 2023 +0700 MailboxAnnotationManager support more reactive api --- .../james/mailbox/MailboxAnnotationManager.java | 11 ++ .../apache/james/mailbox/MailboxManagerTest.java | 6 +- .../store/StoreMailboxAnnotationManager.java | 139 +++++++++++++-------- .../james/mailbox/store/StoreMailboxManager.java | 25 ++++ .../store/StoreMailboxManagerAnnotationTest.java | 38 +++--- 5 files changed, 148 insertions(+), 71 deletions(-) diff --git a/mailbox/api/src/main/java/org/apache/james/mailbox/MailboxAnnotationManager.java b/mailbox/api/src/main/java/org/apache/james/mailbox/MailboxAnnotationManager.java index 740f7ef872..ea47542b9e 100644 --- a/mailbox/api/src/main/java/org/apache/james/mailbox/MailboxAnnotationManager.java +++ b/mailbox/api/src/main/java/org/apache/james/mailbox/MailboxAnnotationManager.java @@ -27,6 +27,7 @@ import org.apache.james.mailbox.exception.MailboxException; import org.apache.james.mailbox.model.MailboxAnnotation; import org.apache.james.mailbox.model.MailboxAnnotationKey; import org.apache.james.mailbox.model.MailboxPath; +import org.reactivestreams.Publisher; /** * <p> @@ -49,6 +50,8 @@ public interface MailboxAnnotationManager { */ List<MailboxAnnotation> getAllAnnotations(MailboxPath mailboxPath, MailboxSession session) throws MailboxException; + Publisher<MailboxAnnotation> getAllAnnotationsReactive(MailboxPath mailboxPath, MailboxSession session); + /** * Return all mailbox's annotation filter by the list of the keys without order and * do not contain any two annotations with the same key @@ -61,6 +64,8 @@ public interface MailboxAnnotationManager { */ List<MailboxAnnotation> getAnnotationsByKeys(MailboxPath mailboxPath, MailboxSession session, Set<MailboxAnnotationKey> keys) throws MailboxException; + Publisher<MailboxAnnotation> getAnnotationsByKeysReactive(MailboxPath mailboxPath, MailboxSession session, Set<MailboxAnnotationKey> keys); + /** * Return all mailbox's annotation by the list of the keys and its children entries without order and * do not contain any two annotations with the same key @@ -73,6 +78,8 @@ public interface MailboxAnnotationManager { */ List<MailboxAnnotation> getAnnotationsByKeysWithOneDepth(MailboxPath mailboxPath, MailboxSession session, Set<MailboxAnnotationKey> keys) throws MailboxException; + Publisher<MailboxAnnotation> getAnnotationsByKeysWithOneDepthReactive(MailboxPath mailboxPath, MailboxSession session, Set<MailboxAnnotationKey> keys); + /** * Return all mailbox's annotation by the list of the keys and its below entries without order and * do not contain any two annotations with the same key @@ -85,6 +92,8 @@ public interface MailboxAnnotationManager { */ List<MailboxAnnotation> getAnnotationsByKeysWithAllDepth(MailboxPath mailboxPath, MailboxSession session, Set<MailboxAnnotationKey> keys) throws MailboxException; + Publisher<MailboxAnnotation> getAnnotationsByKeysWithAllDepthReactive(MailboxPath mailboxPath, MailboxSession session, Set<MailboxAnnotationKey> keys); + /** * Update the mailbox's annotations. This method can: * - Insert new annotation if it does not exist @@ -97,4 +106,6 @@ public interface MailboxAnnotationManager { * @throws MailboxException in case of selected mailbox does not exist */ void updateAnnotations(MailboxPath mailboxPath, MailboxSession session, List<MailboxAnnotation> mailboxAnnotations) throws MailboxException, AnnotationException; + + Publisher<Void> updateAnnotationsReactive(MailboxPath mailboxPath, MailboxSession session, List<MailboxAnnotation> mailboxAnnotations); } diff --git a/mailbox/api/src/test/java/org/apache/james/mailbox/MailboxManagerTest.java b/mailbox/api/src/test/java/org/apache/james/mailbox/MailboxManagerTest.java index 960a365b6c..a6532130c8 100644 --- a/mailbox/api/src/test/java/org/apache/james/mailbox/MailboxManagerTest.java +++ b/mailbox/api/src/test/java/org/apache/james/mailbox/MailboxManagerTest.java @@ -612,7 +612,7 @@ public abstract class MailboxManagerTest<T extends MailboxManager> { } @Test - void updateAnnotationsShouldThrowExceptionIfMailboxDoesNotExist() throws Exception { + void updateAnnotationsShouldThrowExceptionIfMailboxDoesNotExist() { assumeTrue(mailboxManager.hasCapability(MailboxCapabilities.Annotation)); session = mailboxManager.createSystemSession(USER_2); MailboxPath inbox = MailboxPath.inbox(session); @@ -677,7 +677,7 @@ public abstract class MailboxManagerTest<T extends MailboxManager> { } @Test - void getAnnotationsByKeysWithOneDepthShouldRetriveAnnotationsWithOneDepth() throws Exception { + void getAnnotationsByKeysWithOneDepthShouldRetrieveAnnotationsWithOneDepth() throws Exception { assumeTrue(mailboxManager.hasCapability(MailboxCapabilities.Annotation)); session = mailboxManager.createSystemSession(USER_2); MailboxPath inbox = MailboxPath.inbox(session); @@ -700,7 +700,7 @@ public abstract class MailboxManagerTest<T extends MailboxManager> { } @Test - void getAnnotationsByKeysWithAllDepthShouldRetriveAnnotationsWithAllDepth() throws Exception { + void getAnnotationsByKeysWithAllDepthShouldRetrieveAnnotationsWithAllDepth() throws Exception { assumeTrue(mailboxManager.hasCapability(MailboxCapabilities.Annotation)); session = mailboxManager.createSystemSession(USER_2); MailboxPath inbox = MailboxPath.inbox(session); diff --git a/mailbox/store/src/main/java/org/apache/james/mailbox/store/StoreMailboxAnnotationManager.java b/mailbox/store/src/main/java/org/apache/james/mailbox/store/StoreMailboxAnnotationManager.java index b189778798..3ecc60c971 100644 --- a/mailbox/store/src/main/java/org/apache/james/mailbox/store/StoreMailboxAnnotationManager.java +++ b/mailbox/store/src/main/java/org/apache/james/mailbox/store/StoreMailboxAnnotationManager.java @@ -21,6 +21,7 @@ package org.apache.james.mailbox.store; import java.util.List; import java.util.Set; +import java.util.function.Function; import javax.inject.Inject; @@ -30,7 +31,6 @@ import org.apache.james.mailbox.exception.AnnotationException; import org.apache.james.mailbox.exception.InsufficientRightsException; import org.apache.james.mailbox.exception.MailboxException; import org.apache.james.mailbox.exception.MailboxNotFoundException; -import org.apache.james.mailbox.model.Mailbox; import org.apache.james.mailbox.model.MailboxACL.Right; import org.apache.james.mailbox.model.MailboxAnnotation; import org.apache.james.mailbox.model.MailboxAnnotationKey; @@ -38,13 +38,14 @@ import org.apache.james.mailbox.model.MailboxConstants; import org.apache.james.mailbox.model.MailboxId; import org.apache.james.mailbox.model.MailboxPath; import org.apache.james.mailbox.store.mail.AnnotationMapper; -import org.apache.james.mailbox.store.mail.MailboxMapper; -import org.apache.james.mailbox.store.transaction.Mapper; +import org.apache.james.util.FunctionalUtils; + +import reactor.core.publisher.Flux; +import reactor.core.publisher.Mono; public class StoreMailboxAnnotationManager implements MailboxAnnotationManager { private final MailboxSessionMapperFactory mailboxSessionMapperFactory; - private final StoreRightManager rightManager; private final int limitOfAnnotations; private final int limitAnnotationSize; @@ -68,82 +69,114 @@ public class StoreMailboxAnnotationManager implements MailboxAnnotationManager { this.limitAnnotationSize = limitAnnotationSize; } - public MailboxId checkThenGetMailboxId(MailboxPath path, MailboxSession session) throws MailboxException { - MailboxMapper mailboxMapper = mailboxSessionMapperFactory.getMailboxMapper(session); - Mailbox mailbox = mailboxMapper.findMailboxByPath(path) - .blockOptional() - .orElseThrow(() -> new MailboxNotFoundException(path)); - if (!rightManager.hasRight(mailbox, Right.Read, session)) { - throw new InsufficientRightsException("Not enough rights on " + path); - } - return mailbox.getMailboxId(); + @Override + public List<MailboxAnnotation> getAllAnnotations(MailboxPath mailboxPath, MailboxSession session) throws MailboxException { + return MailboxReactorUtils.block(getAllAnnotationsReactive(mailboxPath, session).collectList()); } @Override - public List<MailboxAnnotation> getAllAnnotations(MailboxPath mailboxPath, MailboxSession session) throws MailboxException { + public Flux<MailboxAnnotation> getAllAnnotationsReactive(MailboxPath mailboxPath, MailboxSession session) { AnnotationMapper annotationMapper = mailboxSessionMapperFactory.getAnnotationMapper(session); - - MailboxId mailboxId = checkThenGetMailboxId(mailboxPath, session); - - return annotationMapper.execute( - () -> annotationMapper.getAllAnnotations(mailboxId)); + return checkThenGetMailboxId(mailboxPath, session) + .switchIfEmpty(Mono.error(new MailboxNotFoundException(mailboxPath))) + .flatMapMany(mailboxId -> annotationMapper.executeReactive(Flux.from(annotationMapper.getAllAnnotationsReactive(mailboxId)) + .collectList()) + .flatMapIterable(Function.identity())); } @Override public List<MailboxAnnotation> getAnnotationsByKeys(MailboxPath mailboxPath, MailboxSession session, final Set<MailboxAnnotationKey> keys) - throws MailboxException { + throws MailboxException { + return MailboxReactorUtils.block(getAnnotationsByKeysReactive(mailboxPath, session, keys).collectList()); + } + + @Override + public Flux<MailboxAnnotation> getAnnotationsByKeysReactive(MailboxPath mailboxPath, MailboxSession session, Set<MailboxAnnotationKey> keys) { AnnotationMapper annotationMapper = mailboxSessionMapperFactory.getAnnotationMapper(session); - MailboxId mailboxId = checkThenGetMailboxId(mailboxPath, session); - return annotationMapper.execute( - () -> annotationMapper.getAnnotationsByKeys(mailboxId, keys)); + return checkThenGetMailboxId(mailboxPath, session) + .switchIfEmpty(Mono.error(new MailboxNotFoundException(mailboxPath))) + .flatMapMany(mailboxId -> annotationMapper.executeReactive(Flux.from(annotationMapper.getAnnotationsByKeysReactive(mailboxId, keys)) + .collectList()) + .flatMapIterable(Function.identity())); } @Override public void updateAnnotations(MailboxPath mailboxPath, MailboxSession session, List<MailboxAnnotation> mailboxAnnotations) - throws MailboxException { + throws MailboxException { + MailboxReactorUtils.block(updateAnnotationsReactive(mailboxPath, session, mailboxAnnotations)); + } + + @Override + public Mono<Void> updateAnnotationsReactive(MailboxPath mailboxPath, MailboxSession session, List<MailboxAnnotation> mailboxAnnotations) { AnnotationMapper annotationMapper = mailboxSessionMapperFactory.getAnnotationMapper(session); - MailboxId mailboxId = checkThenGetMailboxId(mailboxPath, session); - - annotationMapper.execute(Mapper.toTransaction(() -> { - for (MailboxAnnotation annotation : mailboxAnnotations) { - if (annotation.isNil()) { - annotationMapper.deleteAnnotation(mailboxId, annotation.getKey()); - } else if (canInsertOrUpdate(mailboxId, annotation, annotationMapper)) { - annotationMapper.insertAnnotation(mailboxId, annotation); - } - } - })); + return annotationMapper.executeReactive(checkThenGetMailboxId(mailboxPath, session) + .switchIfEmpty(Mono.error(new MailboxNotFoundException(mailboxPath))) + .flatMapMany(mailboxId -> Flux.fromIterable(mailboxAnnotations) + .concatMap(annotation -> { + if (annotation.isNil()) { + return Mono.from(annotationMapper.deleteAnnotationReactive(mailboxId, annotation.getKey())); + } + return canInsertOrUpdate(mailboxId, annotation, annotationMapper) + .filter(FunctionalUtils.identityPredicate()) + .flatMap(can -> Mono.from(annotationMapper.insertAnnotationReactive(mailboxId, annotation))); + })) + .then()); + } + + private Mono<Boolean> canInsertOrUpdate(MailboxId mailboxId, MailboxAnnotation annotation, AnnotationMapper annotationMapper) { + return Mono.just(annotation.size() > limitAnnotationSize) + .filter(FunctionalUtils.identityPredicate()) + .flatMap(limited -> Mono.<Boolean>error(new AnnotationException("annotation too big."))) + .switchIfEmpty(annotationCountCanInsertOrUpdate(mailboxId, annotation, annotationMapper)); } - private boolean canInsertOrUpdate(MailboxId mailboxId, MailboxAnnotation annotation, AnnotationMapper annotationMapper) throws AnnotationException { - if (annotation.size() > limitAnnotationSize) { - throw new AnnotationException("annotation too big."); - } - if (!annotationMapper.exist(mailboxId, annotation) - && annotationMapper.countAnnotations(mailboxId) >= limitOfAnnotations) { - throw new AnnotationException("too many annotations."); - } - return true; + private Mono<Boolean> annotationCountCanInsertOrUpdate(MailboxId mailboxId, MailboxAnnotation annotation, AnnotationMapper annotationMapper) { + return Mono.from(annotationMapper.existReactive(mailboxId, annotation)) + .filter(FunctionalUtils.identityPredicate().negate()) + .flatMap(exist -> Mono.from(annotationMapper.countAnnotationsReactive(mailboxId)) + .filter(count -> count >= limitOfAnnotations) + .flatMap(limited -> Mono.<Boolean>error(new AnnotationException("too many annotations.")))) + .switchIfEmpty(Mono.just(true)); } @Override public List<MailboxAnnotation> getAnnotationsByKeysWithOneDepth(MailboxPath mailboxPath, MailboxSession session, - Set<MailboxAnnotationKey> keys) throws MailboxException { - AnnotationMapper annotationMapper = mailboxSessionMapperFactory.getAnnotationMapper(session); - final MailboxId mailboxId = checkThenGetMailboxId(mailboxPath, session); + Set<MailboxAnnotationKey> keys) throws MailboxException { + return MailboxReactorUtils.block(getAnnotationsByKeysWithOneDepthReactive(mailboxPath, session, keys).collectList()); + } - return annotationMapper.execute( - () -> annotationMapper.getAnnotationsByKeysWithOneDepth(mailboxId, keys)); + @Override + public Flux<MailboxAnnotation> getAnnotationsByKeysWithOneDepthReactive(MailboxPath mailboxPath, MailboxSession session, Set<MailboxAnnotationKey> keys) { + AnnotationMapper annotationMapper = mailboxSessionMapperFactory.getAnnotationMapper(session); + return checkThenGetMailboxId(mailboxPath, session) + .switchIfEmpty(Mono.error(new MailboxNotFoundException(mailboxPath))) + .flatMapMany(mailboxId -> annotationMapper.executeReactive(Flux.from(annotationMapper.getAnnotationsByKeysWithOneDepthReactive(mailboxId, keys)) + .collectList()) + .flatMapIterable(Function.identity())); } @Override public List<MailboxAnnotation> getAnnotationsByKeysWithAllDepth(MailboxPath mailboxPath, MailboxSession session, - Set<MailboxAnnotationKey> keys) throws MailboxException { + Set<MailboxAnnotationKey> keys) throws MailboxException { + return MailboxReactorUtils.block(getAnnotationsByKeysWithAllDepthReactive(mailboxPath, session, keys).collectList()); + } + + @Override + public Flux<MailboxAnnotation> getAnnotationsByKeysWithAllDepthReactive(MailboxPath mailboxPath, MailboxSession session, Set<MailboxAnnotationKey> keys) { AnnotationMapper annotationMapper = mailboxSessionMapperFactory.getAnnotationMapper(session); - MailboxId mailboxId = checkThenGetMailboxId(mailboxPath, session); + return checkThenGetMailboxId(mailboxPath, session) + .switchIfEmpty(Mono.error(new MailboxNotFoundException(mailboxPath))) + .flatMapMany(mailboxId -> annotationMapper.executeReactive(Flux.from(annotationMapper.getAnnotationsByKeysWithAllDepthReactive(mailboxId, keys)) + .collectList()) + .flatMapIterable(Function.identity())); + } - return annotationMapper.execute( - () -> annotationMapper.getAnnotationsByKeysWithAllDepth(mailboxId, keys)); + private Mono<MailboxId> checkThenGetMailboxId(MailboxPath mailboxPath, MailboxSession session) { + return mailboxSessionMapperFactory.getMailboxMapper(session).findMailboxByPath(mailboxPath) + .flatMap(mailbox -> Mono.from(rightManager.hasRightReactive(mailboxPath, Right.Read, session)) + .filter(FunctionalUtils.identityPredicate().negate()) + .flatMap(hasRight -> Mono.<MailboxId>error(new InsufficientRightsException("Not enough rights on " + mailboxPath))) + .switchIfEmpty(Mono.just(mailbox.getMailboxId()))); } } diff --git a/mailbox/store/src/main/java/org/apache/james/mailbox/store/StoreMailboxManager.java b/mailbox/store/src/main/java/org/apache/james/mailbox/store/StoreMailboxManager.java index 788c53b47e..d69ff57375 100644 --- a/mailbox/store/src/main/java/org/apache/james/mailbox/store/StoreMailboxManager.java +++ b/mailbox/store/src/main/java/org/apache/james/mailbox/store/StoreMailboxManager.java @@ -1022,18 +1022,33 @@ public class StoreMailboxManager implements MailboxManager { return annotationManager.getAllAnnotations(mailboxPath, session); } + @Override + public Publisher<MailboxAnnotation> getAllAnnotationsReactive(MailboxPath mailboxPath, MailboxSession session) { + return annotationManager.getAllAnnotationsReactive(mailboxPath, session); + } + @Override public List<MailboxAnnotation> getAnnotationsByKeys(MailboxPath mailboxPath, MailboxSession session, Set<MailboxAnnotationKey> keys) throws MailboxException { return annotationManager.getAnnotationsByKeys(mailboxPath, session, keys); } + @Override + public Publisher<MailboxAnnotation> getAnnotationsByKeysReactive(MailboxPath mailboxPath, MailboxSession session, Set<MailboxAnnotationKey> keys) { + return annotationManager.getAnnotationsByKeysReactive(mailboxPath, session, keys); + } + @Override public void updateAnnotations(MailboxPath mailboxPath, MailboxSession session, List<MailboxAnnotation> mailboxAnnotations) throws MailboxException { annotationManager.updateAnnotations(mailboxPath, session, mailboxAnnotations); } + @Override + public Publisher<Void> updateAnnotationsReactive(MailboxPath mailboxPath, MailboxSession session, List<MailboxAnnotation> mailboxAnnotations) { + return annotationManager.updateAnnotationsReactive(mailboxPath, session, mailboxAnnotations); + } + @Override public boolean hasCapability(MailboxCapabilities capability) { @@ -1046,12 +1061,22 @@ public class StoreMailboxManager implements MailboxManager { return annotationManager.getAnnotationsByKeysWithOneDepth(mailboxPath, session, keys); } + @Override + public Publisher<MailboxAnnotation> getAnnotationsByKeysWithOneDepthReactive(MailboxPath mailboxPath, MailboxSession session, Set<MailboxAnnotationKey> keys) { + return annotationManager.getAnnotationsByKeysWithOneDepthReactive(mailboxPath, session, keys); + } + @Override public List<MailboxAnnotation> getAnnotationsByKeysWithAllDepth(MailboxPath mailboxPath, MailboxSession session, Set<MailboxAnnotationKey> keys) throws MailboxException { return annotationManager.getAnnotationsByKeysWithAllDepth(mailboxPath, session, keys); } + @Override + public Publisher<MailboxAnnotation> getAnnotationsByKeysWithAllDepthReactive(MailboxPath mailboxPath, MailboxSession session, Set<MailboxAnnotationKey> keys) { + return annotationManager.getAnnotationsByKeysWithAllDepthReactive(mailboxPath, session, keys); + } + @Override public boolean hasChildren(MailboxPath mailboxPath, MailboxSession session) throws MailboxException { MailboxMapper mapper = mailboxSessionMapperFactory.getMailboxMapper(session); diff --git a/mailbox/store/src/test/java/org/apache/james/mailbox/store/StoreMailboxManagerAnnotationTest.java b/mailbox/store/src/test/java/org/apache/james/mailbox/store/StoreMailboxManagerAnnotationTest.java index 0424b4ce84..338f7a5299 100644 --- a/mailbox/store/src/test/java/org/apache/james/mailbox/store/StoreMailboxManagerAnnotationTest.java +++ b/mailbox/store/src/test/java/org/apache/james/mailbox/store/StoreMailboxManagerAnnotationTest.java @@ -28,7 +28,6 @@ import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; -import java.util.Collections; import java.util.List; import java.util.Set; @@ -53,6 +52,7 @@ import org.mockito.MockitoAnnotations; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableSet; +import reactor.core.publisher.Flux; import reactor.core.publisher.Mono; class StoreMailboxManagerAnnotationTest { @@ -93,8 +93,13 @@ class StoreMailboxManagerAnnotationTest { Mapper.Transaction<?> transaction = (Mapper.Transaction<?>) invocationOnMock.getArguments()[0]; return transaction.run(); }); + when(annotationMapper.executeReactive(any(Mono.class))) + .thenAnswer(invocationOnMock -> invocationOnMock.getArguments()[0]); + when(storeRightManager.hasRight(any(Mailbox.class), any(MailboxACL.Right.class), any(MailboxSession.class))) .thenReturn(true); + when(storeRightManager.hasRightReactive(any(MailboxPath.class), any(MailboxACL.Right.class), any(MailboxSession.class))) + .thenReturn(Mono.just(true)); annotationManager = spy(new StoreMailboxAnnotationManager(mailboxSessionMapperFactory, storeRightManager)); @@ -105,24 +110,27 @@ class StoreMailboxManagerAnnotationTest { when(mailboxMapper.findMailboxByPath(eq(mailboxPath))).thenReturn(Mono.error(new MailboxException())); assertThatThrownBy(() -> annotationManager.updateAnnotations(mailboxPath, session, ImmutableList.of(PRIVATE_ANNOTATION))) - .hasCauseInstanceOf(MailboxException.class); + .isInstanceOf(MailboxException.class); } @Test - void updateAnnotationsShouldCallAnnotationMapperToInsertAnnotation() throws Exception { - when(mailboxMapper.findMailboxByPath(eq(mailboxPath))).thenReturn(Mono.just(mailbox)); + void updateAnnotationsShouldCallAnnotationMapperToInsertAnnotation() throws MailboxException { + when(annotationMapper.existReactive(eq(mailbox.getMailboxId()), any())).thenReturn(Mono.just(true)); + when(annotationMapper.insertAnnotationReactive(eq(mailbox.getMailboxId()), any())).thenReturn(Mono.empty()); annotationManager.updateAnnotations(mailboxPath, session, ANNOTATIONS); - verify(annotationMapper, times(2)).insertAnnotation(eq(mailboxId), any(MailboxAnnotation.class)); + verify(annotationMapper, times(2)).insertAnnotationReactive(eq(mailboxId), any(MailboxAnnotation.class)); } @Test - void updateAnnotationsShouldCallAnnotationMapperToDeleteAnnotation() throws Exception { - when(mailboxMapper.findMailboxByPath(eq(mailboxPath))).thenReturn(Mono.just(mailbox)); + void updateAnnotationsShouldCallAnnotationMapperToDeleteAnnotation() throws MailboxException { + when(annotationMapper.existReactive(eq(mailbox.getMailboxId()), any())).thenReturn(Mono.just(true)); + when(annotationMapper.insertAnnotationReactive(eq(mailbox.getMailboxId()), any())).thenReturn(Mono.empty()); + when(annotationMapper.deleteAnnotationReactive(eq(mailbox.getMailboxId()), any())).thenReturn(Mono.empty()); annotationManager.updateAnnotations(mailboxPath, session, ANNOTATIONS_WITH_NIL_ENTRY); - verify(annotationMapper, times(1)).insertAnnotation(eq(mailboxId), eq(PRIVATE_ANNOTATION)); - verify(annotationMapper, times(1)).deleteAnnotation(eq(mailboxId), eq(SHARED_KEY)); + verify(annotationMapper, times(1)).insertAnnotationReactive(eq(mailboxId), eq(PRIVATE_ANNOTATION)); + verify(annotationMapper, times(1)).deleteAnnotationReactive(eq(mailboxId), eq(SHARED_KEY)); } @Test @@ -130,13 +138,13 @@ class StoreMailboxManagerAnnotationTest { when(mailboxMapper.findMailboxByPath(eq(mailboxPath))).thenReturn(Mono.error(new MailboxException())); assertThatThrownBy(() -> annotationManager.getAllAnnotations(mailboxPath, session)) - .hasCauseInstanceOf(MailboxException.class); + .isInstanceOf(MailboxException.class); } @Test void getAllAnnotationsShouldReturnEmptyForNonStoredAnnotation() throws Exception { when(mailboxMapper.findMailboxByPath(eq(mailboxPath))).thenReturn(Mono.just(mailbox)); - when(annotationMapper.getAllAnnotations(eq(mailboxId))).thenReturn(Collections.<MailboxAnnotation>emptyList()); + when(annotationMapper.getAllAnnotationsReactive(eq(mailboxId))).thenReturn(Flux.fromIterable(List.of())); assertThat(annotationManager.getAllAnnotations(mailboxPath, session)).isEmpty(); } @@ -144,7 +152,7 @@ class StoreMailboxManagerAnnotationTest { @Test void getAllAnnotationsShouldReturnStoredAnnotation() throws Exception { when(mailboxMapper.findMailboxByPath(eq(mailboxPath))).thenReturn(Mono.just(mailbox)); - when(annotationMapper.getAllAnnotations(eq(mailboxId))).thenReturn(ANNOTATIONS); + when(annotationMapper.getAllAnnotationsReactive(eq(mailboxId))).thenReturn(Flux.fromIterable(ANNOTATIONS)); assertThat(annotationManager.getAllAnnotations(mailboxPath, session)).isEqualTo(ANNOTATIONS); } @@ -154,13 +162,13 @@ class StoreMailboxManagerAnnotationTest { when(mailboxMapper.findMailboxByPath(eq(mailboxPath))).thenReturn(Mono.error(new MailboxException())); assertThatThrownBy(() -> annotationManager.getAnnotationsByKeys(mailboxPath, session, KEYS)) - .hasCauseInstanceOf(MailboxException.class); + .isInstanceOf(MailboxException.class); } @Test - void getAnnotationsByKeysShouldRetrieveStoreAnnotationsByKey() throws Exception { + void getAnnotationsByKeysShouldRetrieveStoreAnnotationsByKey() throws MailboxException { when(mailboxMapper.findMailboxByPath(eq(mailboxPath))).thenReturn(Mono.just(mailbox)); - when(annotationMapper.getAnnotationsByKeys(eq(mailboxId), eq(KEYS))).thenReturn(ANNOTATIONS); + when(annotationMapper.getAnnotationsByKeysReactive(eq(mailboxId), eq(KEYS))).thenReturn(Flux.fromIterable(ANNOTATIONS)); assertThat(annotationManager.getAnnotationsByKeys(mailboxPath, session, KEYS)).isEqualTo(ANNOTATIONS); } --------------------------------------------------------------------- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
