You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@james.apache.org by rc...@apache.org on 2023/04/17 06:49:30 UTC
[james-project] 03/04: MailboxAnnotationManager support more reactive api
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 <vt...@linagora.com>
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: notifications-unsubscribe@james.apache.org
For additional commands, e-mail: notifications-help@james.apache.org