You are viewing a plain text version of this content. The canonical link for it is here.
Posted to server-dev@james.apache.org by ma...@apache.org on 2019/01/28 14:53:20 UTC
[05/12] james-project git commit: JAMES-2630 Migrate
CassandraAsyncExecutor.executeReturnExists consumers to Reactor contd
http://git-wip-us.apache.org/repos/asf/james-project/blob/06ee1e43/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraIndexTableHandlerTest.java
----------------------------------------------------------------------
diff --git a/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraIndexTableHandlerTest.java b/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraIndexTableHandlerTest.java
index e504e61..fe13a9f 100644
--- a/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraIndexTableHandlerTest.java
+++ b/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraIndexTableHandlerTest.java
@@ -23,8 +23,6 @@ import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-import java.util.Optional;
-
import javax.mail.Flags;
import org.apache.james.backends.cassandra.CassandraCluster;
@@ -51,8 +49,6 @@ import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.RegisterExtension;
-import com.github.steveash.guavate.Guavate;
-
public class CassandraIndexTableHandlerTest {
public static final CassandraId MAILBOX_ID = CassandraId.timeBased();
@@ -103,11 +99,10 @@ public class CassandraIndexTableHandlerTest {
when(message.createFlags()).thenReturn(new Flags());
when(message.getUid()).thenReturn(MESSAGE_UID);
- testee.updateIndexOnAdd(message, MAILBOX_ID).join();
+ testee.updateIndexOnAdd(message, MAILBOX_ID).block();
- Optional<Long> actual = mailboxCounterDAO.countMessagesInMailbox(mailbox).join();
- assertThat(actual.isPresent()).isTrue();
- assertThat(actual.get()).isEqualTo(1);
+ Long actual = mailboxCounterDAO.countMessagesInMailbox(mailbox).block();
+ assertThat(actual).isEqualTo(1);
}
@Test
@@ -116,11 +111,10 @@ public class CassandraIndexTableHandlerTest {
when(message.createFlags()).thenReturn(new Flags());
when(message.getUid()).thenReturn(MESSAGE_UID);
- testee.updateIndexOnAdd(message, MAILBOX_ID).join();
+ testee.updateIndexOnAdd(message, MAILBOX_ID).block();
- Optional<Long> actual = mailboxCounterDAO.countUnseenMessagesInMailbox(mailbox).join();
- assertThat(actual.isPresent()).isTrue();
- assertThat(actual.get()).isEqualTo(1);
+ Long actual = mailboxCounterDAO.countUnseenMessagesInMailbox(mailbox).block();
+ assertThat(actual).isEqualTo(1);
}
@Test
@@ -129,11 +123,10 @@ public class CassandraIndexTableHandlerTest {
when(message.createFlags()).thenReturn(new Flags(Flags.Flag.SEEN));
when(message.getUid()).thenReturn(MESSAGE_UID);
- testee.updateIndexOnAdd(message, MAILBOX_ID).join();
+ testee.updateIndexOnAdd(message, MAILBOX_ID).block();
- Optional<Long> actual = mailboxCounterDAO.countUnseenMessagesInMailbox(mailbox).join();
- assertThat(actual.isPresent()).isTrue();
- assertThat(actual.get()).isEqualTo(0);
+ Long actual = mailboxCounterDAO.countUnseenMessagesInMailbox(mailbox).block();
+ assertThat(actual).isEqualTo(0);
}
@Test
@@ -142,10 +135,11 @@ public class CassandraIndexTableHandlerTest {
when(message.createFlags()).thenReturn(new Flags());
when(message.getUid()).thenReturn(MESSAGE_UID);
- testee.updateIndexOnAdd(message, MAILBOX_ID).join();
+ testee.updateIndexOnAdd(message, MAILBOX_ID).block();
- assertThat(mailboxRecentsDAO.getRecentMessageUidsInMailbox(MAILBOX_ID).join()
- .collect(Guavate.toImmutableList()))
+ assertThat(mailboxRecentsDAO.getRecentMessageUidsInMailbox(MAILBOX_ID)
+ .collectList()
+ .block())
.isEmpty();
}
@@ -155,10 +149,11 @@ public class CassandraIndexTableHandlerTest {
when(message.createFlags()).thenReturn(new Flags(Flags.Flag.RECENT));
when(message.getUid()).thenReturn(MESSAGE_UID);
- testee.updateIndexOnAdd(message, MAILBOX_ID).join();
+ testee.updateIndexOnAdd(message, MAILBOX_ID).block();
- assertThat(mailboxRecentsDAO.getRecentMessageUidsInMailbox(MAILBOX_ID).join()
- .collect(Guavate.toImmutableList()))
+ assertThat(mailboxRecentsDAO.getRecentMessageUidsInMailbox(MAILBOX_ID)
+ .collectList()
+ .block())
.containsOnly(MESSAGE_UID);
}
@@ -167,17 +162,16 @@ public class CassandraIndexTableHandlerTest {
MailboxMessage message = mock(MailboxMessage.class);
when(message.createFlags()).thenReturn(new Flags());
when(message.getUid()).thenReturn(MESSAGE_UID);
- testee.updateIndexOnAdd(message, MAILBOX_ID).join();
+ testee.updateIndexOnAdd(message, MAILBOX_ID).block();
testee.updateIndexOnDelete(new ComposedMessageIdWithMetaData(
new ComposedMessageId(MAILBOX_ID, CASSANDRA_MESSAGE_ID, MESSAGE_UID),
new Flags(Flags.Flag.RECENT),
MODSEQ),
- MAILBOX_ID).join();
+ MAILBOX_ID).block();
- Optional<Long> actual = mailboxCounterDAO.countMessagesInMailbox(mailbox).join();
- assertThat(actual.isPresent()).isTrue();
- assertThat(actual.get()).isEqualTo(0);
+ Long actual = mailboxCounterDAO.countMessagesInMailbox(mailbox).block();
+ assertThat(actual).isEqualTo(0);
}
@Test
@@ -185,17 +179,16 @@ public class CassandraIndexTableHandlerTest {
MailboxMessage message = mock(MailboxMessage.class);
when(message.createFlags()).thenReturn(new Flags());
when(message.getUid()).thenReturn(MESSAGE_UID);
- testee.updateIndexOnAdd(message, MAILBOX_ID).join();
+ testee.updateIndexOnAdd(message, MAILBOX_ID).block();
testee.updateIndexOnDelete(new ComposedMessageIdWithMetaData(
new ComposedMessageId(MAILBOX_ID, CASSANDRA_MESSAGE_ID, MESSAGE_UID),
new Flags(),
MODSEQ),
- MAILBOX_ID).join();
+ MAILBOX_ID).block();
- Optional<Long> actual = mailboxCounterDAO.countUnseenMessagesInMailbox(mailbox).join();
- assertThat(actual.isPresent()).isTrue();
- assertThat(actual.get()).isEqualTo(0);
+ Long actual = mailboxCounterDAO.countUnseenMessagesInMailbox(mailbox).block();
+ assertThat(actual).isEqualTo(0);
}
@Test
@@ -203,17 +196,16 @@ public class CassandraIndexTableHandlerTest {
MailboxMessage message = mock(MailboxMessage.class);
when(message.createFlags()).thenReturn(new Flags());
when(message.getUid()).thenReturn(MESSAGE_UID);
- testee.updateIndexOnAdd(message, MAILBOX_ID).join();
+ testee.updateIndexOnAdd(message, MAILBOX_ID).block();
testee.updateIndexOnDelete(new ComposedMessageIdWithMetaData(
new ComposedMessageId(MAILBOX_ID, CASSANDRA_MESSAGE_ID, MESSAGE_UID),
new Flags(Flags.Flag.SEEN),
MODSEQ),
- MAILBOX_ID).join();
+ MAILBOX_ID).block();
- Optional<Long> actual = mailboxCounterDAO.countUnseenMessagesInMailbox(mailbox).join();
- assertThat(actual.isPresent()).isTrue();
- assertThat(actual.get()).isEqualTo(1);
+ Long actual = mailboxCounterDAO.countUnseenMessagesInMailbox(mailbox).block();
+ assertThat(actual).isEqualTo(1);
}
@Test
@@ -221,16 +213,17 @@ public class CassandraIndexTableHandlerTest {
MailboxMessage message = mock(MailboxMessage.class);
when(message.createFlags()).thenReturn(new Flags(Flags.Flag.RECENT));
when(message.getUid()).thenReturn(MESSAGE_UID);
- testee.updateIndexOnAdd(message, MAILBOX_ID).join();
+ testee.updateIndexOnAdd(message, MAILBOX_ID).block();
testee.updateIndexOnDelete(new ComposedMessageIdWithMetaData(
new ComposedMessageId(MAILBOX_ID, CASSANDRA_MESSAGE_ID, MESSAGE_UID),
new Flags(Flags.Flag.RECENT),
MODSEQ),
- MAILBOX_ID).join();
+ MAILBOX_ID).block();
- assertThat(mailboxRecentsDAO.getRecentMessageUidsInMailbox(MAILBOX_ID).join()
- .collect(Guavate.toImmutableList()))
+ assertThat(mailboxRecentsDAO.getRecentMessageUidsInMailbox(MAILBOX_ID)
+ .collectList()
+ .block())
.isEmpty();
}
@@ -240,16 +233,17 @@ public class CassandraIndexTableHandlerTest {
MailboxMessage message = mock(MailboxMessage.class);
when(message.createFlags()).thenReturn(new Flags(Flags.Flag.RECENT));
when(message.getUid()).thenReturn(MESSAGE_UID);
- testee.updateIndexOnAdd(message, MAILBOX_ID).join();
+ testee.updateIndexOnAdd(message, MAILBOX_ID).block();
testee.updateIndexOnDelete(new ComposedMessageIdWithMetaData(
new ComposedMessageId(MAILBOX_ID, CASSANDRA_MESSAGE_ID, MESSAGE_UID),
new Flags(),
MODSEQ),
- MAILBOX_ID).join();
+ MAILBOX_ID).block();
- assertThat(mailboxRecentsDAO.getRecentMessageUidsInMailbox(MAILBOX_ID).join()
- .collect(Guavate.toImmutableList()))
+ assertThat(mailboxRecentsDAO.getRecentMessageUidsInMailbox(MAILBOX_ID)
+ .collectList()
+ .block())
.isEmpty();
}
@@ -257,19 +251,19 @@ public class CassandraIndexTableHandlerTest {
void updateIndexOnDeleteShouldDeleteMessageFromDeletedMessage() {
MailboxMessage message = mock(MailboxMessage.class);
when(message.getUid()).thenReturn(MESSAGE_UID);
- deletedMessageDAO.addDeleted(MAILBOX_ID, MESSAGE_UID).join();
+ deletedMessageDAO.addDeleted(MAILBOX_ID, MESSAGE_UID).block();
testee.updateIndexOnDelete(new ComposedMessageIdWithMetaData(
new ComposedMessageId(MAILBOX_ID, CASSANDRA_MESSAGE_ID, MESSAGE_UID),
new Flags(),
MODSEQ),
- MAILBOX_ID).join();
+ MAILBOX_ID).block();
assertThat(
deletedMessageDAO
.retrieveDeletedMessage(MAILBOX_ID, MessageRange.all())
- .join()
- .collect(Guavate.toImmutableList()))
+ .collectList()
+ .block())
.isEmpty();
}
@@ -278,18 +272,17 @@ public class CassandraIndexTableHandlerTest {
MailboxMessage message = mock(MailboxMessage.class);
when(message.createFlags()).thenReturn(new Flags());
when(message.getUid()).thenReturn(MESSAGE_UID);
- testee.updateIndexOnAdd(message, MAILBOX_ID).join();
+ testee.updateIndexOnAdd(message, MAILBOX_ID).block();
testee.updateIndexOnFlagsUpdate(MAILBOX_ID, UpdatedFlags.builder()
.uid(MESSAGE_UID)
.newFlags(new Flags(Flags.Flag.RECENT))
.oldFlags(new Flags())
.modSeq(MODSEQ)
- .build()).join();
+ .build()).block();
- Optional<Long> actual = mailboxCounterDAO.countMessagesInMailbox(mailbox).join();
- assertThat(actual.isPresent()).isTrue();
- assertThat(actual.get()).isEqualTo(1);
+ Long actual = mailboxCounterDAO.countMessagesInMailbox(mailbox).block();
+ assertThat(actual).isEqualTo(1);
}
@Test
@@ -297,18 +290,17 @@ public class CassandraIndexTableHandlerTest {
MailboxMessage message = mock(MailboxMessage.class);
when(message.createFlags()).thenReturn(new Flags());
when(message.getUid()).thenReturn(MESSAGE_UID);
- testee.updateIndexOnAdd(message, MAILBOX_ID).join();
+ testee.updateIndexOnAdd(message, MAILBOX_ID).block();
testee.updateIndexOnFlagsUpdate(MAILBOX_ID, UpdatedFlags.builder()
.uid(MESSAGE_UID)
.newFlags(new Flags(Flags.Flag.SEEN))
.oldFlags(new Flags())
.modSeq(MODSEQ)
- .build()).join();
+ .build()).block();
- Optional<Long> actual = mailboxCounterDAO.countUnseenMessagesInMailbox(mailbox).join();
- assertThat(actual.isPresent()).isTrue();
- assertThat(actual.get()).isEqualTo(0);
+ Long actual = mailboxCounterDAO.countUnseenMessagesInMailbox(mailbox).block();
+ assertThat(actual).isEqualTo(0);
}
@Test
@@ -316,20 +308,20 @@ public class CassandraIndexTableHandlerTest {
MailboxMessage message = mock(MailboxMessage.class);
when(message.createFlags()).thenReturn(new Flags());
when(message.getUid()).thenReturn(MESSAGE_UID);
- testee.updateIndexOnAdd(message, MAILBOX_ID).join();
+ testee.updateIndexOnAdd(message, MAILBOX_ID).block();
testee.updateIndexOnFlagsUpdate(MAILBOX_ID, UpdatedFlags.builder()
.uid(MESSAGE_UID)
.newFlags(new Flags(Flags.Flag.DELETED))
.oldFlags(new Flags())
.modSeq(MODSEQ)
- .build()).join();
+ .build()).block();
assertThat(
deletedMessageDAO
.retrieveDeletedMessage(MAILBOX_ID, MessageRange.all())
- .join()
- .collect(Guavate.toImmutableList()))
+ .collectList()
+ .block())
.containsExactly(MESSAGE_UID);
}
@@ -338,22 +330,22 @@ public class CassandraIndexTableHandlerTest {
MailboxMessage message = mock(MailboxMessage.class);
when(message.createFlags()).thenReturn(new Flags());
when(message.getUid()).thenReturn(MESSAGE_UID);
- testee.updateIndexOnAdd(message, MAILBOX_ID).join();
+ testee.updateIndexOnAdd(message, MAILBOX_ID).block();
- deletedMessageDAO.addDeleted(MAILBOX_ID, MESSAGE_UID).join();
+ deletedMessageDAO.addDeleted(MAILBOX_ID, MESSAGE_UID).block();
testee.updateIndexOnFlagsUpdate(MAILBOX_ID, UpdatedFlags.builder()
.uid(MESSAGE_UID)
.newFlags(new Flags())
.oldFlags(new Flags(Flags.Flag.DELETED))
.modSeq(MODSEQ)
- .build()).join();
+ .build()).block();
assertThat(
deletedMessageDAO
.retrieveDeletedMessage(MAILBOX_ID, MessageRange.all())
- .join()
- .collect(Guavate.toImmutableList()))
+ .collectList()
+ .block())
.isEmpty();
}
@@ -362,22 +354,22 @@ public class CassandraIndexTableHandlerTest {
MailboxMessage message = mock(MailboxMessage.class);
when(message.createFlags()).thenReturn(new Flags());
when(message.getUid()).thenReturn(MESSAGE_UID);
- testee.updateIndexOnAdd(message, MAILBOX_ID).join();
+ testee.updateIndexOnAdd(message, MAILBOX_ID).block();
- deletedMessageDAO.addDeleted(MAILBOX_ID, MESSAGE_UID).join();
+ deletedMessageDAO.addDeleted(MAILBOX_ID, MESSAGE_UID).block();
testee.updateIndexOnFlagsUpdate(MAILBOX_ID, UpdatedFlags.builder()
.uid(MESSAGE_UID)
.newFlags(new Flags())
.oldFlags(new Flags(Flags.Flag.SEEN))
.modSeq(MODSEQ)
- .build()).join();
+ .build()).block();
assertThat(
deletedMessageDAO
.retrieveDeletedMessage(MAILBOX_ID, MessageRange.all())
- .join()
- .collect(Guavate.toImmutableList()))
+ .collectList()
+ .block())
.containsExactly(MESSAGE_UID);
}
@@ -386,20 +378,20 @@ public class CassandraIndexTableHandlerTest {
MailboxMessage message = mock(MailboxMessage.class);
when(message.createFlags()).thenReturn(new Flags());
when(message.getUid()).thenReturn(MESSAGE_UID);
- testee.updateIndexOnAdd(message, MAILBOX_ID).join();
+ testee.updateIndexOnAdd(message, MAILBOX_ID).block();
testee.updateIndexOnFlagsUpdate(MAILBOX_ID, UpdatedFlags.builder()
.uid(MESSAGE_UID)
.newFlags(new Flags(Flags.Flag.RECENT))
.oldFlags(new Flags())
.modSeq(MODSEQ)
- .build()).join();
+ .build()).block();
assertThat(
deletedMessageDAO
.retrieveDeletedMessage(MAILBOX_ID, MessageRange.all())
- .join()
- .collect(Guavate.toImmutableList()))
+ .collectList()
+ .block())
.isEmpty();
}
@@ -408,18 +400,17 @@ public class CassandraIndexTableHandlerTest {
MailboxMessage message = mock(MailboxMessage.class);
when(message.createFlags()).thenReturn(new Flags(Flags.Flag.SEEN));
when(message.getUid()).thenReturn(MESSAGE_UID);
- testee.updateIndexOnAdd(message, MAILBOX_ID).join();
+ testee.updateIndexOnAdd(message, MAILBOX_ID).block();
testee.updateIndexOnFlagsUpdate(MAILBOX_ID, UpdatedFlags.builder()
.uid(MESSAGE_UID)
.newFlags(new Flags())
.oldFlags(new Flags(Flags.Flag.SEEN))
.modSeq(MODSEQ)
- .build()).join();
+ .build()).block();
- Optional<Long> actual = mailboxCounterDAO.countUnseenMessagesInMailbox(mailbox).join();
- assertThat(actual.isPresent()).isTrue();
- assertThat(actual.get()).isEqualTo(1);
+ Long actual = mailboxCounterDAO.countUnseenMessagesInMailbox(mailbox).block();
+ assertThat(actual).isEqualTo(1);
}
@Test
@@ -427,18 +418,17 @@ public class CassandraIndexTableHandlerTest {
MailboxMessage message = mock(MailboxMessage.class);
when(message.createFlags()).thenReturn(new Flags(Flags.Flag.SEEN));
when(message.getUid()).thenReturn(MESSAGE_UID);
- testee.updateIndexOnAdd(message, MAILBOX_ID).join();
+ testee.updateIndexOnAdd(message, MAILBOX_ID).block();
testee.updateIndexOnFlagsUpdate(MAILBOX_ID, UpdatedFlags.builder()
.uid(MESSAGE_UID)
.newFlags(new Flags(Flags.Flag.SEEN))
.oldFlags(new Flags(Flags.Flag.SEEN))
.modSeq(MODSEQ)
- .build()).join();
+ .build()).block();
- Optional<Long> actual = mailboxCounterDAO.countUnseenMessagesInMailbox(mailbox).join();
- assertThat(actual.isPresent()).isTrue();
- assertThat(actual.get()).isEqualTo(0);
+ Long actual = mailboxCounterDAO.countUnseenMessagesInMailbox(mailbox).block();
+ assertThat(actual).isEqualTo(0);
}
@Test
@@ -446,18 +436,17 @@ public class CassandraIndexTableHandlerTest {
MailboxMessage message = mock(MailboxMessage.class);
when(message.createFlags()).thenReturn(new Flags());
when(message.getUid()).thenReturn(MESSAGE_UID);
- testee.updateIndexOnAdd(message, MAILBOX_ID).join();
+ testee.updateIndexOnAdd(message, MAILBOX_ID).block();
testee.updateIndexOnFlagsUpdate(MAILBOX_ID, UpdatedFlags.builder()
.uid(MESSAGE_UID)
.newFlags(new Flags())
.oldFlags(new Flags())
.modSeq(MODSEQ)
- .build()).join();
+ .build()).block();
- Optional<Long> actual = mailboxCounterDAO.countUnseenMessagesInMailbox(mailbox).join();
- assertThat(actual.isPresent()).isTrue();
- assertThat(actual.get()).isEqualTo(1);
+ Long actual = mailboxCounterDAO.countUnseenMessagesInMailbox(mailbox).block();
+ assertThat(actual).isEqualTo(1);
}
@Test
@@ -466,17 +455,18 @@ public class CassandraIndexTableHandlerTest {
MailboxMessage message = mock(MailboxMessage.class);
when(message.createFlags()).thenReturn(new Flags());
when(message.getUid()).thenReturn(MESSAGE_UID);
- testee.updateIndexOnAdd(message, MAILBOX_ID).join();
+ testee.updateIndexOnAdd(message, MAILBOX_ID).block();
testee.updateIndexOnFlagsUpdate(MAILBOX_ID, UpdatedFlags.builder()
.uid(MESSAGE_UID)
.newFlags(new Flags(Flags.Flag.RECENT))
.oldFlags(new Flags())
.modSeq(MODSEQ)
- .build()).join();
+ .build()).block();
- assertThat(mailboxRecentsDAO.getRecentMessageUidsInMailbox(MAILBOX_ID).join()
- .collect(Guavate.toImmutableList()))
+ assertThat(mailboxRecentsDAO.getRecentMessageUidsInMailbox(MAILBOX_ID)
+ .collectList()
+ .block())
.containsOnly(MESSAGE_UID);
}
@@ -486,17 +476,18 @@ public class CassandraIndexTableHandlerTest {
MailboxMessage message = mock(MailboxMessage.class);
when(message.createFlags()).thenReturn(new Flags(Flags.Flag.RECENT));
when(message.getUid()).thenReturn(MESSAGE_UID);
- testee.updateIndexOnAdd(message, MAILBOX_ID).join();
+ testee.updateIndexOnAdd(message, MAILBOX_ID).block();
testee.updateIndexOnFlagsUpdate(MAILBOX_ID, UpdatedFlags.builder()
.uid(MESSAGE_UID)
.newFlags(new Flags())
.oldFlags(new Flags(Flags.Flag.RECENT))
.modSeq(MODSEQ)
- .build()).join();
+ .build()).block();
- assertThat(mailboxRecentsDAO.getRecentMessageUidsInMailbox(MAILBOX_ID).join()
- .collect(Guavate.toImmutableList()))
+ assertThat(mailboxRecentsDAO.getRecentMessageUidsInMailbox(MAILBOX_ID)
+ .collectList()
+ .block())
.isEmpty();
}
@@ -505,11 +496,10 @@ public class CassandraIndexTableHandlerTest {
MailboxMessage message = mock(MailboxMessage.class);
when(message.createFlags()).thenReturn(new Flags());
when(message.getUid()).thenReturn(MESSAGE_UID);
- testee.updateIndexOnAdd(message, MAILBOX_ID).join();
+ testee.updateIndexOnAdd(message, MAILBOX_ID).block();
- Optional<MessageUid> actual = firstUnseenDAO.retrieveFirstUnread(MAILBOX_ID).join();
- assertThat(actual.isPresent()).isTrue();
- assertThat(actual.get()).isEqualTo(MESSAGE_UID);
+ MessageUid actual = firstUnseenDAO.retrieveFirstUnread(MAILBOX_ID).block();
+ assertThat(actual).isEqualTo(MESSAGE_UID);
}
@Test
@@ -517,13 +507,13 @@ public class CassandraIndexTableHandlerTest {
MailboxMessage message = mock(MailboxMessage.class);
when(message.createFlags()).thenReturn(new Flags(Flags.Flag.DELETED));
when(message.getUid()).thenReturn(MESSAGE_UID);
- testee.updateIndexOnAdd(message, MAILBOX_ID).join();
+ testee.updateIndexOnAdd(message, MAILBOX_ID).block();
assertThat(
deletedMessageDAO
.retrieveDeletedMessage(MAILBOX_ID, MessageRange.all())
- .join()
- .collect(Guavate.toImmutableList()))
+ .collectList()
+ .block())
.containsExactly(MESSAGE_UID);
}
@@ -532,13 +522,13 @@ public class CassandraIndexTableHandlerTest {
MailboxMessage message = mock(MailboxMessage.class);
when(message.createFlags()).thenReturn(new Flags());
when(message.getUid()).thenReturn(MESSAGE_UID);
- testee.updateIndexOnAdd(message, MAILBOX_ID).join();
+ testee.updateIndexOnAdd(message, MAILBOX_ID).block();
assertThat(
deletedMessageDAO
.retrieveDeletedMessage(MAILBOX_ID, MessageRange.all())
- .join()
- .collect(Guavate.toImmutableList()))
+ .collectList()
+ .block())
.isEmpty();
}
@@ -547,10 +537,10 @@ public class CassandraIndexTableHandlerTest {
MailboxMessage message = mock(MailboxMessage.class);
when(message.createFlags()).thenReturn(new Flags(Flags.Flag.SEEN));
when(message.getUid()).thenReturn(MESSAGE_UID);
- testee.updateIndexOnAdd(message, MAILBOX_ID).join();
+ testee.updateIndexOnAdd(message, MAILBOX_ID).block();
- Optional<MessageUid> actual = firstUnseenDAO.retrieveFirstUnread(MAILBOX_ID).join();
- assertThat(actual.isPresent()).isFalse();
+ Boolean actual = firstUnseenDAO.retrieveFirstUnread(MAILBOX_ID).hasElement().block();
+ assertThat(actual).isFalse();
}
@Test
@@ -558,17 +548,17 @@ public class CassandraIndexTableHandlerTest {
MailboxMessage message = mock(MailboxMessage.class);
when(message.createFlags()).thenReturn(new Flags());
when(message.getUid()).thenReturn(MESSAGE_UID);
- testee.updateIndexOnAdd(message, MAILBOX_ID).join();
+ testee.updateIndexOnAdd(message, MAILBOX_ID).block();
testee.updateIndexOnFlagsUpdate(MAILBOX_ID, UpdatedFlags.builder()
.uid(MESSAGE_UID)
.newFlags(new Flags(Flags.Flag.SEEN))
.oldFlags(new Flags())
.modSeq(MODSEQ)
- .build()).join();
+ .build()).block();
- Optional<MessageUid> actual = firstUnseenDAO.retrieveFirstUnread(MAILBOX_ID).join();
- assertThat(actual.isPresent()).isFalse();
+ Boolean actual = firstUnseenDAO.retrieveFirstUnread(MAILBOX_ID).hasElement().block();
+ assertThat(actual).isFalse();
}
@Test
@@ -576,18 +566,17 @@ public class CassandraIndexTableHandlerTest {
MailboxMessage message = mock(MailboxMessage.class);
when(message.createFlags()).thenReturn(new Flags(Flags.Flag.SEEN));
when(message.getUid()).thenReturn(MESSAGE_UID);
- testee.updateIndexOnAdd(message, MAILBOX_ID).join();
+ testee.updateIndexOnAdd(message, MAILBOX_ID).block();
testee.updateIndexOnFlagsUpdate(MAILBOX_ID, UpdatedFlags.builder()
.uid(MESSAGE_UID)
.newFlags(new Flags())
.oldFlags(new Flags(Flags.Flag.SEEN))
.modSeq(MODSEQ)
- .build()).join();
+ .build()).block();
- Optional<MessageUid> actual = firstUnseenDAO.retrieveFirstUnread(MAILBOX_ID).join();
- assertThat(actual.isPresent()).isTrue();
- assertThat(actual.get()).isEqualTo(MESSAGE_UID);
+ MessageUid actual = firstUnseenDAO.retrieveFirstUnread(MAILBOX_ID).block();
+ assertThat(actual).isEqualTo(MESSAGE_UID);
}
@Test
@@ -595,18 +584,17 @@ public class CassandraIndexTableHandlerTest {
MailboxMessage message = mock(MailboxMessage.class);
when(message.createFlags()).thenReturn(new Flags());
when(message.getUid()).thenReturn(MESSAGE_UID);
- testee.updateIndexOnAdd(message, MAILBOX_ID).join();
+ testee.updateIndexOnAdd(message, MAILBOX_ID).block();
testee.updateIndexOnFlagsUpdate(MAILBOX_ID, UpdatedFlags.builder()
.uid(MESSAGE_UID)
.newFlags(new Flags())
.oldFlags(new Flags())
.modSeq(MODSEQ)
- .build()).join();
+ .build()).block();
- Optional<MessageUid> actual = firstUnseenDAO.retrieveFirstUnread(MAILBOX_ID).join();
- assertThat(actual.isPresent()).isTrue();
- assertThat(actual.get()).isEqualTo(MESSAGE_UID);
+ MessageUid actual = firstUnseenDAO.retrieveFirstUnread(MAILBOX_ID).block();
+ assertThat(actual).isEqualTo(MESSAGE_UID);
}
@Test
@@ -614,17 +602,17 @@ public class CassandraIndexTableHandlerTest {
MailboxMessage message = mock(MailboxMessage.class);
when(message.createFlags()).thenReturn(new Flags(Flags.Flag.SEEN));
when(message.getUid()).thenReturn(MESSAGE_UID);
- testee.updateIndexOnAdd(message, MAILBOX_ID).join();
+ testee.updateIndexOnAdd(message, MAILBOX_ID).block();
testee.updateIndexOnFlagsUpdate(MAILBOX_ID, UpdatedFlags.builder()
.uid(MESSAGE_UID)
.newFlags(new Flags(Flags.Flag.SEEN))
.oldFlags(new Flags(Flags.Flag.SEEN))
.modSeq(MODSEQ)
- .build()).join();
+ .build()).block();
- Optional<MessageUid> actual = firstUnseenDAO.retrieveFirstUnread(MAILBOX_ID).join();
- assertThat(actual.isPresent()).isFalse();
+ Boolean actual = firstUnseenDAO.retrieveFirstUnread(MAILBOX_ID).hasElement().block();
+ assertThat(actual).isFalse();
}
@Test
@@ -632,15 +620,15 @@ public class CassandraIndexTableHandlerTest {
MailboxMessage message = mock(MailboxMessage.class);
when(message.createFlags()).thenReturn(new Flags());
when(message.getUid()).thenReturn(MESSAGE_UID);
- testee.updateIndexOnAdd(message, MAILBOX_ID).join();
+ testee.updateIndexOnAdd(message, MAILBOX_ID).block();
testee.updateIndexOnDelete(new ComposedMessageIdWithMetaData(
new ComposedMessageId(MAILBOX_ID, CASSANDRA_MESSAGE_ID, MESSAGE_UID),
new Flags(),
- MODSEQ), MAILBOX_ID).join();
+ MODSEQ), MAILBOX_ID).block();
- Optional<MessageUid> actual = firstUnseenDAO.retrieveFirstUnread(MAILBOX_ID).join();
- assertThat(actual.isPresent()).isFalse();
+ Boolean actual = firstUnseenDAO.retrieveFirstUnread(MAILBOX_ID).hasElement().block();
+ assertThat(actual).isFalse();
}
@Test
@@ -649,9 +637,9 @@ public class CassandraIndexTableHandlerTest {
MailboxMessage message = mock(MailboxMessage.class);
when(message.createFlags()).thenReturn(customFlags);
when(message.getUid()).thenReturn(MESSAGE_UID);
- testee.updateIndexOnAdd(message, MAILBOX_ID).join();
+ testee.updateIndexOnAdd(message, MAILBOX_ID).block();
- Flags applicableFlag = applicableFlagDAO.retrieveApplicableFlag(MAILBOX_ID).join().get();
+ Flags applicableFlag = applicableFlagDAO.retrieveApplicableFlag(MAILBOX_ID).block();
assertThat(applicableFlag).isEqualTo(customFlags);
}
@@ -662,7 +650,7 @@ public class CassandraIndexTableHandlerTest {
MailboxMessage message = mock(MailboxMessage.class);
when(message.createFlags()).thenReturn(customFlag);
when(message.getUid()).thenReturn(MESSAGE_UID);
- testee.updateIndexOnAdd(message, MAILBOX_ID).join();
+ testee.updateIndexOnAdd(message, MAILBOX_ID).block();
Flags customBis = new Flags("customBis");
testee.updateIndexOnFlagsUpdate(MAILBOX_ID, UpdatedFlags.builder()
@@ -670,9 +658,9 @@ public class CassandraIndexTableHandlerTest {
.newFlags(customBis)
.oldFlags(customFlag)
.modSeq(MODSEQ)
- .build()).join();
+ .build()).block();
- Flags applicableFlag = applicableFlagDAO.retrieveApplicableFlag(MAILBOX_ID).join().get();
+ Flags applicableFlag = applicableFlagDAO.retrieveApplicableFlag(MAILBOX_ID).block();
assertThat(applicableFlag).isEqualTo(new FlagsBuilder().add(customFlag, customBis).build());
}
@@ -687,16 +675,16 @@ public class CassandraIndexTableHandlerTest {
when(message.createFlags()).thenReturn(messageFlags);
when(message.getUid()).thenReturn(MESSAGE_UID);
- testee.updateIndexOnAdd(message, MAILBOX_ID).join();
+ testee.updateIndexOnAdd(message, MAILBOX_ID).block();
testee.updateIndexOnFlagsUpdate(MAILBOX_ID, UpdatedFlags.builder()
.uid(MESSAGE_UID)
.newFlags(new Flags())
.oldFlags(messageFlags)
.modSeq(MODSEQ)
- .build()).join();
+ .build()).block();
- Flags applicableFlag = applicableFlagDAO.retrieveApplicableFlag(MAILBOX_ID).join().get();
+ Flags applicableFlag = applicableFlagDAO.retrieveApplicableFlag(MAILBOX_ID).block();
assertThat(applicableFlag).isEqualTo(messageFlags);
}
}
http://git-wip-us.apache.org/repos/asf/james-project/blob/06ee1e43/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraMailboxCounterDAOTest.java
----------------------------------------------------------------------
diff --git a/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraMailboxCounterDAOTest.java b/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraMailboxCounterDAOTest.java
index 6292f98..70c0789 100644
--- a/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraMailboxCounterDAOTest.java
+++ b/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraMailboxCounterDAOTest.java
@@ -51,39 +51,39 @@ class CassandraMailboxCounterDAOTest {
@Test
void countMessagesInMailboxShouldReturnEmptyByDefault() throws Exception {
- assertThat(testee.countMessagesInMailbox(mailbox).join()).isEmpty();
+ assertThat(testee.countMessagesInMailbox(mailbox).hasElement().block()).isFalse();
}
@Test
void countUnseenMessagesInMailboxShouldReturnEmptyByDefault() throws Exception {
- assertThat(testee.countUnseenMessagesInMailbox(mailbox).join()).isEmpty();
+ assertThat(testee.countUnseenMessagesInMailbox(mailbox).hasElement().block()).isFalse();
}
@Test
void retrieveMailboxCounterShouldReturnEmptyByDefault() throws Exception {
- assertThat(testee.retrieveMailboxCounters(mailbox).join()).isEmpty();
+ assertThat(testee.retrieveMailboxCounters(mailbox).hasElement().block()).isFalse();
}
@Test
void incrementCountShouldAddOneWhenAbsent() throws Exception {
- testee.incrementCount(MAILBOX_ID).join();
+ testee.incrementCount(MAILBOX_ID).block();
- assertThat(testee.countMessagesInMailbox(mailbox).join()).contains(1L);
+ assertThat(testee.countMessagesInMailbox(mailbox).block()).isEqualTo(1L);
}
@Test
void incrementUnseenShouldAddOneWhenAbsent() throws Exception {
- testee.incrementUnseen(MAILBOX_ID).join();
+ testee.incrementUnseen(MAILBOX_ID).block();
- assertThat(testee.countUnseenMessagesInMailbox(mailbox).join()).contains(1L);
+ assertThat(testee.countUnseenMessagesInMailbox(mailbox).block()).isEqualTo(1L);
}
@Test
void incrementUnseenShouldAddOneWhenAbsentOnMailboxCounters() throws Exception {
- testee.incrementUnseen(MAILBOX_ID).join();
+ testee.incrementUnseen(MAILBOX_ID).block();
- assertThat(testee.retrieveMailboxCounters(mailbox).join())
- .contains(MailboxCounters.builder()
+ assertThat(testee.retrieveMailboxCounters(mailbox).block())
+ .isEqualTo(MailboxCounters.builder()
.count(0L)
.unseen(1L)
.build());
@@ -91,10 +91,10 @@ class CassandraMailboxCounterDAOTest {
@Test
void incrementCountShouldAddOneWhenAbsentOnMailboxCounters() throws Exception {
- testee.incrementCount(MAILBOX_ID).join();
+ testee.incrementCount(MAILBOX_ID).block();
- assertThat(testee.retrieveMailboxCounters(mailbox).join())
- .contains(MailboxCounters.builder()
+ assertThat(testee.retrieveMailboxCounters(mailbox).block())
+ .isEqualTo(MailboxCounters.builder()
.count(1L)
.unseen(0L)
.build());
@@ -102,11 +102,11 @@ class CassandraMailboxCounterDAOTest {
@Test
void retrieveMailboxCounterShouldWorkWhenFullRow() throws Exception {
- testee.incrementCount(MAILBOX_ID).join();
- testee.incrementUnseen(MAILBOX_ID).join();
+ testee.incrementCount(MAILBOX_ID).block();
+ testee.incrementUnseen(MAILBOX_ID).block();
- assertThat(testee.retrieveMailboxCounters(mailbox).join())
- .contains(MailboxCounters.builder()
+ assertThat(testee.retrieveMailboxCounters(mailbox).block())
+ .isEqualTo(MailboxCounters.builder()
.count(1L)
.unseen(1L)
.build());
@@ -114,73 +114,73 @@ class CassandraMailboxCounterDAOTest {
@Test
void decrementCountShouldRemoveOne() throws Exception {
- testee.incrementCount(MAILBOX_ID).join();
+ testee.incrementCount(MAILBOX_ID).block();
- testee.decrementCount(MAILBOX_ID).join();
+ testee.decrementCount(MAILBOX_ID).block();
- assertThat(testee.countMessagesInMailbox(mailbox).join())
- .contains(0L);
+ assertThat(testee.countMessagesInMailbox(mailbox).block())
+ .isEqualTo(0L);
}
@Test
void decrementUnseenShouldRemoveOne() throws Exception {
- testee.incrementUnseen(MAILBOX_ID).join();
+ testee.incrementUnseen(MAILBOX_ID).block();
- testee.decrementUnseen(MAILBOX_ID).join();
+ testee.decrementUnseen(MAILBOX_ID).block();
- assertThat(testee.countUnseenMessagesInMailbox(mailbox).join())
- .contains(0L);
+ assertThat(testee.countUnseenMessagesInMailbox(mailbox).block())
+ .isEqualTo(0L);
}
@Test
void incrementUnseenShouldHaveNoImpactOnMessageCount() throws Exception {
- testee.incrementUnseen(MAILBOX_ID).join();
+ testee.incrementUnseen(MAILBOX_ID).block();
- assertThat(testee.countMessagesInMailbox(mailbox).join())
- .contains(0L);
+ assertThat(testee.countMessagesInMailbox(mailbox).block())
+ .isEqualTo(0L);
}
@Test
void incrementCountShouldHaveNoEffectOnUnseenCount() throws Exception {
- testee.incrementCount(MAILBOX_ID).join();
+ testee.incrementCount(MAILBOX_ID).block();
- assertThat(testee.countUnseenMessagesInMailbox(mailbox).join())
- .contains(0L);
+ assertThat(testee.countUnseenMessagesInMailbox(mailbox).block())
+ .isEqualTo(0L);
}
@Test
void decrementUnseenShouldHaveNoEffectOnMessageCount() throws Exception {
- testee.incrementCount(MAILBOX_ID).join();
+ testee.incrementCount(MAILBOX_ID).block();
- testee.decrementUnseen(MAILBOX_ID).join();
+ testee.decrementUnseen(MAILBOX_ID).block();
- assertThat(testee.countMessagesInMailbox(mailbox).join())
- .contains(1L);
+ assertThat(testee.countMessagesInMailbox(mailbox).block())
+ .isEqualTo(1L);
}
@Test
void decrementCountShouldHaveNoEffectOnUnseenCount() throws Exception {
- testee.incrementUnseen(MAILBOX_ID).join();
+ testee.incrementUnseen(MAILBOX_ID).block();
- testee.decrementCount(MAILBOX_ID).join();
+ testee.decrementCount(MAILBOX_ID).block();
- assertThat(testee.countUnseenMessagesInMailbox(mailbox).join())
- .contains(1L);
+ assertThat(testee.countUnseenMessagesInMailbox(mailbox).block())
+ .isEqualTo(1L);
}
@Test
void decrementCountCanLeadToNegativeValue() throws Exception {
- testee.decrementCount(MAILBOX_ID).join();
+ testee.decrementCount(MAILBOX_ID).block();
- assertThat(testee.countMessagesInMailbox(mailbox).join())
- .contains(-1L);
+ assertThat(testee.countMessagesInMailbox(mailbox).block())
+ .isEqualTo(-1L);
}
@Test
void decrementUnseenCanLeadToNegativeValue() throws Exception {
- testee.decrementUnseen(MAILBOX_ID).join();
+ testee.decrementUnseen(MAILBOX_ID).block();
- assertThat(testee.countUnseenMessagesInMailbox(mailbox).join())
- .contains(-1L);
+ assertThat(testee.countUnseenMessagesInMailbox(mailbox).block())
+ .isEqualTo(-1L);
}
}
http://git-wip-us.apache.org/repos/asf/james-project/blob/06ee1e43/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraMailboxRecentDAOTest.java
----------------------------------------------------------------------
diff --git a/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraMailboxRecentDAOTest.java b/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraMailboxRecentDAOTest.java
index f189677..8e05300 100644
--- a/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraMailboxRecentDAOTest.java
+++ b/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraMailboxRecentDAOTest.java
@@ -32,8 +32,6 @@ import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.RegisterExtension;
-import com.github.steveash.guavate.Guavate;
-
class CassandraMailboxRecentDAOTest {
private static final MessageUid UID1 = MessageUid.of(36L);
private static final MessageUid UID2 = MessageUid.of(37L);
@@ -51,64 +49,78 @@ class CassandraMailboxRecentDAOTest {
@Test
void getRecentMessageUidsInMailboxShouldBeEmptyByDefault() {
- assertThat(testee.getRecentMessageUidsInMailbox(CASSANDRA_ID).join()
- .collect(Guavate.toImmutableList())).isEmpty();
+ assertThat(testee.getRecentMessageUidsInMailbox(CASSANDRA_ID)
+ .collectList()
+ .block())
+ .isEmpty();
}
@Test
void addToRecentShouldAddUidWhenEmpty() {
- testee.addToRecent(CASSANDRA_ID, UID1).join();
+ testee.addToRecent(CASSANDRA_ID, UID1).block();
- assertThat(testee.getRecentMessageUidsInMailbox(CASSANDRA_ID).join()
- .collect(Guavate.toImmutableList())).containsOnly(UID1);
+ assertThat(testee.getRecentMessageUidsInMailbox(CASSANDRA_ID)
+ .collectList()
+ .block())
+ .containsOnly(UID1);
}
@Test
void removeFromRecentShouldRemoveUidWhenOnlyOneUid() {
- testee.addToRecent(CASSANDRA_ID, UID1).join();
+ testee.addToRecent(CASSANDRA_ID, UID1).block();
- testee.removeFromRecent(CASSANDRA_ID, UID1).join();
+ testee.removeFromRecent(CASSANDRA_ID, UID1).block();
- assertThat(testee.getRecentMessageUidsInMailbox(CASSANDRA_ID).join()
- .collect(Guavate.toImmutableList())).isEmpty();
+ assertThat(testee.getRecentMessageUidsInMailbox(CASSANDRA_ID)
+ .collectList()
+ .block())
+ .isEmpty();
}
@Test
void removeFromRecentShouldNotFailIfNotExisting() {
- testee.removeFromRecent(CASSANDRA_ID, UID1).join();
+ testee.removeFromRecent(CASSANDRA_ID, UID1).block();
- assertThat(testee.getRecentMessageUidsInMailbox(CASSANDRA_ID).join()
- .collect(Guavate.toImmutableList())).isEmpty();
+ assertThat(testee.getRecentMessageUidsInMailbox(CASSANDRA_ID)
+ .collectList()
+ .block())
+ .isEmpty();
}
@Test
void addToRecentShouldAddUidWhenNotEmpty() {
- testee.addToRecent(CASSANDRA_ID, UID1).join();
+ testee.addToRecent(CASSANDRA_ID, UID1).block();
- testee.addToRecent(CASSANDRA_ID, UID2).join();
+ testee.addToRecent(CASSANDRA_ID, UID2).block();
- assertThat(testee.getRecentMessageUidsInMailbox(CASSANDRA_ID).join()
- .collect(Guavate.toImmutableList())).containsOnly(UID1, UID2);
+ assertThat(testee.getRecentMessageUidsInMailbox(CASSANDRA_ID)
+ .collectList()
+ .block())
+ .containsOnly(UID1, UID2);
}
@Test
void removeFromRecentShouldOnlyRemoveUidWhenNotEmpty() {
- testee.addToRecent(CASSANDRA_ID, UID1).join();
- testee.addToRecent(CASSANDRA_ID, UID2).join();
+ testee.addToRecent(CASSANDRA_ID, UID1).block();
+ testee.addToRecent(CASSANDRA_ID, UID2).block();
- testee.removeFromRecent(CASSANDRA_ID, UID2).join();
+ testee.removeFromRecent(CASSANDRA_ID, UID2).block();
- assertThat(testee.getRecentMessageUidsInMailbox(CASSANDRA_ID).join()
- .collect(Guavate.toImmutableList())).containsOnly(UID1);
+ assertThat(testee.getRecentMessageUidsInMailbox(CASSANDRA_ID)
+ .collectList()
+ .block())
+ .containsOnly(UID1);
}
@Test
void addToRecentShouldBeIdempotent() {
- testee.addToRecent(CASSANDRA_ID, UID1).join();
- testee.addToRecent(CASSANDRA_ID, UID1).join();
+ testee.addToRecent(CASSANDRA_ID, UID1).block();
+ testee.addToRecent(CASSANDRA_ID, UID1).block();
- assertThat(testee.getRecentMessageUidsInMailbox(CASSANDRA_ID).join()
- .collect(Guavate.toImmutableList())).containsOnly(UID1);
+ assertThat(testee.getRecentMessageUidsInMailbox(CASSANDRA_ID)
+ .collectList()
+ .block())
+ .containsOnly(UID1);
}
@Test
@@ -117,9 +129,11 @@ class CassandraMailboxRecentDAOTest {
int size = pageSize + 1000;
IntStream.range(0, size)
.parallel()
- .forEach(i -> testee.addToRecent(CASSANDRA_ID, MessageUid.of(i + 1)).join());
+ .forEach(i -> testee.addToRecent(CASSANDRA_ID, MessageUid.of(i + 1)).block());
- assertThat(testee.getRecentMessageUidsInMailbox(CASSANDRA_ID).join()
- .collect(Guavate.toImmutableList())).hasSize(size);
+ assertThat(testee.getRecentMessageUidsInMailbox(CASSANDRA_ID)
+ .collectList()
+ .block())
+ .hasSize(size);
}
}
http://git-wip-us.apache.org/repos/asf/james-project/blob/06ee1e43/server/protocols/webadmin/webadmin-cassandra/src/main/java/org/apache/james/webadmin/routes/CassandraMailboxMergingRoutes.java
----------------------------------------------------------------------
diff --git a/server/protocols/webadmin/webadmin-cassandra/src/main/java/org/apache/james/webadmin/routes/CassandraMailboxMergingRoutes.java b/server/protocols/webadmin/webadmin-cassandra/src/main/java/org/apache/james/webadmin/routes/CassandraMailboxMergingRoutes.java
index e1f3cd3..b882013 100644
--- a/server/protocols/webadmin/webadmin-cassandra/src/main/java/org/apache/james/webadmin/routes/CassandraMailboxMergingRoutes.java
+++ b/server/protocols/webadmin/webadmin-cassandra/src/main/java/org/apache/james/webadmin/routes/CassandraMailboxMergingRoutes.java
@@ -115,7 +115,7 @@ public class CassandraMailboxMergingRoutes implements Routes {
CassandraId originId = mailboxIdFactory.fromString(mailboxMergingRequest.getMergeOrigin());
CassandraId destinationId = mailboxIdFactory.fromString(mailboxMergingRequest.getMergeDestination());
- long totalMessagesToMove = counterDAO.countMessagesInMailbox(originId).join().orElse(0L);
+ long totalMessagesToMove = counterDAO.countMessagesInMailbox(originId).defaultIfEmpty(0L).block();
MailboxMergingTask task = new MailboxMergingTask(mailboxMergingTaskRunner, totalMessagesToMove, originId, destinationId);
TaskId taskId = taskManager.submit(task);
return TaskIdDto.respond(response, taskId);
---------------------------------------------------------------------
To unsubscribe, e-mail: server-dev-unsubscribe@james.apache.org
For additional commands, e-mail: server-dev-help@james.apache.org