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: [email protected] For additional commands, e-mail: [email protected]
