Repository: james-project Updated Branches: refs/heads/master d8e844e3c -> 55b58b859
http://git-wip-us.apache.org/repos/asf/james-project/blob/e9a73fd1/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MessageIdMapperTest.java ---------------------------------------------------------------------- diff --git a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MessageIdMapperTest.java b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MessageIdMapperTest.java index e9089e7..5c2f47b 100644 --- a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MessageIdMapperTest.java +++ b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MessageIdMapperTest.java @@ -49,16 +49,14 @@ import org.apache.james.util.concurrency.ConcurrentTestRunner; import org.assertj.core.data.MapEntry; import org.junit.After; import org.junit.Assume; +import org.junit.Before; import org.junit.Rule; +import org.junit.Test; import org.junit.rules.ExpectedException; -import org.xenei.junit.contract.Contract; -import org.xenei.junit.contract.ContractTest; -import org.xenei.junit.contract.IProducer; import com.google.common.collect.ImmutableList; -@Contract(MapperProvider.class) -public class MessageIdMapperTest<T extends MapperProvider> { +public abstract class MessageIdMapperTest { @Rule public ExpectedException expectedException = ExpectedException.none(); @@ -67,7 +65,6 @@ public class MessageIdMapperTest<T extends MapperProvider> { private static final int BODY_START = 16; private final static long UID_VALIDITY = 42; - private IProducer<T> producer; private MessageMapper messageMapper; private MailboxMapper mailboxMapper; private MessageIdMapper sut; @@ -82,12 +79,13 @@ public class MessageIdMapperTest<T extends MapperProvider> { @Rule public ExpectedException expected = ExpectedException.none(); - private T mapperProvider; + private MapperProvider mapperProvider; - @Contract.Inject - public final void setProducer(IProducer<T> producer) throws MailboxException { - this.producer = producer; - this.mapperProvider = producer.newInstance(); + protected abstract MapperProvider provideMapper(); + + @Before + public final void setUp() throws MailboxException { + this.mapperProvider = provideMapper(); Assume.assumeTrue(mapperProvider.getSupportedCapabilities().contains(MapperProvider.Capabilities.UNIQUE_MESSAGE_ID)); this.mapperProvider.ensureMapperPrepared(); @@ -106,48 +104,48 @@ public class MessageIdMapperTest<T extends MapperProvider> { @After public void tearDown() throws MailboxException { - producer.cleanUp(); + mapperProvider.clearMapper(); } - @ContractTest + @Test public void findShouldReturnEmptyWhenIdListIsEmpty() throws MailboxException { assertThat(sut.find(ImmutableList.<MessageId> of(), FetchType.Full)).isEmpty(); } - @ContractTest + @Test public void findShouldReturnOneMessageWhenIdListContainsOne() throws MailboxException { saveMessages(); List<MailboxMessage> messages = sut.find(ImmutableList.of(message1.getMessageId()), FetchType.Full); assertThat(messages).containsOnly(message1); } - @ContractTest + @Test public void findShouldReturnMultipleMessagesWhenIdContainsMultiple() throws MailboxException { saveMessages(); List<MailboxMessage> messages = sut.find(ImmutableList.of(message1.getMessageId(), message2.getMessageId(), message3.getMessageId()), FetchType.Full); assertThat(messages).containsOnly(message1, message2, message3); } - @ContractTest + @Test public void findShouldReturnMultipleMessagesWhenIdContainsMultipleInDifferentMailboxes() throws MailboxException { saveMessages(); List<MailboxMessage> messages = sut.find(ImmutableList.of(message1.getMessageId(), message4.getMessageId(), message3.getMessageId()), FetchType.Full); assertThat(messages).containsOnly(message1, message4, message3); } - @ContractTest + @Test public void findMailboxesShouldReturnEmptyWhenMessageDoesntExist() throws MailboxException { assertThat(sut.findMailboxes(mapperProvider.generateMessageId())).isEmpty(); } - @ContractTest + @Test public void findMailboxesShouldReturnOneMailboxWhenMessageExistsInOneMailbox() throws MailboxException { saveMessages(); List<MailboxId> mailboxes = sut.findMailboxes(message1.getMessageId()); assertThat(mailboxes).containsOnly(benwaInboxMailbox.getMailboxId()); } - @ContractTest + @Test public void findMailboxesShouldReturnTwoMailboxesWhenMessageExistsInTwoMailboxes() throws MailboxException { saveMessages(); @@ -160,7 +158,7 @@ public class MessageIdMapperTest<T extends MapperProvider> { assertThat(mailboxes).containsOnly(benwaInboxMailbox.getMailboxId(), benwaWorkMailbox.getMailboxId()); } - @ContractTest + @Test public void saveShouldSaveAMessage() throws Exception { message1.setUid(mapperProvider.generateMessageUid()); message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox)); @@ -169,7 +167,7 @@ public class MessageIdMapperTest<T extends MapperProvider> { assertThat(messages).containsOnly(message1); } - @ContractTest + @Test public void saveShouldThrowWhenMailboxDoesntExist() throws Exception { SimpleMailbox notPersistedMailbox = new SimpleMailbox(new MailboxPath("#private", "benwa", "mybox"), UID_VALIDITY); notPersistedMailbox.setMailboxId(mapperProvider.generateId()); @@ -181,7 +179,7 @@ public class MessageIdMapperTest<T extends MapperProvider> { sut.save(message); } - @ContractTest + @Test public void saveShouldSaveMessageInAnotherMailboxWhenMessageAlreadyInOneMailbox() throws Exception { message1.setUid(mapperProvider.generateMessageUid()); message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox)); @@ -196,7 +194,7 @@ public class MessageIdMapperTest<T extends MapperProvider> { assertThat(mailboxes).containsOnly(benwaInboxMailbox.getMailboxId(), benwaWorkMailbox.getMailboxId()); } - @ContractTest + @Test public void saveShouldWorkWhenSavingTwoTimesWithSameMessageIdAndSameMailboxId() throws Exception { message1.setUid(mapperProvider.generateMessageUid()); message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox)); @@ -210,12 +208,12 @@ public class MessageIdMapperTest<T extends MapperProvider> { assertThat(mailboxes).containsOnly(benwaInboxMailbox.getMailboxId(), benwaInboxMailbox.getMailboxId()); } - @ContractTest + @Test public void deleteShouldNotThrowWhenUnknownMessage() { sut.delete(message1.getMessageId()); } - @ContractTest + @Test public void deleteShouldDeleteAMessage() throws Exception { message1.setUid(mapperProvider.generateMessageUid()); message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox)); @@ -228,7 +226,7 @@ public class MessageIdMapperTest<T extends MapperProvider> { assertThat(messages).isEmpty(); } - @ContractTest + @Test public void deleteShouldDeleteMessageIndicesWhenStoredInTwoMailboxes() throws Exception { message1.setUid(mapperProvider.generateMessageUid()); message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox)); @@ -246,7 +244,7 @@ public class MessageIdMapperTest<T extends MapperProvider> { assertThat(mailboxes).isEmpty(); } - @ContractTest + @Test public void deleteShouldDeleteMessageIndicesWhenStoredTwoTimesInTheSameMailbox() throws Exception { message1.setUid(mapperProvider.generateMessageUid()); message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox)); @@ -263,7 +261,7 @@ public class MessageIdMapperTest<T extends MapperProvider> { assertThat(mailboxes).isEmpty(); } - @ContractTest + @Test public void deleteWithMailboxIdsShouldNotDeleteIndicesWhenMailboxIdsIsEmpty() throws Exception { message1.setUid(mapperProvider.generateMessageUid()); message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox)); @@ -281,7 +279,7 @@ public class MessageIdMapperTest<T extends MapperProvider> { assertThat(mailboxes).containsOnly(benwaInboxMailbox.getMailboxId(), benwaWorkMailbox.getMailboxId()); } - @ContractTest + @Test public void deleteWithMailboxIdsShouldDeleteOneIndexWhenMailboxIdsContainsOneElement() throws Exception { message1.setUid(mapperProvider.generateMessageUid()); message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox)); @@ -299,7 +297,7 @@ public class MessageIdMapperTest<T extends MapperProvider> { assertThat(mailboxes).containsOnly(benwaWorkMailbox.getMailboxId()); } - @ContractTest + @Test public void deleteWithMailboxIdsShouldDeleteIndicesWhenMailboxIdsContainsMultipleElements() throws Exception { message1.setUid(mapperProvider.generateMessageUid()); message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox)); @@ -317,7 +315,7 @@ public class MessageIdMapperTest<T extends MapperProvider> { assertThat(mailboxes).isEmpty(); } - @ContractTest + @Test public void setFlagsShouldReturnUpdatedFlagsWhenMessageIsInOneMailbox() throws Exception { message1.setUid(mapperProvider.generateMessageUid()); message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox)); @@ -337,7 +335,7 @@ public class MessageIdMapperTest<T extends MapperProvider> { assertThat(flags).containsOnly(MapEntry.entry(benwaInboxMailbox.getMailboxId(), expectedUpdatedFlags)); } - @ContractTest + @Test public void setFlagsShouldReturnUpdatedFlagsWhenReplaceMode() throws Exception { Flags messageFlags = new FlagsBuilder().add(Flags.Flag.RECENT, Flags.Flag.FLAGGED) .build(); @@ -365,7 +363,7 @@ public class MessageIdMapperTest<T extends MapperProvider> { assertThat(flags).contains(MapEntry.entry(benwaInboxMailbox.getMailboxId(), expectedUpdatedFlags)); } - @ContractTest + @Test public void setFlagsShouldReturnUpdatedFlagsWhenRemoveMode() throws Exception { Flags messageFlags = new FlagsBuilder().add(Flags.Flag.RECENT, Flags.Flag.FLAGGED) .build(); @@ -393,7 +391,7 @@ public class MessageIdMapperTest<T extends MapperProvider> { assertThat(flags).contains(MapEntry.entry(benwaInboxMailbox.getMailboxId(), expectedUpdatedFlags)); } - @ContractTest + @Test public void setFlagsShouldUpdateMessageFlagsWhenRemoveMode() throws Exception { Flags messageFlags = new FlagsBuilder().add(Flags.Flag.RECENT, Flags.Flag.FLAGGED) .build(); @@ -416,7 +414,7 @@ public class MessageIdMapperTest<T extends MapperProvider> { assertThat(messages.get(0).isFlagged()).isFalse(); } - @ContractTest + @Test public void setFlagsShouldReturnEmptyWhenMailboxIdsIsEmpty() throws Exception { message1.setUid(mapperProvider.generateMessageUid()); message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox)); @@ -429,7 +427,7 @@ public class MessageIdMapperTest<T extends MapperProvider> { assertThat(flags).isEmpty(); } - @ContractTest + @Test public void setFlagsShouldReturnEmptyWhenMessageIdDoesntExist() throws Exception { MessageId unknownMessageId = mapperProvider.generateMessageId(); Map<MailboxId, UpdatedFlags> flags = sut.setFlags(unknownMessageId, ImmutableList.of(message1.getMailboxId()), new Flags(Flag.RECENT), FlagsUpdateMode.REMOVE); @@ -437,7 +435,7 @@ public class MessageIdMapperTest<T extends MapperProvider> { assertThat(flags).isEmpty(); } - @ContractTest + @Test public void setFlagsShouldAddFlagsWhenAddUpdateMode() throws Exception { Flags initialFlags = new Flags(Flag.RECENT); message1.setUid(mapperProvider.generateMessageUid()); @@ -463,7 +461,7 @@ public class MessageIdMapperTest<T extends MapperProvider> { assertThat(flags).containsOnly(MapEntry.entry(benwaInboxMailbox.getMailboxId(), expectedUpdatedFlags)); } - @ContractTest + @Test public void setFlagsShouldReturnUpdatedFlagsWhenMessageIsInTwoMailboxes() throws Exception { message1.setUid(mapperProvider.generateMessageUid()); message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox)); @@ -496,7 +494,7 @@ public class MessageIdMapperTest<T extends MapperProvider> { MapEntry.entry(message1InOtherMailbox.getMailboxId(), expectedUpdatedFlags2)); } - @ContractTest + @Test public void setFlagsShouldUpdateFlagsWhenMessageIsInOneMailbox() throws Exception { message1.setUid(mapperProvider.generateMessageUid()); message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox)); @@ -510,7 +508,7 @@ public class MessageIdMapperTest<T extends MapperProvider> { assertThat(messages.get(0).isAnswered()).isTrue(); } - @ContractTest + @Test public void setFlagsShouldNotModifyModSeqWhenMailboxIdsIsEmpty() throws Exception { message1.setUid(mapperProvider.generateMessageUid()); long modSeq = mapperProvider.generateModSeq(benwaInboxMailbox); @@ -526,7 +524,7 @@ public class MessageIdMapperTest<T extends MapperProvider> { assertThat(messages.get(0).getModSeq()).isEqualTo(modSeq); } - @ContractTest + @Test public void setFlagsShouldUpdateModSeqWhenMessageIsInOneMailbox() throws Exception { message1.setUid(mapperProvider.generateMessageUid()); long modSeq = mapperProvider.generateModSeq(benwaInboxMailbox); @@ -541,7 +539,7 @@ public class MessageIdMapperTest<T extends MapperProvider> { assertThat(messages.get(0).getModSeq()).isGreaterThan(modSeq); } - @ContractTest + @Test public void setFlagsShouldNotModifyFlagsWhenMailboxIdsIsEmpty() throws Exception { message1.setUid(mapperProvider.generateMessageUid()); long modSeq = mapperProvider.generateModSeq(benwaInboxMailbox); @@ -559,7 +557,7 @@ public class MessageIdMapperTest<T extends MapperProvider> { assertThat(messages.get(0).createFlags()).isEqualTo(initialFlags); } - @ContractTest + @Test public void setFlagsShouldUpdateFlagsWhenMessageIsInTwoMailboxes() throws Exception { message1.setUid(mapperProvider.generateMessageUid()); message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox)); @@ -579,7 +577,7 @@ public class MessageIdMapperTest<T extends MapperProvider> { assertThat(messages.get(1).isAnswered()).isTrue(); } - @ContractTest + @Test public void setFlagsShouldWorkWhenCalledOnFirstMessage() throws Exception { message1.setUid(mapperProvider.generateMessageUid()); message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox)); @@ -602,7 +600,7 @@ public class MessageIdMapperTest<T extends MapperProvider> { assertThat(messages.get(0).isAnswered()).isTrue(); } - @ContractTest + @Test public void setFlagsShouldWorkWhenCalledOnDuplicatedMailbox() throws Exception { message1.setUid(mapperProvider.generateMessageUid()); message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox)); @@ -625,7 +623,7 @@ public class MessageIdMapperTest<T extends MapperProvider> { assertThat(messages.get(0).isAnswered()).isTrue(); } - @ContractTest + @Test public void setFlagsShouldWorkWithConcurrencyWithAdd() throws Exception { message1.setUid(mapperProvider.generateMessageUid()); message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox)); @@ -650,7 +648,7 @@ public class MessageIdMapperTest<T extends MapperProvider> { assertThat(messages.get(0).createFlags().getUserFlags()).hasSize(threadCount * updateCount); } - @ContractTest + @Test public void setFlagsShouldWorkWithConcurrencyWithRemove() throws Exception { message1.setUid(mapperProvider.generateMessageUid()); message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox)); @@ -682,7 +680,7 @@ public class MessageIdMapperTest<T extends MapperProvider> { assertThat(messages.get(0).createFlags().getUserFlags()).isEmpty(); } - @ContractTest + @Test public void countMessageShouldReturnWhenCreateNewMessage() throws Exception { message1.setUid(mapperProvider.generateMessageUid()); message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox)); @@ -691,7 +689,7 @@ public class MessageIdMapperTest<T extends MapperProvider> { assertThat(messageMapper.countMessagesInMailbox(benwaInboxMailbox)).isEqualTo(1); } - @ContractTest + @Test public void countUnseenMessageShouldBeEmptyWhenMessageIsSeen() throws Exception { message1.setUid(mapperProvider.generateMessageUid()); message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox)); @@ -701,7 +699,7 @@ public class MessageIdMapperTest<T extends MapperProvider> { assertThat(messageMapper.countUnseenMessagesInMailbox(benwaInboxMailbox)).isEqualTo(0); } - @ContractTest + @Test public void countUnseenMessageShouldReturnWhenMessageIsNotSeen() throws Exception { message1.setUid(mapperProvider.generateMessageUid()); message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox)); @@ -710,7 +708,7 @@ public class MessageIdMapperTest<T extends MapperProvider> { assertThat(messageMapper.countUnseenMessagesInMailbox(benwaInboxMailbox)).isEqualTo(1); } - @ContractTest + @Test public void countMessageShouldBeEmptyWhenDeleteMessage() throws Exception { message1.setUid(mapperProvider.generateMessageUid()); message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox)); @@ -721,7 +719,7 @@ public class MessageIdMapperTest<T extends MapperProvider> { assertThat(messageMapper.countMessagesInMailbox(benwaInboxMailbox)).isEqualTo(0); } - @ContractTest + @Test public void countUnseenMessageShouldBeEmptyWhenDeleteMessage() throws Exception { message1.setUid(mapperProvider.generateMessageUid()); message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox)); @@ -732,7 +730,7 @@ public class MessageIdMapperTest<T extends MapperProvider> { assertThat(messageMapper.countUnseenMessagesInMailbox(benwaInboxMailbox)).isEqualTo(0); } - @ContractTest + @Test public void countUnseenMessageShouldReturnWhenDeleteMessage() throws Exception { message1.setUid(mapperProvider.generateMessageUid()); message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox)); @@ -748,7 +746,7 @@ public class MessageIdMapperTest<T extends MapperProvider> { assertThat(messageMapper.countUnseenMessagesInMailbox(benwaInboxMailbox)).isEqualTo(1); } - @ContractTest + @Test public void countUnseenMessageShouldTakeCareOfMessagesMarkedAsRead() throws Exception { message1.setUid(mapperProvider.generateMessageUid()); message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox)); @@ -759,7 +757,7 @@ public class MessageIdMapperTest<T extends MapperProvider> { assertThat(messageMapper.countUnseenMessagesInMailbox(benwaInboxMailbox)).isEqualTo(0); } - @ContractTest + @Test public void countUnseenMessageShouldTakeCareOfMessagesMarkedAsUnread() throws Exception { message1.setUid(mapperProvider.generateMessageUid()); message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox)); @@ -771,7 +769,7 @@ public class MessageIdMapperTest<T extends MapperProvider> { assertThat(messageMapper.countUnseenMessagesInMailbox(benwaInboxMailbox)).isEqualTo(1); } - @ContractTest + @Test public void setFlagsShouldNotUpdateModSeqWhenNoop() throws Exception { message1.setUid(mapperProvider.generateMessageUid()); long modSeq = mapperProvider.generateModSeq(benwaInboxMailbox); @@ -789,7 +787,7 @@ public class MessageIdMapperTest<T extends MapperProvider> { assertThat(messages.get(0).getModSeq()).isEqualTo(modSeq); } - @ContractTest + @Test public void addingFlagToAMessageThatAlreadyHasThisFlagShouldResultInNoChange() throws Exception { message1.setUid(mapperProvider.generateMessageUid()); long modSeq = mapperProvider.generateModSeq(benwaInboxMailbox); @@ -808,7 +806,7 @@ public class MessageIdMapperTest<T extends MapperProvider> { assertThat(messages.get(0).createFlags()).isEqualTo(flags); } - @ContractTest + @Test public void setFlagsShouldReturnUpdatedFlagsWhenNoop() throws Exception { message1.setUid(mapperProvider.generateMessageUid()); long modSeq = mapperProvider.generateModSeq(benwaInboxMailbox); @@ -832,7 +830,7 @@ public class MessageIdMapperTest<T extends MapperProvider> { .build())); } - @ContractTest + @Test public void countUnseenMessageShouldNotTakeCareOfOtherFlagsUpdates() throws Exception { message1.setUid(mapperProvider.generateMessageUid()); message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox)); http://git-wip-us.apache.org/repos/asf/james-project/blob/e9a73fd1/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MessageMapperTest.java ---------------------------------------------------------------------- diff --git a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MessageMapperTest.java b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MessageMapperTest.java index 955f39a..90cbada 100644 --- a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MessageMapperTest.java +++ b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MessageMapperTest.java @@ -54,17 +54,15 @@ import org.apache.james.mailbox.store.mail.model.impl.SimpleMailboxMessage; import org.apache.james.util.concurrency.ConcurrentTestRunner; import org.junit.After; import org.junit.Assume; +import org.junit.Before; import org.junit.Rule; +import org.junit.Test; import org.junit.rules.ExpectedException; -import org.xenei.junit.contract.Contract; -import org.xenei.junit.contract.ContractTest; -import org.xenei.junit.contract.IProducer; import com.google.common.base.Optional; import com.google.common.collect.Lists; -@Contract(MapperProvider.class) -public class MessageMapperTest<T extends MapperProvider> { +public abstract class MessageMapperTest { private final static char DELIMITER = '.'; private static final int LIMIT = 10; @@ -74,7 +72,6 @@ public class MessageMapperTest<T extends MapperProvider> { public static final String CUSTOMS_USER_FLAGS_VALUE = "CustomsFlags"; - private IProducer<T> producer; private MapperProvider mapperProvider; private MessageMapper messageMapper; private MailboxMapper mailboxMapper; @@ -92,10 +89,11 @@ public class MessageMapperTest<T extends MapperProvider> { @Rule public ExpectedException expected = ExpectedException.none(); - @Contract.Inject - public final void setProducer(IProducer<T> producer) throws MailboxException { - this.producer = producer; - this.mapperProvider = producer.newInstance(); + protected abstract MapperProvider createMapperProvider(); + + @Before + public final void setProducer() throws MailboxException { + this.mapperProvider = createMapperProvider(); this.mapperProvider.ensureMapperPrepared(); Assume.assumeTrue(mapperProvider.getSupportedCapabilities().contains(MapperProvider.Capabilities.MESSAGE)); @@ -120,39 +118,39 @@ public class MessageMapperTest<T extends MapperProvider> { @After public void tearDown() throws MailboxException { - producer.cleanUp(); + mapperProvider.clearMapper(); } - @ContractTest + @Test public void emptyMailboxShouldHaveZeroMessageCount() throws MailboxException { assertThat(messageMapper.countMessagesInMailbox(benwaInboxMailbox)).isEqualTo(0); } - @ContractTest + @Test public void mailboxContainingMessagesShouldHaveTheGoodMessageCount() throws MailboxException { saveMessages(); assertThat(messageMapper.countMessagesInMailbox(benwaInboxMailbox)).isEqualTo(5); } - @ContractTest + @Test public void mailboxCountShouldBeDecrementedAfterAMessageDelete() throws MailboxException { saveMessages(); messageMapper.delete(benwaInboxMailbox, message1); assertThat(messageMapper.countMessagesInMailbox(benwaInboxMailbox)).isEqualTo(4); } - @ContractTest + @Test public void emptyMailboxShouldNotHaveUnseenMessages() throws MailboxException { assertThat(messageMapper.countUnseenMessagesInMailbox(benwaInboxMailbox)).isEqualTo(0); } - @ContractTest + @Test public void mailboxContainingMessagesShouldHaveTheGoodUnseenMessageCount() throws MailboxException { saveMessages(); assertThat(messageMapper.countUnseenMessagesInMailbox(benwaInboxMailbox)).isEqualTo(5); } - @ContractTest + @Test public void mailboxUnSeenCountShouldBeDecrementedAfterAMessageIsMarkedSeen() throws MailboxException { saveMessages(); FlagsUpdateCalculator newFlags = new FlagsUpdateCalculator(new Flags(Flags.Flag.SEEN), FlagsUpdateMode.REPLACE); @@ -162,7 +160,7 @@ public class MessageMapperTest<T extends MapperProvider> { assertThat(messageMapper.countUnseenMessagesInMailbox(benwaInboxMailbox)).isEqualTo(4); } - @ContractTest + @Test public void mailboxUnSeenCountShouldBeDecrementedAfterAMessageIsMarkedUnSeen() throws MailboxException { saveMessages(); messageMapper.updateFlags(benwaInboxMailbox, new FlagsUpdateCalculator(new Flags(Flags.Flag.SEEN), FlagsUpdateMode.REPLACE), MessageRange.one(message1.getUid())); @@ -170,21 +168,21 @@ public class MessageMapperTest<T extends MapperProvider> { assertThat(messageMapper.countUnseenMessagesInMailbox(benwaInboxMailbox)).isEqualTo(5); } - @ContractTest + @Test public void mailboxUnSeenCountShouldBeDecrementedAfterAMessageDelete() throws MailboxException { saveMessages(); messageMapper.delete(benwaInboxMailbox, message1); assertThat(messageMapper.countUnseenMessagesInMailbox(benwaInboxMailbox)).isEqualTo(4); } - @ContractTest + @Test public void deletedMessagesShouldBeRemovedFromStorage() throws MailboxException { saveMessages(); messageMapper.delete(benwaInboxMailbox, message1); assertThat(messageMapper.findInMailbox(benwaInboxMailbox, MessageRange.one(message1.getUid()), MessageMapper.FetchType.Metadata, LIMIT)).isEmpty(); } - @ContractTest + @Test public void deletingUnExistingMessageShouldHaveNoSideEffect() throws MailboxException, IOException { saveMessages(); message6.setUid(messageMapper.getLastUid(benwaInboxMailbox).get().next()); @@ -194,12 +192,12 @@ public class MessageMapperTest<T extends MapperProvider> { assertMessages(Lists.newArrayList(retrievedMessageIterator)).containOnly(message1, message2, message3, message4, message5); } - @ContractTest + @Test public void noMessageShouldBeRetrievedInEmptyMailbox() throws MailboxException { assertThat(messageMapper.findInMailbox(benwaInboxMailbox, MessageRange.one(MessageUid.MIN_VALUE), MessageMapper.FetchType.Metadata, LIMIT)).isEmpty(); } - @ContractTest + @Test public void messagesCanBeRetrievedInMailboxWithRangeTypeOne() throws MailboxException, IOException{ saveMessages(); MessageMapper.FetchType fetchType = MessageMapper.FetchType.Full; @@ -208,7 +206,7 @@ public class MessageMapperTest<T extends MapperProvider> { .isEqualToWithoutAttachment(message1, fetchType); } - @ContractTest + @Test public void messagesCanBeRetrievedInMailboxWithRangeTypeRange() throws MailboxException, IOException{ saveMessages(); Iterator<MailboxMessage> retrievedMessageIterator = messageMapper @@ -217,7 +215,7 @@ public class MessageMapperTest<T extends MapperProvider> { assertMessages(Lists.newArrayList(retrievedMessageIterator)).containOnly(message1, message2, message3, message4); } - @ContractTest + @Test public void messagesCanBeRetrievedInMailboxWithRangeTypeRangeContainingAHole() throws MailboxException, IOException { saveMessages(); messageMapper.delete(benwaInboxMailbox, message3); @@ -226,7 +224,7 @@ public class MessageMapperTest<T extends MapperProvider> { assertMessages(Lists.newArrayList(retrievedMessageIterator)).containOnly(message1, message2, message4); } - @ContractTest + @Test public void messagesCanBeRetrievedInMailboxWithRangeTypeFrom() throws MailboxException, IOException { saveMessages(); Iterator<MailboxMessage> retrievedMessageIterator = messageMapper @@ -234,7 +232,7 @@ public class MessageMapperTest<T extends MapperProvider> { assertMessages(Lists.newArrayList(retrievedMessageIterator)).containOnly(message3, message4, message5); } - @ContractTest + @Test public void messagesCanBeRetrievedInMailboxWithRangeTypeFromContainingAHole() throws MailboxException, IOException { saveMessages(); messageMapper.delete(benwaInboxMailbox, message4); @@ -243,14 +241,14 @@ public class MessageMapperTest<T extends MapperProvider> { assertMessages(Lists.newArrayList(retrievedMessageIterator)).containOnly(message3, message5); } - @ContractTest + @Test public void messagesCanBeRetrievedInMailboxWithRangeTypeAll() throws MailboxException, IOException { saveMessages(); Iterator<MailboxMessage> retrievedMessageIterator = messageMapper.findInMailbox(benwaInboxMailbox, MessageRange.all(), MessageMapper.FetchType.Full, LIMIT); assertMessages(Lists.newArrayList(retrievedMessageIterator)).containOnly(message1, message2, message3, message4, message5); } - @ContractTest + @Test public void messagesCanBeRetrievedInMailboxWithRangeTypeAllContainingHole() throws MailboxException, IOException { saveMessages(); messageMapper.delete(benwaInboxMailbox, message1); @@ -259,7 +257,7 @@ public class MessageMapperTest<T extends MapperProvider> { assertMessages(Lists.newArrayList(retrievedMessageIterator)).containOnly(message2, message3, message4, message5); } - @ContractTest + @Test public void messagesRetrievedUsingFetchTypeMetadataShouldHaveAtLastMetadataDataLoaded() throws MailboxException, IOException{ saveMessages(); MessageMapper.FetchType fetchType = MessageMapper.FetchType.Metadata; @@ -268,7 +266,7 @@ public class MessageMapperTest<T extends MapperProvider> { assertThat(retrievedMessageIterator).isEmpty(); } - @ContractTest + @Test public void messagesRetrievedUsingFetchTypeHeaderShouldHaveHeaderDataLoaded() throws MailboxException, IOException{ saveMessages(); MessageMapper.FetchType fetchType = MessageMapper.FetchType.Headers; @@ -277,7 +275,7 @@ public class MessageMapperTest<T extends MapperProvider> { assertThat(retrievedMessageIterator).isEmpty(); } - @ContractTest + @Test public void messagesRetrievedUsingFetchTypeBodyShouldHaveBodyDataLoaded() throws MailboxException, IOException{ saveMessages(); MessageMapper.FetchType fetchType = MessageMapper.FetchType.Body; @@ -286,19 +284,19 @@ public class MessageMapperTest<T extends MapperProvider> { assertThat(retrievedMessageIterator).isEmpty(); } - @ContractTest + @Test public void retrievingMessagesWithALimitShouldLimitTheNumberOfMessages() throws MailboxException { int limit = 2; saveMessages(); assertThat(messageMapper.findInMailbox(benwaInboxMailbox, MessageRange.all(), MessageMapper.FetchType.Full, limit)).hasSize(2); } - @ContractTest + @Test public void findRecentUidsInMailboxShouldReturnEmptyListWhenNoMessagesMarkedAsRecentArePresentInMailbox() throws MailboxException { assertThat(messageMapper.findRecentMessageUidsInMailbox(benwaInboxMailbox)).isEmpty(); } - @ContractTest + @Test public void findRecentUidsInMailboxShouldReturnListOfMessagesHoldingFlagsRecent() throws MailboxException { saveMessages(); messageMapper.updateFlags(benwaInboxMailbox, new FlagsUpdateCalculator(new Flags(Flags.Flag.RECENT), FlagsUpdateMode.REPLACE), MessageRange.one(message2.getUid())); @@ -307,7 +305,7 @@ public class MessageMapperTest<T extends MapperProvider> { assertThat(messageMapper.findRecentMessageUidsInMailbox(benwaInboxMailbox)).containsOnly(message2.getUid(), message4.getUid()); } - @ContractTest + @Test public void deleteShouldUpdateRecentWhenNeeded() throws MailboxException { saveMessages(); messageMapper.updateFlags(benwaInboxMailbox, new FlagsUpdateCalculator(new Flags(Flags.Flag.RECENT), FlagsUpdateMode.REPLACE), MessageRange.one(message2.getUid())); @@ -319,7 +317,7 @@ public class MessageMapperTest<T extends MapperProvider> { assertThat(messageMapper.findRecentMessageUidsInMailbox(benwaInboxMailbox)).containsOnly(message4.getUid()); } - @ContractTest + @Test public void deleteShouldNotUpdateRecentWhenNotNeeded() throws MailboxException { saveMessages(); messageMapper.updateFlags(benwaInboxMailbox, new FlagsUpdateCalculator(new Flags(Flags.Flag.RECENT), FlagsUpdateMode.REPLACE), MessageRange.one(message2.getUid())); @@ -331,7 +329,7 @@ public class MessageMapperTest<T extends MapperProvider> { assertThat(messageMapper.findRecentMessageUidsInMailbox(benwaInboxMailbox)).containsOnly(message2.getUid(), message4.getUid()); } - @ContractTest + @Test public void addShouldUpdateRecentWhenNeeded() throws MailboxException { message1.setFlags(new Flags(Flags.Flag.RECENT)); messageMapper.add(benwaInboxMailbox, message1); @@ -340,7 +338,7 @@ public class MessageMapperTest<T extends MapperProvider> { assertThat(messageMapper.findRecentMessageUidsInMailbox(benwaInboxMailbox)).containsOnly(message1.getUid()); } - @ContractTest + @Test public void addShouldNotUpdateRecentWhenNotNeeded() throws MailboxException { messageMapper.add(benwaInboxMailbox, message1); message1.setModSeq(messageMapper.getHighestModSeq(benwaInboxMailbox)); @@ -348,18 +346,18 @@ public class MessageMapperTest<T extends MapperProvider> { assertThat(messageMapper.findRecentMessageUidsInMailbox(benwaInboxMailbox)).isEmpty(); } - @ContractTest + @Test public void findFirstUnseenMessageUidShouldReturnNullWhenNoUnseenMessagesCanBeFound() throws MailboxException { assertThat(messageMapper.findFirstUnseenMessageUid(benwaInboxMailbox)).isNull(); } - @ContractTest + @Test public void findFirstUnseenMessageUidShouldReturnUid1WhenUid1isNotSeen() throws MailboxException { saveMessages(); assertThat(messageMapper.findFirstUnseenMessageUid(benwaInboxMailbox)).isEqualTo(message1.getUid()); } - @ContractTest + @Test public void findFirstUnseenMessageUidShouldReturnUid2WhenUid2isSeen() throws MailboxException { saveMessages(); messageMapper.updateFlags(benwaInboxMailbox, new FlagsUpdateCalculator(new Flags(Flags.Flag.SEEN), FlagsUpdateMode.REPLACE), MessageRange.one(message1.getUid())); @@ -368,12 +366,12 @@ public class MessageMapperTest<T extends MapperProvider> { assertThat(messageMapper.findFirstUnseenMessageUid(benwaInboxMailbox)).isEqualTo(message2.getUid()); } - @ContractTest + @Test public void expungeMarkedForDeletionInMailboxShouldReturnEmptyResultOnEmptyMailbox() throws MailboxException, IOException { assertThat(messageMapper.expungeMarkedForDeletionInMailbox(benwaInboxMailbox, MessageRange.all())).isEmpty(); } - @ContractTest + @Test public void expungeMarkedForDeletionInMailboxShouldReturnEmptyResultWhenNoMessageInMailboxIsDeleted() throws MailboxException, IOException { saveMessages(); assertThat(messageMapper.expungeMarkedForDeletionInMailbox(benwaInboxMailbox, MessageRange.all())).isEmpty(); @@ -382,7 +380,7 @@ public class MessageMapperTest<T extends MapperProvider> { assertMessages(Lists.newArrayList(retrievedMessageIterator)).containOnly(message1, message2, message3, message4, message5); } - @ContractTest + @Test public void expungeShouldReturnCorrectMetadataWithRangeAll() throws MailboxException, IOException { saveMessages(); MetadataMapAssert.assertThat(markThenPerformExpunge(MessageRange.all())) @@ -390,7 +388,7 @@ public class MessageMapperTest<T extends MapperProvider> { .containsMetadataForMessages(message1, message4); } - @ContractTest + @Test public void expungeShouldModifyUnderlyingStorageWithRangeAll() throws MailboxException, IOException { saveMessages(); markThenPerformExpunge(MessageRange.all()); @@ -400,7 +398,7 @@ public class MessageMapperTest<T extends MapperProvider> { assertMessages(Lists.newArrayList(retrievedMessageIterator)).containOnly(message2, message3, message5); } - @ContractTest + @Test public void expungeShouldReturnCorrectMetadataWithRangeOne() throws MailboxException, IOException { saveMessages(); MetadataMapAssert.assertThat(markThenPerformExpunge(MessageRange.one(message1.getUid()))) @@ -408,7 +406,7 @@ public class MessageMapperTest<T extends MapperProvider> { .containsMetadataForMessages(message1); } - @ContractTest + @Test public void expungeShouldModifyUnderlyingStorageWithRangeOne() throws MailboxException, IOException { saveMessages(); markThenPerformExpunge(MessageRange.one(message1.getUid())); @@ -418,7 +416,7 @@ public class MessageMapperTest<T extends MapperProvider> { assertMessages(Lists.newArrayList(retrievedMessageIterator)).containOnly(message4, message2, message3, message5); } - @ContractTest + @Test public void expungeShouldReturnCorrectMetadataWithRangeFrom() throws MailboxException, IOException { saveMessages(); MetadataMapAssert.assertThat(markThenPerformExpunge(MessageRange.from(message3.getUid()))) @@ -426,7 +424,7 @@ public class MessageMapperTest<T extends MapperProvider> { .containsMetadataForMessages(message4); } - @ContractTest + @Test public void expungeShouldModifyUnderlyingStorageWithRangeFrom() throws MailboxException, IOException { saveMessages(); markThenPerformExpunge(MessageRange.from(message3.getUid())); @@ -436,7 +434,7 @@ public class MessageMapperTest<T extends MapperProvider> { assertMessages(Lists.newArrayList(retrievedMessageIterator)).containOnly(message1, message2, message3, message5); } - @ContractTest + @Test public void expungeShouldReturnCorrectMetadataWithRange() throws MailboxException, IOException { saveMessages(); MetadataMapAssert.assertThat(markThenPerformExpunge(MessageRange.range(message3.getUid(), message5.getUid()))) @@ -444,7 +442,7 @@ public class MessageMapperTest<T extends MapperProvider> { .containsMetadataForMessages(message4); } - @ContractTest + @Test public void expungeShouldModifyUnderlyingStorageWithRange() throws MailboxException, IOException { saveMessages(); markThenPerformExpunge(MessageRange.range(message3.getUid(), message5.getUid())); @@ -454,12 +452,12 @@ public class MessageMapperTest<T extends MapperProvider> { assertMessages(Lists.newArrayList(retrievedMessageIterator)).containOnly(message1, message2, message3, message5); } - @ContractTest + @Test public void getHighestMoseqShouldBeEqualToZeroOnEmptyMailbox() throws MailboxException { assertThat(messageMapper.getHighestModSeq(benwaInboxMailbox)).isEqualTo(0); } - @ContractTest + @Test public void insertingAMessageShouldIncrementModSeq() throws MailboxException { messageMapper.add(benwaInboxMailbox, message1); long modSeq = messageMapper.getHighestModSeq(benwaInboxMailbox); @@ -468,12 +466,12 @@ public class MessageMapperTest<T extends MapperProvider> { assertThat(messageMapper.getHighestModSeq(benwaInboxMailbox)).isGreaterThan(modSeq); } - @ContractTest + @Test public void getLastUidShouldReturnEmptyOnEmptyMailbox() throws MailboxException { assertThat(messageMapper.getLastUid(benwaInboxMailbox)).isEqualTo(Optional.absent()); } - @ContractTest + @Test public void insertingAMessageShouldIncrementLastUid() throws MailboxException { messageMapper.add(benwaInboxMailbox, message1); Optional<MessageUid> uid = messageMapper.getLastUid(benwaInboxMailbox); @@ -482,7 +480,7 @@ public class MessageMapperTest<T extends MapperProvider> { assertThat(messageMapper.getLastUid(benwaInboxMailbox).get()).isGreaterThan(uid.get()); } - @ContractTest + @Test public void copyShouldIncrementUid() throws MailboxException, IOException { saveMessages(); MessageUid uid = messageMapper.getLastUid(benwaInboxMailbox).get(); @@ -490,21 +488,21 @@ public class MessageMapperTest<T extends MapperProvider> { assertThat(messageMapper.getLastUid(benwaInboxMailbox).get()).isGreaterThan(uid); } - @ContractTest + @Test public void copyShouldIncrementMessageCount() throws MailboxException, IOException { saveMessages(); messageMapper.copy(benwaInboxMailbox, SimpleMailboxMessage.copy(benwaInboxMailbox.getMailboxId(), message6)); assertThat(messageMapper.countMessagesInMailbox(benwaInboxMailbox)).isEqualTo(6); } - @ContractTest + @Test public void copyOfUnSeenMessageShouldIncrementUnSeenMessageCount() throws MailboxException, IOException { saveMessages(); messageMapper.copy(benwaInboxMailbox, SimpleMailboxMessage.copy(benwaInboxMailbox.getMailboxId(), message6)); assertThat(messageMapper.countUnseenMessagesInMailbox(benwaInboxMailbox)).isEqualTo(6); } - @ContractTest + @Test public void copyShouldIncrementModSeq() throws MailboxException, IOException { saveMessages(); long modSeq = messageMapper.getHighestModSeq(benwaInboxMailbox); @@ -512,7 +510,7 @@ public class MessageMapperTest<T extends MapperProvider> { assertThat(messageMapper.getHighestModSeq(benwaInboxMailbox)).isGreaterThan(modSeq); } - @ContractTest + @Test public void copyShouldCreateAMessageInDestination() throws MailboxException, IOException { saveMessages(); MailboxMessage message7 = SimpleMailboxMessage.copy(benwaInboxMailbox.getMailboxId(), message6); @@ -530,7 +528,7 @@ public class MessageMapperTest<T extends MapperProvider> { assertThat(result.getUid()).isEqualTo(messageMapper.getLastUid(benwaInboxMailbox).get()); } - @ContractTest + @Test public void copyOfSeenMessageShouldNotIncrementUnSeenMessageCount() throws MailboxException { message6.setFlags(new Flags(Flags.Flag.SEEN)); saveMessages(); @@ -540,7 +538,7 @@ public class MessageMapperTest<T extends MapperProvider> { assertThat(messageMapper.countUnseenMessagesInMailbox(benwaInboxMailbox)).isEqualTo(expectedUnseenMessages); } - @ContractTest + @Test public void copiedMessageShouldBeMarkedAsRecent() throws MailboxException { saveMessages(); MessageMetaData metaData = messageMapper.copy(benwaInboxMailbox, SimpleMailboxMessage.copy(benwaInboxMailbox.getMailboxId(), message6)); @@ -554,7 +552,7 @@ public class MessageMapperTest<T extends MapperProvider> { ).isTrue(); } - @ContractTest + @Test public void copiedRecentMessageShouldBeMarkedAsRecent() throws MailboxException { saveMessages(); message6.setFlags(new Flags(Flags.Flag.RECENT)); @@ -569,7 +567,7 @@ public class MessageMapperTest<T extends MapperProvider> { ).isTrue(); } - @ContractTest + @Test public void copiedMessageShouldNotChangeTheFlagsOnOriginalMessage() throws MailboxException { saveMessages(); messageMapper.copy(benwaInboxMailbox, SimpleMailboxMessage.copy(benwaInboxMailbox.getMailboxId(), message6)); @@ -583,14 +581,14 @@ public class MessageMapperTest<T extends MapperProvider> { ).isFalse(); } - @ContractTest + @Test public void flagsReplacementShouldReplaceStoredMessageFlags() throws MailboxException { saveMessages(); messageMapper.updateFlags(benwaInboxMailbox, new FlagsUpdateCalculator(new Flags(Flags.Flag.FLAGGED), FlagsUpdateMode.REPLACE), MessageRange.one(message1.getUid())); assertThat(retrieveMessageFromStorage(message1)).hasFlags(new Flags(Flags.Flag.FLAGGED)); } - @ContractTest + @Test public void flagsReplacementShouldReturnAnUpdatedFlagHighlightingTheReplacement() throws MailboxException { saveMessages(); long modSeq = messageMapper.getHighestModSeq(benwaInboxMailbox); @@ -605,7 +603,7 @@ public class MessageMapperTest<T extends MapperProvider> { .build()); } - @ContractTest + @Test public void flagsAdditionShouldReturnAnUpdatedFlagHighlightingTheAddition() throws MailboxException { saveMessages(); messageMapper.updateFlags(benwaInboxMailbox, new FlagsUpdateCalculator(new Flags(Flags.Flag.FLAGGED), FlagsUpdateMode.REPLACE), MessageRange.one(message1.getUid())); @@ -619,7 +617,7 @@ public class MessageMapperTest<T extends MapperProvider> { .build()); } - @ContractTest + @Test public void flagsAdditionShouldUpdateStoredMessageFlags() throws MailboxException { saveMessages(); messageMapper.updateFlags(benwaInboxMailbox, new FlagsUpdateCalculator(new Flags(Flags.Flag.FLAGGED), FlagsUpdateMode.REPLACE), MessageRange.one(message1.getUid())); @@ -627,7 +625,7 @@ public class MessageMapperTest<T extends MapperProvider> { assertThat(retrieveMessageFromStorage(message1)).hasFlags(new FlagsBuilder().add(Flags.Flag.SEEN, Flags.Flag.FLAGGED).build()); } - @ContractTest + @Test public void flagsAdditionShouldHaveNoEffectOnStoredFlagsWhenNoop() throws MailboxException { saveMessages(); messageMapper.updateFlags(benwaInboxMailbox, new FlagsUpdateCalculator(new Flags(Flags.Flag.FLAGGED), FlagsUpdateMode.REPLACE), MessageRange.one(message1.getUid())); @@ -637,7 +635,7 @@ public class MessageMapperTest<T extends MapperProvider> { .hasFlags(new FlagsBuilder().add(Flags.Flag.FLAGGED).build()); } - @ContractTest + @Test public void flagsRemovalShouldReturnAnUpdatedFlagHighlightingTheRemoval() throws MailboxException { saveMessages(); messageMapper.updateFlags(benwaInboxMailbox, new FlagsUpdateCalculator(new FlagsBuilder().add(Flags.Flag.FLAGGED, Flags.Flag.SEEN).build(), FlagsUpdateMode.REPLACE), MessageRange.one(message1.getUid())); @@ -652,7 +650,7 @@ public class MessageMapperTest<T extends MapperProvider> { .build()); } - @ContractTest + @Test public void flagsRemovalShouldUpdateStoredMessageFlags() throws MailboxException { saveMessages(); messageMapper.updateFlags(benwaInboxMailbox, new FlagsUpdateCalculator(new FlagsBuilder().add(Flags.Flag.FLAGGED, Flags.Flag.SEEN).build(), FlagsUpdateMode.REPLACE), MessageRange.one(message1.getUid())); @@ -660,26 +658,26 @@ public class MessageMapperTest<T extends MapperProvider> { assertThat(retrieveMessageFromStorage(message1)).hasFlags(new Flags(Flags.Flag.FLAGGED)); } - @ContractTest + @Test public void updateFlagsOnRangeShouldAffectMessagesContainedInThisRange() throws MailboxException { saveMessages(); assertThat(messageMapper.updateFlags(benwaInboxMailbox, new FlagsUpdateCalculator(new Flags(Flags.Flag.SEEN), FlagsUpdateMode.REPLACE), MessageRange.range(message1.getUid(), message3.getUid()))) .hasSize(3); } - @ContractTest + @Test public void updateFlagsWithRangeFromShouldAffectMessagesContainedInThisRange() throws MailboxException { saveMessages(); assertThat(messageMapper.updateFlags(benwaInboxMailbox, new FlagsUpdateCalculator(new Flags(Flags.Flag.SEEN), FlagsUpdateMode.REPLACE), MessageRange.from(message3.getUid()))).hasSize(3); } - @ContractTest + @Test public void updateFlagsWithRangeAllRangeShouldAffectAllMessages() throws MailboxException { saveMessages(); assertThat(messageMapper.updateFlags(benwaInboxMailbox, new FlagsUpdateCalculator(new Flags(Flags.Flag.SEEN), FlagsUpdateMode.REPLACE), MessageRange.all())).hasSize(5); } - @ContractTest + @Test public void messagePropertiesShouldBeStored() throws Exception { PropertyBuilder propBuilder = new PropertyBuilder(); propBuilder.setMediaType("text"); @@ -695,7 +693,7 @@ public class MessageMapperTest<T extends MapperProvider> { assertProperties(message.getProperties()).containsOnly(propBuilder.toProperties()); } - @ContractTest + @Test public void messagePropertiesShouldBeStoredWhenDuplicateEntries() throws Exception { PropertyBuilder propBuilder = new PropertyBuilder(); propBuilder.setProperty(StandardNames.MIME_CONTENT_LANGUAGE_SPACE, StandardNames.MIME_CONTENT_LANGUAGE_NAME, "us"); @@ -708,7 +706,7 @@ public class MessageMapperTest<T extends MapperProvider> { assertProperties(message.getProperties()).containsOnly(propBuilder.toProperties()); } - @ContractTest + @Test public void messagePropertiesShouldBeStoredWhenNoProperty() throws Exception { MailboxMessage messageWithProperties = createMessage(benwaWorkMailbox, mapperProvider.generateMessageId(), "Subject: messagePropertiesShouldBeStoredWhenNoProperty \n\nBody\n.\n", BODY_START, new PropertyBuilder()); MessageMetaData messageMetaData = messageMapper.add(benwaInboxMailbox, messageWithProperties); @@ -716,7 +714,7 @@ public class MessageMapperTest<T extends MapperProvider> { assertThat(message.getProperties()).isEmpty(); } - @ContractTest + @Test public void textualLineCountShouldBeWellStored() throws Exception { long textualLineCount = 48L; PropertyBuilder propBuilder = new PropertyBuilder(); @@ -728,7 +726,7 @@ public class MessageMapperTest<T extends MapperProvider> { assertThat(message.getTextualLineCount()).isEqualTo(textualLineCount); } - @ContractTest + @Test public void mediaTypeShouldBeWellStored() throws Exception { String mediaType = "plain"; PropertyBuilder propBuilder = new PropertyBuilder(); @@ -740,7 +738,7 @@ public class MessageMapperTest<T extends MapperProvider> { assertThat(message.getMediaType()).isEqualTo(mediaType); } - @ContractTest + @Test public void subTypeShouldBeWellStored() throws Exception { String subType = "text"; PropertyBuilder propBuilder = new PropertyBuilder(); @@ -752,14 +750,14 @@ public class MessageMapperTest<T extends MapperProvider> { assertThat(message.getSubType()).isEqualTo(subType); } - @ContractTest + @Test public void userFlagsShouldBeSupported() throws Exception { saveMessages(); messageMapper.updateFlags(benwaInboxMailbox, new FlagsUpdateCalculator(new Flags(USER_FLAG), FlagsUpdateMode.ADD), MessageRange.one(message1.getUid())); assertThat(retrieveMessageFromStorage(message1)).hasFlags(new Flags(USER_FLAG)); } - @ContractTest + @Test public void userFlagsUpdateShouldReturnCorrectUpdatedFlags() throws Exception { saveMessages(); long modSeq = messageMapper.getHighestModSeq(benwaInboxMailbox); @@ -773,7 +771,7 @@ public class MessageMapperTest<T extends MapperProvider> { .build()); } - @ContractTest + @Test public void userFlagsUpdateShouldReturnCorrectUpdatedFlagsWhenNoop() throws Exception { saveMessages(); @@ -790,8 +788,10 @@ public class MessageMapperTest<T extends MapperProvider> { .build()); } - @ContractTest + @Test public void userFlagsUpdateShouldWorkInConcurrentEnvironment() throws Exception { + Assume.assumeTrue(mapperProvider.getSupportedCapabilities().contains(MapperProvider.Capabilities.THREAD_SAFE_FLAGS_UPDATE)); + saveMessages(); int threadCount = 2; @@ -813,7 +813,7 @@ public class MessageMapperTest<T extends MapperProvider> { assertThat(messages.next().createFlags().getUserFlags()).hasSize(threadCount * updateCount); } - @ContractTest + @Test public void setFlagsShouldWorkWithConcurrencyWithRemove() throws Exception { Assume.assumeTrue(mapperProvider.getSupportedCapabilities().contains(MapperProvider.Capabilities.THREAD_SAFE_FLAGS_UPDATE)); saveMessages(); @@ -844,14 +844,14 @@ public class MessageMapperTest<T extends MapperProvider> { assertThat(messages.next().createFlags().getUserFlags()).isEmpty(); } - @ContractTest + @Test public void messagesShouldBeSavedWithTheirUserFlags() throws Exception { MailboxMessage message = SimpleMailboxMessage.copy(benwaInboxMailbox.getMailboxId(), message1); messageMapper.add(benwaInboxMailbox, message); assertThat(retrieveMessageFromStorage(message)).hasFlags(new Flags(USER_FLAG)); } - @ContractTest + @Test public void getApplicableFlagShouldUnionAllMessageFlags() throws Exception { message1.setFlags(new Flags(Flag.ANSWERED)); message2.setFlags(new Flags(Flag.DELETED)); @@ -864,7 +864,7 @@ public class MessageMapperTest<T extends MapperProvider> { .build()); } - @ContractTest + @Test public void getApplicableFlagShouldUnionAllMessageFlagsExceptRecentAndUser() throws Exception { message1.setFlags(new Flags(Flag.ANSWERED)); message2.setFlags(new Flags(Flag.DELETED)); @@ -883,7 +883,7 @@ public class MessageMapperTest<T extends MapperProvider> { .build()); } - @ContractTest + @Test public void getApplicableFlagShouldHaveEffectWhenUpdateFlagsByAddingThenComputingApplicableFlagsFromCurrentMailboxState() throws Exception { message1.setFlags(new Flags(Flag.ANSWERED)); message2.setFlags(new Flags(Flag.DELETED)); @@ -898,7 +898,7 @@ public class MessageMapperTest<T extends MapperProvider> { .build()); } - @ContractTest + @Test public void getApplicableFlagShouldHaveNotEffectWhenUpdateFlagsByReplaceThenIncrementalApplicableFlags() throws Exception { Assume.assumeTrue(mapperProvider.getSupportedCapabilities().contains(Capabilities.INCREMENTAL_APPLICABLE_FLAGS)); message1.setFlags(new Flags(Flag.ANSWERED)); @@ -914,7 +914,7 @@ public class MessageMapperTest<T extends MapperProvider> { .build()); } - @ContractTest + @Test public void getApplicableFlagShouldHaveEffectWhenUpdateFlagsByReplaceThenComputingApplicableFlagsFromCurrentMailboxState() throws Exception { Assume.assumeFalse(mapperProvider.getSupportedCapabilities().contains(Capabilities.INCREMENTAL_APPLICABLE_FLAGS)); message1.setFlags(new Flags(Flag.ANSWERED)); @@ -930,7 +930,7 @@ public class MessageMapperTest<T extends MapperProvider> { .build()); } - @ContractTest + @Test public void getApplicableFlagShouldHaveNotEffectWhenUpdateFlagsByRemoveThenIncrementalApplicableFlags() throws Exception { Assume.assumeTrue(mapperProvider.getSupportedCapabilities().contains(Capabilities.INCREMENTAL_APPLICABLE_FLAGS)); message1.setFlags(new FlagsBuilder().add(Flag.ANSWERED, Flag.SEEN).build()); @@ -946,7 +946,7 @@ public class MessageMapperTest<T extends MapperProvider> { .build()); } - @ContractTest + @Test public void getApplicableFlagShouldHaveEffectWhenUpdateFlagsByRemoveThenComputingApplicableFlagsFromCurrentMailboxState() throws Exception { Assume.assumeFalse(mapperProvider.getSupportedCapabilities().contains(Capabilities.INCREMENTAL_APPLICABLE_FLAGS)); message1.setFlags(new FlagsBuilder().add(Flag.ANSWERED, Flag.SEEN).build()); @@ -962,7 +962,7 @@ public class MessageMapperTest<T extends MapperProvider> { .build()); } - @ContractTest + @Test public void getApplicableFlagShouldHaveEffectWhenUnsetMessageFlagThenComputingApplicableFlagsFromCurrentMailboxState() throws Exception { Assume.assumeFalse(mapperProvider.getSupportedCapabilities().contains(Capabilities.INCREMENTAL_APPLICABLE_FLAGS)); message1.setFlags(new FlagsBuilder().add(Flag.ANSWERED, Flag.SEEN).build()); @@ -978,7 +978,7 @@ public class MessageMapperTest<T extends MapperProvider> { .build()); } - @ContractTest + @Test public void getApplicableFlagShouldHaveNotEffectWhenUnsetMessageFlagThenIncrementalApplicableFlags() throws Exception { Assume.assumeTrue(mapperProvider.getSupportedCapabilities().contains(MapperProvider.Capabilities.THREAD_SAFE_FLAGS_UPDATE)); message1.setFlags(new Flags(Flag.ANSWERED)); @@ -995,7 +995,7 @@ public class MessageMapperTest<T extends MapperProvider> { } - @ContractTest + @Test public void getApplicableFlagShouldHaveNotEffectWhenDeleteMessageThenIncrementalApplicableFlags() throws Exception { Assume.assumeTrue(mapperProvider.getSupportedCapabilities().contains(Capabilities.INCREMENTAL_APPLICABLE_FLAGS)); message1.setFlags(new Flags(Flag.ANSWERED)); @@ -1010,7 +1010,7 @@ public class MessageMapperTest<T extends MapperProvider> { .build()); } - @ContractTest + @Test public void getApplicableFlagShouldHaveEffectWhenDeleteMessageThenComputingApplicableFlagsFromCurrentMailboxState() throws Exception { Assume.assumeFalse(mapperProvider.getSupportedCapabilities().contains(Capabilities.INCREMENTAL_APPLICABLE_FLAGS)); message1.setFlags(new Flags(Flag.ANSWERED)); http://git-wip-us.apache.org/repos/asf/james-project/blob/e9a73fd1/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MessageMoveTest.java ---------------------------------------------------------------------- diff --git a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MessageMoveTest.java b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MessageMoveTest.java index f3eae89..ff9460a 100644 --- a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MessageMoveTest.java +++ b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MessageMoveTest.java @@ -39,14 +39,12 @@ import org.apache.james.mailbox.store.mail.model.impl.SimpleMailbox; import org.apache.james.mailbox.store.mail.model.impl.SimpleMailboxMessage; import org.junit.After; import org.junit.Assume; +import org.junit.Before; import org.junit.Rule; +import org.junit.Test; import org.junit.rules.ExpectedException; -import org.xenei.junit.contract.Contract; -import org.xenei.junit.contract.ContractTest; -import org.xenei.junit.contract.IProducer; -@Contract(MapperProvider.class) -public class MessageMoveTest<T extends MapperProvider> { +public abstract class MessageMoveTest { private final static char DELIMITER = '.'; private static final int LIMIT = 10; @@ -55,20 +53,20 @@ public class MessageMoveTest<T extends MapperProvider> { private MapperProvider mapperProvider; private MessageMapper messageMapper; - private IProducer<T> producer; private SimpleMailbox benwaInboxMailbox; private SimpleMailbox benwaWorkMailbox; private SimpleMailboxMessage message1; + protected abstract MapperProvider createMapperProvider(); + @Rule public ExpectedException expected = ExpectedException.none(); - @Contract.Inject - public final void setProducer(IProducer<T> producer) throws MailboxException { - this.producer = producer; - this.mapperProvider = producer.newInstance(); + @Before + public final void setUp() throws MailboxException { + this.mapperProvider = createMapperProvider(); this.mapperProvider.ensureMapperPrepared(); Assume.assumeTrue(mapperProvider.getSupportedCapabilities().contains(MapperProvider.Capabilities.MOVE)); this.messageMapper = mapperProvider.createMessageMapper(); @@ -80,11 +78,11 @@ public class MessageMoveTest<T extends MapperProvider> { } @After - public void tearDown() { - producer.cleanUp(); + public void tearDown() throws MailboxException { + mapperProvider.clearMapper(); } - @ContractTest + @Test public void movingAMessageShouldWork() throws Exception { messageMapper.add(benwaInboxMailbox, message1); message1.setModSeq(messageMapper.getHighestModSeq(benwaInboxMailbox)); @@ -94,7 +92,7 @@ public class MessageMoveTest<T extends MapperProvider> { assertThat(retrieveMessageFromStorage(benwaWorkMailbox, message1)).isEqualTo(message1); } - @ContractTest + @Test public void movingAMessageShouldReturnCorrectMetadata() throws Exception { messageMapper.add(benwaInboxMailbox, message1); message1.setModSeq(messageMapper.getHighestModSeq(benwaInboxMailbox)); @@ -108,7 +106,7 @@ public class MessageMoveTest<T extends MapperProvider> { assertThat(messageMetaData.getModSeq()).isEqualTo(messageMapper.getHighestModSeq(benwaWorkMailbox)); } - @ContractTest + @Test public void movingAMessageShouldNotViolateMessageCount() throws Exception { messageMapper.add(benwaInboxMailbox, message1); message1.setModSeq(messageMapper.getHighestModSeq(benwaInboxMailbox)); @@ -119,7 +117,7 @@ public class MessageMoveTest<T extends MapperProvider> { assertThat(messageMapper.countMessagesInMailbox(benwaWorkMailbox)).isEqualTo(1); } - @ContractTest + @Test public void movingAMessageShouldNotViolateUnseenMessageCount() throws Exception { messageMapper.add(benwaInboxMailbox, message1); message1.setModSeq(messageMapper.getHighestModSeq(benwaInboxMailbox)); @@ -130,7 +128,7 @@ public class MessageMoveTest<T extends MapperProvider> { assertThat(messageMapper.countUnseenMessagesInMailbox(benwaWorkMailbox)).isEqualTo(1); } - @ContractTest + @Test public void movingASeenMessageShouldNotIncrementUnseenMessageCount() throws Exception { message1.setFlags(new Flags(Flags.Flag.SEEN)); messageMapper.add(benwaInboxMailbox, message1); http://git-wip-us.apache.org/repos/asf/james-project/blob/e9a73fd1/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MessageWithAttachmentMapperTest.java ---------------------------------------------------------------------- diff --git a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MessageWithAttachmentMapperTest.java b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MessageWithAttachmentMapperTest.java index 6844d36..724234c 100644 --- a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MessageWithAttachmentMapperTest.java +++ b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MessageWithAttachmentMapperTest.java @@ -46,23 +46,19 @@ import org.apache.james.mailbox.store.mail.model.impl.SimpleMailbox; import org.apache.james.mailbox.store.mail.model.impl.SimpleMailboxMessage; import org.junit.After; import org.junit.Assume; +import org.junit.Before; import org.junit.Rule; +import org.junit.Test; import org.junit.rules.ExpectedException; -import org.xenei.junit.contract.Contract; -import org.xenei.junit.contract.ContractTest; -import org.xenei.junit.contract.IProducer; import com.google.common.collect.ImmutableList; -@Contract(MapperProvider.class) -public class MessageWithAttachmentMapperTest<T extends MapperProvider> { +public abstract class MessageWithAttachmentMapperTest { private static final int LIMIT = 10; private static final int BODY_START = 16; public static final int UID_VALIDITY = 42; - public static final String USER_FLAG = "userFlag"; - private IProducer<T> producer; private MapperProvider mapperProvider; private MessageMapper messageMapper; private AttachmentMapper attachmentMapper; @@ -76,10 +72,11 @@ public class MessageWithAttachmentMapperTest<T extends MapperProvider> { @Rule public ExpectedException expected = ExpectedException.none(); - @Contract.Inject - public final void setProducer(IProducer<T> producer) throws MailboxException { - this.producer = producer; - this.mapperProvider = producer.newInstance(); + protected abstract MapperProvider createMapperProvider(); + + @Before + public final void setUp() throws MailboxException { + this.mapperProvider = createMapperProvider(); this.mapperProvider.ensureMapperPrepared(); Assume.assumeTrue(mapperProvider.getSupportedCapabilities().contains(MapperProvider.Capabilities.MESSAGE)); @@ -126,10 +123,10 @@ public class MessageWithAttachmentMapperTest<T extends MapperProvider> { @After public void tearDown() throws MailboxException { - producer.cleanUp(); + mapperProvider.clearMapper(); } - @ContractTest + @Test public void messagesRetrievedUsingFetchTypeFullShouldHaveAttachmentsLoadedWhenOneAttachment() throws MailboxException, IOException{ saveMessages(); MessageMapper.FetchType fetchType = MessageMapper.FetchType.Full; @@ -137,7 +134,7 @@ public class MessageWithAttachmentMapperTest<T extends MapperProvider> { assertThat(retrievedMessageIterator.next().getAttachments()).isEqualTo(messageWith1Attachment.getAttachments()); } - @ContractTest + @Test public void messagesRetrievedUsingFetchTypeFullShouldHaveAttachmentsLoadedWhenTwoAttachments() throws MailboxException, IOException{ saveMessages(); MessageMapper.FetchType fetchType = MessageMapper.FetchType.Full; @@ -145,7 +142,7 @@ public class MessageWithAttachmentMapperTest<T extends MapperProvider> { assertThat(retrievedMessageIterator.next().getAttachments()).isEqualTo(messageWith2Attachments.getAttachments()); } - @ContractTest + @Test public void messagesRetrievedUsingFetchTypeBodyShouldHaveAttachmentsLoadedWhenOneAttachment() throws MailboxException, IOException{ saveMessages(); MessageMapper.FetchType fetchType = MessageMapper.FetchType.Body; @@ -153,7 +150,7 @@ public class MessageWithAttachmentMapperTest<T extends MapperProvider> { assertThat(retrievedMessageIterator.next().getAttachments()).isEqualTo(messageWith1Attachment.getAttachments()); } - @ContractTest + @Test public void messagesRetrievedUsingFetchTypeHeadersShouldHaveAttachmentsEmptyWhenOneAttachment() throws MailboxException, IOException{ Assume.assumeTrue(mapperProvider.supportPartialAttachmentFetch()); saveMessages(); @@ -162,7 +159,7 @@ public class MessageWithAttachmentMapperTest<T extends MapperProvider> { assertThat(retrievedMessageIterator.next().getAttachments()).isEmpty(); } - @ContractTest + @Test public void messagesRetrievedUsingFetchTypeMetadataShouldHaveAttachmentsEmptyWhenOneAttachment() throws MailboxException, IOException{ Assume.assumeTrue(mapperProvider.supportPartialAttachmentFetch()); saveMessages(); @@ -171,7 +168,7 @@ public class MessageWithAttachmentMapperTest<T extends MapperProvider> { assertThat(retrievedMessageIterator.next().getAttachments()).isEmpty(); } - @ContractTest + @Test public void messagesRetrievedUsingFetchTypeFullShouldHaveAttachmentsEmptyWhenNoAttachment() throws MailboxException, IOException{ saveMessages(); MessageMapper.FetchType fetchType = MessageMapper.FetchType.Full; @@ -179,7 +176,7 @@ public class MessageWithAttachmentMapperTest<T extends MapperProvider> { assertThat(retrievedMessageIterator.next().getAttachments()).isEmpty(); } - @ContractTest + @Test public void messagesCanBeRetrievedInMailboxWithRangeTypeOne() throws MailboxException, IOException{ saveMessages(); MessageMapper.FetchType fetchType = MessageMapper.FetchType.Full; @@ -187,7 +184,7 @@ public class MessageWithAttachmentMapperTest<T extends MapperProvider> { .isEqualTo(messageWith1Attachment, fetchType); } - @ContractTest + @Test public void messagesRetrievedUsingFetchTypeBodyShouldHaveBodyDataLoaded() throws MailboxException, IOException{ saveMessages(); MessageMapper.FetchType fetchType = MessageMapper.FetchType.Body; --------------------------------------------------------------------- To unsubscribe, e-mail: server-dev-unsubscr...@james.apache.org For additional commands, e-mail: server-dev-h...@james.apache.org
