You are viewing a plain text version of this content. The canonical link for it is here.
Posted to server-dev@james.apache.org by bt...@apache.org on 2019/11/19 02:43:21 UTC
[james-project] 19/43: [Refactoring] Move last batch of tests in
mailbox cassandra with other dependant implementations to JUnit 5
This is an automated email from the ASF dual-hosted git repository.
btellier pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/james-project.git
commit 41fe3fa5167ddc419b29312f85c0d97a18528364
Author: Rene Cordier <rc...@linagora.com>
AuthorDate: Fri Nov 15 16:34:53 2019 +0700
[Refactoring] Move last batch of tests in mailbox cassandra with other dependant implementations to JUnit 5
---
.../mail/CassandraAnnotationMapperTest.java | 32 +---
.../mail/CassandraAttachmentMapperTest.java | 33 +---
.../mail/CassandraGenericMailboxMapperTest.java | 32 +---
.../CassandraMailboxManagerAttachmentTest.java | 33 ++--
.../mail/CassandraMailboxMapperAclTest.java | 32 +---
.../mail/CassandraMessageIdMapperTest.java | 41 ++--
.../cassandra/mail/CassandraMessageMapperTest.java | 32 +---
.../cassandra/mail/CassandraMessageMoveTest.java | 32 +---
.../CassandraMessageWithAttachmentMapperTest.java | 32 +---
.../quota/CassandraCurrentQuotaManagerTest.java | 32 +---
.../quota/CassandraPerUserMaxQuotaManagerTest.java | 38 +---
.../mailbox/jpa/mail/JpaAnnotationMapperTest.java | 15 +-
.../mailbox/jpa/mail/JpaMailboxMapperTest.java | 15 +-
.../mailbox/jpa/mail/JpaMessageMapperTest.java | 15 +-
.../james/mailbox/jpa/mail/JpaMessageMoveTest.java | 91 ++++-----
.../jpa/quota/JPACurrentQuotaManagerTest.java | 8 +-
.../mailbox/jpa/quota/JPAPerUserMaxQuotaTest.java | 8 +-
.../mail/InMemoryMailboxManagerAttachmentTest.java | 10 +-
.../inmemory/mail/InMemoryMessageIdMapperTest.java | 10 +-
.../inmemory/mail/MemoryAnnotationMapperTest.java | 9 +-
.../inmemory/mail/MemoryAttachmentMapperTest.java | 10 +-
.../inmemory/mail/MemoryMailboxMapperAclTest.java | 9 +-
.../inmemory/mail/MemoryMailboxMapperTest.java | 9 +-
.../inmemory/mail/MemoryMessageMapperTest.java | 9 +-
.../inmemory/mail/MemoryMessageMoveTest.java | 9 +-
.../MemoryMessageWithAttachmentMapperTest.java | 9 +-
.../quota/InMemoryPerUserMaxQuotaManagerTest.java | 2 +-
.../AbstractMailboxManagerAttachmentTest.java | 22 +--
.../store/mail/model/AnnotationMapperTest.java | 55 +++---
.../store/mail/model/AttachmentMapperTest.java | 65 +++----
.../store/mail/model/MailboxMapperACLTest.java | 63 +++---
.../store/mail/model/MailboxMapperTest.java | 35 ++--
.../store/mail/model/MessageIdMapperTest.java | 134 +++++++------
.../store/mail/model/MessageMapperTest.java | 211 ++++++++++-----------
.../mailbox/store/mail/model/MessageMoveTest.java | 25 ++-
.../model/MessageWithAttachmentMapperTest.java | 39 ++--
.../store/quota/GenericMaxQuotaManagerTest.java | 86 ++++-----
.../store/quota/StoreCurrentQuotaManagerTest.java | 73 +++----
38 files changed, 582 insertions(+), 833 deletions(-)
diff --git a/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraAnnotationMapperTest.java b/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraAnnotationMapperTest.java
index 66eba02..a2aa280 100644
--- a/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraAnnotationMapperTest.java
+++ b/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraAnnotationMapperTest.java
@@ -19,40 +19,26 @@
package org.apache.james.mailbox.cassandra.mail;
-import org.apache.james.backends.cassandra.CassandraCluster;
-import org.apache.james.backends.cassandra.DockerCassandraRule;
+import org.apache.james.backends.cassandra.CassandraClusterExtension;
+import org.apache.james.backends.cassandra.CassandraRestartExtension;
import org.apache.james.mailbox.cassandra.ids.CassandraId;
import org.apache.james.mailbox.cassandra.mail.utils.GuiceUtils;
import org.apache.james.mailbox.cassandra.modules.CassandraAnnotationModule;
import org.apache.james.mailbox.model.MailboxId;
import org.apache.james.mailbox.store.mail.AnnotationMapper;
import org.apache.james.mailbox.store.mail.model.AnnotationMapperTest;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Rule;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.extension.RegisterExtension;
-public class CassandraAnnotationMapperTest extends AnnotationMapperTest {
-
- @Rule public DockerCassandraRule cassandraServer = new DockerCassandraRule().allowRestart();
+@ExtendWith(CassandraRestartExtension.class)
+class CassandraAnnotationMapperTest extends AnnotationMapperTest {
- private CassandraCluster cassandra;
-
- @Override
- @Before
- public void setUp() throws Exception {
- cassandra = CassandraCluster.create(CassandraAnnotationModule.MODULE, cassandraServer.getHost());
- super.setUp();
- }
-
- @After
- public void tearDown() {
- cassandra.clearTables();
- cassandra.closeCluster();
- }
+ @RegisterExtension
+ static CassandraClusterExtension cassandraCluster = new CassandraClusterExtension(CassandraAnnotationModule.MODULE);
@Override
protected AnnotationMapper createAnnotationMapper() {
- return GuiceUtils.testInjector(cassandra)
+ return GuiceUtils.testInjector(cassandraCluster.getCassandraCluster())
.getInstance(CassandraAnnotationMapper.class);
}
diff --git a/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraAttachmentMapperTest.java b/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraAttachmentMapperTest.java
index 8e6eebd..3c3d05d 100644
--- a/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraAttachmentMapperTest.java
+++ b/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraAttachmentMapperTest.java
@@ -19,47 +19,32 @@
package org.apache.james.mailbox.cassandra.mail;
-import org.apache.james.backends.cassandra.CassandraCluster;
-import org.apache.james.backends.cassandra.DockerCassandraRule;
+import org.apache.james.backends.cassandra.CassandraClusterExtension;
+import org.apache.james.backends.cassandra.CassandraRestartExtension;
import org.apache.james.backends.cassandra.components.CassandraModule;
import org.apache.james.blob.cassandra.CassandraBlobModule;
import org.apache.james.mailbox.cassandra.ids.CassandraMessageId;
import org.apache.james.mailbox.cassandra.mail.utils.GuiceUtils;
import org.apache.james.mailbox.cassandra.modules.CassandraAttachmentModule;
-import org.apache.james.mailbox.exception.MailboxException;
import org.apache.james.mailbox.model.MessageId;
import org.apache.james.mailbox.store.mail.AttachmentMapper;
import org.apache.james.mailbox.store.mail.model.AttachmentMapperTest;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Rule;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.extension.RegisterExtension;
-public class CassandraAttachmentMapperTest extends AttachmentMapperTest {
+@ExtendWith(CassandraRestartExtension.class)
+class CassandraAttachmentMapperTest extends AttachmentMapperTest {
private static final CassandraModule MODULES = CassandraModule.aggregateModules(
CassandraAttachmentModule.MODULE,
CassandraBlobModule.MODULE);
- @Rule public DockerCassandraRule cassandraServer = new DockerCassandraRule().allowRestart();
-
- private CassandraCluster cassandra;
-
- @Override
- @Before
- public void setUp() throws MailboxException {
- cassandra = CassandraCluster.create(MODULES, cassandraServer.getHost());
- super.setUp();
- }
-
- @After
- public void tearDown() {
- cassandra.clearTables();
- cassandra.closeCluster();
- }
+ @RegisterExtension
+ static CassandraClusterExtension cassandraCluster = new CassandraClusterExtension(MODULES);
@Override
protected AttachmentMapper createAttachmentMapper() {
- return GuiceUtils.testInjector(cassandra)
+ return GuiceUtils.testInjector(cassandraCluster.getCassandraCluster())
.getInstance(CassandraAttachmentMapper.class);
}
diff --git a/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraGenericMailboxMapperTest.java b/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraGenericMailboxMapperTest.java
index c61a98a..bf84354 100644
--- a/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraGenericMailboxMapperTest.java
+++ b/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraGenericMailboxMapperTest.java
@@ -19,8 +19,8 @@
package org.apache.james.mailbox.cassandra.mail;
-import org.apache.james.backends.cassandra.CassandraCluster;
-import org.apache.james.backends.cassandra.DockerCassandraRule;
+import org.apache.james.backends.cassandra.CassandraClusterExtension;
+import org.apache.james.backends.cassandra.CassandraRestartExtension;
import org.apache.james.backends.cassandra.components.CassandraModule;
import org.apache.james.backends.cassandra.versions.CassandraSchemaVersionModule;
import org.apache.james.mailbox.cassandra.ids.CassandraId;
@@ -32,11 +32,11 @@ import org.apache.james.mailbox.cassandra.modules.CassandraUidModule;
import org.apache.james.mailbox.model.MailboxId;
import org.apache.james.mailbox.store.mail.MailboxMapper;
import org.apache.james.mailbox.store.mail.model.MailboxMapperTest;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Rule;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.extension.RegisterExtension;
-public class CassandraGenericMailboxMapperTest extends MailboxMapperTest {
+@ExtendWith(CassandraRestartExtension.class)
+class CassandraGenericMailboxMapperTest extends MailboxMapperTest {
private static final CassandraModule MODULES = CassandraModule.aggregateModules(
CassandraSchemaVersionModule.MODULE,
@@ -45,26 +45,12 @@ public class CassandraGenericMailboxMapperTest extends MailboxMapperTest {
CassandraModSeqModule.MODULE,
CassandraUidModule.MODULE);
- @Rule public DockerCassandraRule cassandraServer = new DockerCassandraRule().allowRestart();
-
- private CassandraCluster cassandra;
-
- @Override
- @Before
- public void setUp() throws Exception {
- cassandra = CassandraCluster.create(MODULES, cassandraServer.getHost());
- super.setUp();
- }
-
- @After
- public void tearDown() {
- cassandra.clearTables();
- cassandra.closeCluster();
- }
+ @RegisterExtension
+ static CassandraClusterExtension cassandraCluster = new CassandraClusterExtension(MODULES);
@Override
protected MailboxMapper createMailboxMapper() {
- return GuiceUtils.testInjector(cassandra)
+ return GuiceUtils.testInjector(cassandraCluster.getCassandraCluster())
.getInstance(CassandraMailboxMapper.class);
}
diff --git a/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraMailboxManagerAttachmentTest.java b/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraMailboxManagerAttachmentTest.java
index 3670730..dacea2b 100644
--- a/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraMailboxManagerAttachmentTest.java
+++ b/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraMailboxManagerAttachmentTest.java
@@ -22,8 +22,8 @@ import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-import org.apache.james.backends.cassandra.CassandraCluster;
-import org.apache.james.backends.cassandra.DockerCassandraRule;
+import org.apache.james.backends.cassandra.CassandraClusterExtension;
+import org.apache.james.backends.cassandra.CassandraRestartExtension;
import org.apache.james.mailbox.MailboxManager;
import org.apache.james.mailbox.acl.SimpleGroupMembershipResolver;
import org.apache.james.mailbox.acl.UnionMailboxACLResolver;
@@ -50,39 +50,32 @@ import org.apache.james.mailbox.store.quota.QuotaComponents;
import org.apache.james.mailbox.store.search.MessageSearchIndex;
import org.apache.james.mailbox.store.search.SimpleMessageSearchIndex;
import org.apache.james.metrics.api.NoopMetricFactory;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Rule;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.extension.RegisterExtension;
-public class CassandraMailboxManagerAttachmentTest extends AbstractMailboxManagerAttachmentTest {
+@ExtendWith(CassandraRestartExtension.class)
+class CassandraMailboxManagerAttachmentTest extends AbstractMailboxManagerAttachmentTest {
- @Rule public DockerCassandraRule cassandraServer = new DockerCassandraRule().allowRestart();
-
- private CassandraCluster cassandra;
+ @RegisterExtension
+ static CassandraClusterExtension cassandraCluster = new CassandraClusterExtension(MailboxAggregateModule.MODULE);
private CassandraMailboxSessionMapperFactory mailboxSessionMapperFactory;
private CassandraMailboxManager mailboxManager;
private CassandraMailboxManager parseFailingMailboxManager;
- @Before
- public void init() throws Exception {
- cassandra = CassandraCluster.create(MailboxAggregateModule.MODULE, cassandraServer.getHost());
+ @BeforeEach
+ void init() throws Exception {
initSystemUnderTest();
super.setUp();
}
- @After
- public void tearDown() {
- cassandra.clearTables();
- cassandra.closeCluster();
- }
-
private void initSystemUnderTest() throws Exception {
CassandraMessageId.Factory messageIdFactory = new CassandraMessageId.Factory();
mailboxSessionMapperFactory = TestCassandraMailboxSessionMapperFactory.forTests(
- cassandra.getConf(),
- cassandra.getTypesProvider(),
+ cassandraCluster.getCassandraCluster().getConf(),
+ cassandraCluster.getCassandraCluster().getTypesProvider(),
messageIdFactory);
Authenticator noAuthenticator = null;
Authorizator noAuthorizator = null;
diff --git a/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraMailboxMapperAclTest.java b/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraMailboxMapperAclTest.java
index 3337e99..f0a8166 100644
--- a/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraMailboxMapperAclTest.java
+++ b/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraMailboxMapperAclTest.java
@@ -19,8 +19,8 @@
package org.apache.james.mailbox.cassandra.mail;
-import org.apache.james.backends.cassandra.CassandraCluster;
-import org.apache.james.backends.cassandra.DockerCassandraRule;
+import org.apache.james.backends.cassandra.CassandraClusterExtension;
+import org.apache.james.backends.cassandra.CassandraRestartExtension;
import org.apache.james.backends.cassandra.components.CassandraModule;
import org.apache.james.backends.cassandra.versions.CassandraSchemaVersionModule;
import org.apache.james.mailbox.cassandra.ids.CassandraId;
@@ -30,37 +30,23 @@ import org.apache.james.mailbox.cassandra.modules.CassandraMailboxModule;
import org.apache.james.mailbox.model.MailboxId;
import org.apache.james.mailbox.store.mail.MailboxMapper;
import org.apache.james.mailbox.store.mail.model.MailboxMapperACLTest;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Rule;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.extension.RegisterExtension;
-public class CassandraMailboxMapperAclTest extends MailboxMapperACLTest {
+@ExtendWith(CassandraRestartExtension.class)
+class CassandraMailboxMapperAclTest extends MailboxMapperACLTest {
private static final CassandraModule MODULES = CassandraModule.aggregateModules(
CassandraSchemaVersionModule.MODULE,
CassandraAclModule.MODULE,
CassandraMailboxModule.MODULE);
- @Rule public DockerCassandraRule cassandraServer = new DockerCassandraRule().allowRestart();
-
- private CassandraCluster cassandra;
-
- @Override
- @Before
- public void setUp() throws Exception {
- cassandra = CassandraCluster.create(MODULES, cassandraServer.getHost());
- super.setUp();
- }
-
- @After
- public void tearDown() {
- cassandra.clearTables();
- cassandra.closeCluster();
- }
+ @RegisterExtension
+ static CassandraClusterExtension cassandraCluster = new CassandraClusterExtension(MODULES);
@Override
protected MailboxMapper createMailboxMapper() {
- return GuiceUtils.testInjector(cassandra)
+ return GuiceUtils.testInjector(cassandraCluster.getCassandraCluster())
.getInstance(CassandraMailboxMapper.class);
}
diff --git a/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraMessageIdMapperTest.java b/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraMessageIdMapperTest.java
index 62ce79f..8980d92 100644
--- a/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraMessageIdMapperTest.java
+++ b/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraMessageIdMapperTest.java
@@ -23,8 +23,8 @@ import static org.assertj.core.api.Assertions.assertThat;
import java.util.List;
-import org.apache.james.backends.cassandra.CassandraCluster;
-import org.apache.james.backends.cassandra.DockerCassandraRule;
+import org.apache.james.backends.cassandra.CassandraClusterExtension;
+import org.apache.james.backends.cassandra.CassandraRestartExtension;
import org.apache.james.backends.cassandra.init.configuration.CassandraConfiguration;
import org.apache.james.core.Username;
import org.apache.james.mailbox.MailboxSession;
@@ -32,48 +32,35 @@ import org.apache.james.mailbox.MailboxSessionUtil;
import org.apache.james.mailbox.cassandra.CassandraMailboxSessionMapperFactory;
import org.apache.james.mailbox.cassandra.TestCassandraMailboxSessionMapperFactory;
import org.apache.james.mailbox.cassandra.ids.CassandraMessageId;
-import org.apache.james.mailbox.exception.MailboxException;
import org.apache.james.mailbox.store.mail.MessageMapper;
import org.apache.james.mailbox.store.mail.model.MailboxMessage;
import org.apache.james.mailbox.store.mail.model.MessageIdMapperTest;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.extension.RegisterExtension;
import com.google.common.collect.ImmutableList;
-public class CassandraMessageIdMapperTest extends MessageIdMapperTest {
+@ExtendWith(CassandraRestartExtension.class)
+class CassandraMessageIdMapperTest extends MessageIdMapperTest {
private static final MailboxSession MAILBOX_SESSION = MailboxSessionUtil.create(Username.of("benwa"));
- @Rule public DockerCassandraRule cassandraServer = new DockerCassandraRule().allowRestart();
-
- private CassandraCluster cassandra;
-
- @Override
- @Before
- public void setUp() throws MailboxException {
- cassandra = CassandraCluster.create(MailboxAggregateModule.MODULE, cassandraServer.getHost());
- super.setUp();
- }
-
- @After
- public void tearDown() {
- cassandra.clearTables();
- cassandra.closeCluster();
- }
+ @RegisterExtension
+ static CassandraClusterExtension cassandraCluster = new CassandraClusterExtension(MailboxAggregateModule.MODULE);
@Override
protected CassandraMapperProvider provideMapper() {
- return new CassandraMapperProvider(cassandra);
+ return new CassandraMapperProvider(cassandraCluster.getCassandraCluster());
}
@Test
- public void findShouldReturnCorrectElementsWhenChunking() throws Exception {
+ void findShouldReturnCorrectElementsWhenChunking() throws Exception {
CassandraMessageId.Factory messageIdFactory = new CassandraMessageId.Factory();
CassandraMailboxSessionMapperFactory mapperFactory = TestCassandraMailboxSessionMapperFactory.forTests(
- cassandra.getConf(), cassandra.getTypesProvider(), messageIdFactory,
+ cassandraCluster.getCassandraCluster().getConf(),
+ cassandraCluster.getCassandraCluster().getTypesProvider(),
+ messageIdFactory,
CassandraConfiguration.builder()
.messageReadChunkSize(3)
.build());
diff --git a/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraMessageMapperTest.java b/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraMessageMapperTest.java
index 948078d..f4022aa 100644
--- a/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraMessageMapperTest.java
+++ b/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraMessageMapperTest.java
@@ -19,35 +19,21 @@
package org.apache.james.mailbox.cassandra.mail;
-import org.apache.james.backends.cassandra.CassandraCluster;
-import org.apache.james.backends.cassandra.DockerCassandraRule;
+import org.apache.james.backends.cassandra.CassandraClusterExtension;
+import org.apache.james.backends.cassandra.CassandraRestartExtension;
import org.apache.james.mailbox.store.mail.model.MapperProvider;
import org.apache.james.mailbox.store.mail.model.MessageMapperTest;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Rule;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.extension.RegisterExtension;
-public class CassandraMessageMapperTest extends MessageMapperTest {
-
- @Rule public DockerCassandraRule cassandraServer = new DockerCassandraRule().allowRestart();
-
- private CassandraCluster cassandra;
+@ExtendWith(CassandraRestartExtension.class)
+class CassandraMessageMapperTest extends MessageMapperTest {
- @Override
- @Before
- public void setUp() throws Exception {
- cassandra = CassandraCluster.create(MailboxAggregateModule.MODULE, cassandraServer.getHost());
- super.setUp();
- }
-
- @After
- public void tearDown() {
- cassandra.clearTables();
- cassandra.closeCluster();
- }
+ @RegisterExtension
+ static CassandraClusterExtension cassandraCluster = new CassandraClusterExtension(MailboxAggregateModule.MODULE);
@Override
protected MapperProvider createMapperProvider() {
- return new CassandraMapperProvider(cassandra);
+ return new CassandraMapperProvider(cassandraCluster.getCassandraCluster());
}
}
diff --git a/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraMessageMoveTest.java b/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraMessageMoveTest.java
index 1b54998..d89dc9c 100644
--- a/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraMessageMoveTest.java
+++ b/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraMessageMoveTest.java
@@ -19,35 +19,21 @@
package org.apache.james.mailbox.cassandra.mail;
-import org.apache.james.backends.cassandra.CassandraCluster;
-import org.apache.james.backends.cassandra.DockerCassandraRule;
+import org.apache.james.backends.cassandra.CassandraClusterExtension;
+import org.apache.james.backends.cassandra.CassandraRestartExtension;
import org.apache.james.mailbox.store.mail.model.MapperProvider;
import org.apache.james.mailbox.store.mail.model.MessageMoveTest;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Rule;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.extension.RegisterExtension;
-public class CassandraMessageMoveTest extends MessageMoveTest {
-
- @Rule public DockerCassandraRule cassandraServer = new DockerCassandraRule().allowRestart();
-
- private CassandraCluster cassandra;
+@ExtendWith(CassandraRestartExtension.class)
+class CassandraMessageMoveTest extends MessageMoveTest {
- @Override
- @Before
- public void setUp() throws Exception {
- cassandra = CassandraCluster.create(MailboxAggregateModule.MODULE, cassandraServer.getHost());
- super.setUp();
- }
-
- @After
- public void tearDown() {
- cassandra.clearTables();
- cassandra.closeCluster();
- }
+ @RegisterExtension
+ static CassandraClusterExtension cassandraCluster = new CassandraClusterExtension(MailboxAggregateModule.MODULE);
@Override
protected MapperProvider createMapperProvider() {
- return new CassandraMapperProvider(cassandra);
+ return new CassandraMapperProvider(cassandraCluster.getCassandraCluster());
}
}
diff --git a/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraMessageWithAttachmentMapperTest.java b/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraMessageWithAttachmentMapperTest.java
index cc3b797..b39fd11 100644
--- a/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraMessageWithAttachmentMapperTest.java
+++ b/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/mail/CassandraMessageWithAttachmentMapperTest.java
@@ -19,35 +19,21 @@
package org.apache.james.mailbox.cassandra.mail;
-import org.apache.james.backends.cassandra.CassandraCluster;
-import org.apache.james.backends.cassandra.DockerCassandraRule;
+import org.apache.james.backends.cassandra.CassandraClusterExtension;
+import org.apache.james.backends.cassandra.CassandraRestartExtension;
import org.apache.james.mailbox.store.mail.model.MapperProvider;
import org.apache.james.mailbox.store.mail.model.MessageWithAttachmentMapperTest;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Rule;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.extension.RegisterExtension;
-public class CassandraMessageWithAttachmentMapperTest extends MessageWithAttachmentMapperTest {
-
- @Rule public DockerCassandraRule cassandraServer = new DockerCassandraRule().allowRestart();
-
- private CassandraCluster cassandra;
+@ExtendWith(CassandraRestartExtension.class)
+class CassandraMessageWithAttachmentMapperTest extends MessageWithAttachmentMapperTest {
- @Override
- @Before
- public void setUp() throws Exception {
- cassandra = CassandraCluster.create(MailboxAggregateModule.MODULE, cassandraServer.getHost());
- super.setUp();
- }
-
- @After
- public void tearDown() {
- cassandra.clearTables();
- cassandra.closeCluster();
- }
+ @RegisterExtension
+ static CassandraClusterExtension cassandraCluster = new CassandraClusterExtension(MailboxAggregateModule.MODULE);
@Override
protected MapperProvider createMapperProvider() {
- return new CassandraMapperProvider(cassandra);
+ return new CassandraMapperProvider(cassandraCluster.getCassandraCluster());
}
}
diff --git a/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/quota/CassandraCurrentQuotaManagerTest.java b/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/quota/CassandraCurrentQuotaManagerTest.java
index f8e42c0..426da1e 100644
--- a/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/quota/CassandraCurrentQuotaManagerTest.java
+++ b/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/quota/CassandraCurrentQuotaManagerTest.java
@@ -19,36 +19,22 @@
package org.apache.james.mailbox.cassandra.quota;
-import org.apache.james.backends.cassandra.CassandraCluster;
-import org.apache.james.backends.cassandra.DockerCassandraRule;
+import org.apache.james.backends.cassandra.CassandraClusterExtension;
+import org.apache.james.backends.cassandra.CassandraRestartExtension;
import org.apache.james.mailbox.cassandra.modules.CassandraQuotaModule;
import org.apache.james.mailbox.store.quota.StoreCurrentQuotaManager;
import org.apache.james.mailbox.store.quota.StoreCurrentQuotaManagerTest;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Rule;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.extension.RegisterExtension;
-public class CassandraCurrentQuotaManagerTest extends StoreCurrentQuotaManagerTest {
+@ExtendWith(CassandraRestartExtension.class)
+class CassandraCurrentQuotaManagerTest extends StoreCurrentQuotaManagerTest {
- @Rule public DockerCassandraRule cassandraServer = new DockerCassandraRule().allowRestart();
-
- private CassandraCluster cassandra;
-
- @Override
- @Before
- public void setUp() throws Exception {
- cassandra = CassandraCluster.create(CassandraQuotaModule.MODULE, cassandraServer.getHost());
- super.setUp();
- }
+ @RegisterExtension
+ static CassandraClusterExtension cassandraCluster = new CassandraClusterExtension(CassandraQuotaModule.MODULE);
@Override
protected StoreCurrentQuotaManager provideTestee() {
- return new CassandraCurrentQuotaManager(cassandra.getConf());
- }
-
- @After
- public void tearDown() {
- cassandra.clearTables();
- cassandra.closeCluster();
+ return new CassandraCurrentQuotaManager(cassandraCluster.getCassandraCluster().getConf());
}
}
diff --git a/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/quota/CassandraPerUserMaxQuotaManagerTest.java b/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/quota/CassandraPerUserMaxQuotaManagerTest.java
index 711b391..a7b5ac4 100644
--- a/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/quota/CassandraPerUserMaxQuotaManagerTest.java
+++ b/mailbox/cassandra/src/test/java/org/apache/james/mailbox/cassandra/quota/CassandraPerUserMaxQuotaManagerTest.java
@@ -19,45 +19,25 @@
package org.apache.james.mailbox.cassandra.quota;
-import org.apache.james.backends.cassandra.CassandraCluster;
-import org.apache.james.backends.cassandra.DockerCassandraRule;
+import org.apache.james.backends.cassandra.CassandraClusterExtension;
+import org.apache.james.backends.cassandra.CassandraRestartExtension;
import org.apache.james.mailbox.cassandra.mail.utils.GuiceUtils;
import org.apache.james.mailbox.cassandra.modules.CassandraQuotaModule;
import org.apache.james.mailbox.quota.MaxQuotaManager;
import org.apache.james.mailbox.store.quota.GenericMaxQuotaManagerTest;
-import org.junit.After;
-import org.junit.AfterClass;
-import org.junit.Before;
-import org.junit.Rule;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.extension.RegisterExtension;
-public class CassandraPerUserMaxQuotaManagerTest extends GenericMaxQuotaManagerTest {
+@ExtendWith(CassandraRestartExtension.class)
+class CassandraPerUserMaxQuotaManagerTest extends GenericMaxQuotaManagerTest {
- @Rule public DockerCassandraRule cassandraServer = new DockerCassandraRule().allowRestart();
-
- private CassandraCluster cassandra;
-
- @Override
- @Before
- public void setUp() {
- cassandra = CassandraCluster.create(CassandraQuotaModule.MODULE, cassandraServer.getHost());
- super.setUp();
- }
+ @RegisterExtension
+ static CassandraClusterExtension cassandraCluster = new CassandraClusterExtension(CassandraQuotaModule.MODULE);
@Override
protected MaxQuotaManager provideMaxQuotaManager() {
- return GuiceUtils.testInjector(cassandra)
+ return GuiceUtils.testInjector(cassandraCluster.getCassandraCluster())
.getInstance(CassandraPerUserMaxQuotaManager.class);
}
- @After
- public void cleanUp() {
- cassandra.clearTables();
- cassandra.closeCluster();
- }
-
- @AfterClass
- public static void tearDownClass() {
-
- }
-
}
diff --git a/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/mail/JpaAnnotationMapperTest.java b/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/mail/JpaAnnotationMapperTest.java
index c697b2e..641e298 100644
--- a/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/mail/JpaAnnotationMapperTest.java
+++ b/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/mail/JpaAnnotationMapperTest.java
@@ -27,23 +27,16 @@ import org.apache.james.mailbox.jpa.JPAMailboxFixture;
import org.apache.james.mailbox.model.MailboxId;
import org.apache.james.mailbox.store.mail.AnnotationMapper;
import org.apache.james.mailbox.store.mail.model.AnnotationMapperTest;
-import org.junit.After;
-import org.junit.Before;
+import org.junit.jupiter.api.AfterEach;
-public class JpaAnnotationMapperTest extends AnnotationMapperTest {
+class JpaAnnotationMapperTest extends AnnotationMapperTest {
public static final JpaTestCluster JPA_TEST_CLUSTER = JpaTestCluster.create(JPAMailboxFixture.MAILBOX_PERSISTANCE_CLASSES);
private final AtomicInteger counter = new AtomicInteger();
- @Override
- @Before
- public void setUp() throws Exception {
- super.setUp();
- }
-
- @After
- public void tearDown() {
+ @AfterEach
+ void tearDown() {
JPA_TEST_CLUSTER.clear(JPAMailboxFixture.MAILBOX_TABLE_NAMES);
}
diff --git a/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/mail/JpaMailboxMapperTest.java b/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/mail/JpaMailboxMapperTest.java
index 36b0a84..c9fe5be 100644
--- a/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/mail/JpaMailboxMapperTest.java
+++ b/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/mail/JpaMailboxMapperTest.java
@@ -27,22 +27,15 @@ import org.apache.james.mailbox.jpa.JPAMailboxFixture;
import org.apache.james.mailbox.model.MailboxId;
import org.apache.james.mailbox.store.mail.MailboxMapper;
import org.apache.james.mailbox.store.mail.model.MailboxMapperTest;
-import org.junit.After;
-import org.junit.Before;
+import org.junit.jupiter.api.AfterEach;
-public class JpaMailboxMapperTest extends MailboxMapperTest {
+class JpaMailboxMapperTest extends MailboxMapperTest {
public static final JpaTestCluster JPA_TEST_CLUSTER = JpaTestCluster.create(JPAMailboxFixture.MAILBOX_PERSISTANCE_CLASSES);
private final AtomicInteger counter = new AtomicInteger();
@Override
- @Before
- public void setUp() throws Exception {
- super.setUp();
- }
-
- @Override
protected MailboxMapper createMailboxMapper() {
return new TransactionalMailboxMapper(new JPAMailboxMapper(JPA_TEST_CLUSTER.getEntityManagerFactory()));
}
@@ -52,8 +45,8 @@ public class JpaMailboxMapperTest extends MailboxMapperTest {
return JPAId.of(counter.incrementAndGet());
}
- @After
- public void cleanUp() {
+ @AfterEach
+ void cleanUp() {
JPA_TEST_CLUSTER.clear(JPAMailboxFixture.MAILBOX_TABLE_NAMES);
}
}
diff --git a/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/mail/JpaMessageMapperTest.java b/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/mail/JpaMessageMapperTest.java
index dba6c5b..5ebe877 100644
--- a/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/mail/JpaMessageMapperTest.java
+++ b/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/mail/JpaMessageMapperTest.java
@@ -23,26 +23,19 @@ import org.apache.james.backends.jpa.JpaTestCluster;
import org.apache.james.mailbox.jpa.JPAMailboxFixture;
import org.apache.james.mailbox.store.mail.model.MapperProvider;
import org.apache.james.mailbox.store.mail.model.MessageMapperTest;
-import org.junit.After;
-import org.junit.Before;
+import org.junit.jupiter.api.AfterEach;
-public class JpaMessageMapperTest extends MessageMapperTest {
+class JpaMessageMapperTest extends MessageMapperTest {
public static final JpaTestCluster JPA_TEST_CLUSTER = JpaTestCluster.create(JPAMailboxFixture.MAILBOX_PERSISTANCE_CLASSES);
-
- @Override
- @Before
- public void setUp() throws Exception {
- super.setUp();
- }
@Override
protected MapperProvider createMapperProvider() {
return new JPAMapperProvider(JPA_TEST_CLUSTER);
}
- @After
- public void cleanUp() {
+ @AfterEach
+ void cleanUp() {
JPA_TEST_CLUSTER.clear(JPAMailboxFixture.MAILBOX_TABLE_NAMES);
}
}
diff --git a/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/mail/JpaMessageMoveTest.java b/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/mail/JpaMessageMoveTest.java
index abc9a30..1940cb3 100644
--- a/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/mail/JpaMessageMoveTest.java
+++ b/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/mail/JpaMessageMoveTest.java
@@ -1,49 +1,42 @@
-/****************************************************************
- * Licensed to the Apache Software Foundation (ASF) under one *
- * or more contributor license agreements. See the NOTICE file *
- * distributed with this work for additional information *
- * regarding copyright ownership. The ASF licenses this file *
- * to you under the Apache License, Version 2.0 (the *
- * "License"); you may not use this file except in compliance *
- * with the License. You may obtain a copy of the License at *
- * *
- * http://www.apache.org/licenses/LICENSE-2.0 *
- * *
- * Unless required by applicable law or agreed to in writing, *
- * software distributed under the License is distributed on an *
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY *
- * KIND, either express or implied. See the License for the *
- * specific language governing permissions and limitations *
- * under the License. *
- ****************************************************************/
-
-package org.apache.james.mailbox.jpa.mail;
-
-import org.apache.james.backends.jpa.JpaTestCluster;
-import org.apache.james.mailbox.jpa.JPAMailboxFixture;
-import org.apache.james.mailbox.store.mail.model.MapperProvider;
-import org.apache.james.mailbox.store.mail.model.MessageMoveTest;
-import org.junit.After;
-import org.junit.Before;
-
-public class JpaMessageMoveTest extends MessageMoveTest {
-
- public static final JpaTestCluster JPA_TEST_CLUSTER = JpaTestCluster.create(JPAMailboxFixture.MAILBOX_PERSISTANCE_CLASSES);
-
- @Override
- @Before
- public void setUp() throws Exception {
- super.setUp();
- }
-
- @Override
- protected MapperProvider createMapperProvider() {
- return new JPAMapperProvider(JPA_TEST_CLUSTER);
- }
-
- @After
- public void cleanUp() {
- JPA_TEST_CLUSTER.clear(JPAMailboxFixture.MAILBOX_TABLE_NAMES);
- }
-
-}
+/****************************************************************
+ * Licensed to the Apache Software Foundation (ASF) under one *
+ * or more contributor license agreements. See the NOTICE file *
+ * distributed with this work for additional information *
+ * regarding copyright ownership. The ASF licenses this file *
+ * to you under the Apache License, Version 2.0 (the *
+ * "License"); you may not use this file except in compliance *
+ * with the License. You may obtain a copy of the License at *
+ * *
+ * http://www.apache.org/licenses/LICENSE-2.0 *
+ * *
+ * Unless required by applicable law or agreed to in writing, *
+ * software distributed under the License is distributed on an *
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY *
+ * KIND, either express or implied. See the License for the *
+ * specific language governing permissions and limitations *
+ * under the License. *
+ ****************************************************************/
+
+package org.apache.james.mailbox.jpa.mail;
+
+import org.apache.james.backends.jpa.JpaTestCluster;
+import org.apache.james.mailbox.jpa.JPAMailboxFixture;
+import org.apache.james.mailbox.store.mail.model.MapperProvider;
+import org.apache.james.mailbox.store.mail.model.MessageMoveTest;
+import org.junit.jupiter.api.AfterEach;
+
+class JpaMessageMoveTest extends MessageMoveTest {
+
+ public static final JpaTestCluster JPA_TEST_CLUSTER = JpaTestCluster.create(JPAMailboxFixture.MAILBOX_PERSISTANCE_CLASSES);
+
+ @Override
+ protected MapperProvider createMapperProvider() {
+ return new JPAMapperProvider(JPA_TEST_CLUSTER);
+ }
+
+ @AfterEach
+ void cleanUp() {
+ JPA_TEST_CLUSTER.clear(JPAMailboxFixture.MAILBOX_TABLE_NAMES);
+ }
+
+}
diff --git a/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/quota/JPACurrentQuotaManagerTest.java b/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/quota/JPACurrentQuotaManagerTest.java
index 44f6c0e..885a63f 100644
--- a/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/quota/JPACurrentQuotaManagerTest.java
+++ b/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/quota/JPACurrentQuotaManagerTest.java
@@ -23,9 +23,9 @@ import org.apache.james.backends.jpa.JpaTestCluster;
import org.apache.james.mailbox.jpa.JPAMailboxFixture;
import org.apache.james.mailbox.store.quota.StoreCurrentQuotaManager;
import org.apache.james.mailbox.store.quota.StoreCurrentQuotaManagerTest;
-import org.junit.After;
+import org.junit.jupiter.api.AfterEach;
-public class JPACurrentQuotaManagerTest extends StoreCurrentQuotaManagerTest {
+class JPACurrentQuotaManagerTest extends StoreCurrentQuotaManagerTest {
private static final JpaTestCluster JPA_TEST_CLUSTER = JpaTestCluster.create(JPAMailboxFixture.QUOTA_PERSISTANCE_CLASSES);
@@ -34,8 +34,8 @@ public class JPACurrentQuotaManagerTest extends StoreCurrentQuotaManagerTest {
return new JpaCurrentQuotaManager(JPA_TEST_CLUSTER.getEntityManagerFactory());
}
- @After
- public void tearDown() {
+ @AfterEach
+ void tearDown() {
JPA_TEST_CLUSTER.clear(JPAMailboxFixture.QUOTA_TABLES_NAMES);
}
diff --git a/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/quota/JPAPerUserMaxQuotaTest.java b/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/quota/JPAPerUserMaxQuotaTest.java
index aca05da..b557d95 100644
--- a/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/quota/JPAPerUserMaxQuotaTest.java
+++ b/mailbox/jpa/src/test/java/org/apache/james/mailbox/jpa/quota/JPAPerUserMaxQuotaTest.java
@@ -23,9 +23,9 @@ import org.apache.james.backends.jpa.JpaTestCluster;
import org.apache.james.mailbox.jpa.JPAMailboxFixture;
import org.apache.james.mailbox.quota.MaxQuotaManager;
import org.apache.james.mailbox.store.quota.GenericMaxQuotaManagerTest;
-import org.junit.After;
+import org.junit.jupiter.api.AfterEach;
-public class JPAPerUserMaxQuotaTest extends GenericMaxQuotaManagerTest {
+class JPAPerUserMaxQuotaTest extends GenericMaxQuotaManagerTest {
private static final JpaTestCluster JPA_TEST_CLUSTER = JpaTestCluster.create(JPAMailboxFixture.QUOTA_PERSISTANCE_CLASSES);
@@ -34,8 +34,8 @@ public class JPAPerUserMaxQuotaTest extends GenericMaxQuotaManagerTest {
return new JPAPerUserMaxQuotaManager(new JPAPerUserMaxQuotaDAO(JPA_TEST_CLUSTER.getEntityManagerFactory()));
}
- @After
- public void cleanUp() {
+ @AfterEach
+ void cleanUp() {
JPA_TEST_CLUSTER.clear(JPAMailboxFixture.QUOTA_TABLES_NAMES);
}
}
diff --git a/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/mail/InMemoryMailboxManagerAttachmentTest.java b/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/mail/InMemoryMailboxManagerAttachmentTest.java
index 7f21920..f913c8c 100644
--- a/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/mail/InMemoryMailboxManagerAttachmentTest.java
+++ b/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/mail/InMemoryMailboxManagerAttachmentTest.java
@@ -32,15 +32,15 @@ import org.apache.james.mailbox.store.AbstractMailboxManagerAttachmentTest;
import org.apache.james.mailbox.store.MailboxSessionMapperFactory;
import org.apache.james.mailbox.store.mail.AttachmentMapperFactory;
import org.apache.james.mailbox.store.mail.model.impl.MessageParser;
-import org.junit.Before;
+import org.junit.jupiter.api.BeforeEach;
-public class InMemoryMailboxManagerAttachmentTest extends AbstractMailboxManagerAttachmentTest {
+class InMemoryMailboxManagerAttachmentTest extends AbstractMailboxManagerAttachmentTest {
private InMemoryMailboxManager mailboxManager;
private InMemoryMailboxManager parseFailingMailboxManager;
- @Override
- @Before
- public void setUp() throws Exception {
+
+ @BeforeEach
+ void setup() throws Exception {
MessageParser failingMessageParser = mock(MessageParser.class);
when(failingMessageParser.retrieveAttachments(any(InputStream.class)))
.thenThrow(new RuntimeException("Message parser set to fail"));
diff --git a/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/mail/InMemoryMessageIdMapperTest.java b/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/mail/InMemoryMessageIdMapperTest.java
index da85ccc..faf70ab 100644
--- a/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/mail/InMemoryMessageIdMapperTest.java
+++ b/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/mail/InMemoryMessageIdMapperTest.java
@@ -19,18 +19,10 @@
package org.apache.james.mailbox.inmemory.mail;
-import org.apache.james.mailbox.exception.MailboxException;
import org.apache.james.mailbox.store.mail.model.MapperProvider;
import org.apache.james.mailbox.store.mail.model.MessageIdMapperTest;
-import org.junit.Before;
-public class InMemoryMessageIdMapperTest extends MessageIdMapperTest {
-
- @Override
- @Before
- public void setUp() throws MailboxException {
- super.setUp();
- }
+class InMemoryMessageIdMapperTest extends MessageIdMapperTest {
@Override
protected MapperProvider provideMapper() {
diff --git a/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/mail/MemoryAnnotationMapperTest.java b/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/mail/MemoryAnnotationMapperTest.java
index 6e736fb..321e461 100644
--- a/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/mail/MemoryAnnotationMapperTest.java
+++ b/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/mail/MemoryAnnotationMapperTest.java
@@ -25,19 +25,12 @@ import org.apache.james.mailbox.inmemory.InMemoryId;
import org.apache.james.mailbox.model.MailboxId;
import org.apache.james.mailbox.store.mail.AnnotationMapper;
import org.apache.james.mailbox.store.mail.model.AnnotationMapperTest;
-import org.junit.Before;
-public class MemoryAnnotationMapperTest extends AnnotationMapperTest {
+class MemoryAnnotationMapperTest extends AnnotationMapperTest {
private final AtomicInteger counter = new AtomicInteger();
@Override
- @Before
- public void setUp() throws Exception {
- super.setUp();
- }
-
- @Override
protected AnnotationMapper createAnnotationMapper() {
return new InMemoryAnnotationMapper();
}
diff --git a/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/mail/MemoryAttachmentMapperTest.java b/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/mail/MemoryAttachmentMapperTest.java
index b379621..2045455 100644
--- a/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/mail/MemoryAttachmentMapperTest.java
+++ b/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/mail/MemoryAttachmentMapperTest.java
@@ -19,20 +19,12 @@
package org.apache.james.mailbox.inmemory.mail;
-import org.apache.james.mailbox.exception.MailboxException;
import org.apache.james.mailbox.inmemory.InMemoryMessageId;
import org.apache.james.mailbox.model.MessageId;
import org.apache.james.mailbox.store.mail.AttachmentMapper;
import org.apache.james.mailbox.store.mail.model.AttachmentMapperTest;
-import org.junit.Before;
-public class MemoryAttachmentMapperTest extends AttachmentMapperTest {
-
- @Override
- @Before
- public void setUp() throws MailboxException {
- super.setUp();
- }
+class MemoryAttachmentMapperTest extends AttachmentMapperTest {
@Override
protected AttachmentMapper createAttachmentMapper() {
diff --git a/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/mail/MemoryMailboxMapperAclTest.java b/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/mail/MemoryMailboxMapperAclTest.java
index df6d73f..c9e7d77 100644
--- a/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/mail/MemoryMailboxMapperAclTest.java
+++ b/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/mail/MemoryMailboxMapperAclTest.java
@@ -25,16 +25,9 @@ import org.apache.james.mailbox.inmemory.InMemoryId;
import org.apache.james.mailbox.model.MailboxId;
import org.apache.james.mailbox.store.mail.MailboxMapper;
import org.apache.james.mailbox.store.mail.model.MailboxMapperACLTest;
-import org.junit.Before;
-public class MemoryMailboxMapperAclTest extends MailboxMapperACLTest {
+class MemoryMailboxMapperAclTest extends MailboxMapperACLTest {
private final AtomicInteger counter = new AtomicInteger();
-
- @Override
- @Before
- public void setUp() throws Exception {
- super.setUp();
- }
@Override
protected MailboxMapper createMailboxMapper() {
diff --git a/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/mail/MemoryMailboxMapperTest.java b/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/mail/MemoryMailboxMapperTest.java
index 3f29233..d7c1d34 100644
--- a/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/mail/MemoryMailboxMapperTest.java
+++ b/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/mail/MemoryMailboxMapperTest.java
@@ -25,19 +25,12 @@ import org.apache.james.mailbox.inmemory.InMemoryId;
import org.apache.james.mailbox.model.MailboxId;
import org.apache.james.mailbox.store.mail.MailboxMapper;
import org.apache.james.mailbox.store.mail.model.MailboxMapperTest;
-import org.junit.Before;
-public class MemoryMailboxMapperTest extends MailboxMapperTest {
+class MemoryMailboxMapperTest extends MailboxMapperTest {
private final AtomicInteger counter = new AtomicInteger();
@Override
- @Before
- public void setUp() throws Exception {
- super.setUp();
- }
-
- @Override
protected MailboxMapper createMailboxMapper() {
return new InMemoryMailboxMapper();
}
diff --git a/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/mail/MemoryMessageMapperTest.java b/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/mail/MemoryMessageMapperTest.java
index b259fd3..77b3696 100644
--- a/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/mail/MemoryMessageMapperTest.java
+++ b/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/mail/MemoryMessageMapperTest.java
@@ -21,15 +21,8 @@ package org.apache.james.mailbox.inmemory.mail;
import org.apache.james.mailbox.store.mail.model.MapperProvider;
import org.apache.james.mailbox.store.mail.model.MessageMapperTest;
-import org.junit.Before;
-public class MemoryMessageMapperTest extends MessageMapperTest {
-
- @Override
- @Before
- public void setUp() throws Exception {
- super.setUp();
- }
+class MemoryMessageMapperTest extends MessageMapperTest {
@Override
protected MapperProvider createMapperProvider() {
diff --git a/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/mail/MemoryMessageMoveTest.java b/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/mail/MemoryMessageMoveTest.java
index a906c22..5d308dd 100644
--- a/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/mail/MemoryMessageMoveTest.java
+++ b/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/mail/MemoryMessageMoveTest.java
@@ -21,15 +21,8 @@ package org.apache.james.mailbox.inmemory.mail;
import org.apache.james.mailbox.store.mail.model.MapperProvider;
import org.apache.james.mailbox.store.mail.model.MessageMoveTest;
-import org.junit.Before;
-public class MemoryMessageMoveTest extends MessageMoveTest {
-
- @Override
- @Before
- public void setUp() throws Exception {
- super.setUp();
- }
+class MemoryMessageMoveTest extends MessageMoveTest {
@Override
protected MapperProvider createMapperProvider() {
diff --git a/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/mail/MemoryMessageWithAttachmentMapperTest.java b/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/mail/MemoryMessageWithAttachmentMapperTest.java
index 32f77f3..fbc7a1a 100644
--- a/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/mail/MemoryMessageWithAttachmentMapperTest.java
+++ b/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/mail/MemoryMessageWithAttachmentMapperTest.java
@@ -21,15 +21,8 @@ package org.apache.james.mailbox.inmemory.mail;
import org.apache.james.mailbox.store.mail.model.MapperProvider;
import org.apache.james.mailbox.store.mail.model.MessageWithAttachmentMapperTest;
-import org.junit.Before;
-public class MemoryMessageWithAttachmentMapperTest extends MessageWithAttachmentMapperTest {
-
- @Override
- @Before
- public void setUp() throws Exception {
- super.setUp();
- }
+class MemoryMessageWithAttachmentMapperTest extends MessageWithAttachmentMapperTest {
@Override
protected MapperProvider createMapperProvider() {
diff --git a/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/quota/InMemoryPerUserMaxQuotaManagerTest.java b/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/quota/InMemoryPerUserMaxQuotaManagerTest.java
index 51edc31..1864f2a 100644
--- a/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/quota/InMemoryPerUserMaxQuotaManagerTest.java
+++ b/mailbox/memory/src/test/java/org/apache/james/mailbox/inmemory/quota/InMemoryPerUserMaxQuotaManagerTest.java
@@ -22,7 +22,7 @@ package org.apache.james.mailbox.inmemory.quota;
import org.apache.james.mailbox.quota.MaxQuotaManager;
import org.apache.james.mailbox.store.quota.GenericMaxQuotaManagerTest;
-public class InMemoryPerUserMaxQuotaManagerTest extends GenericMaxQuotaManagerTest {
+class InMemoryPerUserMaxQuotaManagerTest extends GenericMaxQuotaManagerTest {
@Override
protected MaxQuotaManager provideMaxQuotaManager() {
diff --git a/mailbox/store/src/test/java/org/apache/james/mailbox/store/AbstractMailboxManagerAttachmentTest.java b/mailbox/store/src/test/java/org/apache/james/mailbox/store/AbstractMailboxManagerAttachmentTest.java
index 8727d45..a2a09d8 100644
--- a/mailbox/store/src/test/java/org/apache/james/mailbox/store/AbstractMailboxManagerAttachmentTest.java
+++ b/mailbox/store/src/test/java/org/apache/james/mailbox/store/AbstractMailboxManagerAttachmentTest.java
@@ -45,7 +45,7 @@ import org.apache.james.mailbox.store.mail.MailboxMapper;
import org.apache.james.mailbox.store.mail.MessageMapper;
import org.apache.james.mailbox.store.mail.MessageMapper.FetchType;
import org.apache.james.mailbox.store.mail.model.MailboxMessage;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
import com.github.fge.lambdas.Throwing;
import com.google.common.collect.ImmutableList;
@@ -69,8 +69,8 @@ public abstract class AbstractMailboxManagerAttachmentTest {
protected abstract MailboxSessionMapperFactory getMailboxSessionMapperFactory();
protected abstract AttachmentMapperFactory getAttachmentMapperFactory();
-
- public void setUp() throws Exception {
+
+ protected void setUp() throws Exception {
mailboxSession = MailboxSessionUtil.create(USERNAME);
messageMapper = getMailboxSessionMapperFactory().getMessageMapper(mailboxSession);
mailboxMapper = getMailboxSessionMapperFactory().getMailboxMapper(mailboxSession);
@@ -83,7 +83,7 @@ public abstract class AbstractMailboxManagerAttachmentTest {
}
@Test
- public void appendMessageShouldStoreWithoutAttachmentWhenMailWithoutAttachment() throws Exception {
+ void appendMessageShouldStoreWithoutAttachmentWhenMailWithoutAttachment() throws Exception {
String mail = "Subject: Test\n\nBody";
InputStream mailInputStream = new ByteArrayInputStream(mail.getBytes());
inboxMessageManager.appendMessage(MessageManager.AppendCommand.builder()
@@ -95,7 +95,7 @@ public abstract class AbstractMailboxManagerAttachmentTest {
}
@Test
- public void appendMessageShouldStoreAttachmentWhenMailWithOneAttachment() throws Exception {
+ void appendMessageShouldStoreAttachmentWhenMailWithOneAttachment() throws Exception {
InputStream mailInputStream = ClassLoader.getSystemResourceAsStream("eml/oneAttachmentAndSomeTextInlined.eml");
inboxMessageManager.appendMessage(MessageManager.AppendCommand.builder()
.build(mailInputStream), mailboxSession);
@@ -106,7 +106,7 @@ public abstract class AbstractMailboxManagerAttachmentTest {
}
@Test
- public void appendMessageShouldStoreAttachmentNameWhenMailWithOneAttachment() throws Exception {
+ void appendMessageShouldStoreAttachmentNameWhenMailWithOneAttachment() throws Exception {
InputStream mailInputStream = ClassLoader.getSystemResourceAsStream("eml/oneAttachmentAndSomeTextInlined.eml");
inboxMessageManager.appendMessage(MessageManager.AppendCommand.builder()
.build(mailInputStream), mailboxSession);
@@ -119,7 +119,7 @@ public abstract class AbstractMailboxManagerAttachmentTest {
}
@Test
- public void appendMessageShouldStoreARetrievableAttachmentWhenMailWithOneAttachment() throws Exception {
+ void appendMessageShouldStoreARetrievableAttachmentWhenMailWithOneAttachment() throws Exception {
InputStream mailInputStream = ClassLoader.getSystemResourceAsStream("eml/oneAttachmentAndSomeTextInlined.eml");
inboxMessageManager.appendMessage(MessageManager.AppendCommand.builder()
@@ -134,7 +134,7 @@ public abstract class AbstractMailboxManagerAttachmentTest {
}
@Test
- public void appendMessageShouldStoreAttachmentsWhenMailWithTwoAttachment() throws Exception {
+ void appendMessageShouldStoreAttachmentsWhenMailWithTwoAttachment() throws Exception {
InputStream mailInputStream = ClassLoader.getSystemResourceAsStream("eml/twoAttachments.eml");
inboxMessageManager.appendMessage(MessageManager.AppendCommand.builder()
@@ -146,7 +146,7 @@ public abstract class AbstractMailboxManagerAttachmentTest {
}
@Test
- public void appendMessageShouldStoreTwoRetrievableAttachmentsWhenMailWithTwoAttachment() throws Exception {
+ void appendMessageShouldStoreTwoRetrievableAttachmentsWhenMailWithTwoAttachment() throws Exception {
InputStream mailInputStream = ClassLoader.getSystemResourceAsStream("eml/twoAttachments.eml");
inboxMessageManager.appendMessage(MessageManager.AppendCommand.builder()
@@ -173,7 +173,7 @@ public abstract class AbstractMailboxManagerAttachmentTest {
}
@Test
- public void appendMessageShouldStoreEmbeddedMailAsAttachmentWhenMailWithEmbeddedAttachment() throws Exception {
+ void appendMessageShouldStoreEmbeddedMailAsAttachmentWhenMailWithEmbeddedAttachment() throws Exception {
InputStream mailInputStream = ClassLoader.getSystemResourceAsStream("eml/embeddedAttachmentWithAttachment.eml");
inboxMessageManager.appendMessage(MessageManager.AppendCommand.builder()
@@ -185,7 +185,7 @@ public abstract class AbstractMailboxManagerAttachmentTest {
}
@Test
- public void appendMessageShouldNotStoreAnyAttachmentWhenUnparsableMail() throws Exception {
+ void appendMessageShouldNotStoreAnyAttachmentWhenUnparsableMail() throws Exception {
MailboxManager parseFailingMailboxManager = getParseFailingMailboxManager();
MessageManager parseFailingInboxMessageManager = parseFailingMailboxManager.getMailbox(inboxPath, mailboxSession);
InputStream mailInputStream = new ByteArrayInputStream("content".getBytes());
diff --git a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/AnnotationMapperTest.java b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/AnnotationMapperTest.java
index e1552fb..c00d6b2 100644
--- a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/AnnotationMapperTest.java
+++ b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/AnnotationMapperTest.java
@@ -20,15 +20,14 @@
package org.apache.james.mailbox.store.mail.model;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import org.apache.james.mailbox.exception.MailboxException;
import org.apache.james.mailbox.model.MailboxAnnotation;
import org.apache.james.mailbox.model.MailboxAnnotationKey;
import org.apache.james.mailbox.model.MailboxId;
import org.apache.james.mailbox.store.mail.AnnotationMapper;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import com.google.common.collect.ImmutableSet;
@@ -52,33 +51,31 @@ public abstract class AnnotationMapperTest {
private AnnotationMapper annotationMapper;
private MailboxId mailboxId;
- @Rule
- public ExpectedException expected = ExpectedException.none();
-
protected abstract AnnotationMapper createAnnotationMapper();
protected abstract MailboxId generateMailboxId();
- public void setUp() throws Exception {
+ @BeforeEach
+ void setUp() {
this.annotationMapper = createAnnotationMapper();
this.mailboxId = generateMailboxId();
}
@Test
- public void insertAnnotationShouldThrowExceptionWithNilData() {
- expected.expect(IllegalArgumentException.class);
- annotationMapper.insertAnnotation(mailboxId, MailboxAnnotation.nil(PRIVATE_KEY));
+ void insertAnnotationShouldThrowExceptionWithNilData() {
+ assertThatThrownBy(() -> annotationMapper.insertAnnotation(mailboxId, MailboxAnnotation.nil(PRIVATE_KEY)))
+ .isInstanceOf(IllegalArgumentException.class);
}
@Test
- public void insertAnnotationShouldCreateNewAnnotation() throws MailboxException {
+ void insertAnnotationShouldCreateNewAnnotation() {
annotationMapper.insertAnnotation(mailboxId, PRIVATE_ANNOTATION);
assertThat(annotationMapper.getAllAnnotations(mailboxId)).containsExactly(PRIVATE_ANNOTATION);
}
@Test
- public void insertAnnotationShouldUpdateExistedAnnotation() throws MailboxException {
+ void insertAnnotationShouldUpdateExistedAnnotation() {
annotationMapper.insertAnnotation(mailboxId, PRIVATE_ANNOTATION);
annotationMapper.insertAnnotation(mailboxId, PRIVATE_ANNOTATION_UPDATE);
@@ -86,7 +83,7 @@ public abstract class AnnotationMapperTest {
}
@Test
- public void deleteAnnotationShouldDeleteStoredAnnotation() throws MailboxException {
+ void deleteAnnotationShouldDeleteStoredAnnotation() {
annotationMapper.insertAnnotation(mailboxId, PRIVATE_ANNOTATION);
annotationMapper.deleteAnnotation(mailboxId, PRIVATE_KEY);
@@ -94,12 +91,12 @@ public abstract class AnnotationMapperTest {
}
@Test
- public void getEmptyAnnotationsWithNonStoredAnnotations() throws MailboxException {
+ void getEmptyAnnotationsWithNonStoredAnnotations() {
assertThat(annotationMapper.getAllAnnotations(mailboxId)).isEmpty();
}
@Test
- public void getAllAnnotationsShouldRetrieveStoredAnnotations() throws MailboxException {
+ void getAllAnnotationsShouldRetrieveStoredAnnotations() {
annotationMapper.insertAnnotation(mailboxId, PRIVATE_ANNOTATION);
annotationMapper.insertAnnotation(mailboxId, SHARED_ANNOTATION);
@@ -107,7 +104,7 @@ public abstract class AnnotationMapperTest {
}
@Test
- public void getAnnotationsByKeysShouldReturnStoredAnnotationWithFilter() throws MailboxException {
+ void getAnnotationsByKeysShouldReturnStoredAnnotationWithFilter() {
annotationMapper.insertAnnotation(mailboxId, PRIVATE_ANNOTATION);
annotationMapper.insertAnnotation(mailboxId, PRIVATE_CHILD_ANNOTATION);
@@ -116,7 +113,7 @@ public abstract class AnnotationMapperTest {
}
@Test
- public void getAnnotationsByKeysWithOneDepthShouldReturnThatEntryAndItsChildren() throws MailboxException {
+ void getAnnotationsByKeysWithOneDepthShouldReturnThatEntryAndItsChildren() {
annotationMapper.insertAnnotation(mailboxId, PRIVATE_ANNOTATION);
annotationMapper.insertAnnotation(mailboxId, PRIVATE_CHILD_ANNOTATION);
annotationMapper.insertAnnotation(mailboxId, PRIVATE_GRANDCHILD_ANNOTATION);
@@ -128,7 +125,7 @@ public abstract class AnnotationMapperTest {
}
@Test
- public void getAnnotationsByKeysWithAllDepthShouldReturnThatEntryAndAllBelowEntries() throws MailboxException {
+ void getAnnotationsByKeysWithAllDepthShouldReturnThatEntryAndAllBelowEntries() {
annotationMapper.insertAnnotation(mailboxId, PRIVATE_ANNOTATION);
annotationMapper.insertAnnotation(mailboxId, PRIVATE_CHILD_ANNOTATION);
annotationMapper.insertAnnotation(mailboxId, PRIVATE_GRANDCHILD_ANNOTATION);
@@ -140,7 +137,7 @@ public abstract class AnnotationMapperTest {
}
@Test
- public void getAnnotationsByKeysWithOneDepthShouldReturnTheChildrenEntriesEvenItDoesNotExist() throws Exception {
+ void getAnnotationsByKeysWithOneDepthShouldReturnTheChildrenEntriesEvenItDoesNotExist() {
annotationMapper.insertAnnotation(mailboxId, PRIVATE_CHILD_ANNOTATION);
annotationMapper.insertAnnotation(mailboxId, PRIVATE_GRANDCHILD_ANNOTATION);
annotationMapper.insertAnnotation(mailboxId, SHARED_ANNOTATION);
@@ -151,7 +148,7 @@ public abstract class AnnotationMapperTest {
}
@Test
- public void getAnnotationsByKeysWithAllDepthShouldReturnTheChildrenEntriesEvenItDoesNotExist() throws Exception {
+ void getAnnotationsByKeysWithAllDepthShouldReturnTheChildrenEntriesEvenItDoesNotExist() {
annotationMapper.insertAnnotation(mailboxId, PRIVATE_CHILD_ANNOTATION);
annotationMapper.insertAnnotation(mailboxId, PRIVATE_GRANDCHILD_ANNOTATION);
annotationMapper.insertAnnotation(mailboxId, SHARED_ANNOTATION);
@@ -162,7 +159,7 @@ public abstract class AnnotationMapperTest {
}
@Test
- public void getAnnotationsByKeysWithOneDepthShouldReturnEmptyWithEmptyInputKeys() throws Exception {
+ void getAnnotationsByKeysWithOneDepthShouldReturnEmptyWithEmptyInputKeys() {
annotationMapper.insertAnnotation(mailboxId, PRIVATE_CHILD_ANNOTATION);
annotationMapper.insertAnnotation(mailboxId, PRIVATE_GRANDCHILD_ANNOTATION);
annotationMapper.insertAnnotation(mailboxId, SHARED_ANNOTATION);
@@ -172,7 +169,7 @@ public abstract class AnnotationMapperTest {
}
@Test
- public void getAnnotationsByKeysWithOneDepthShouldReturnEmptyIfDoNotFind() throws Exception {
+ void getAnnotationsByKeysWithOneDepthShouldReturnEmptyIfDoNotFind() {
annotationMapper.insertAnnotation(mailboxId, SHARED_ANNOTATION);
annotationMapper.insertAnnotation(mailboxId, PRIVATE_USER_ANNOTATION);
@@ -180,7 +177,7 @@ public abstract class AnnotationMapperTest {
}
@Test
- public void getAnnotationsByKeysWithAllDepthShouldReturnEmptyIfDoNotFind() throws Exception {
+ void getAnnotationsByKeysWithAllDepthShouldReturnEmptyIfDoNotFind() {
annotationMapper.insertAnnotation(mailboxId, SHARED_ANNOTATION);
annotationMapper.insertAnnotation(mailboxId, PRIVATE_USER_ANNOTATION);
@@ -188,7 +185,7 @@ public abstract class AnnotationMapperTest {
}
@Test
- public void annotationShouldBeCaseInsentive() throws Exception {
+ void annotationShouldBeCaseInsentive() {
annotationMapper.insertAnnotation(mailboxId, PRIVATE_ANNOTATION);
annotationMapper.insertAnnotation(mailboxId, PRIVATE_ANNOTATION_WITH_KEY_UPPER);
@@ -196,24 +193,24 @@ public abstract class AnnotationMapperTest {
}
@Test
- public void isExistedShouldReturnTrueIfAnnotationIsStored() throws Exception {
+ void isExistedShouldReturnTrueIfAnnotationIsStored() {
annotationMapper.insertAnnotation(mailboxId, PRIVATE_ANNOTATION);
assertThat(annotationMapper.exist(mailboxId, PRIVATE_ANNOTATION)).isTrue();
}
@Test
- public void isExistedShouldReturnFalseIfAnnotationIsNotStored() throws Exception {
+ void isExistedShouldReturnFalseIfAnnotationIsNotStored() {
assertThat(annotationMapper.exist(mailboxId, PRIVATE_ANNOTATION)).isFalse();
}
@Test
- public void countAnnotationShouldReturnZeroIfNoMoreAnnotationBelongToMailbox() throws Exception {
+ void countAnnotationShouldReturnZeroIfNoMoreAnnotationBelongToMailbox() {
assertThat(annotationMapper.countAnnotations(mailboxId)).isEqualTo(0);
}
@Test
- public void countAnnotationShouldReturnNumberOfAnnotationBelongToMailbox() throws Exception {
+ void countAnnotationShouldReturnNumberOfAnnotationBelongToMailbox() {
annotationMapper.insertAnnotation(mailboxId, PRIVATE_ANNOTATION);
annotationMapper.insertAnnotation(mailboxId, PRIVATE_ANNOTATION_UPDATE);
annotationMapper.insertAnnotation(mailboxId, SHARED_ANNOTATION);
diff --git a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/AttachmentMapperTest.java b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/AttachmentMapperTest.java
index 7312bc7..97469eb 100644
--- a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/AttachmentMapperTest.java
+++ b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/AttachmentMapperTest.java
@@ -20,6 +20,7 @@
package org.apache.james.mailbox.store.mail.model;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.nio.charset.StandardCharsets;
import java.util.Collection;
@@ -27,49 +28,45 @@ import java.util.List;
import org.apache.james.core.Username;
import org.apache.james.mailbox.exception.AttachmentNotFoundException;
-import org.apache.james.mailbox.exception.MailboxException;
import org.apache.james.mailbox.model.Attachment;
import org.apache.james.mailbox.model.AttachmentId;
import org.apache.james.mailbox.model.MessageId;
import org.apache.james.mailbox.store.mail.AttachmentMapper;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import com.google.common.collect.ImmutableList;
public abstract class AttachmentMapperTest {
private static final AttachmentId UNKNOWN_ATTACHMENT_ID = AttachmentId.from("unknown");
- public static final Username OWNER = Username.of("owner");
- public static final Username ADDITIONAL_OWNER = Username.of("additionalOwner");
+ private static final Username OWNER = Username.of("owner");
+ private static final Username ADDITIONAL_OWNER = Username.of("additionalOwner");
private AttachmentMapper attachmentMapper;
- @Rule
- public ExpectedException expected = ExpectedException.none();
-
protected abstract AttachmentMapper createAttachmentMapper();
protected abstract MessageId generateMessageId();
- public void setUp() throws MailboxException {
+ @BeforeEach
+ void setUp() {
this.attachmentMapper = createAttachmentMapper();
}
@Test
- public void getAttachmentShouldThrowWhenNullAttachmentId() throws Exception {
- expected.expect(IllegalArgumentException.class);
- attachmentMapper.getAttachment(null);
+ void getAttachmentShouldThrowWhenNullAttachmentId() {
+ assertThatThrownBy(() -> attachmentMapper.getAttachment(null))
+ .isInstanceOf(IllegalArgumentException.class);
}
@Test
- public void getAttachmentShouldThrowWhenNonReferencedAttachmentId() throws Exception {
- expected.expect(AttachmentNotFoundException.class);
- attachmentMapper.getAttachment(UNKNOWN_ATTACHMENT_ID);
+ void getAttachmentShouldThrowWhenNonReferencedAttachmentId() {
+ assertThatThrownBy(() -> attachmentMapper.getAttachment(UNKNOWN_ATTACHMENT_ID))
+ .isInstanceOf(AttachmentNotFoundException.class);
}
@Test
- public void getAttachmentShouldReturnTheAttachmentWhenReferenced() throws Exception {
+ void getAttachmentShouldReturnTheAttachmentWhenReferenced() throws Exception {
//Given
Attachment expected = Attachment.builder()
.bytes("payload".getBytes(StandardCharsets.UTF_8))
@@ -84,7 +81,7 @@ public abstract class AttachmentMapperTest {
}
@Test
- public void getAttachmentShouldReturnTheAttachmentsWhenMultipleStored() throws Exception {
+ void getAttachmentShouldReturnTheAttachmentsWhenMultipleStored() throws Exception {
//Given
Attachment expected1 = Attachment.builder()
.bytes("payload1".getBytes(StandardCharsets.UTF_8))
@@ -106,20 +103,20 @@ public abstract class AttachmentMapperTest {
}
@Test
- public void getAttachmentsShouldThrowWhenNullAttachmentId() {
- expected.expect(IllegalArgumentException.class);
- attachmentMapper.getAttachments(null);
+ void getAttachmentsShouldThrowWhenNullAttachmentId() {
+ assertThatThrownBy(() -> attachmentMapper.getAttachments(null))
+ .isInstanceOf(IllegalArgumentException.class);
}
@Test
- public void getAttachmentsShouldReturnEmptyListWhenNonReferencedAttachmentId() {
+ void getAttachmentsShouldReturnEmptyListWhenNonReferencedAttachmentId() {
List<Attachment> attachments = attachmentMapper.getAttachments(ImmutableList.of(UNKNOWN_ATTACHMENT_ID));
assertThat(attachments).isEmpty();
}
@Test
- public void getAttachmentsShouldReturnTheAttachmentsWhenSome() throws Exception {
+ void getAttachmentsShouldReturnTheAttachmentsWhenSome() throws Exception {
//Given
Attachment expected = Attachment.builder()
.bytes("payload".getBytes(StandardCharsets.UTF_8))
@@ -142,14 +139,14 @@ public abstract class AttachmentMapperTest {
}
@Test
- public void getOwnerMessageIdsShouldReturnEmptyWhenNone() throws Exception {
+ void getOwnerMessageIdsShouldReturnEmptyWhenNone() throws Exception {
Collection<MessageId> messageIds = attachmentMapper.getRelatedMessageIds(UNKNOWN_ATTACHMENT_ID);
assertThat(messageIds).isEmpty();
}
@Test
- public void getOwnerMessageIdsShouldReturnEmptyWhenStoredWithoutMessageId() throws Exception {
+ void getOwnerMessageIdsShouldReturnEmptyWhenStoredWithoutMessageId() throws Exception {
//Given
Attachment attachment = Attachment.builder()
.bytes("payload".getBytes(StandardCharsets.UTF_8))
@@ -165,7 +162,7 @@ public abstract class AttachmentMapperTest {
}
@Test
- public void getOwnerMessageIdsShouldReturnMessageIdWhenStoredWithMessageId() throws Exception {
+ void getOwnerMessageIdsShouldReturnMessageIdWhenStoredWithMessageId() throws Exception {
//Given
Attachment attachment = Attachment.builder()
.bytes("payload".getBytes(StandardCharsets.UTF_8))
@@ -182,7 +179,7 @@ public abstract class AttachmentMapperTest {
}
@Test
- public void getOwnerMessageIdsShouldReturnTwoMessageIdsWhenStoredTwice() throws Exception {
+ void getOwnerMessageIdsShouldReturnTwoMessageIdsWhenStoredTwice() throws Exception {
//Given
Attachment attachment = Attachment.builder()
.bytes("payload".getBytes(StandardCharsets.UTF_8))
@@ -201,7 +198,7 @@ public abstract class AttachmentMapperTest {
}
@Test
- public void getOwnerMessageIdsShouldReturnOnlyMatchingMessageId() throws Exception {
+ void getOwnerMessageIdsShouldReturnOnlyMatchingMessageId() throws Exception {
//Given
Attachment attachment = Attachment.builder()
.bytes("payload".getBytes(StandardCharsets.UTF_8))
@@ -224,7 +221,7 @@ public abstract class AttachmentMapperTest {
}
@Test
- public void getOwnerMessageIdsShouldReturnOnlyOneMessageIdWhenStoredTwice() throws Exception {
+ void getOwnerMessageIdsShouldReturnOnlyOneMessageIdWhenStoredTwice() throws Exception {
//Given
Attachment attachment = Attachment.builder()
.bytes("payload".getBytes(StandardCharsets.UTF_8))
@@ -242,7 +239,7 @@ public abstract class AttachmentMapperTest {
}
@Test
- public void getOwnerMessageIdsShouldReturnMessageIdForTwoAttachmentsWhenBothStoredAtTheSameTime() throws Exception {
+ void getOwnerMessageIdsShouldReturnMessageIdForTwoAttachmentsWhenBothStoredAtTheSameTime() throws Exception {
//Given
Attachment attachment = Attachment.builder()
.bytes("payload".getBytes(StandardCharsets.UTF_8))
@@ -265,7 +262,7 @@ public abstract class AttachmentMapperTest {
}
@Test
- public void getOwnersShouldBeRetrievedWhenExplicitlySpecified() throws Exception {
+ void getOwnersShouldBeRetrievedWhenExplicitlySpecified() throws Exception {
//Given
Attachment attachment = Attachment.builder()
.bytes("payload".getBytes(StandardCharsets.UTF_8))
@@ -283,7 +280,7 @@ public abstract class AttachmentMapperTest {
}
@Test
- public void getOwnersShouldReturnEmptyWhenMessageIdReferenced() throws Exception {
+ void getOwnersShouldReturnEmptyWhenMessageIdReferenced() throws Exception {
//Given
Attachment attachment = Attachment.builder()
.bytes("payload".getBytes(StandardCharsets.UTF_8))
@@ -300,7 +297,7 @@ public abstract class AttachmentMapperTest {
}
@Test
- public void getOwnersShouldReturnAllOwners() throws Exception {
+ void getOwnersShouldReturnAllOwners() throws Exception {
//Given
Attachment attachment = Attachment.builder()
.bytes("payload".getBytes(StandardCharsets.UTF_8))
@@ -319,7 +316,7 @@ public abstract class AttachmentMapperTest {
}
@Test
- public void getOwnersShouldReturnEmptyWhenUnknownAttachmentId() throws Exception {
+ void getOwnersShouldReturnEmptyWhenUnknownAttachmentId() throws Exception {
Collection<Username> actualOwners = attachmentMapper.getOwners(AttachmentId.from("any"));
assertThat(actualOwners).isEmpty();
diff --git a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MailboxMapperACLTest.java b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MailboxMapperACLTest.java
index 9e9d07a..1815659 100644
--- a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MailboxMapperACLTest.java
+++ b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MailboxMapperACLTest.java
@@ -32,32 +32,29 @@ import org.apache.james.mailbox.model.MailboxACL.Right;
import org.apache.james.mailbox.model.MailboxId;
import org.apache.james.mailbox.model.MailboxPath;
import org.apache.james.mailbox.store.mail.MailboxMapper;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import com.google.common.collect.ImmutableMap;
public abstract class MailboxMapperACLTest {
private static final long UID_VALIDITY = 42;
- public static final boolean POSITIVE = true;
- public static final boolean NEGATIVE = !POSITIVE;
+ private static final boolean POSITIVE = true;
+ private static final boolean NEGATIVE = !POSITIVE;
private static final Username USER = Username.of("user");
private static final Username USER_1 = Username.of("user1");
private static final Username USER_2 = Username.of("user2");
private Mailbox benwaInboxMailbox;
- @Rule
- public ExpectedException expected = ExpectedException.none();
-
private MailboxMapper mailboxMapper;
protected abstract MailboxMapper createMailboxMapper();
protected abstract MailboxId generateId();
- public void setUp() throws Exception {
+ @BeforeEach
+ void setUp() throws Exception {
mailboxMapper = createMailboxMapper();
MailboxPath benwaInboxPath = MailboxPath.forUser(Username.of("benwa"), "INBOX");
benwaInboxMailbox = createMailbox(benwaInboxPath);
@@ -65,7 +62,7 @@ public abstract class MailboxMapperACLTest {
}
@Test
- public void storedAclShouldBeEmptyByDefault() throws MailboxException {
+ void storedAclShouldBeEmptyByDefault() throws MailboxException {
assertThat(
mailboxMapper.findMailboxById(benwaInboxMailbox.getMailboxId())
.getACL()
@@ -74,7 +71,7 @@ public abstract class MailboxMapperACLTest {
}
@Test
- public void updateAclShouldSaveAclWhenReplace() throws MailboxException {
+ void updateAclShouldSaveAclWhenReplace() throws MailboxException {
EntryKey key = EntryKey.createUserEntryKey(USER);
Rfc4314Rights rights = new Rfc4314Rights(Right.Administer, Right.PerformExpunge, Right.Write, Right.WriteSeenFlag);
mailboxMapper.updateACL(benwaInboxMailbox, MailboxACL.command().key(key).rights(rights).asReplacement());
@@ -88,7 +85,7 @@ public abstract class MailboxMapperACLTest {
}
@Test
- public void updateAclShouldOverwriteStoredAclWhenReplace() throws MailboxException {
+ void updateAclShouldOverwriteStoredAclWhenReplace() throws MailboxException {
EntryKey key = EntryKey.createUserEntryKey(USER);
Rfc4314Rights rights = new Rfc4314Rights(Right.Administer, Right.PerformExpunge, Right.Write, Right.WriteSeenFlag);
Rfc4314Rights newRights = new Rfc4314Rights(Right.WriteSeenFlag, Right.CreateMailbox, Right.Administer, Right.PerformExpunge, Right.DeleteMessages);
@@ -105,7 +102,7 @@ public abstract class MailboxMapperACLTest {
}
@Test
- public void updateAclShouldTreatNegativeAndPositiveRightSeparately() throws MailboxException {
+ void updateAclShouldTreatNegativeAndPositiveRightSeparately() throws MailboxException {
EntryKey key1 = EntryKey.createUserEntryKey(USER, NEGATIVE);
EntryKey key2 = EntryKey.createUserEntryKey(USER, POSITIVE);
Rfc4314Rights rights = new Rfc4314Rights(Right.Administer, Right.PerformExpunge, Right.Write, Right.WriteSeenFlag);
@@ -123,7 +120,7 @@ public abstract class MailboxMapperACLTest {
}
@Test
- public void updateAclShouldTreatNameTypesRightSeparately() throws MailboxException {
+ void updateAclShouldTreatNameTypesRightSeparately() throws MailboxException {
EntryKey key1 = EntryKey.createUserEntryKey(USER);
EntryKey key2 = EntryKey.createGroupEntryKey(USER.asString());
Rfc4314Rights rights = new Rfc4314Rights(Right.Administer, Right.PerformExpunge, Right.Write, Right.WriteSeenFlag);
@@ -141,7 +138,7 @@ public abstract class MailboxMapperACLTest {
}
@Test
- public void updateAclShouldCleanAclEntryWhenEmptyReplace() throws MailboxException {
+ void updateAclShouldCleanAclEntryWhenEmptyReplace() throws MailboxException {
EntryKey key = EntryKey.createUserEntryKey(USER);
Rfc4314Rights rights = new Rfc4314Rights(Right.Administer, Right.PerformExpunge, Right.Write, Right.WriteSeenFlag);
Rfc4314Rights newRights = new Rfc4314Rights();
@@ -156,7 +153,7 @@ public abstract class MailboxMapperACLTest {
}
@Test
- public void updateAclShouldCombineStoredAclWhenAdd() throws MailboxException {
+ void updateAclShouldCombineStoredAclWhenAdd() throws MailboxException {
EntryKey key = EntryKey.createUserEntryKey(USER);
Rfc4314Rights rights = new Rfc4314Rights(Right.Administer, Right.PerformExpunge, Right.Write, Right.WriteSeenFlag);
Rfc4314Rights newRights = new Rfc4314Rights(Right.WriteSeenFlag, Right.CreateMailbox, Right.Administer, Right.PerformExpunge, Right.DeleteMessages);
@@ -173,7 +170,7 @@ public abstract class MailboxMapperACLTest {
}
@Test
- public void removeAclShouldRemoveSomeStoredAclWhenAdd() throws MailboxException {
+ void removeAclShouldRemoveSomeStoredAclWhenAdd() throws MailboxException {
EntryKey key = EntryKey.createUserEntryKey(USER);
Rfc4314Rights rights = new Rfc4314Rights(Right.Administer, Right.PerformExpunge, Right.Write, Right.WriteSeenFlag);
Rfc4314Rights removedRights = new Rfc4314Rights(Right.WriteSeenFlag, Right.PerformExpunge);
@@ -190,7 +187,7 @@ public abstract class MailboxMapperACLTest {
}
@Test
- public void removeAclShouldNotFailWhenRemovingNonExistingRight() throws MailboxException {
+ void removeAclShouldNotFailWhenRemovingNonExistingRight() throws MailboxException {
EntryKey key = EntryKey.createUserEntryKey(USER);
Rfc4314Rights rights = new Rfc4314Rights(Right.Administer, Right.PerformExpunge, Right.Write, Right.WriteSeenFlag);
Rfc4314Rights removedRights = new Rfc4314Rights(Right.WriteSeenFlag, Right.PerformExpunge, Right.Lookup);
@@ -207,7 +204,7 @@ public abstract class MailboxMapperACLTest {
}
@Test
- public void resetAclShouldReplaceStoredAcl() throws MailboxException {
+ void resetAclShouldReplaceStoredAcl() throws MailboxException {
EntryKey key = EntryKey.createUserEntryKey(USER);
Rfc4314Rights rights = new Rfc4314Rights(Right.Administer, Right.PerformExpunge, Right.Write, Right.WriteSeenFlag);
Rfc4314Rights newRights = new Rfc4314Rights(Right.WriteSeenFlag, Right.CreateMailbox, Right.Administer, Right.PerformExpunge, Right.DeleteMessages);
@@ -223,7 +220,7 @@ public abstract class MailboxMapperACLTest {
}
@Test
- public void resetAclShouldInitializeStoredAcl() throws MailboxException {
+ void resetAclShouldInitializeStoredAcl() throws MailboxException {
EntryKey key = EntryKey.createUserEntryKey(USER);
Rfc4314Rights rights = new Rfc4314Rights(Right.WriteSeenFlag, Right.CreateMailbox, Right.Administer, Right.PerformExpunge, Right.DeleteMessages);
mailboxMapper.setACL(benwaInboxMailbox,
@@ -244,12 +241,12 @@ public abstract class MailboxMapperACLTest {
}
@Test
- public void findMailboxesShouldReturnEmptyWhenNone() throws MailboxException {
+ void findMailboxesShouldReturnEmptyWhenNone() throws MailboxException {
assertThat(mailboxMapper.findNonPersonalMailboxes(USER, Right.Administer)).isEmpty();
}
@Test
- public void findMailboxesShouldReturnEmptyWhenRightDoesntMatch() throws MailboxException {
+ void findMailboxesShouldReturnEmptyWhenRightDoesntMatch() throws MailboxException {
EntryKey key = EntryKey.createUserEntryKey(USER);
Rfc4314Rights rights = new Rfc4314Rights(Right.Administer);
mailboxMapper.updateACL(benwaInboxMailbox,
@@ -262,7 +259,7 @@ public abstract class MailboxMapperACLTest {
}
@Test
- public void updateACLShouldInsertUsersRights() throws MailboxException {
+ void updateACLShouldInsertUsersRights() throws MailboxException {
Rfc4314Rights rights = new Rfc4314Rights(Right.Administer, Right.PerformExpunge);
mailboxMapper.updateACL(benwaInboxMailbox,
MailboxACL.command()
@@ -275,7 +272,7 @@ public abstract class MailboxMapperACLTest {
}
@Test
- public void updateACLShouldOverwriteUsersRights() throws MailboxException {
+ void updateACLShouldOverwriteUsersRights() throws MailboxException {
EntryKey key = EntryKey.createUserEntryKey(USER);
Rfc4314Rights initialRights = new Rfc4314Rights(Right.Administer);
mailboxMapper.updateACL(benwaInboxMailbox,
@@ -298,7 +295,7 @@ public abstract class MailboxMapperACLTest {
}
@Test
- public void findMailboxesShouldNotReportDeletedACLViaReplace() throws MailboxException {
+ void findMailboxesShouldNotReportDeletedACLViaReplace() throws MailboxException {
EntryKey key = EntryKey.createUserEntryKey(USER);
Rfc4314Rights initialRights = new Rfc4314Rights(Right.Administer);
mailboxMapper.updateACL(benwaInboxMailbox,
@@ -319,7 +316,7 @@ public abstract class MailboxMapperACLTest {
}
@Test
- public void findMailboxesShouldNotReportDeletedACLViaRemove() throws MailboxException {
+ void findMailboxesShouldNotReportDeletedACLViaRemove() throws MailboxException {
EntryKey key = EntryKey.createUserEntryKey(USER);
Rfc4314Rights initialRights = new Rfc4314Rights(Right.Administer);
mailboxMapper.updateACL(benwaInboxMailbox,
@@ -338,7 +335,7 @@ public abstract class MailboxMapperACLTest {
}
@Test
- public void findMailboxesShouldNotReportDeletedMailboxes() throws MailboxException {
+ void findMailboxesShouldNotReportDeletedMailboxes() throws MailboxException {
EntryKey key = EntryKey.createUserEntryKey(USER);
Rfc4314Rights initialRights = new Rfc4314Rights(Right.Administer);
mailboxMapper.updateACL(benwaInboxMailbox,
@@ -353,7 +350,7 @@ public abstract class MailboxMapperACLTest {
}
@Test
- public void setACLShouldStoreMultipleUsersRights() throws MailboxException {
+ void setACLShouldStoreMultipleUsersRights() throws MailboxException {
EntryKey user1 = EntryKey.createUserEntryKey(USER_1);
EntryKey user2 = EntryKey.createUserEntryKey(USER_2);
@@ -368,7 +365,7 @@ public abstract class MailboxMapperACLTest {
}
@Test
- public void findMailboxesShouldNotReportRightsRemovedViaSetAcl() throws MailboxException {
+ void findMailboxesShouldNotReportRightsRemovedViaSetAcl() throws MailboxException {
EntryKey user1 = EntryKey.createUserEntryKey(USER_1);
EntryKey user2 = EntryKey.createUserEntryKey(USER_2);
@@ -384,7 +381,7 @@ public abstract class MailboxMapperACLTest {
}
@Test
- public void findMailboxesShouldReportRightsUpdatedViaSetAcl() throws MailboxException {
+ void findMailboxesShouldReportRightsUpdatedViaSetAcl() throws MailboxException {
EntryKey user1 = EntryKey.createUserEntryKey(USER_1);
EntryKey user2 = EntryKey.createUserEntryKey(USER_2);
@@ -400,7 +397,7 @@ public abstract class MailboxMapperACLTest {
}
@Test
- public void findMailboxByPathShouldReturnMailboxWithACL() throws MailboxException {
+ void findMailboxByPathShouldReturnMailboxWithACL() throws MailboxException {
EntryKey key = EntryKey.createUserEntryKey(USER);
Rfc4314Rights rights = new Rfc4314Rights(Right.WriteSeenFlag, Right.CreateMailbox, Right.Administer, Right.PerformExpunge, Right.DeleteMessages);
mailboxMapper.setACL(benwaInboxMailbox,
@@ -415,7 +412,7 @@ public abstract class MailboxMapperACLTest {
}
@Test
- public void setACLShouldReturnACLDiff() throws MailboxException {
+ void setACLShouldReturnACLDiff() throws MailboxException {
EntryKey key = EntryKey.createUserEntryKey(USER);
Rfc4314Rights rights = new Rfc4314Rights(Right.WriteSeenFlag, Right.CreateMailbox, Right.Administer, Right.PerformExpunge, Right.DeleteMessages);
@@ -430,7 +427,7 @@ public abstract class MailboxMapperACLTest {
}
@Test
- public void updateACLShouldReturnACLDiff() throws MailboxException {
+ void updateACLShouldReturnACLDiff() throws MailboxException {
EntryKey key = EntryKey.createUserEntryKey(USER);
Rfc4314Rights rights = new Rfc4314Rights(Right.WriteSeenFlag, Right.CreateMailbox, Right.Administer, Right.PerformExpunge, Right.DeleteMessages);
diff --git a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MailboxMapperTest.java b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MailboxMapperTest.java
index 2c4efef..00be365 100644
--- a/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MailboxMapperTest.java
+++ b/mailbox/store/src/test/java/org/apache/james/mailbox/store/mail/model/MailboxMapperTest.java
@@ -37,7 +37,8 @@ import org.apache.james.mailbox.model.search.ExactName;
import org.apache.james.mailbox.model.search.MailboxQuery;
import org.apache.james.mailbox.model.search.PrefixedWildcard;
import org.apache.james.mailbox.store.mail.MailboxMapper;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
/**
* Generic purpose tests for your implementation MailboxMapper.
@@ -47,7 +48,6 @@ import org.junit.Test;
public abstract class MailboxMapperTest {
private static final char DELIMITER = '.';
- private static final char WILDCARD = '%';
private static final long UID_VALIDITY = 42;
private static final Username BENWA = Username.of("benwa");
@@ -74,26 +74,27 @@ public abstract class MailboxMapperTest {
protected abstract MailboxId generateId();
- public void setUp() throws Exception {
+ @BeforeEach
+ void setUp() {
this.mailboxMapper = createMailboxMapper();
initData();
}
@Test
- public void findMailboxByPathWhenAbsentShouldFail() throws MailboxException {
+ void findMailboxByPathWhenAbsentShouldFail() throws MailboxException {
assertThatThrownBy(() -> mailboxMapper.findMailboxByPath(MailboxPath.forUser(BENWA, "INBOX")))
.isInstanceOf(MailboxNotFoundException.class);
}
@Test
- public void saveShouldPersistTheMailbox() throws MailboxException {
+ void saveShouldPersistTheMailbox() throws MailboxException {
mailboxMapper.save(benwaInboxMailbox);
MailboxAssert.assertThat(mailboxMapper.findMailboxByPath(benwaInboxPath)).isEqualTo(benwaInboxMailbox);
}
@Test
- public void saveShouldThrowWhenMailboxAlreadyExist() throws MailboxException {
+ void saveShouldThrowWhenMailboxAlreadyExist() throws MailboxException {
mailboxMapper.save(benwaInboxMailbox);
Mailbox mailbox = new Mailbox(benwaInboxMailbox);
@@ -104,7 +105,7 @@ public abstract class MailboxMapperTest {
}
@Test
- public void listShouldRetrieveAllMailbox() throws MailboxException {
+ void listShouldRetrieveAllMailbox() throws MailboxException {
saveAll();
List<Mailbox> mailboxes = mailboxMapper.list();
@@ -114,25 +115,25 @@ public abstract class MailboxMapperTest {
}
@Test
- public void hasChildrenShouldReturnFalseWhenNoChildrenExists() throws MailboxException {
+ void hasChildrenShouldReturnFalseWhenNoChildrenExists() throws MailboxException {
saveAll();
assertThat(mailboxMapper.hasChildren(benwaWorkTodoMailbox, DELIMITER)).isFalse();
}
@Test
- public void hasChildrenShouldReturnTrueWhenChildrenExists() throws MailboxException {
+ void hasChildrenShouldReturnTrueWhenChildrenExists() throws MailboxException {
saveAll();
assertThat(mailboxMapper.hasChildren(benwaInboxMailbox, DELIMITER)).isTrue();
}
@Test
- public void hasChildrenShouldNotBeAcrossUsersAndNamespace() throws MailboxException {
+ void hasChildrenShouldNotBeAcrossUsersAndNamespace() throws MailboxException {
saveAll();
assertThat(mailboxMapper.hasChildren(bobInboxMailbox, '.')).isFalse();
}
@Test
- public void findMailboxWithPathLikeShouldBeLimitedToUserAndNamespace() throws MailboxException {
+ void findMailboxWithPathLikeShouldBeLimitedToUserAndNamespace() throws MailboxException {
saveAll();
MailboxQuery.UserBound mailboxQuery = MailboxQuery.builder()
.userAndNamespaceFrom(bobInboxPath)
@@ -146,7 +147,7 @@ public abstract class MailboxMapperTest {
}
@Test
- public void deleteShouldEraseTheGivenMailbox() throws MailboxException {
+ void deleteShouldEraseTheGivenMailbox() throws MailboxException {
saveAll();
mailboxMapper.delete(benwaInboxMailbox);
@@ -155,7 +156,7 @@ public abstract class MailboxMapperTest {
}
@Test
- public void findMailboxWithPathLikeWithChildRegexShouldRetrieveChildren() throws MailboxException {
+ void findMailboxWithPathLikeWithChildRegexShouldRetrieveChildren() throws MailboxException {
saveAll();
MailboxQuery.UserBound mailboxQuery = MailboxQuery.builder()
.userAndNamespaceFrom(benwaWorkPath)
@@ -169,7 +170,7 @@ public abstract class MailboxMapperTest {
}
@Test
- public void findMailboxWithPathLikeWithRegexShouldRetrieveCorrespondingMailbox() throws MailboxException {
+ void findMailboxWithPathLikeWithRegexShouldRetrieveCorrespondingMailbox() throws MailboxException {
saveAll();
MailboxQuery.UserBound mailboxQuery = MailboxQuery.builder()
.userAndNamespaceFrom(benwaWorkPath)
@@ -183,7 +184,7 @@ public abstract class MailboxMapperTest {
}
@Test
- public void findMailboxWithPathLikeShouldEscapeMailboxName() throws MailboxException {
+ void findMailboxWithPathLikeShouldEscapeMailboxName() throws MailboxException {
saveAll();
MailboxQuery.UserBound mailboxQuery = MailboxQuery.builder()
.userAndNamespaceFrom(benwaInboxPath)
@@ -195,14 +196,14 @@ public abstract class MailboxMapperTest {
}
@Test
- public void findMailboxByIdShouldReturnExistingMailbox() throws MailboxException {
+ void findMailboxByIdShouldReturnExistingMailbox() throws MailboxException {
saveAll();
Mailbox actual = mailboxMapper.findMailboxById(benwaInboxMailbox.getMailboxId());
MailboxAssert.assertThat(actual).isEqualTo(benwaInboxMailbox);
}
@Test
- public void findMailboxByIdShouldFailWhenAbsent() throws MailboxException {
+ void findMailboxByIdShouldFailWhenAbsent() throws MailboxException {
saveAll();
MailboxId removed = benwaInboxMailbox.getMailboxId();
mailboxMapper.delete(benwaInboxMailbox);
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 264f2bc..349b39c 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
@@ -20,6 +20,7 @@
package org.apache.james.mailbox.store.mail.model;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.time.Duration;
import java.util.Date;
@@ -50,9 +51,8 @@ import org.apache.james.mailbox.store.mail.model.impl.SimpleMailboxMessage;
import org.apache.james.util.concurrency.ConcurrentTestRunner;
import org.assertj.core.data.MapEntry;
import org.junit.Assume;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import com.github.steveash.guavate.Guavate;
import com.google.common.collect.ImmutableList;
@@ -61,9 +61,6 @@ import com.google.common.collect.ImmutableMultimap;
public abstract class MessageIdMapperTest {
private static final Username BENWA = Username.of("benwa");
- @Rule
- public ExpectedException expectedException = ExpectedException.none();
-
private static final char DELIMITER = '.';
private static final int BODY_START = 16;
protected static final long UID_VALIDITY = 42;
@@ -72,21 +69,20 @@ public abstract class MessageIdMapperTest {
private MailboxMapper mailboxMapper;
private MessageIdMapper sut;
- protected Mailbox benwaInboxMailbox;
- protected Mailbox benwaWorkMailbox;
+ private Mailbox benwaInboxMailbox;
+ private Mailbox benwaWorkMailbox;
protected SimpleMailboxMessage message1;
protected SimpleMailboxMessage message2;
protected SimpleMailboxMessage message3;
protected SimpleMailboxMessage message4;
- @Rule
- public ExpectedException expected = ExpectedException.none();
private MapperProvider mapperProvider;
protected abstract MapperProvider provideMapper();
- public void setUp() throws MailboxException {
+ @BeforeEach
+ void setUp() throws MailboxException {
this.mapperProvider = provideMapper();
Assume.assumeTrue(mapperProvider.getSupportedCapabilities().contains(MapperProvider.Capabilities.UNIQUE_MESSAGE_ID));
@@ -104,45 +100,45 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void findShouldReturnEmptyWhenIdListIsEmpty() {
+ void findShouldReturnEmptyWhenIdListIsEmpty() {
assertThat(sut.find(ImmutableList.of(), FetchType.Full)).isEmpty();
}
@Test
- public void findShouldReturnOneMessageWhenIdListContainsOne() throws MailboxException {
+ void findShouldReturnOneMessageWhenIdListContainsOne() throws MailboxException {
saveMessages();
List<MailboxMessage> messages = sut.find(ImmutableList.of(message1.getMessageId()), FetchType.Full);
assertThat(messages).containsOnly(message1);
}
@Test
- public void findShouldReturnMultipleMessagesWhenIdContainsMultiple() throws MailboxException {
+ 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);
}
@Test
- public void findShouldReturnMultipleMessagesWhenIdContainsMultipleInDifferentMailboxes() throws MailboxException {
+ 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);
}
@Test
- public void findMailboxesShouldReturnEmptyWhenMessageDoesntExist() {
+ void findMailboxesShouldReturnEmptyWhenMessageDoesntExist() {
assertThat(sut.findMailboxes(mapperProvider.generateMessageId())).isEmpty();
}
@Test
- public void findMailboxesShouldReturnOneMailboxWhenMessageExistsInOneMailbox() throws MailboxException {
+ void findMailboxesShouldReturnOneMailboxWhenMessageExistsInOneMailbox() throws MailboxException {
saveMessages();
List<MailboxId> mailboxes = sut.findMailboxes(message1.getMessageId());
assertThat(mailboxes).containsOnly(benwaInboxMailbox.getMailboxId());
}
@Test
- public void findMailboxesShouldReturnTwoMailboxesWhenMessageExistsInTwoMailboxes() throws MailboxException {
+ void findMailboxesShouldReturnTwoMailboxesWhenMessageExistsInTwoMailboxes() throws MailboxException {
saveMessages();
SimpleMailboxMessage message1InOtherMailbox = SimpleMailboxMessage.copy(benwaWorkMailbox.getMailboxId(), message1);
@@ -155,7 +151,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void saveShouldSaveAMessage() throws Exception {
+ void saveShouldSaveAMessage() throws Exception {
message1.setUid(mapperProvider.generateMessageUid());
message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox));
sut.save(message1);
@@ -164,19 +160,19 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void saveShouldThrowWhenMailboxDoesntExist() throws Exception {
+ void saveShouldThrowWhenMailboxDoesntExist() throws Exception {
Mailbox notPersistedMailbox = new Mailbox(MailboxPath.forUser(BENWA, "mybox"), UID_VALIDITY);
notPersistedMailbox.setMailboxId(mapperProvider.generateId());
SimpleMailboxMessage message = createMessage(notPersistedMailbox, "Subject: Test \n\nBody\n.\n", BODY_START, new PropertyBuilder());
message.setUid(mapperProvider.generateMessageUid());
message.setModSeq(mapperProvider.generateModSeq(notPersistedMailbox));
- expectedException.expect(MailboxNotFoundException.class);
- sut.save(message);
+ assertThatThrownBy(() -> sut.save(message))
+ .isInstanceOf(MailboxNotFoundException.class);
}
@Test
- public void saveShouldSaveMessageInAnotherMailboxWhenMessageAlreadyInOneMailbox() throws Exception {
+ void saveShouldSaveMessageInAnotherMailboxWhenMessageAlreadyInOneMailbox() throws Exception {
message1.setUid(mapperProvider.generateMessageUid());
message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox));
sut.save(message1);
@@ -191,7 +187,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void saveShouldWorkWhenSavingTwoTimesWithSameMessageIdAndSameMailboxId() throws Exception {
+ void saveShouldWorkWhenSavingTwoTimesWithSameMessageIdAndSameMailboxId() throws Exception {
message1.setUid(mapperProvider.generateMessageUid());
message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox));
sut.save(message1);
@@ -205,7 +201,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void copyInMailboxShouldThrowWhenMailboxDoesntExist() throws Exception {
+ void copyInMailboxShouldThrowWhenMailboxDoesntExist() throws Exception {
message1.setUid(mapperProvider.generateMessageUid());
message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox));
sut.save(message1);
@@ -217,12 +213,12 @@ public abstract class MessageIdMapperTest {
message1InOtherMailbox.setUid(mapperProvider.generateMessageUid());
message1InOtherMailbox.setModSeq(mapperProvider.generateModSeq(benwaWorkMailbox));
- expectedException.expect(MailboxNotFoundException.class);
- sut.copyInMailbox(message1InOtherMailbox);
+ assertThatThrownBy(() -> sut.copyInMailbox(message1InOtherMailbox))
+ .isInstanceOf(MailboxNotFoundException.class);
}
@Test
- public void copyInMailboxShouldSaveMessageInAnotherMailbox() throws Exception {
+ void copyInMailboxShouldSaveMessageInAnotherMailbox() throws Exception {
message1.setUid(mapperProvider.generateMessageUid());
message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox));
sut.save(message1);
@@ -237,7 +233,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void copyInMailboxShouldWorkWhenSavingTwoTimesWithSameMessageIdAndSameMailboxId() throws Exception {
+ void copyInMailboxShouldWorkWhenSavingTwoTimesWithSameMessageIdAndSameMailboxId() throws Exception {
message1.setUid(mapperProvider.generateMessageUid());
message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox));
sut.save(message1);
@@ -256,12 +252,12 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void deleteShouldNotThrowWhenUnknownMessage() {
+ void deleteShouldNotThrowWhenUnknownMessage() {
sut.delete(message1.getMessageId());
}
@Test
- public void deleteShouldDeleteAMessage() throws Exception {
+ void deleteShouldDeleteAMessage() throws Exception {
message1.setUid(mapperProvider.generateMessageUid());
message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox));
sut.save(message1);
@@ -274,7 +270,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void deleteShouldDeleteMessageIndicesWhenStoredInTwoMailboxes() throws Exception {
+ void deleteShouldDeleteMessageIndicesWhenStoredInTwoMailboxes() throws Exception {
message1.setUid(mapperProvider.generateMessageUid());
message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox));
sut.save(message1);
@@ -292,7 +288,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void deleteShouldDeleteMessageIndicesWhenStoredTwoTimesInTheSameMailbox() throws Exception {
+ void deleteShouldDeleteMessageIndicesWhenStoredTwoTimesInTheSameMailbox() throws Exception {
message1.setUid(mapperProvider.generateMessageUid());
message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox));
sut.save(message1);
@@ -309,7 +305,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void deleteWithMailboxIdsShouldNotDeleteIndicesWhenMailboxIdsIsEmpty() throws Exception {
+ void deleteWithMailboxIdsShouldNotDeleteIndicesWhenMailboxIdsIsEmpty() throws Exception {
message1.setUid(mapperProvider.generateMessageUid());
message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox));
sut.save(message1);
@@ -327,7 +323,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void deleteWithMailboxIdsShouldDeleteOneIndexWhenMailboxIdsContainsOneElement() throws Exception {
+ void deleteWithMailboxIdsShouldDeleteOneIndexWhenMailboxIdsContainsOneElement() throws Exception {
message1.setUid(mapperProvider.generateMessageUid());
message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox));
sut.save(message1);
@@ -345,7 +341,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void deleteWithMailboxIdsShouldDeleteIndicesWhenMailboxIdsContainsMultipleElements() throws Exception {
+ void deleteWithMailboxIdsShouldDeleteIndicesWhenMailboxIdsContainsMultipleElements() throws Exception {
message1.setUid(mapperProvider.generateMessageUid());
message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox));
sut.save(message1);
@@ -363,7 +359,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void setFlagsShouldReturnUpdatedFlagsWhenMessageIsInOneMailbox() throws Exception {
+ void setFlagsShouldReturnUpdatedFlagsWhenMessageIsInOneMailbox() throws Exception {
message1.setUid(mapperProvider.generateMessageUid());
message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox));
sut.save(message1);
@@ -383,7 +379,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void setFlagsShouldReturnUpdatedFlagsWhenReplaceMode() throws Exception {
+ void setFlagsShouldReturnUpdatedFlagsWhenReplaceMode() throws Exception {
Flags messageFlags = new FlagsBuilder().add(Flags.Flag.RECENT, Flags.Flag.FLAGGED)
.build();
@@ -411,7 +407,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void setFlagsShouldReturnUpdatedFlagsWhenRemoveMode() throws Exception {
+ void setFlagsShouldReturnUpdatedFlagsWhenRemoveMode() throws Exception {
Flags messageFlags = new FlagsBuilder().add(Flags.Flag.RECENT, Flags.Flag.FLAGGED)
.build();
@@ -439,7 +435,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void setFlagsShouldUpdateMessageFlagsWhenRemoveMode() throws Exception {
+ void setFlagsShouldUpdateMessageFlagsWhenRemoveMode() throws Exception {
Flags messageFlags = new FlagsBuilder().add(Flags.Flag.RECENT, Flags.Flag.FLAGGED)
.build();
@@ -462,7 +458,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void setFlagsShouldReturnEmptyWhenMailboxIdsIsEmpty() throws Exception {
+ void setFlagsShouldReturnEmptyWhenMailboxIdsIsEmpty() throws Exception {
message1.setUid(mapperProvider.generateMessageUid());
message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox));
sut.save(message1);
@@ -475,7 +471,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void setFlagsShouldReturnEmptyWhenMessageIdDoesntExist() throws Exception {
+ 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);
@@ -483,7 +479,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void setFlagsShouldAddFlagsWhenAddUpdateMode() throws Exception {
+ void setFlagsShouldAddFlagsWhenAddUpdateMode() throws Exception {
Flags initialFlags = new Flags(Flag.RECENT);
message1.setUid(mapperProvider.generateMessageUid());
message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox));
@@ -509,7 +505,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void setFlagsShouldReturnUpdatedFlagsWhenMessageIsInTwoMailboxes() throws Exception {
+ void setFlagsShouldReturnUpdatedFlagsWhenMessageIsInTwoMailboxes() throws Exception {
message1.setUid(mapperProvider.generateMessageUid());
message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox));
sut.save(message1);
@@ -542,7 +538,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void setFlagsShouldUpdateFlagsWhenMessageIsInOneMailbox() throws Exception {
+ void setFlagsShouldUpdateFlagsWhenMessageIsInOneMailbox() throws Exception {
message1.setUid(mapperProvider.generateMessageUid());
message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox));
sut.save(message1);
@@ -556,7 +552,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void setFlagsShouldNotModifyModSeqWhenMailboxIdsIsEmpty() throws Exception {
+ void setFlagsShouldNotModifyModSeqWhenMailboxIdsIsEmpty() throws Exception {
message1.setUid(mapperProvider.generateMessageUid());
long modSeq = mapperProvider.generateModSeq(benwaInboxMailbox);
message1.setModSeq(modSeq);
@@ -572,7 +568,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void setFlagsShouldUpdateModSeqWhenMessageIsInOneMailbox() throws Exception {
+ void setFlagsShouldUpdateModSeqWhenMessageIsInOneMailbox() throws Exception {
message1.setUid(mapperProvider.generateMessageUid());
long modSeq = mapperProvider.generateModSeq(benwaInboxMailbox);
message1.setModSeq(modSeq);
@@ -587,7 +583,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void setFlagsShouldNotModifyFlagsWhenMailboxIdsIsEmpty() throws Exception {
+ void setFlagsShouldNotModifyFlagsWhenMailboxIdsIsEmpty() throws Exception {
message1.setUid(mapperProvider.generateMessageUid());
long modSeq = mapperProvider.generateModSeq(benwaInboxMailbox);
message1.setModSeq(modSeq);
@@ -605,7 +601,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void setFlagsShouldUpdateFlagsWhenMessageIsInTwoMailboxes() throws Exception {
+ void setFlagsShouldUpdateFlagsWhenMessageIsInTwoMailboxes() throws Exception {
message1.setUid(mapperProvider.generateMessageUid());
message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox));
sut.save(message1);
@@ -625,7 +621,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void setFlagsShouldWorkWhenCalledOnFirstMessage() throws Exception {
+ void setFlagsShouldWorkWhenCalledOnFirstMessage() throws Exception {
message1.setUid(mapperProvider.generateMessageUid());
message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox));
sut.save(message1);
@@ -648,7 +644,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void setFlagsShouldWorkWhenCalledOnDuplicatedMailbox() throws Exception {
+ void setFlagsShouldWorkWhenCalledOnDuplicatedMailbox() throws Exception {
message1.setUid(mapperProvider.generateMessageUid());
message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox));
sut.save(message1);
@@ -671,7 +667,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void setFlagsShouldWorkWithConcurrencyWithAdd() throws Exception {
+ void setFlagsShouldWorkWithConcurrencyWithAdd() throws Exception {
Assume.assumeTrue(mapperProvider.getSupportedCapabilities().contains(MapperProvider.Capabilities.THREAD_SAFE_FLAGS_UPDATE));
message1.setUid(mapperProvider.generateMessageUid());
message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox));
@@ -694,7 +690,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void setFlagsShouldWorkWithConcurrencyWithRemove() throws Exception {
+ void setFlagsShouldWorkWithConcurrencyWithRemove() throws Exception {
Assume.assumeTrue(mapperProvider.getSupportedCapabilities().contains(MapperProvider.Capabilities.THREAD_SAFE_FLAGS_UPDATE));
message1.setUid(mapperProvider.generateMessageUid());
message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox));
@@ -726,7 +722,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void countMessageShouldReturnWhenCreateNewMessage() throws Exception {
+ void countMessageShouldReturnWhenCreateNewMessage() throws Exception {
message1.setUid(mapperProvider.generateMessageUid());
message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox));
sut.save(message1);
@@ -735,7 +731,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void countUnseenMessageShouldBeEmptyWhenMessageIsSeen() throws Exception {
+ void countUnseenMessageShouldBeEmptyWhenMessageIsSeen() throws Exception {
message1.setUid(mapperProvider.generateMessageUid());
message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox));
message1.setFlags(new Flags(Flag.SEEN));
@@ -745,7 +741,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void countUnseenMessageShouldReturnWhenMessageIsNotSeen() throws Exception {
+ void countUnseenMessageShouldReturnWhenMessageIsNotSeen() throws Exception {
message1.setUid(mapperProvider.generateMessageUid());
message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox));
sut.save(message1);
@@ -754,7 +750,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void countMessageShouldBeEmptyWhenDeleteMessage() throws Exception {
+ void countMessageShouldBeEmptyWhenDeleteMessage() throws Exception {
message1.setUid(mapperProvider.generateMessageUid());
message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox));
sut.save(message1);
@@ -765,7 +761,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void countUnseenMessageShouldBeEmptyWhenDeleteMessage() throws Exception {
+ void countUnseenMessageShouldBeEmptyWhenDeleteMessage() throws Exception {
message1.setUid(mapperProvider.generateMessageUid());
message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox));
sut.save(message1);
@@ -776,7 +772,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void countUnseenMessageShouldReturnWhenDeleteMessage() throws Exception {
+ void countUnseenMessageShouldReturnWhenDeleteMessage() throws Exception {
message1.setUid(mapperProvider.generateMessageUid());
message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox));
message1.setFlags(new Flags(Flag.SEEN));
@@ -792,7 +788,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void countUnseenMessageShouldTakeCareOfMessagesMarkedAsRead() throws Exception {
+ void countUnseenMessageShouldTakeCareOfMessagesMarkedAsRead() throws Exception {
message1.setUid(mapperProvider.generateMessageUid());
message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox));
sut.save(message1);
@@ -803,7 +799,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void countUnseenMessageShouldTakeCareOfMessagesMarkedAsUnread() throws Exception {
+ void countUnseenMessageShouldTakeCareOfMessagesMarkedAsUnread() throws Exception {
message1.setUid(mapperProvider.generateMessageUid());
message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox));
message1.setFlags(new Flags(Flag.SEEN));
@@ -815,7 +811,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void setFlagsShouldNotUpdateModSeqWhenNoop() throws Exception {
+ void setFlagsShouldNotUpdateModSeqWhenNoop() throws Exception {
message1.setUid(mapperProvider.generateMessageUid());
long modSeq = mapperProvider.generateModSeq(benwaInboxMailbox);
message1.setModSeq(modSeq);
@@ -833,7 +829,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void addingFlagToAMessageThatAlreadyHasThisFlagShouldResultInNoChange() throws Exception {
+ void addingFlagToAMessageThatAlreadyHasThisFlagShouldResultInNoChange() throws Exception {
message1.setUid(mapperProvider.generateMessageUid());
long modSeq = mapperProvider.generateModSeq(benwaInboxMailbox);
message1.setModSeq(modSeq);
@@ -852,7 +848,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void setFlagsShouldReturnUpdatedFlagsWhenNoop() throws Exception {
+ void setFlagsShouldReturnUpdatedFlagsWhenNoop() throws Exception {
message1.setUid(mapperProvider.generateMessageUid());
long modSeq = mapperProvider.generateModSeq(benwaInboxMailbox);
message1.setModSeq(modSeq);
@@ -876,7 +872,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void countUnseenMessageShouldNotTakeCareOfOtherFlagsUpdates() throws Exception {
+ void countUnseenMessageShouldNotTakeCareOfOtherFlagsUpdates() throws Exception {
message1.setUid(mapperProvider.generateMessageUid());
message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox));
message1.setFlags(new Flags(Flag.RECENT));
@@ -888,7 +884,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void deletesShouldOnlyRemoveConcernedMessages() throws Exception {
+ void deletesShouldOnlyRemoveConcernedMessages() throws Exception {
saveMessages();
SimpleMailboxMessage copiedMessage = SimpleMailboxMessage.copy(benwaWorkMailbox.getMailboxId(), message1);
@@ -913,7 +909,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void deletesShouldUpdateMessageCount() throws Exception {
+ void deletesShouldUpdateMessageCount() throws Exception {
saveMessages();
SimpleMailboxMessage copiedMessage = SimpleMailboxMessage.copy(benwaWorkMailbox.getMailboxId(), message1);
@@ -932,7 +928,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void deletesShouldUpdateUnreadCount() throws Exception {
+ void deletesShouldUpdateUnreadCount() throws Exception {
message1.setUid(mapperProvider.generateMessageUid());
message1.setModSeq(mapperProvider.generateModSeq(benwaInboxMailbox));
message1.setFlags(new Flags(Flag.SEEN));
@@ -953,7 +949,7 @@ public abstract class MessageIdMapperTest {
}
@Test
- public void deletesShouldNotFailUponMissingMessage() {
+ void deletesShouldNotFailUponMissingMessage() {
sut.delete(
ImmutableMultimap.<MessageId, MailboxId>builder()
.put(message1.getMessageId(), benwaWorkMailbox.getMailboxId())
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 09323b8..68083f8 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
@@ -57,9 +57,8 @@ import org.apache.james.mailbox.store.mail.model.impl.PropertyBuilder;
import org.apache.james.mailbox.store.mail.model.impl.SimpleMailboxMessage;
import org.apache.james.util.concurrency.ConcurrentTestRunner;
import org.junit.Assume;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
@@ -69,7 +68,7 @@ public abstract class MessageMapperTest {
private static final char DELIMITER = '.';
private static final int LIMIT = 10;
private static final int BODY_START = 16;
- public static final int UID_VALIDITY = 42;
+ private static final int UID_VALIDITY = 42;
private static final String USER_FLAG = "userFlag";
private static final String CUSTOMS_USER_FLAGS_VALUE = "CustomsFlags";
@@ -89,12 +88,10 @@ public abstract class MessageMapperTest {
private MailboxMessage message5;
private MailboxMessage message6;
- @Rule
- public ExpectedException expected = ExpectedException.none();
-
protected abstract MapperProvider createMapperProvider();
- public void setUp() throws Exception {
+ @BeforeEach
+ void setUp() throws Exception {
this.mapperProvider = createMapperProvider();
Assume.assumeTrue(mapperProvider.getSupportedCapabilities().contains(MapperProvider.Capabilities.MESSAGE));
@@ -118,18 +115,18 @@ public abstract class MessageMapperTest {
}
@Test
- public void emptyMailboxShouldHaveZeroMessageCount() throws MailboxException {
+ void emptyMailboxShouldHaveZeroMessageCount() throws MailboxException {
assertThat(messageMapper.countMessagesInMailbox(benwaInboxMailbox)).isEqualTo(0);
}
@Test
- public void mailboxContainingMessagesShouldHaveTheGoodMessageCount() throws MailboxException {
+ void mailboxContainingMessagesShouldHaveTheGoodMessageCount() throws MailboxException {
saveMessages();
assertThat(messageMapper.countMessagesInMailbox(benwaInboxMailbox)).isEqualTo(5);
}
@Test
- public void getMailboxCountersShouldReturnStoredValue() throws MailboxException {
+ void getMailboxCountersShouldReturnStoredValue() throws MailboxException {
saveMessages();
assertThat(messageMapper.getMailboxCounters(ImmutableList.of(benwaInboxMailbox, benwaWorkMailbox)))
.containsExactlyInAnyOrder(
@@ -146,25 +143,25 @@ public abstract class MessageMapperTest {
}
@Test
- public void mailboxCountShouldBeDecrementedAfterAMessageDelete() throws MailboxException {
+ void mailboxCountShouldBeDecrementedAfterAMessageDelete() throws MailboxException {
saveMessages();
messageMapper.delete(benwaInboxMailbox, message1);
assertThat(messageMapper.countMessagesInMailbox(benwaInboxMailbox)).isEqualTo(4);
}
@Test
- public void emptyMailboxShouldNotHaveUnseenMessages() throws MailboxException {
+ void emptyMailboxShouldNotHaveUnseenMessages() throws MailboxException {
assertThat(messageMapper.countUnseenMessagesInMailbox(benwaInboxMailbox)).isEqualTo(0);
}
@Test
- public void mailboxContainingMessagesShouldHaveTheGoodUnseenMessageCount() throws MailboxException {
+ void mailboxContainingMessagesShouldHaveTheGoodUnseenMessageCount() throws MailboxException {
saveMessages();
assertThat(messageMapper.countUnseenMessagesInMailbox(benwaInboxMailbox)).isEqualTo(5);
}
@Test
- public void mailboxUnSeenCountShouldBeDecrementedAfterAMessageIsMarkedSeen() throws MailboxException {
+ void mailboxUnSeenCountShouldBeDecrementedAfterAMessageIsMarkedSeen() throws MailboxException {
saveMessages();
FlagsUpdateCalculator newFlags = new FlagsUpdateCalculator(new Flags(Flags.Flag.SEEN), FlagsUpdateMode.REPLACE);
@@ -174,7 +171,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void mailboxUnSeenCountShouldBeDecrementedAfterAMessageIsMarkedUnSeen() throws MailboxException {
+ void mailboxUnSeenCountShouldBeDecrementedAfterAMessageIsMarkedUnSeen() throws MailboxException {
saveMessages();
messageMapper.updateFlags(benwaInboxMailbox, new FlagsUpdateCalculator(new Flags(Flags.Flag.SEEN), FlagsUpdateMode.REPLACE), MessageRange.one(message1.getUid()));
messageMapper.updateFlags(benwaInboxMailbox, new FlagsUpdateCalculator(new Flags(), FlagsUpdateMode.REPLACE), MessageRange.one(message1.getUid()));
@@ -182,14 +179,14 @@ public abstract class MessageMapperTest {
}
@Test
- public void mailboxUnSeenCountShouldBeDecrementedAfterAMessageDelete() throws MailboxException {
+ void mailboxUnSeenCountShouldBeDecrementedAfterAMessageDelete() throws MailboxException {
saveMessages();
messageMapper.delete(benwaInboxMailbox, message1);
assertThat(messageMapper.countUnseenMessagesInMailbox(benwaInboxMailbox)).isEqualTo(4);
}
@Test
- public void deletedMessagesShouldBeRemovedFromStorage() throws MailboxException {
+ void deletedMessagesShouldBeRemovedFromStorage() throws MailboxException {
saveMessages();
messageMapper.delete(benwaInboxMailbox, message1);
assertThat(messageMapper.findInMailbox(benwaInboxMailbox, MessageRange.one(message1.getUid()), MessageMapper.FetchType.Metadata, LIMIT))
@@ -198,7 +195,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void deletingUnExistingMessageShouldHaveNoSideEffect() throws MailboxException, IOException {
+ void deletingUnExistingMessageShouldHaveNoSideEffect() throws MailboxException, IOException {
saveMessages();
message6.setUid(messageMapper.getLastUid(benwaInboxMailbox).get().next());
messageMapper.delete(benwaInboxMailbox, message6);
@@ -208,14 +205,14 @@ public abstract class MessageMapperTest {
}
@Test
- public void noMessageShouldBeRetrievedInEmptyMailbox() throws MailboxException {
+ void noMessageShouldBeRetrievedInEmptyMailbox() throws MailboxException {
assertThat(messageMapper.findInMailbox(benwaInboxMailbox, MessageRange.one(MessageUid.MIN_VALUE), MessageMapper.FetchType.Metadata, LIMIT))
.toIterable()
.isEmpty();
}
@Test
- public void messagesCanBeRetrievedInMailboxWithRangeTypeOne() throws MailboxException, IOException {
+ void messagesCanBeRetrievedInMailboxWithRangeTypeOne() throws MailboxException, IOException {
saveMessages();
MessageMapper.FetchType fetchType = MessageMapper.FetchType.Full;
int limit = 10;
@@ -224,7 +221,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void messagesCanBeRetrievedInMailboxWithRangeTypeRange() throws MailboxException, IOException {
+ void messagesCanBeRetrievedInMailboxWithRangeTypeRange() throws MailboxException, IOException {
saveMessages();
Iterator<MailboxMessage> retrievedMessageIterator = messageMapper
.findInMailbox(benwaInboxMailbox, MessageRange.range(message1.getUid(), message4.getUid()), MessageMapper.FetchType.Full, LIMIT);
@@ -233,7 +230,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void messagesCanBeRetrievedInMailboxWithRangeTypeRangeContainingAHole() throws MailboxException, IOException {
+ void messagesCanBeRetrievedInMailboxWithRangeTypeRangeContainingAHole() throws MailboxException, IOException {
saveMessages();
messageMapper.delete(benwaInboxMailbox, message3);
Iterator<MailboxMessage> retrievedMessageIterator = messageMapper
@@ -242,7 +239,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void messagesCanBeRetrievedInMailboxWithRangeTypeFrom() throws MailboxException, IOException {
+ void messagesCanBeRetrievedInMailboxWithRangeTypeFrom() throws MailboxException, IOException {
saveMessages();
Iterator<MailboxMessage> retrievedMessageIterator = messageMapper
.findInMailbox(benwaInboxMailbox, MessageRange.from(message3.getUid()), MessageMapper.FetchType.Full, LIMIT);
@@ -250,7 +247,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void messagesCanBeRetrievedInMailboxWithRangeTypeFromContainingAHole() throws MailboxException, IOException {
+ void messagesCanBeRetrievedInMailboxWithRangeTypeFromContainingAHole() throws MailboxException, IOException {
saveMessages();
messageMapper.delete(benwaInboxMailbox, message4);
Iterator<MailboxMessage> retrievedMessageIterator = messageMapper
@@ -259,14 +256,14 @@ public abstract class MessageMapperTest {
}
@Test
- public void messagesCanBeRetrievedInMailboxWithRangeTypeAll() throws MailboxException, IOException {
+ 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);
}
@Test
- public void messagesCanBeRetrievedInMailboxWithRangeTypeAllContainingHole() throws MailboxException, IOException {
+ void messagesCanBeRetrievedInMailboxWithRangeTypeAllContainingHole() throws MailboxException, IOException {
saveMessages();
messageMapper.delete(benwaInboxMailbox, message1);
Iterator<MailboxMessage> retrievedMessageIterator = messageMapper
@@ -275,7 +272,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void messagesRetrievedUsingFetchTypeMetadataShouldHaveAtLastMetadataDataLoaded() throws MailboxException, IOException {
+ void messagesRetrievedUsingFetchTypeMetadataShouldHaveAtLastMetadataDataLoaded() throws MailboxException, IOException {
saveMessages();
MessageMapper.FetchType fetchType = MessageMapper.FetchType.Metadata;
Iterator<MailboxMessage> retrievedMessageIterator = messageMapper.findInMailbox(benwaInboxMailbox, MessageRange.one(message1.getUid()), fetchType, LIMIT);
@@ -286,7 +283,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void messagesRetrievedUsingFetchTypeHeaderShouldHaveHeaderDataLoaded() throws MailboxException, IOException {
+ void messagesRetrievedUsingFetchTypeHeaderShouldHaveHeaderDataLoaded() throws MailboxException, IOException {
saveMessages();
MessageMapper.FetchType fetchType = MessageMapper.FetchType.Headers;
Iterator<MailboxMessage> retrievedMessageIterator = messageMapper.findInMailbox(benwaInboxMailbox, MessageRange.one(message1.getUid()), fetchType, LIMIT);
@@ -297,7 +294,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void messagesRetrievedUsingFetchTypeBodyShouldHaveBodyDataLoaded() throws MailboxException, IOException {
+ void messagesRetrievedUsingFetchTypeBodyShouldHaveBodyDataLoaded() throws MailboxException, IOException {
saveMessages();
MessageMapper.FetchType fetchType = MessageMapper.FetchType.Body;
Iterator<MailboxMessage> retrievedMessageIterator = messageMapper.findInMailbox(benwaInboxMailbox, MessageRange.one(message1.getUid()), fetchType, LIMIT);
@@ -308,7 +305,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void messagesRetrievedUsingFetchTypeFullShouldHaveBodyDataLoaded() throws MailboxException, IOException {
+ void messagesRetrievedUsingFetchTypeFullShouldHaveBodyDataLoaded() throws MailboxException, IOException {
saveMessages();
MessageMapper.FetchType fetchType = FetchType.Full;
Iterator<MailboxMessage> retrievedMessageIterator = messageMapper.findInMailbox(benwaInboxMailbox, MessageRange.one(message1.getUid()), fetchType, LIMIT);
@@ -319,7 +316,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void retrievingMessagesWithALimitShouldLimitTheNumberOfMessages() throws MailboxException {
+ void retrievingMessagesWithALimitShouldLimitTheNumberOfMessages() throws MailboxException {
int limit = 2;
saveMessages();
assertThat(messageMapper.findInMailbox(benwaInboxMailbox, MessageRange.all(), MessageMapper.FetchType.Full, limit))
@@ -328,12 +325,12 @@ public abstract class MessageMapperTest {
}
@Test
- public void findRecentUidsInMailboxShouldReturnEmptyListWhenNoMessagesMarkedAsRecentArePresentInMailbox() throws MailboxException {
+ void findRecentUidsInMailboxShouldReturnEmptyListWhenNoMessagesMarkedAsRecentArePresentInMailbox() throws MailboxException {
assertThat(messageMapper.findRecentMessageUidsInMailbox(benwaInboxMailbox)).isEmpty();
}
@Test
- public void findRecentUidsInMailboxShouldReturnListOfMessagesHoldingFlagsRecent() throws MailboxException {
+ void findRecentUidsInMailboxShouldReturnListOfMessagesHoldingFlagsRecent() throws MailboxException {
saveMessages();
messageMapper.updateFlags(benwaInboxMailbox, new FlagsUpdateCalculator(new Flags(Flags.Flag.RECENT), FlagsUpdateMode.REPLACE), MessageRange.one(message2.getUid()));
messageMapper.updateFlags(benwaInboxMailbox, new FlagsUpdateCalculator(new Flags(Flags.Flag.RECENT), FlagsUpdateMode.REPLACE), MessageRange.one(message4.getUid()));
@@ -342,7 +339,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void deleteShouldUpdateRecentWhenNeeded() throws MailboxException {
+ void deleteShouldUpdateRecentWhenNeeded() throws MailboxException {
saveMessages();
messageMapper.updateFlags(benwaInboxMailbox, new FlagsUpdateCalculator(new Flags(Flags.Flag.RECENT), FlagsUpdateMode.REPLACE), MessageRange.one(message2.getUid()));
messageMapper.updateFlags(benwaInboxMailbox, new FlagsUpdateCalculator(new Flags(Flags.Flag.RECENT), FlagsUpdateMode.REPLACE), MessageRange.one(message4.getUid()));
@@ -354,7 +351,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void deleteShouldNotUpdateRecentWhenNotNeeded() throws MailboxException {
+ void deleteShouldNotUpdateRecentWhenNotNeeded() throws MailboxException {
saveMessages();
messageMapper.updateFlags(benwaInboxMailbox, new FlagsUpdateCalculator(new Flags(Flags.Flag.RECENT), FlagsUpdateMode.REPLACE), MessageRange.one(message2.getUid()));
messageMapper.updateFlags(benwaInboxMailbox, new FlagsUpdateCalculator(new Flags(Flags.Flag.RECENT), FlagsUpdateMode.REPLACE), MessageRange.one(message4.getUid()));
@@ -366,7 +363,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void addShouldUpdateRecentWhenNeeded() throws MailboxException {
+ void addShouldUpdateRecentWhenNeeded() throws MailboxException {
message1.setFlags(new Flags(Flags.Flag.RECENT));
messageMapper.add(benwaInboxMailbox, message1);
message1.setModSeq(messageMapper.getHighestModSeq(benwaInboxMailbox));
@@ -375,7 +372,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void addShouldNotUpdateRecentWhenNotNeeded() throws MailboxException {
+ void addShouldNotUpdateRecentWhenNotNeeded() throws MailboxException {
messageMapper.add(benwaInboxMailbox, message1);
message1.setModSeq(messageMapper.getHighestModSeq(benwaInboxMailbox));
@@ -383,18 +380,18 @@ public abstract class MessageMapperTest {
}
@Test
- public void findFirstUnseenMessageUidShouldReturnNullWhenNoUnseenMessagesCanBeFound() throws MailboxException {
+ void findFirstUnseenMessageUidShouldReturnNullWhenNoUnseenMessagesCanBeFound() throws MailboxException {
assertThat(messageMapper.findFirstUnseenMessageUid(benwaInboxMailbox)).isNull();
}
@Test
- public void findFirstUnseenMessageUidShouldReturnUid1WhenUid1isNotSeen() throws MailboxException {
+ void findFirstUnseenMessageUidShouldReturnUid1WhenUid1isNotSeen() throws MailboxException {
saveMessages();
assertThat(messageMapper.findFirstUnseenMessageUid(benwaInboxMailbox)).isEqualTo(message1.getUid());
}
@Test
- public void findFirstUnseenMessageUidShouldReturnUid2WhenUid2isSeen() throws MailboxException {
+ void findFirstUnseenMessageUidShouldReturnUid2WhenUid2isSeen() throws MailboxException {
saveMessages();
messageMapper.updateFlags(benwaInboxMailbox, new FlagsUpdateCalculator(new Flags(Flags.Flag.SEEN), FlagsUpdateMode.REPLACE), MessageRange.one(message1.getUid()));
messageMapper.updateFlags(benwaInboxMailbox, new FlagsUpdateCalculator(new Flags(Flags.Flag.SEEN), FlagsUpdateMode.REPLACE), MessageRange.one(message3.getUid()));
@@ -403,23 +400,23 @@ public abstract class MessageMapperTest {
}
@Test
- public void retrieveMessagesMarkedForDeletionInMailboxShouldReturnEmptyResultOnEmptyMailbox() throws MailboxException {
+ void retrieveMessagesMarkedForDeletionInMailboxShouldReturnEmptyResultOnEmptyMailbox() throws MailboxException {
assertThat(messageMapper.retrieveMessagesMarkedForDeletion(benwaInboxMailbox, MessageRange.all())).isEmpty();
}
@Test
- public void deleteMessagesInMailboxShouldReturnEmptyResultOnEmptyMailbox() throws MailboxException {
+ void deleteMessagesInMailboxShouldReturnEmptyResultOnEmptyMailbox() throws MailboxException {
assertThat(messageMapper.deleteMessages(benwaInboxMailbox, ImmutableList.of())).isEmpty();
}
@Test
- public void retrieveMessagesMarkedForDeletionInMailboxShouldReturnEmptyResultWhenNoMessageInMailboxIsMarkedAsDeleted() throws MailboxException, IOException {
+ void retrieveMessagesMarkedForDeletionInMailboxShouldReturnEmptyResultWhenNoMessageInMailboxIsMarkedAsDeleted() throws MailboxException, IOException {
saveMessages();
assertThat(messageMapper.retrieveMessagesMarkedForDeletion(benwaInboxMailbox, MessageRange.all())).isEmpty();
}
@Test
- public void deleteMessagesInMailboxShouldReturnEmptyResultWhenNoMessageInMailboxIsDeleted() throws MailboxException, IOException {
+ void deleteMessagesInMailboxShouldReturnEmptyResultWhenNoMessageInMailboxIsDeleted() throws MailboxException, IOException {
saveMessages();
assertThat(messageMapper.deleteMessages(benwaInboxMailbox, ImmutableList.of())).isEmpty();
Iterator<MailboxMessage> retrievedMessageIterator = messageMapper.findInMailbox(benwaInboxMailbox, MessageRange.all(), MessageMapper.FetchType.Full, LIMIT);
@@ -428,14 +425,14 @@ public abstract class MessageMapperTest {
}
@Test
- public void retrieveMessagesMarkedForDeletionShouldReturnCorrectUidsWithRangeAll() throws MailboxException {
+ void retrieveMessagesMarkedForDeletionShouldReturnCorrectUidsWithRangeAll() throws MailboxException {
saveMessages();
assertThat(markThenPerformRetrieveMessagesMarkedForDeletion(MessageRange.all()))
.containsOnly(message1.getUid(), message4.getUid());
}
@Test
- public void deleteMessagesShouldReturnCorrectMetadataWithRangeAll() throws MailboxException {
+ void deleteMessagesShouldReturnCorrectMetadataWithRangeAll() throws MailboxException {
saveMessages();
MetadataMapAssert.assertThat(markThenPerformDeleteMessages(MessageRange.all()))
.hasSize(2)
@@ -443,7 +440,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void deleteMessagesShouldModifyUnderlyingStorageWithRangeAll() throws MailboxException, IOException {
+ void deleteMessagesShouldModifyUnderlyingStorageWithRangeAll() throws MailboxException, IOException {
saveMessages();
markThenPerformDeleteMessages(MessageRange.all());
@@ -453,14 +450,14 @@ public abstract class MessageMapperTest {
}
@Test
- public void retrieveMessagesMarkedForDeletionShouldReturnCorrectMetadataWithRangeOne() throws MailboxException {
+ void retrieveMessagesMarkedForDeletionShouldReturnCorrectMetadataWithRangeOne() throws MailboxException {
saveMessages();
assertThat(markThenPerformRetrieveMessagesMarkedForDeletion(MessageRange.one(message1.getUid())))
.containsOnly(message1.getUid());
}
@Test
- public void deleteMessagesShouldReturnCorrectMetadataWithRangeOne() throws MailboxException {
+ void deleteMessagesShouldReturnCorrectMetadataWithRangeOne() throws MailboxException {
saveMessages();
MetadataMapAssert.assertThat(markThenPerformDeleteMessages(MessageRange.one(message1.getUid())))
.hasSize(1)
@@ -468,7 +465,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void deleteMessagesShouldModifyUnderlyingStorageWithRangeOne() throws MailboxException, IOException {
+ void deleteMessagesShouldModifyUnderlyingStorageWithRangeOne() throws MailboxException, IOException {
saveMessages();
markThenPerformDeleteMessages(MessageRange.one(message1.getUid()));
@@ -478,14 +475,14 @@ public abstract class MessageMapperTest {
}
@Test
- public void retrieveMessagesMarkedForDeletionShouldReturnCorrectMetadataWithRangeFrom() throws MailboxException {
+ void retrieveMessagesMarkedForDeletionShouldReturnCorrectMetadataWithRangeFrom() throws MailboxException {
saveMessages();
assertThat(markThenPerformRetrieveMessagesMarkedForDeletion(MessageRange.from(message3.getUid())))
.containsOnly(message4.getUid());
}
@Test
- public void deleteMessagesShouldReturnCorrectMetadataWithRangeFrom() throws MailboxException {
+ void deleteMessagesShouldReturnCorrectMetadataWithRangeFrom() throws MailboxException {
saveMessages();
MetadataMapAssert.assertThat(markThenPerformDeleteMessages(MessageRange.from(message3.getUid())))
.hasSize(1)
@@ -493,7 +490,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void deleteMessagesShouldModifyUnderlyingStorageWithRangeFrom() throws MailboxException, IOException {
+ void deleteMessagesShouldModifyUnderlyingStorageWithRangeFrom() throws MailboxException, IOException {
saveMessages();
markThenPerformDeleteMessages(MessageRange.from(message3.getUid()));
@@ -503,14 +500,14 @@ public abstract class MessageMapperTest {
}
@Test
- public void retrieveMessagesMarkedForDeletionShouldReturnCorrectMetadataWithRange() throws MailboxException {
+ void retrieveMessagesMarkedForDeletionShouldReturnCorrectMetadataWithRange() throws MailboxException {
saveMessages();
assertThat(markThenPerformRetrieveMessagesMarkedForDeletion(MessageRange.range(message3.getUid(), message5.getUid())))
.containsOnly(message4.getUid());
}
@Test
- public void deleteMessagesShouldReturnCorrectMetadataWithRange() throws MailboxException {
+ void deleteMessagesShouldReturnCorrectMetadataWithRange() throws MailboxException {
saveMessages();
MetadataMapAssert.assertThat(markThenPerformDeleteMessages(MessageRange.range(message3.getUid(), message5.getUid())))
.hasSize(1)
@@ -518,7 +515,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void deleteMessagesShouldModifyUnderlyingStorageWithRange() throws MailboxException, IOException {
+ void deleteMessagesShouldModifyUnderlyingStorageWithRange() throws MailboxException, IOException {
saveMessages();
markThenPerformDeleteMessages(MessageRange.range(message3.getUid(), message5.getUid()));
@@ -528,12 +525,12 @@ public abstract class MessageMapperTest {
}
@Test
- public void getHighestMoseqShouldBeEqualToZeroOnEmptyMailbox() throws MailboxException {
+ void getHighestMoseqShouldBeEqualToZeroOnEmptyMailbox() throws MailboxException {
assertThat(messageMapper.getHighestModSeq(benwaInboxMailbox)).isEqualTo(0);
}
@Test
- public void insertingAMessageShouldIncrementModSeq() throws MailboxException {
+ void insertingAMessageShouldIncrementModSeq() throws MailboxException {
messageMapper.add(benwaInboxMailbox, message1);
long modSeq = messageMapper.getHighestModSeq(benwaInboxMailbox);
assertThat(modSeq).isGreaterThan(0);
@@ -542,12 +539,12 @@ public abstract class MessageMapperTest {
}
@Test
- public void getLastUidShouldReturnEmptyOnEmptyMailbox() throws MailboxException {
+ void getLastUidShouldReturnEmptyOnEmptyMailbox() throws MailboxException {
assertThat(messageMapper.getLastUid(benwaInboxMailbox)).isEqualTo(Optional.empty());
}
@Test
- public void insertingAMessageShouldIncrementLastUid() throws MailboxException {
+ void insertingAMessageShouldIncrementLastUid() throws MailboxException {
messageMapper.add(benwaInboxMailbox, message1);
Optional<MessageUid> uid = messageMapper.getLastUid(benwaInboxMailbox);
assertThat(uid).isNotEqualTo(Optional.empty());
@@ -556,7 +553,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void copyShouldIncrementUid() throws MailboxException {
+ void copyShouldIncrementUid() throws MailboxException {
saveMessages();
MessageUid uid = messageMapper.getLastUid(benwaInboxMailbox).get();
messageMapper.copy(benwaInboxMailbox, SimpleMailboxMessage.copy(benwaInboxMailbox.getMailboxId(), message6));
@@ -564,21 +561,21 @@ public abstract class MessageMapperTest {
}
@Test
- public void copyShouldIncrementMessageCount() throws MailboxException {
+ void copyShouldIncrementMessageCount() throws MailboxException {
saveMessages();
messageMapper.copy(benwaInboxMailbox, SimpleMailboxMessage.copy(benwaInboxMailbox.getMailboxId(), message6));
assertThat(messageMapper.countMessagesInMailbox(benwaInboxMailbox)).isEqualTo(6);
}
@Test
- public void copyOfUnSeenMessageShouldIncrementUnSeenMessageCount() throws MailboxException {
+ void copyOfUnSeenMessageShouldIncrementUnSeenMessageCount() throws MailboxException {
saveMessages();
messageMapper.copy(benwaInboxMailbox, SimpleMailboxMessage.copy(benwaInboxMailbox.getMailboxId(), message6));
assertThat(messageMapper.countUnseenMessagesInMailbox(benwaInboxMailbox)).isEqualTo(6);
}
@Test
- public void copyShouldIncrementModSeq() throws MailboxException, IOException {
+ void copyShouldIncrementModSeq() throws MailboxException, IOException {
saveMessages();
long modSeq = messageMapper.getHighestModSeq(benwaInboxMailbox);
messageMapper.copy(benwaInboxMailbox, SimpleMailboxMessage.copy(benwaInboxMailbox.getMailboxId(), message6));
@@ -586,7 +583,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void copyShouldCreateAMessageInDestination() throws MailboxException, IOException {
+ void copyShouldCreateAMessageInDestination() throws MailboxException, IOException {
saveMessages();
MailboxMessage message7 = SimpleMailboxMessage.copy(benwaInboxMailbox.getMailboxId(), message6);
messageMapper.copy(benwaInboxMailbox, message7);
@@ -604,7 +601,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void copyOfSeenMessageShouldNotIncrementUnSeenMessageCount() throws MailboxException {
+ void copyOfSeenMessageShouldNotIncrementUnSeenMessageCount() throws MailboxException {
message6.setFlags(new Flags(Flags.Flag.SEEN));
saveMessages();
long expectedUnseenMessages = messageMapper.countUnseenMessagesInMailbox(benwaInboxMailbox);
@@ -614,7 +611,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void copiedMessageShouldBeMarkedAsRecent() throws MailboxException {
+ void copiedMessageShouldBeMarkedAsRecent() throws MailboxException {
saveMessages();
MessageMetaData metaData = messageMapper.copy(benwaInboxMailbox, SimpleMailboxMessage.copy(benwaInboxMailbox.getMailboxId(), message6));
assertThat(
@@ -628,7 +625,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void copiedRecentMessageShouldBeMarkedAsRecent() throws MailboxException {
+ void copiedRecentMessageShouldBeMarkedAsRecent() throws MailboxException {
saveMessages();
message6.setFlags(new Flags(Flags.Flag.RECENT));
MessageMetaData metaData = messageMapper.copy(benwaInboxMailbox, SimpleMailboxMessage.copy(benwaInboxMailbox.getMailboxId(), message6));
@@ -643,7 +640,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void copiedMessageShouldNotChangeTheFlagsOnOriginalMessage() throws MailboxException {
+ void copiedMessageShouldNotChangeTheFlagsOnOriginalMessage() throws MailboxException {
saveMessages();
messageMapper.copy(benwaInboxMailbox, SimpleMailboxMessage.copy(benwaInboxMailbox.getMailboxId(), message6));
assertThat(
@@ -657,14 +654,14 @@ public abstract class MessageMapperTest {
}
@Test
- public void flagsReplacementShouldReplaceStoredMessageFlags() throws MailboxException {
+ 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));
}
@Test
- public void flagsReplacementShouldReturnAnUpdatedFlagHighlightingTheReplacement() throws MailboxException {
+ void flagsReplacementShouldReturnAnUpdatedFlagHighlightingTheReplacement() throws MailboxException {
saveMessages();
long modSeq = messageMapper.getHighestModSeq(benwaInboxMailbox);
Iterator<UpdatedFlags> updatedFlags = messageMapper.updateFlags(benwaInboxMailbox,
@@ -679,7 +676,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void flagsAdditionShouldReturnAnUpdatedFlagHighlightingTheAddition() throws MailboxException {
+ void flagsAdditionShouldReturnAnUpdatedFlagHighlightingTheAddition() throws MailboxException {
saveMessages();
messageMapper.updateFlags(benwaInboxMailbox, new FlagsUpdateCalculator(new Flags(Flags.Flag.FLAGGED), FlagsUpdateMode.REPLACE), MessageRange.one(message1.getUid()));
long modSeq = messageMapper.getHighestModSeq(benwaInboxMailbox);
@@ -694,7 +691,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void flagsAdditionShouldUpdateStoredMessageFlags() throws MailboxException {
+ void flagsAdditionShouldUpdateStoredMessageFlags() throws MailboxException {
saveMessages();
messageMapper.updateFlags(benwaInboxMailbox, new FlagsUpdateCalculator(new Flags(Flags.Flag.FLAGGED), FlagsUpdateMode.REPLACE), MessageRange.one(message1.getUid()));
messageMapper.updateFlags(benwaInboxMailbox, new FlagsUpdateCalculator(new Flags(Flags.Flag.SEEN), FlagsUpdateMode.ADD), MessageRange.one(message1.getUid()));
@@ -702,7 +699,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void flagsAdditionShouldHaveNoEffectOnStoredFlagsWhenNoop() throws MailboxException {
+ void flagsAdditionShouldHaveNoEffectOnStoredFlagsWhenNoop() throws MailboxException {
saveMessages();
messageMapper.updateFlags(benwaInboxMailbox, new FlagsUpdateCalculator(new Flags(Flags.Flag.FLAGGED), FlagsUpdateMode.REPLACE), MessageRange.one(message1.getUid()));
@@ -712,7 +709,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void flagsRemovalShouldReturnAnUpdatedFlagHighlightingTheRemoval() throws MailboxException {
+ 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()));
long modSeq = messageMapper.getHighestModSeq(benwaInboxMailbox);
@@ -728,7 +725,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void flagsRemovalShouldUpdateStoredMessageFlags() throws MailboxException {
+ 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()));
messageMapper.updateFlags(benwaInboxMailbox, new FlagsUpdateCalculator(new Flags(Flags.Flag.SEEN), FlagsUpdateMode.REMOVE), MessageRange.one(message1.getUid()));
@@ -736,7 +733,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void updateFlagsOnRangeShouldAffectMessagesContainedInThisRange() throws MailboxException {
+ void updateFlagsOnRangeShouldAffectMessagesContainedInThisRange() throws MailboxException {
saveMessages();
assertThat(messageMapper.updateFlags(benwaInboxMailbox, new FlagsUpdateCalculator(new Flags(Flags.Flag.SEEN), FlagsUpdateMode.REPLACE), MessageRange.range(message1.getUid(), message3.getUid())))
.toIterable()
@@ -744,7 +741,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void updateFlagsWithRangeFromShouldAffectMessagesContainedInThisRange() throws MailboxException {
+ void updateFlagsWithRangeFromShouldAffectMessagesContainedInThisRange() throws MailboxException {
saveMessages();
assertThat(messageMapper.updateFlags(benwaInboxMailbox, new FlagsUpdateCalculator(new Flags(Flags.Flag.SEEN), FlagsUpdateMode.REPLACE), MessageRange.from(message3.getUid())))
.toIterable()
@@ -752,7 +749,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void updateFlagsWithRangeAllRangeShouldAffectAllMessages() throws MailboxException {
+ void updateFlagsWithRangeAllRangeShouldAffectAllMessages() throws MailboxException {
saveMessages();
assertThat(messageMapper.updateFlags(benwaInboxMailbox, new FlagsUpdateCalculator(new Flags(Flags.Flag.SEEN), FlagsUpdateMode.REPLACE), MessageRange.all()))
.toIterable()
@@ -760,7 +757,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void messagePropertiesShouldBeStored() throws Exception {
+ void messagePropertiesShouldBeStored() throws Exception {
PropertyBuilder propBuilder = new PropertyBuilder();
propBuilder.setMediaType("text");
propBuilder.setSubType("html");
@@ -776,7 +773,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void messagePropertiesShouldBeStoredWhenDuplicateEntries() throws Exception {
+ void messagePropertiesShouldBeStoredWhenDuplicateEntries() throws Exception {
PropertyBuilder propBuilder = new PropertyBuilder();
propBuilder.setProperty(StandardNames.MIME_CONTENT_LANGUAGE_SPACE, StandardNames.MIME_CONTENT_LANGUAGE_NAME, "us");
propBuilder.setProperty(StandardNames.MIME_CONTENT_LANGUAGE_SPACE, StandardNames.MIME_CONTENT_LANGUAGE_NAME, "fr");
@@ -789,7 +786,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void messagePropertiesShouldBeStoredWhenNoProperty() throws Exception {
+ 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);
MailboxMessage message = messageMapper.findInMailbox(benwaInboxMailbox, MessageRange.one(messageMetaData.getUid()), FetchType.Body, 1).next();
@@ -797,7 +794,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void textualLineCountShouldBeWellStored() throws Exception {
+ void textualLineCountShouldBeWellStored() throws Exception {
long textualLineCount = 48L;
PropertyBuilder propBuilder = new PropertyBuilder();
propBuilder.setTextualLineCount(textualLineCount);
@@ -809,7 +806,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void mediaTypeShouldBeWellStored() throws Exception {
+ void mediaTypeShouldBeWellStored() throws Exception {
String mediaType = "plain";
PropertyBuilder propBuilder = new PropertyBuilder();
propBuilder.setMediaType(mediaType);
@@ -821,7 +818,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void subTypeShouldBeWellStored() throws Exception {
+ void subTypeShouldBeWellStored() throws Exception {
String subType = "text";
PropertyBuilder propBuilder = new PropertyBuilder();
propBuilder.setSubType(subType);
@@ -833,14 +830,14 @@ public abstract class MessageMapperTest {
}
@Test
- public void userFlagsShouldBeSupported() throws Exception {
+ 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));
}
@Test
- public void userFlagsUpdateShouldReturnCorrectUpdatedFlags() throws Exception {
+ void userFlagsUpdateShouldReturnCorrectUpdatedFlags() throws Exception {
saveMessages();
long modSeq = messageMapper.getHighestModSeq(benwaInboxMailbox);
assertThat(messageMapper.updateFlags(benwaInboxMailbox, new FlagsUpdateCalculator(new Flags(USER_FLAG), FlagsUpdateMode.ADD), MessageRange.one(message1.getUid())))
@@ -855,7 +852,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void userFlagsUpdateShouldReturnCorrectUpdatedFlagsWhenNoop() throws Exception {
+ void userFlagsUpdateShouldReturnCorrectUpdatedFlagsWhenNoop() throws Exception {
saveMessages();
assertThat(
@@ -873,7 +870,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void userFlagsUpdateShouldWorkInConcurrentEnvironment() throws Exception {
+ void userFlagsUpdateShouldWorkInConcurrentEnvironment() throws Exception {
Assume.assumeTrue(mapperProvider.getSupportedCapabilities().contains(MapperProvider.Capabilities.THREAD_SAFE_FLAGS_UPDATE));
saveMessages();
@@ -895,7 +892,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void setFlagsShouldWorkWithConcurrencyWithRemove() throws Exception {
+ void setFlagsShouldWorkWithConcurrencyWithRemove() throws Exception {
Assume.assumeTrue(mapperProvider.getSupportedCapabilities().contains(MapperProvider.Capabilities.THREAD_SAFE_FLAGS_UPDATE));
saveMessages();
@@ -925,14 +922,14 @@ public abstract class MessageMapperTest {
}
@Test
- public void messagesShouldBeSavedWithTheirUserFlags() throws Exception {
+ void messagesShouldBeSavedWithTheirUserFlags() throws Exception {
MailboxMessage message = SimpleMailboxMessage.copy(benwaInboxMailbox.getMailboxId(), message1);
messageMapper.add(benwaInboxMailbox, message);
assertThat(retrieveMessageFromStorage(message)).hasFlags(new Flags(USER_FLAG));
}
@Test
- public void getApplicableFlagShouldUnionAllMessageFlags() throws Exception {
+ void getApplicableFlagShouldUnionAllMessageFlags() throws Exception {
String customFlags1 = "custom1";
String customFlags2 = "custom2";
message1.setFlags(new Flags(customFlags1));
@@ -948,7 +945,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void getApplicableFlagShouldUnionAllMessageFlagsExceptRecentAndUser() throws Exception {
+ void getApplicableFlagShouldUnionAllMessageFlagsExceptRecentAndUser() throws Exception {
message1.setFlags(new Flags(Flag.ANSWERED));
message2.setFlags(new Flags(Flag.DELETED));
@@ -967,7 +964,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void getApplicableFlagShouldContainSystemFlagsByDefault() throws Exception {
+ void getApplicableFlagShouldContainSystemFlagsByDefault() throws Exception {
assertThat(messageMapper.getApplicableFlag(benwaInboxMailbox))
.isEqualTo(FlagsBuilder.builder()
.add(Flag.DELETED, Flag.ANSWERED, Flag.DRAFT, Flag.FLAGGED, Flag.SEEN)
@@ -976,7 +973,7 @@ public abstract class MessageMapperTest {
@Test
- public void getApplicableFlagShouldHaveEffectWhenUpdateFlagsByAddingThenComputingApplicableFlagsFromCurrentMailboxState() throws Exception {
+ void getApplicableFlagShouldHaveEffectWhenUpdateFlagsByAddingThenComputingApplicableFlagsFromCurrentMailboxState() throws Exception {
message1.setFlags(new Flags(Flag.ANSWERED));
message2.setFlags(new Flags(Flag.DELETED));
@@ -994,7 +991,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void getApplicableFlagShouldHaveNotEffectWhenUpdateFlagsByReplaceThenIncrementalApplicableFlags() throws Exception {
+ void getApplicableFlagShouldHaveNotEffectWhenUpdateFlagsByReplaceThenIncrementalApplicableFlags() throws Exception {
Assume.assumeTrue(mapperProvider.getSupportedCapabilities().contains(Capabilities.INCREMENTAL_APPLICABLE_FLAGS));
String customFlags = "custom";
message1.setFlags(new Flags(customFlags));
@@ -1012,7 +1009,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void getApplicableFlagShouldHaveEffectWhenUpdateFlagsByReplaceThenComputingApplicableFlagsFromCurrentMailboxState() throws Exception {
+ void getApplicableFlagShouldHaveEffectWhenUpdateFlagsByReplaceThenComputingApplicableFlagsFromCurrentMailboxState() throws Exception {
Assume.assumeFalse(mapperProvider.getSupportedCapabilities().contains(Capabilities.INCREMENTAL_APPLICABLE_FLAGS));
String customFlags = "custom";
message1.setFlags(new Flags(customFlags));
@@ -1029,7 +1026,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void getApplicableFlagShouldHaveNotEffectWhenUpdateFlagsByRemoveThenIncrementalApplicableFlags() throws Exception {
+ void getApplicableFlagShouldHaveNotEffectWhenUpdateFlagsByRemoveThenIncrementalApplicableFlags() throws Exception {
Assume.assumeTrue(mapperProvider.getSupportedCapabilities().contains(Capabilities.INCREMENTAL_APPLICABLE_FLAGS));
String customFlags = "custom";
message1.setFlags(new FlagsBuilder().add(Flag.ANSWERED).add(customFlags).build());
@@ -1047,7 +1044,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void getApplicableFlagShouldHaveEffectWhenUpdateFlagsByRemoveThenComputingApplicableFlagsFromCurrentMailboxState() throws Exception {
+ void getApplicableFlagShouldHaveEffectWhenUpdateFlagsByRemoveThenComputingApplicableFlagsFromCurrentMailboxState() throws Exception {
Assume.assumeFalse(mapperProvider.getSupportedCapabilities().contains(Capabilities.INCREMENTAL_APPLICABLE_FLAGS));
String customFlags = "custom";
message1.setFlags(new FlagsBuilder().add(Flag.ANSWERED).add(customFlags).build());
@@ -1064,7 +1061,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void getApplicableFlagShouldHaveEffectWhenUnsetMessageFlagThenComputingApplicableFlagsFromCurrentMailboxState() throws Exception {
+ void getApplicableFlagShouldHaveEffectWhenUnsetMessageFlagThenComputingApplicableFlagsFromCurrentMailboxState() throws Exception {
Assume.assumeFalse(mapperProvider.getSupportedCapabilities().contains(Capabilities.INCREMENTAL_APPLICABLE_FLAGS));
String customFlag1 = "custom1";
String customFlag2 = "custom2";
@@ -1084,7 +1081,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void getApplicableFlagShouldHaveNotEffectWhenUnsetMessageFlagThenIncrementalApplicableFlags() throws Exception {
+ void getApplicableFlagShouldHaveNotEffectWhenUnsetMessageFlagThenIncrementalApplicableFlags() throws Exception {
Assume.assumeTrue(mapperProvider.getSupportedCapabilities().contains(MapperProvider.Capabilities.THREAD_SAFE_FLAGS_UPDATE));
String customFlag1 = "custom1";
String customFlag2 = "custom2";
@@ -1104,7 +1101,7 @@ public abstract class MessageMapperTest {
@Test
- public void getApplicableFlagShouldHaveNotEffectWhenDeleteMessageThenIncrementalApplicableFlags() throws Exception {
+ void getApplicableFlagShouldHaveNotEffectWhenDeleteMessageThenIncrementalApplicableFlags() throws Exception {
Assume.assumeTrue(mapperProvider.getSupportedCapabilities().contains(Capabilities.INCREMENTAL_APPLICABLE_FLAGS));
String customFlag1 = "custom1";
String customFlag2 = "custom2";
@@ -1122,7 +1119,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void getApplicableFlagShouldReturnDefaultApplicableFlagsWhenMailboxEmpty() throws Exception {
+ void getApplicableFlagShouldReturnDefaultApplicableFlagsWhenMailboxEmpty() throws Exception {
Mailbox emptyMailbox = createMailbox(MailboxPath.forUser(BENWA, "EMPTY"));
assertThat(messageMapper.getApplicableFlag(emptyMailbox))
@@ -1132,7 +1129,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void getApplicableFlagShouldHaveEffectWhenDeleteMessageThenComputingApplicableFlagsFromCurrentMailboxState() throws Exception {
+ void getApplicableFlagShouldHaveEffectWhenDeleteMessageThenComputingApplicableFlagsFromCurrentMailboxState() throws Exception {
Assume.assumeFalse(mapperProvider.getSupportedCapabilities().contains(Capabilities.INCREMENTAL_APPLICABLE_FLAGS));
String customFlag1 = "custom1";
String customFlag2 = "custom2";
@@ -1150,7 +1147,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void getUidsShouldReturnUidsOfMessagesInTheMailbox() throws Exception {
+ void getUidsShouldReturnUidsOfMessagesInTheMailbox() throws Exception {
saveMessages();
assertThat(messageMapper.listAllMessageUids(benwaInboxMailbox))
@@ -1163,7 +1160,7 @@ public abstract class MessageMapperTest {
}
@Test
- public void getUidsShouldNotReturnUidsOfDeletedMessages() throws Exception {
+ void getUidsShouldNotReturnUidsOfDeletedMessages() throws Exception {
saveMessages();
messageMapper.updateFlags(benwaInboxMailbox,
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 8658d50..c531a59 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
@@ -40,16 +40,15 @@ import org.apache.james.mailbox.store.mail.MessageMapper.FetchType;
import org.apache.james.mailbox.store.mail.model.impl.PropertyBuilder;
import org.apache.james.mailbox.store.mail.model.impl.SimpleMailboxMessage;
import org.junit.Assume;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
public abstract class MessageMoveTest {
private static final char DELIMITER = '.';
private static final int LIMIT = 10;
private static final int BODY_START = 16;
- public static final int UID_VALIDITY = 42;
+ private static final int UID_VALIDITY = 42;
private MapperProvider mapperProvider;
private MessageMapper messageMapper;
@@ -62,10 +61,8 @@ public abstract class MessageMoveTest {
protected abstract MapperProvider createMapperProvider();
- @Rule
- public ExpectedException expected = ExpectedException.none();
-
- public void setUp() throws Exception {
+ @BeforeEach
+ void setUp() throws Exception {
this.mapperProvider = createMapperProvider();
Assume.assumeTrue(mapperProvider.getSupportedCapabilities().contains(MapperProvider.Capabilities.MOVE));
this.messageMapper = mapperProvider.createMessageMapper();
@@ -80,7 +77,7 @@ public abstract class MessageMoveTest {
}
@Test
- public void movingAMessageShouldWork() throws Exception {
+ void movingAMessageShouldWork() throws Exception {
messageMapper.add(benwaInboxMailbox, message1);
message1.setModSeq(messageMapper.getHighestModSeq(benwaInboxMailbox));
@@ -90,7 +87,7 @@ public abstract class MessageMoveTest {
}
@Test
- public void movingAMessageShouldReturnCorrectMetadata() throws Exception {
+ void movingAMessageShouldReturnCorrectMetadata() throws Exception {
messageMapper.add(benwaInboxMailbox, message1);
message1.setModSeq(messageMapper.getHighestModSeq(benwaInboxMailbox));
@@ -104,7 +101,7 @@ public abstract class MessageMoveTest {
}
@Test
- public void movingAMessageShouldNotViolateMessageCount() throws Exception {
+ void movingAMessageShouldNotViolateMessageCount() throws Exception {
messageMapper.add(benwaInboxMailbox, message1);
message1.setModSeq(messageMapper.getHighestModSeq(benwaInboxMailbox));
@@ -115,7 +112,7 @@ public abstract class MessageMoveTest {
}
@Test
- public void movingAMessageShouldNotViolateUnseenMessageCount() throws Exception {
+ void movingAMessageShouldNotViolateUnseenMessageCount() throws Exception {
messageMapper.add(benwaInboxMailbox, message1);
message1.setModSeq(messageMapper.getHighestModSeq(benwaInboxMailbox));
@@ -126,7 +123,7 @@ public abstract class MessageMoveTest {
}
@Test
- public void movingASeenMessageShouldNotIncrementUnseenMessageCount() throws Exception {
+ void movingASeenMessageShouldNotIncrementUnseenMessageCount() throws Exception {
message1.setFlags(new Flags(Flags.Flag.SEEN));
messageMapper.add(benwaInboxMailbox, message1);
message1.setModSeq(messageMapper.getHighestModSeq(benwaInboxMailbox));
@@ -150,7 +147,7 @@ public abstract class MessageMoveTest {
return messageMapper.findInMailbox(mailbox, MessageRange.one(message.getUid()), FetchType.Metadata, LIMIT).next();
}
- private MailboxMessage createMessage(Mailbox mailbox, MessageId messageId, String content, int bodyStart, PropertyBuilder propertyBuilder) throws MailboxException {
+ private MailboxMessage createMessage(Mailbox mailbox, MessageId messageId, String content, int bodyStart, PropertyBuilder propertyBuilder) {
return new SimpleMailboxMessage(messageId, new Date(), content.length(), bodyStart, new SharedByteArrayInputStream(content.getBytes()), new Flags(), propertyBuilder, mailbox.getMailboxId());
}
}
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 7ab9137..a270819 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
@@ -45,10 +45,9 @@ import org.apache.james.mailbox.store.mail.AttachmentMapper;
import org.apache.james.mailbox.store.mail.MessageMapper;
import org.apache.james.mailbox.store.mail.model.impl.PropertyBuilder;
import org.apache.james.mailbox.store.mail.model.impl.SimpleMailboxMessage;
-import org.junit.Assume;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
+import org.junit.jupiter.api.Assumptions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import com.google.common.collect.ImmutableList;
@@ -56,7 +55,7 @@ public abstract class MessageWithAttachmentMapperTest {
private static final int LIMIT = 10;
private static final int BODY_START = 16;
- public static final int UID_VALIDITY = 42;
+ private static final int UID_VALIDITY = 42;
private MapperProvider mapperProvider;
private MessageMapper messageMapper;
@@ -68,16 +67,14 @@ public abstract class MessageWithAttachmentMapperTest {
private SimpleMailboxMessage messageWith1Attachment;
private SimpleMailboxMessage messageWith2Attachments;
- @Rule
- public ExpectedException expected = ExpectedException.none();
-
protected abstract MapperProvider createMapperProvider();
- public void setUp() throws Exception {
+ @BeforeEach
+ void setUp() throws Exception {
this.mapperProvider = createMapperProvider();
- Assume.assumeTrue(mapperProvider.getSupportedCapabilities().contains(MapperProvider.Capabilities.MESSAGE));
- Assume.assumeTrue(mapperProvider.getSupportedCapabilities().contains(MapperProvider.Capabilities.ATTACHMENT));
+ Assumptions.assumeTrue(mapperProvider.getSupportedCapabilities().contains(MapperProvider.Capabilities.MESSAGE));
+ Assumptions.assumeTrue(mapperProvider.getSupportedCapabilities().contains(MapperProvider.Capabilities.ATTACHMENT));
this.messageMapper = mapperProvider.createMessageMapper();
this.attachmentMapper = mapperProvider.createAttachmentMapper();
@@ -120,7 +117,7 @@ public abstract class MessageWithAttachmentMapperTest {
}
@Test
- public void messagesRetrievedUsingFetchTypeFullShouldHaveAttachmentsLoadedWhenOneAttachment() throws MailboxException, IOException {
+ void messagesRetrievedUsingFetchTypeFullShouldHaveAttachmentsLoadedWhenOneAttachment() throws MailboxException {
saveMessages();
MessageMapper.FetchType fetchType = MessageMapper.FetchType.Full;
Iterator<MailboxMessage> retrievedMessageIterator = messageMapper.findInMailbox(attachmentsMailbox, MessageRange.one(messageWith1Attachment.getUid()), fetchType, LIMIT);
@@ -128,7 +125,7 @@ public abstract class MessageWithAttachmentMapperTest {
}
@Test
- public void messagesRetrievedUsingFetchTypeFullShouldHaveAttachmentsLoadedWhenTwoAttachments() throws MailboxException, IOException {
+ void messagesRetrievedUsingFetchTypeFullShouldHaveAttachmentsLoadedWhenTwoAttachments() throws MailboxException {
saveMessages();
MessageMapper.FetchType fetchType = MessageMapper.FetchType.Full;
Iterator<MailboxMessage> retrievedMessageIterator = messageMapper.findInMailbox(attachmentsMailbox, MessageRange.one(messageWith2Attachments.getUid()), fetchType, LIMIT);
@@ -136,7 +133,7 @@ public abstract class MessageWithAttachmentMapperTest {
}
@Test
- public void messagesRetrievedUsingFetchTypeBodyShouldHaveAttachmentsLoadedWhenOneAttachment() throws MailboxException, IOException {
+ void messagesRetrievedUsingFetchTypeBodyShouldHaveAttachmentsLoadedWhenOneAttachment() throws MailboxException {
saveMessages();
MessageMapper.FetchType fetchType = MessageMapper.FetchType.Body;
Iterator<MailboxMessage> retrievedMessageIterator = messageMapper.findInMailbox(attachmentsMailbox, MessageRange.one(messageWith1Attachment.getUid()), fetchType, LIMIT);
@@ -144,8 +141,8 @@ public abstract class MessageWithAttachmentMapperTest {
}
@Test
- public void messagesRetrievedUsingFetchTypeHeadersShouldHaveAttachmentsEmptyWhenOneAttachment() throws MailboxException, IOException {
- Assume.assumeTrue(mapperProvider.supportPartialAttachmentFetch());
+ void messagesRetrievedUsingFetchTypeHeadersShouldHaveAttachmentsEmptyWhenOneAttachment() throws MailboxException {
+ Assumptions.assumeTrue(mapperProvider.supportPartialAttachmentFetch());
saveMessages();
MessageMapper.FetchType fetchType = MessageMapper.FetchType.Headers;
Iterator<MailboxMessage> retrievedMessageIterator = messageMapper.findInMailbox(attachmentsMailbox, MessageRange.one(messageWith1Attachment.getUid()), fetchType, LIMIT);
@@ -153,8 +150,8 @@ public abstract class MessageWithAttachmentMapperTest {
}
@Test
- public void messagesRetrievedUsingFetchTypeMetadataShouldHaveAttachmentsEmptyWhenOneAttachment() throws MailboxException, IOException {
- Assume.assumeTrue(mapperProvider.supportPartialAttachmentFetch());
+ void messagesRetrievedUsingFetchTypeMetadataShouldHaveAttachmentsEmptyWhenOneAttachment() throws MailboxException {
+ Assumptions.assumeTrue(mapperProvider.supportPartialAttachmentFetch());
saveMessages();
MessageMapper.FetchType fetchType = MessageMapper.FetchType.Metadata;
Iterator<MailboxMessage> retrievedMessageIterator = messageMapper.findInMailbox(attachmentsMailbox, MessageRange.one(messageWith1Attachment.getUid()), fetchType, LIMIT);
@@ -162,7 +159,7 @@ public abstract class MessageWithAttachmentMapperTest {
}
@Test
- public void messagesRetrievedUsingFetchTypeFullShouldHaveAttachmentsEmptyWhenNoAttachment() throws MailboxException, IOException {
+ void messagesRetrievedUsingFetchTypeFullShouldHaveAttachmentsEmptyWhenNoAttachment() throws MailboxException {
saveMessages();
MessageMapper.FetchType fetchType = MessageMapper.FetchType.Full;
Iterator<MailboxMessage> retrievedMessageIterator = messageMapper.findInMailbox(attachmentsMailbox, MessageRange.one(messageWithoutAttachment.getUid()), fetchType, LIMIT);
@@ -170,7 +167,7 @@ public abstract class MessageWithAttachmentMapperTest {
}
@Test
- public void messagesCanBeRetrievedInMailboxWithRangeTypeOne() throws MailboxException, IOException {
+ void messagesCanBeRetrievedInMailboxWithRangeTypeOne() throws MailboxException, IOException {
saveMessages();
MessageMapper.FetchType fetchType = MessageMapper.FetchType.Full;
assertThat(messageMapper.findInMailbox(attachmentsMailbox, MessageRange.one(messageWith1Attachment.getUid()), fetchType, LIMIT).next())
@@ -178,7 +175,7 @@ public abstract class MessageWithAttachmentMapperTest {
}
@Test
- public void messagesRetrievedUsingFetchTypeBodyShouldHaveBodyDataLoaded() throws MailboxException, IOException {
+ void messagesRetrievedUsingFetchTypeBodyShouldHaveBodyDataLoaded() throws MailboxException, IOException {
saveMessages();
MessageMapper.FetchType fetchType = MessageMapper.FetchType.Body;
Iterator<MailboxMessage> retrievedMessageIterator = messageMapper.findInMailbox(attachmentsMailbox, MessageRange.one(messageWith1Attachment.getUid()), fetchType, LIMIT);
diff --git a/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/GenericMaxQuotaManagerTest.java b/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/GenericMaxQuotaManagerTest.java
index 9513974..40a8adf 100644
--- a/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/GenericMaxQuotaManagerTest.java
+++ b/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/GenericMaxQuotaManagerTest.java
@@ -29,111 +29,111 @@ import org.apache.james.core.quota.QuotaSize;
import org.apache.james.mailbox.model.Quota;
import org.apache.james.mailbox.model.QuotaRoot;
import org.apache.james.mailbox.quota.MaxQuotaManager;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
public abstract class GenericMaxQuotaManagerTest {
- public static final Domain DOMAIN = Domain.of("domain");
- public static final Domain DOMAIN_CASE_VARIATION = Domain.of("doMain");
- public static final QuotaRoot QUOTA_ROOT = QuotaRoot.quotaRoot("benwa@domain", Optional.of(DOMAIN));
+ private static final Domain DOMAIN = Domain.of("domain");
+ private static final Domain DOMAIN_CASE_VARIATION = Domain.of("doMain");
+ private static final QuotaRoot QUOTA_ROOT = QuotaRoot.quotaRoot("benwa@domain", Optional.of(DOMAIN));
private MaxQuotaManager maxQuotaManager;
protected abstract MaxQuotaManager provideMaxQuotaManager();
- @Before
- public void setUp() {
+ @BeforeEach
+ void setUp() {
maxQuotaManager = provideMaxQuotaManager();
}
@Test
- public void getMaxMessageShouldReturnEmptyWhenNoGlobalValue() throws Exception {
+ void getMaxMessageShouldReturnEmptyWhenNoGlobalValue() throws Exception {
assertThat(maxQuotaManager.getMaxMessage(QUOTA_ROOT)).isEmpty();
}
@Test
- public void getMaxStorageShouldReturnEmptyWhenNoGlobalValue() throws Exception {
+ void getMaxStorageShouldReturnEmptyWhenNoGlobalValue() throws Exception {
assertThat(maxQuotaManager.getMaxStorage(QUOTA_ROOT)).isEmpty();
}
@Test
- public void getMaxMessageShouldReturnDomainWhenNoValue() throws Exception {
+ void getMaxMessageShouldReturnDomainWhenNoValue() throws Exception {
maxQuotaManager.setGlobalMaxMessage(QuotaCount.count(36));
maxQuotaManager.setDomainMaxMessage(DOMAIN, QuotaCount.count(23));
assertThat(maxQuotaManager.getMaxMessage(QUOTA_ROOT)).contains(QuotaCount.count(23));
}
@Test
- public void getMaxMessageShouldReturnGlobalWhenNoValue() throws Exception {
+ void getMaxMessageShouldReturnGlobalWhenNoValue() throws Exception {
maxQuotaManager.setGlobalMaxMessage(QuotaCount.count(36));
assertThat(maxQuotaManager.getMaxMessage(QUOTA_ROOT)).contains(QuotaCount.count(36));
}
@Test
- public void getMaxStorageShouldReturnGlobalWhenNoValue() throws Exception {
+ void getMaxStorageShouldReturnGlobalWhenNoValue() throws Exception {
maxQuotaManager.setGlobalMaxStorage(QuotaSize.size(36));
assertThat(maxQuotaManager.getMaxStorage(QUOTA_ROOT)).contains(QuotaSize.size(36));
}
@Test
- public void getMaxStorageShouldReturnDomainWhenNoValue() throws Exception {
+ void getMaxStorageShouldReturnDomainWhenNoValue() throws Exception {
maxQuotaManager.setGlobalMaxStorage(QuotaSize.size(234));
maxQuotaManager.setDomainMaxStorage(DOMAIN, QuotaSize.size(111));
assertThat(maxQuotaManager.getMaxStorage(QUOTA_ROOT)).contains(QuotaSize.size(111));
}
@Test
- public void getMaxMessageShouldReturnProvidedValue() throws Exception {
+ void getMaxMessageShouldReturnProvidedValue() throws Exception {
maxQuotaManager.setMaxMessage(QUOTA_ROOT, QuotaCount.count(36));
assertThat(maxQuotaManager.getMaxMessage(QUOTA_ROOT)).contains(QuotaCount.count(36));
}
@Test
- public void getMaxStorageShouldReturnProvidedValue() throws Exception {
+ void getMaxStorageShouldReturnProvidedValue() throws Exception {
maxQuotaManager.setMaxStorage(QUOTA_ROOT, QuotaSize.size(36));
assertThat(maxQuotaManager.getMaxStorage(QUOTA_ROOT)).contains(QuotaSize.size(36));
}
@Test
- public void deleteMaxStorageShouldRemoveCurrentValue() throws Exception {
+ void deleteMaxStorageShouldRemoveCurrentValue() throws Exception {
maxQuotaManager.setMaxStorage(QUOTA_ROOT, QuotaSize.size(36));
maxQuotaManager.removeMaxStorage(QUOTA_ROOT);
assertThat(maxQuotaManager.getMaxStorage(QUOTA_ROOT)).isEmpty();
}
@Test
- public void deleteMaxMessageShouldRemoveCurrentValue() throws Exception {
+ void deleteMaxMessageShouldRemoveCurrentValue() throws Exception {
maxQuotaManager.setMaxMessage(QUOTA_ROOT, QuotaCount.count(36));
maxQuotaManager.removeMaxMessage(QUOTA_ROOT);
assertThat(maxQuotaManager.getMaxMessage(QUOTA_ROOT)).isEmpty();
}
@Test
- public void deleteGlobalMaxStorageShouldRemoveCurrentValue() throws Exception {
+ void deleteGlobalMaxStorageShouldRemoveCurrentValue() throws Exception {
maxQuotaManager.setGlobalMaxStorage(QuotaSize.size(36));
maxQuotaManager.removeGlobalMaxStorage();
assertThat(maxQuotaManager.getGlobalMaxStorage()).isEmpty();
}
@Test
- public void deleteGlobalMaxMessageShouldRemoveCurrentValue() throws Exception {
+ void deleteGlobalMaxMessageShouldRemoveCurrentValue() throws Exception {
maxQuotaManager.setGlobalMaxMessage(QuotaCount.count(36));
maxQuotaManager.removeGlobalMaxMessage();
assertThat(maxQuotaManager.getGlobalMaxMessage()).isEmpty();
}
@Test
- public void listMaxMessagesDetailsShouldReturnEmptyWhenNoQuotaDefined() {
+ void listMaxMessagesDetailsShouldReturnEmptyWhenNoQuotaDefined() {
assertThat(maxQuotaManager.listMaxMessagesDetails(QUOTA_ROOT)).isEmpty();
}
@Test
- public void listMaxStorageDetailsShouldReturnEmptyWhenNoQuotaDefined() {
+ void listMaxStorageDetailsShouldReturnEmptyWhenNoQuotaDefined() {
assertThat(maxQuotaManager.listMaxStorageDetails(QUOTA_ROOT)).isEmpty();
}
@Test
- public void listMaxMessagesDetailsShouldReturnGlobalValueWhenDefined() throws Exception {
+ void listMaxMessagesDetailsShouldReturnGlobalValueWhenDefined() throws Exception {
maxQuotaManager.setGlobalMaxMessage(QuotaCount.count(123));
assertThat(maxQuotaManager.listMaxMessagesDetails(QUOTA_ROOT))
.hasSize(1)
@@ -141,7 +141,7 @@ public abstract class GenericMaxQuotaManagerTest {
}
@Test
- public void listMaxMessagesDetailsShouldReturnDomainValueWhenDefined() throws Exception {
+ void listMaxMessagesDetailsShouldReturnDomainValueWhenDefined() throws Exception {
maxQuotaManager.setDomainMaxMessage(DOMAIN, QuotaCount.count(123));
assertThat(maxQuotaManager.listMaxMessagesDetails(QUOTA_ROOT))
.hasSize(1)
@@ -149,7 +149,7 @@ public abstract class GenericMaxQuotaManagerTest {
}
@Test
- public void listMaxMessagesDetailsShouldReturnUserValueWhenDefined() throws Exception {
+ void listMaxMessagesDetailsShouldReturnUserValueWhenDefined() throws Exception {
maxQuotaManager.setMaxMessage(QUOTA_ROOT, QuotaCount.count(123));
assertThat(maxQuotaManager.listMaxMessagesDetails(QUOTA_ROOT))
.hasSize(1)
@@ -157,7 +157,7 @@ public abstract class GenericMaxQuotaManagerTest {
}
@Test
- public void listMaxMessagesDetailsShouldReturnBothValuesWhenGlobalAndUserDefined() throws Exception {
+ void listMaxMessagesDetailsShouldReturnBothValuesWhenGlobalAndUserDefined() throws Exception {
maxQuotaManager.setGlobalMaxMessage(QuotaCount.count(1234));
maxQuotaManager.setMaxMessage(QUOTA_ROOT, QuotaCount.count(123));
assertThat(maxQuotaManager.listMaxMessagesDetails(QUOTA_ROOT))
@@ -167,7 +167,7 @@ public abstract class GenericMaxQuotaManagerTest {
}
@Test
- public void listMaxMessagesDetailsShouldReturnAllValuesWhenDefined() throws Exception {
+ void listMaxMessagesDetailsShouldReturnAllValuesWhenDefined() throws Exception {
maxQuotaManager.setGlobalMaxMessage(QuotaCount.count(1234));
maxQuotaManager.setDomainMaxMessage(DOMAIN, QuotaCount.count(333));
maxQuotaManager.setMaxMessage(QUOTA_ROOT, QuotaCount.count(123));
@@ -179,7 +179,7 @@ public abstract class GenericMaxQuotaManagerTest {
}
@Test
- public void listMaxStorageDetailsShouldReturnGlobalValueWhenDefined() throws Exception {
+ void listMaxStorageDetailsShouldReturnGlobalValueWhenDefined() throws Exception {
maxQuotaManager.setGlobalMaxStorage(QuotaSize.size(1111));
assertThat(maxQuotaManager.listMaxStorageDetails(QUOTA_ROOT))
.hasSize(1)
@@ -187,7 +187,7 @@ public abstract class GenericMaxQuotaManagerTest {
}
@Test
- public void listMaxStorageDetailsShouldReturnDomainValueWhenDefined() throws Exception {
+ void listMaxStorageDetailsShouldReturnDomainValueWhenDefined() throws Exception {
maxQuotaManager.setDomainMaxStorage(DOMAIN, QuotaSize.size(1111));
assertThat(maxQuotaManager.listMaxStorageDetails(QUOTA_ROOT))
.hasSize(1)
@@ -195,7 +195,7 @@ public abstract class GenericMaxQuotaManagerTest {
}
@Test
- public void listMaxStorageDetailsShouldReturnUserValueWhenDefined() throws Exception {
+ void listMaxStorageDetailsShouldReturnUserValueWhenDefined() throws Exception {
maxQuotaManager.setMaxStorage(QUOTA_ROOT, QuotaSize.size(2222));
assertThat(maxQuotaManager.listMaxStorageDetails(QUOTA_ROOT))
.hasSize(1)
@@ -203,7 +203,7 @@ public abstract class GenericMaxQuotaManagerTest {
}
@Test
- public void listMaxStorageDetailsShouldReturnBothValuesWhenDefined() throws Exception {
+ void listMaxStorageDetailsShouldReturnBothValuesWhenDefined() throws Exception {
maxQuotaManager.setGlobalMaxStorage(QuotaSize.size(3333));
maxQuotaManager.setMaxStorage(QUOTA_ROOT, QuotaSize.size(4444));
assertThat(maxQuotaManager.listMaxStorageDetails(QUOTA_ROOT))
@@ -213,7 +213,7 @@ public abstract class GenericMaxQuotaManagerTest {
}
@Test
- public void listMaxStorageDetailsShouldReturnAllValuesWhenDefined() throws Exception {
+ void listMaxStorageDetailsShouldReturnAllValuesWhenDefined() throws Exception {
maxQuotaManager.setGlobalMaxStorage(QuotaSize.size(3333));
maxQuotaManager.setDomainMaxStorage(DOMAIN, QuotaSize.size(2222));
maxQuotaManager.setMaxStorage(QUOTA_ROOT, QuotaSize.size(4444));
@@ -225,43 +225,43 @@ public abstract class GenericMaxQuotaManagerTest {
}
@Test
- public void getDomainMaxMessageShouldReturnEmptyWhenNoGlobalValue() {
+ void getDomainMaxMessageShouldReturnEmptyWhenNoGlobalValue() {
assertThat(maxQuotaManager.getDomainMaxMessage(DOMAIN)).isEmpty();
}
@Test
- public void getDomainMaxStorageShouldReturnEmptyWhenNoGlobalValue() {
+ void getDomainMaxStorageShouldReturnEmptyWhenNoGlobalValue() {
assertThat(maxQuotaManager.getDomainMaxStorage(DOMAIN)).isEmpty();
}
@Test
- public void getDomainMaxMessageShouldReturnProvidedValue() throws Exception {
+ void getDomainMaxMessageShouldReturnProvidedValue() throws Exception {
maxQuotaManager.setDomainMaxMessage(DOMAIN, QuotaCount.count(36));
assertThat(maxQuotaManager.getDomainMaxMessage(DOMAIN)).contains(QuotaCount.count(36));
}
@Test
- public void getDomainMaxStorageShouldReturnProvidedValue() throws Exception {
+ void getDomainMaxStorageShouldReturnProvidedValue() throws Exception {
maxQuotaManager.setDomainMaxStorage(DOMAIN, QuotaSize.size(36));
assertThat(maxQuotaManager.getDomainMaxStorage(DOMAIN)).contains(QuotaSize.size(36));
}
@Test
- public void deleteDomainMaxStorageShouldRemoveCurrentValue() throws Exception {
+ void deleteDomainMaxStorageShouldRemoveCurrentValue() throws Exception {
maxQuotaManager.setDomainMaxStorage(DOMAIN, QuotaSize.size(36));
maxQuotaManager.removeDomainMaxStorage(DOMAIN);
assertThat(maxQuotaManager.getDomainMaxStorage(DOMAIN)).isEmpty();
}
@Test
- public void deleteDomainMaxMessageShouldRemoveCurrentValue() throws Exception {
+ void deleteDomainMaxMessageShouldRemoveCurrentValue() throws Exception {
maxQuotaManager.setDomainMaxMessage(DOMAIN, QuotaCount.count(36));
maxQuotaManager.removeDomainMaxMessage(DOMAIN);
assertThat(maxQuotaManager.getDomainMaxMessage(DOMAIN)).isEmpty();
}
@Test
- public void deleteDomainMaxMessageShouldNotBeCaseSensitive() throws Exception {
+ void deleteDomainMaxMessageShouldNotBeCaseSensitive() throws Exception {
maxQuotaManager.setDomainMaxMessage(DOMAIN, QuotaCount.count(36));
maxQuotaManager.removeDomainMaxMessage(DOMAIN_CASE_VARIATION);
@@ -270,7 +270,7 @@ public abstract class GenericMaxQuotaManagerTest {
}
@Test
- public void deleteDomainMaxStorageShouldNotBeCaseSensitive() throws Exception {
+ void deleteDomainMaxStorageShouldNotBeCaseSensitive() throws Exception {
maxQuotaManager.setDomainMaxStorage(DOMAIN, QuotaSize.size(36));
maxQuotaManager.removeDomainMaxStorage(DOMAIN_CASE_VARIATION);
@@ -279,7 +279,7 @@ public abstract class GenericMaxQuotaManagerTest {
}
@Test
- public void setDomainMaxMessageShouldNotBeCaseSensitive() throws Exception {
+ void setDomainMaxMessageShouldNotBeCaseSensitive() throws Exception {
maxQuotaManager.setDomainMaxMessage(DOMAIN_CASE_VARIATION, QuotaCount.count(36));
@@ -288,7 +288,7 @@ public abstract class GenericMaxQuotaManagerTest {
}
@Test
- public void setDomainMaxStorageShouldNotBeCaseSensitive() throws Exception {
+ void setDomainMaxStorageShouldNotBeCaseSensitive() throws Exception {
maxQuotaManager.setDomainMaxStorage(DOMAIN_CASE_VARIATION, QuotaSize.size(36));
assertThat(maxQuotaManager.getDomainMaxStorage(DOMAIN))
@@ -296,7 +296,7 @@ public abstract class GenericMaxQuotaManagerTest {
}
@Test
- public void getDomainMaxMessageShouldNotBeCaseSensitive() throws Exception {
+ void getDomainMaxMessageShouldNotBeCaseSensitive() throws Exception {
maxQuotaManager.setDomainMaxMessage(DOMAIN, QuotaCount.count(36));
@@ -305,7 +305,7 @@ public abstract class GenericMaxQuotaManagerTest {
}
@Test
- public void getDomainMaxStorageShouldNotBeCaseSensitive() throws Exception {
+ void getDomainMaxStorageShouldNotBeCaseSensitive() throws Exception {
maxQuotaManager.setDomainMaxStorage(DOMAIN, QuotaSize.size(36));
assertThat(maxQuotaManager.getDomainMaxStorage(DOMAIN_CASE_VARIATION))
diff --git a/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/StoreCurrentQuotaManagerTest.java b/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/StoreCurrentQuotaManagerTest.java
index e83aee6..b80322f 100644
--- a/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/StoreCurrentQuotaManagerTest.java
+++ b/mailbox/store/src/test/java/org/apache/james/mailbox/store/quota/StoreCurrentQuotaManagerTest.java
@@ -20,14 +20,15 @@
package org.apache.james.mailbox.store.quota;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.Optional;
import org.apache.james.core.quota.QuotaCount;
import org.apache.james.core.quota.QuotaSize;
import org.apache.james.mailbox.model.QuotaRoot;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
public abstract class StoreCurrentQuotaManagerTest {
public static final QuotaRoot QUOTA_ROOT = QuotaRoot.quotaRoot("benwa", Optional.empty());
@@ -36,18 +37,18 @@ public abstract class StoreCurrentQuotaManagerTest {
private StoreCurrentQuotaManager testee;
- @Before
- public void setUp() throws Exception {
+ @BeforeEach
+ void setUp() {
testee = provideTestee();
}
@Test
- public void getCurrentStorageShouldReturnZeroByDefault() throws Exception {
+ void getCurrentStorageShouldReturnZeroByDefault() throws Exception {
assertThat(testee.getCurrentStorage(QUOTA_ROOT)).isEqualTo(QuotaSize.size(0));
}
@Test
- public void increaseShouldWork() throws Exception {
+ void increaseShouldWork() throws Exception {
testee.increase(QUOTA_ROOT, 10, 100);
assertThat(testee.getCurrentMessageCount(QUOTA_ROOT)).isEqualTo(QuotaCount.count(10));
@@ -55,7 +56,7 @@ public abstract class StoreCurrentQuotaManagerTest {
}
@Test
- public void decreaseShouldWork() throws Exception {
+ void decreaseShouldWork() throws Exception {
testee.increase(QUOTA_ROOT, 20, 200);
testee.decrease(QUOTA_ROOT, 10, 100);
@@ -65,50 +66,58 @@ public abstract class StoreCurrentQuotaManagerTest {
}
@Test
- public void decreaseShouldNotFailWhenItLeadsToNegativeValues() throws Exception {
+ void decreaseShouldNotFailWhenItLeadsToNegativeValues() throws Exception {
testee.decrease(QUOTA_ROOT, 10, 100);
assertThat(testee.getCurrentMessageCount(QUOTA_ROOT)).isEqualTo(QuotaCount.count(-10));
assertThat(testee.getCurrentStorage(QUOTA_ROOT)).isEqualTo(QuotaSize.size(-100));
}
- @Test(expected = IllegalArgumentException.class)
- public void increaseShouldThrowOnZeroCount() throws Exception {
- testee.increase(QUOTA_ROOT, 0, 5);
+ @Test
+ void increaseShouldThrowOnZeroCount() {
+ assertThatThrownBy(() -> testee.increase(QUOTA_ROOT, 0, 5))
+ .isInstanceOf(IllegalArgumentException.class);
}
- @Test(expected = IllegalArgumentException.class)
- public void increaseShouldThrowOnNegativeCount() throws Exception {
- testee.increase(QUOTA_ROOT, -1, 5);
+ @Test
+ void increaseShouldThrowOnNegativeCount() {
+ assertThatThrownBy(() -> testee.increase(QUOTA_ROOT, -1, 5))
+ .isInstanceOf(IllegalArgumentException.class);
}
- @Test(expected = IllegalArgumentException.class)
- public void increaseShouldThrowOnZeroSize() throws Exception {
- testee.increase(QUOTA_ROOT, 5, 0);
+ @Test
+ void increaseShouldThrowOnZeroSize() {
+ assertThatThrownBy(() -> testee.increase(QUOTA_ROOT, 5, 0))
+ .isInstanceOf(IllegalArgumentException.class);
}
- @Test(expected = IllegalArgumentException.class)
- public void increaseShouldThrowOnNegativeSize() throws Exception {
- testee.increase(QUOTA_ROOT, 5, -1);
+ @Test
+ void increaseShouldThrowOnNegativeSize() {
+ assertThatThrownBy(() -> testee.increase(QUOTA_ROOT, 5, -1))
+ .isInstanceOf(IllegalArgumentException.class);
}
- @Test(expected = IllegalArgumentException.class)
- public void decreaseShouldThrowOnZeroCount() throws Exception {
- testee.decrease(QUOTA_ROOT, 0, 5);
+ @Test
+ void decreaseShouldThrowOnZeroCount() {
+ assertThatThrownBy(() -> testee.decrease(QUOTA_ROOT, 0, 5))
+ .isInstanceOf(IllegalArgumentException.class);
}
- @Test(expected = IllegalArgumentException.class)
- public void decreaseShouldThrowOnNegativeCount() throws Exception {
- testee.decrease(QUOTA_ROOT, -1, 5);
+ @Test
+ void decreaseShouldThrowOnNegativeCount() {
+ assertThatThrownBy(() -> testee.decrease(QUOTA_ROOT, -1, 5))
+ .isInstanceOf(IllegalArgumentException.class);
}
- @Test(expected = IllegalArgumentException.class)
- public void decreaseShouldThrowOnZeroSize() throws Exception {
- testee.decrease(QUOTA_ROOT, 5, 0);
+ @Test
+ void decreaseShouldThrowOnZeroSize() {
+ assertThatThrownBy(() -> testee.decrease(QUOTA_ROOT, 5, 0))
+ .isInstanceOf(IllegalArgumentException.class);
}
- @Test(expected = IllegalArgumentException.class)
- public void decreaseShouldThrowOnNegativeSize() throws Exception {
- testee.decrease(QUOTA_ROOT, 5, -1);
+ @Test
+ void decreaseShouldThrowOnNegativeSize() {
+ assertThatThrownBy(() -> testee.decrease(QUOTA_ROOT, 5, -1))
+ .isInstanceOf(IllegalArgumentException.class);
}
}
---------------------------------------------------------------------
To unsubscribe, e-mail: server-dev-unsubscribe@james.apache.org
For additional commands, e-mail: server-dev-help@james.apache.org